Back to index

wims  3.65+svn20090927
Icon.java
Go to the documentation of this file.
00001 /*
00002 $Id: Icon.java,v 1.3 2003/02/18 11:48:47 sander Exp $
00003 */
00004 
00005 
00006 /*
00007 Copyright (C) 2001-2002 Mainline Project (I3S - ESSI - CNRS -UNSA)
00008 
00009 This library is free software; you can redistribute it and/or
00010 modify it under the terms of the GNU Lesser General Public
00011 License as published by the Free Software Foundation; either
00012 version 2.1 of the License, or (at your option) any later version.
00013 
00014 This library is distributed in the hope that it will be useful,
00015 but WITHOUT ANY WARRANTY; without even the implied warranty of
00016 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00017 Lesser General Public License for more details.
00018 
00019 You should have received a copy of the GNU Lesser General Public
00020 License along with this library; if not, write to the Free Software
00021 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00022 
00023 For further information on the GNU Lesser General Public License,
00024 see: http://www.gnu.org/copyleft/lesser.html
00025 For further information on this library, contact: mainline@essi.fr
00026 */
00027 
00028 
00029 package fr.ove.openmath.jome.model;
00030 
00031 import java.util.*;
00032 import fr.ove.openmath.jome.model.*;
00033 import fr.ove.openmath.jome.model.events.*;
00034 import fr.ove.openmath.jome.ctrlview.events.*;
00035 import fr.ove.openmath.jome.model.evaluation.*;
00036 
00047 public class Icon extends FormulaTreeStructure {
00051     private String iconName = null;    // Le nom de l'icone
00052     
00056     private Vector iconified = new Vector();
00057     
00061     private Vector rankOfIconified = new Vector(); // On en a besoin si on veut lors de la déisconification
00062     // essayer de garder la position initiale de chaque élément iconifié. En effet, à chaque fois 
00063     // que l'on supprime/ajoute un élément de/dans la FTS, le rang des éléments est mis à jour, et
00064     // comme iconified est une liste qui contient des références sur des éléments de la FTS, quand
00065     // le rang des éléments de la FTS est mis à jour, le rang des éléments de iconified est mis à
00066     // jour également. Donc on perd la "VRAI" position initiale.
00067     
00075     private boolean isSubstitution = false;
00076     
00083     public Icon(FormulaTreeStructure toIconify) {
00084         this(toIconify.getIconName());
00085         isSubstitution = false;
00086     }
00087     
00092     public Icon(String iconName) {
00093         setResourceIdentifier("ICON");
00094         setAsOperatorPriority(resourcesManager.getAsOperatorPriority("constantPriorities"));
00095         setAsOperandPriority(resourcesManager.getAsOperandPriority("constantPriorities"));
00096         isSubstitution = true;
00097         this.iconName = iconName;
00098     }
00099     
00105     public FormulaTreeStructure insert(FormulaTreeStructure current) {
00106         // La méthode utilisée pour l'insertion de l'icon est la même, mais 
00107         // son comportement diffère dans l'ensemble de celui des autres fts.
00108         // En effet current est la position d'insertion, puisque c'est à sa 
00109         // place, que l'instance courante va être insérée.
00110         // De plus la valeur de retour n'est pas utilisée.
00111         
00112         // On prend le père de current pou l'insertion.
00113         FormulaTreeStructure father = (FormulaTreeStructure) current.getFather();
00114         // On récupère le rank de current (i.e. la position d'insertion dans father)
00115         int rank = current.getRank();
00116         // On insère notre icone (i.e l'instance courante)
00117         father.addChild(this, rank);
00118         // On parcourre toutes les fts inconifiées pour les enlever de father.
00119         for (int i = 0; i < iconified.size(); i++)
00120             father.removeChild((FormulaTreeStructure) iconified.elementAt(i));
00121         
00122         return null;
00123     }
00124     
00129     public boolean isOperator() {
00130         return false;
00131     }
00132         
00136     public String createLinear(String linear) {
00137         // Si le nombre d'éléments iconifiés est 1, alors on concatène la forme linéaire de cet élément
00138         // Sinon, c'est qu'on a iconifié plusieurs opérandes d'une opération. On doit concaténer la
00139         // forme linéaire de cette sous-expression.
00140         
00141         int nbIconified = iconified.size();
00142         if (nbIconified == 1) 
00143             linear = getIconified(0).createLinear(linear);
00144         else {
00145             FormulaTreeStructure father = (FormulaTreeStructure) getIconified(0).getFather();
00146             // On duplique le father pour avoir la méthode createLinear
00147             father = (FormulaTreeStructure) father.duplicate();
00148             // On ajoute à father les éléments iconifiés
00149             for (int i = 0; i < nbIconified; i++)
00150                 father.addChild(getIconified(i));
00151             // On récupère la sous-expression
00152             linear = father.createLinear(linear);
00153         }
00154         
00155         return linear;
00156     }
00157     
00163     public void setIsSubstitution(boolean isSubstitution) {
00164         this.isSubstitution = isSubstitution;
00165     }
00166     
00171     public boolean isSubstitution() {
00172         return isSubstitution;
00173     }
00174     
00175     // On a redéfini une liste d'opérateur fils (les opérateurs iconifiés) malgrè le fait que 
00176     // l'on étende FormulaTreeStructure pour éviter que l'insertion ne change le rang d'un 
00177     // opérateur parmi les fils de son père pour que, lors de la désiconification, il se retrouve
00178     // à la même place. De plus, le fait de rajouter des fils comme si Icon était un opérateur
00179     // entraînerai la poursuite de la recherche dans l'arbre alors que l'on ne
00180     // souhaite pas, cela poserait des problèmes lors de l'affichage.
00181     
00182     /*
00183     * Adds into the list of the fts to iconify, a fts ... to iconify.
00184     * @param fts a formula tree structure to iconify.
00185     */
00186     public void addIconified(FormulaTreeStructure fts) {
00187         iconified.addElement(fts);
00188         // On conserve le rang dans la FTS
00189         rankOfIconified.addElement(new Integer(fts.getRank()));
00190     }
00191     
00196     public int getNbIconified() {
00197         return iconified.size();
00198     }
00199     
00205     public FormulaTreeStructure getIconified(int rank) {
00206         return (FormulaTreeStructure) iconified.elementAt(rank);
00207     }
00208     
00215     public int getRankOfIconified(int rank) {
00216         return ((Integer) rankOfIconified.elementAt(rank)).intValue();
00217     }
00218     
00222     public String evaluate() {
00223         // A voir ce qu'on fait pour plus tard
00224         return "";
00225     }
00226 
00227     
00228     // *****************************************
00229     // Implémentation de l'interface Iconifiable
00230     
00234     public boolean isIcon() {
00235         return true;
00236     }
00237     
00242     public void setIconName(String iconName) {
00243         this.iconName = iconName;
00244     }
00245     
00252     public String getIconName() {
00253         if (!isSubstitution) {
00254             // Si le nombre d'éléments iconifiés est 1, alors le nom de l'icone est le nom
00255             // de l'élément à iconifier.
00256             // Sinon, c'est qu'on a à iconifier plusieurs opérandes d'une opération, donc le nom
00257             // de l'icone correspond à celui de cette opération, donc au nom du père de l'instance.
00258             if (iconified.size() == 1) 
00259                 iconName = getIconified(0).getIconName();
00260             else
00261                 iconName = ((FormulaTreeStructure) getFather()).getIconName();
00262         }
00263         
00264         return iconName;
00265     }
00266     
00271     public boolean isIconifiable() {
00272         return false;  // On n'iconifie pas une icone !!!
00273     }
00274     
00278     public void iconify() {
00279         // On n'iconifie pas une icone
00280     }
00281     
00285     public void uniconify() {
00286         FormulaTreeStructure father = (FormulaTreeStructure) getFather();
00287         // On enlève notre icon (i.e. l'instance).
00288         father.removeChild(this);
00289         // On parcourre la liste des fts iconifiées pour les réinsérer à leur position
00290         // avant iconification. (heuu... ce sera leur ancienne position si aucune modif.
00291         // de father n'a été faite, of course.)
00292         int fatherNbChildren = father.getNbChildren();
00293         int countIconified = iconified.size();
00294         FormulaTreeStructure iconifiedFts = null;
00295         int rankOfIconifiedFts;
00296         for (int i = 0; i < countIconified; i++) {
00297             iconifiedFts = (FormulaTreeStructure) iconified.elementAt(i);
00298             rankOfIconifiedFts = getRankOfIconified(i);
00299             if (rankOfIconifiedFts > fatherNbChildren)
00300                 father.addChild(iconifiedFts);
00301             else
00302                 father.addChild(iconifiedFts, rankOfIconifiedFts);
00303                 
00304             // On a ajouté une fts anciennement iconifiée, on incrémente donc le nbre
00305             // d'enfant du père
00306             fatherNbChildren++;
00307         }
00308     }
00309     
00310     // *** Fin de l'interface Iconifiable ***
00311     // **************************************
00312 }