Back to index

wims  3.65+svn20090927
FunctionLayout.java
Go to the documentation of this file.
00001 /*
00002 $Id: FunctionLayout.java,v 1.3 2003/02/18 11:48:46 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.ctrlview.bidim;
00030 
00031 import java.awt.*;
00032 import java.util.*;
00033 import fr.ove.openmath.jome.ctrlview.bidim.Display;
00034 import fr.ove.openmath.jome.ctrlview.bidim.DisplayLayout;
00035 import fr.ove.openmath.jome.ctrlview.bidim.selection.events.SelectionEvent;
00036 import fr.ove.openmath.jome.model.*;
00037 
00044 public class FunctionLayout extends UnaryOperatorLayout {
00053     public void initDisplay(Display displayToLay) {
00054         super.initDisplay(displayToLay);  // Par cet appel, on ajoute dans displayToLay le display du nom de la fonction
00055         // On va maintenant y rajouter un display, dans lequel on va mettre tous les displays correspondants
00056         // aux arguments de la fonction, display à qui on va affecter un EnumerationOperatorLayout, qui va se charger
00057         // d'afficher les arguments de la function de manière horizontale avec chacun des arguments séparés par une
00058         // virgule (un séparateur)
00059         Display argumentsDisplay = new BidimDisplay(displayToLay.getGraphicContext());
00060         // On met un listener à argumentsDisplay
00061         // En fait, il n'y en a pas besoin, dans le sens où il n'y a pas spécifiquement de fts qui
00062         // écoute le comportement de ce display. Néanmoins, il s'avère nécessaire qu'il en ait
00063         // un, par exemple lors de l'iconification, car c'est le display qui reçoit la demande
00064         // d'iconification qui envoie l'événement correspondant à la FTS. Or si ce display n'a pas
00065         // d'écouteur, alors pb. Par cohérence, l'écouteur du display d'opérateur, est le fts qui
00066         // représente cette opération. Par contre, la fts en question, n'écoute pas le display
00067         // d'opérateur.
00068         argumentsDisplay.addControlListener((FormulaTreeStructure) this.displayToLay.getListener());
00069         
00070         EnumerationLayout layout = new EnumerationLayout();
00071         layout.initDisplay(argumentsDisplay);
00072         argumentsDisplay.setLayout(layout);
00073         
00074         // On l'ajoute comme fils à display
00075         this.displayToLay.add(argumentsDisplay);
00076     }
00077     
00083     public Dimension computeAttributes() {
00084         updateLevel(displayToLay.getLevel());
00085         
00086         if (displayToLay.getComponentCount() > 2) {
00087             // Dans l'ordre, displayToLay contient [displayOperator, argumentsDisplay, var1, var2, ...]
00088             // Il faut mettre tous les vari dans argumentsDisplay.
00089             
00090             Display argumentsDisplay = (Display) displayToLay.getComponent(1);
00091             Display d;
00092             for (int i = 2; i < displayToLay.getComponentCount(); ) {
00093                 d = (Display) displayToLay.getComponent(i);
00094                 // argumentsDisplay.add(d) appelle un displayToLay.remove(d).
00095                 // remove(d), enlève également d de la liste des listeners de l'objet (fts) qu'il écoutait.
00096                 // Ce qu'on ne veut pas, puisqu'il s'agit d'un simple déplacement de display. 
00097                 d.setDoRemoveFromListListeners(false);
00098                 argumentsDisplay.add(d);
00099                 // On remet le comportement de suppression par défault.
00100                 d.setDoRemoveFromListListeners(true);
00101             }
00102         }
00103         
00104         return super.computeAttributes();
00105     }
00106     
00110     public Display createOperatorDisplay() {
00111         Operator fts = (Operator) displayToLay.getListener();
00112         // On créé un display pour l'opérateur.
00113         // Attention, fts.getOperatorName() retourne le nom de la fonction, mais "(" y est collée.
00114         // Il faut donc la supprimer.
00115         String funcName = fts.getTheOperator();
00116         funcName = funcName.substring(0, funcName.length()-1);
00117         
00118         StringDisplay stringDisplay = new StringDisplay(displayToLay.getGraphicContext(), funcName, true);
00119         stringDisplay.setIsSymbolOperatorDisplay(true);
00120         
00121         return stringDisplay;
00122         
00123         /*
00124         Display operatorDisplay;
00125         if (ImageLoader.exists(funcName)) {
00126             SpecialSymbolView symbolOperator = new SpecialSymbolView(funcName, displayToLay);
00127             operatorDisplay = new SymbolDisplay(displayToLay.getGraphicContext(), symbolOperator);
00128             operatorDisplay.setIsSymbolOperatorDisplay(true);
00129         }
00130         else
00131             operatorDisplay = new StringDisplay(displayToLay.getGraphicContext(), funcName, true);
00132             
00133         return operatorDisplay;
00134         
00135         // En fait, si au nom de la fonction est associée une image (e.g. alpha), alors le nom de la func
00136         // est représenté par l'image.
00137         */
00138     }
00139 }