Back to index

wims  3.65+svn20090927
LambdaExpLayout.java
Go to the documentation of this file.
00001 /*
00002 $Id: LambdaExpLayout.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 fr.ove.openmath.jome.ctrlview.bidim.DisplayLayout;
00033 import fr.ove.openmath.jome.ctrlview.bidim.Display;
00034 import fr.ove.openmath.jome.ctrlview.bidim.selection.events.SelectionEvent;
00035 import fr.ove.openmath.jome.model.*;
00036 
00043 public class LambdaExpLayout extends HorizontalLayout {
00044     private boolean arrangeDisplay = true; // Au premier calcul, il faudra arranger les displays correctement
00045     private Display enumeration = null;
00054     public void initDisplay(Display displayToLay) {
00055         super.initDisplay(displayToLay);
00056         
00057         // La fts associée au display
00058         LambdaExpression fts = (LambdaExpression) this.displayToLay.getListener();
00059         GraphicContext gc = this.displayToLay.getGraphicContext();
00060         // Display temporaire pour manipulations
00061         Display displayElems = null;
00062         if (!fts.isJustFunction()) {
00063             if (fts.getNbChildren() > 2) {
00064                 // Alors il faut qu'on ajoute un display supplémentaire, qui contiendra les variables liées
00065                 // du bind. Ce display aura un EnumerationLayout.
00066                 enumeration = new BidimDisplay(gc);
00067                 enumeration.addControlListener(fts);
00068                 EnumerationLayout layout = new EnumerationLayout();
00069                 layout.initDisplay(enumeration);
00070                 enumeration.setLayout(layout);
00071                 this.displayToLay.add(enumeration);
00072             }
00073             
00074             // Le symbole de la flèche
00075             SymbolDisplay arrow = new SymbolDisplay(gc, new ImageSymbol("RightArrow", this.displayToLay));
00076             // Le display de la somme est le display d'un opérateur (on peut le considérer comme tel)
00077             arrow.setIsSymbolOperatorDisplay(true);
00078             this.displayToLay.add(arrow);
00079             arrow.addControlListener(fts);
00080         }
00081         
00082         // De part la méthode d'allocation des displays, si fts.isJustFunction() est vrai, alors display n'a
00083         // pour le moment pas de fils.
00084         // Si fts.getNbChildren() > 2, alors display contient, dans cet ordre [enumeration, arrow].
00085         // Sinon, display contient seulement [arrow]
00086         // Donc selon les cas, après allocation complète, display sera de la forme :
00087         // [ftc, var1, var2,....] : il faut donc virer les var* (puisqu'en fait <=> fts.isJustFunction() == true)
00088         // [arrow, fct, var1] : juste faire un shiftX pour que affichage soit de la forme [var1, arrow, fct]
00089         // [enumeration, arrow, fct, var1, var2, ...] : il faut mettre les var* comme fils de enumeration
00090         
00091     }
00092     
00096     public void validateSelection() {
00097     }
00098     
00103     public void validateDeselection(Display display) {
00104     }
00105     
00111     public Dimension computeAttributes() {
00112         updateLevel(displayToLay.getLevel());
00113         LambdaExpression fts = (LambdaExpression) displayToLay.getListener();
00114         
00115         if (displayToLay.getComponentCount() > 3) {
00116         //if (arrangeDisplay) {
00117             if (!fts.isJustFunction()) {
00118                 if (fts.getNbChildren() > 2) {
00119                     // On enlève tous les displays correspondant en fait aux variables, de displayToLay,
00120                     // pour le mettre comme fils à enumeration
00121                     //Display enumeration = (Display) displayToLay.getComponent(0);
00122                     Display d;
00123                     for (int i = 3; i < displayToLay.getComponentCount(); ) {
00124                         d = (Display) displayToLay.getComponent(i);
00125                         // enumeration.add(d) appelle un displayToLay.remove(d).
00126                         // remove(d), enlève également d de la liste des listeners de l'objet (fts) qu'il écoutait.
00127                         // Ce qu'on ne veut pas, puisqu'il s'agit d'un simple déplacement de display. 
00128                         d.setDoRemoveFromListListeners(false);
00129                         enumeration.add(d);
00130                         // On remet le comportement de suppression par défault.
00131                         d.setDoRemoveFromListListeners(true);
00132                     }
00133                 }
00134             }
00135             else {
00136                 // On enlève tous les displays correspondant en fait aux variables.
00137                 for (int i = 1; i < displayToLay.getComponentCount(); )
00138                     displayToLay.remove(i);
00139             }
00140             arrangeDisplay = false;
00141         }        
00142         
00143         Dimension dim = super.computeAttributes();
00144         
00145         if ((!fts.isJustFunction()) && (fts.getNbChildren() == 2)) {
00146             // en fait un truc du style lambda(sin(x), x), displayToLay est de a forme [arrow, sin(x), x]
00147             // faut faire en sorte qsue ce soit affiché [x, arrow, sin(x)]
00148             ((Display) displayToLay.getComponent(0)).setShiftX(((Display) displayToLay.getComponent(2)).getWidth());
00149             ((Display) displayToLay.getComponent(2)).setShiftX(-dim.width);
00150         }
00151                 
00152         return dim;
00153     }
00154     
00158     public void rebuildDisplay() {
00159         // Il y a besoin de reconstruire le display, seulement lorsque nous avons un lambda expression avec
00160         // une variable. Au départ, display est de la forme [arrow, fct, var]. L'iconification modifie
00161         // display de telle sorte qu'il devient [arrow, var, icon].
00162         // Pour que cela colle avec le computeAttributes() il faut remettre dans l'ordre [arrox, icon, var]
00163         LambdaExpression fts = (LambdaExpression) displayToLay.getListener();
00164         if (!fts.isJustFunction() && (fts.getNbChildren() == 2)) {
00165             Display variable = (Display) displayToLay.getComponent(1);
00166             // On l'enlève mais on ne veut pas l'enlever de la liste des listeners dont elle fait partie
00167             variable.setDoRemoveFromListListeners(false);
00168             displayToLay.remove(variable);
00169             // On remet le comportement par défaut
00170             variable.setDoRemoveFromListListeners(true);
00171             // On rajoute la variable à la fin de display
00172             displayToLay.add(variable);
00173             
00174             int count = displayToLay.getComponentCount();
00175             for (int i = 0; i < count; i++)
00176                 ((Display) displayToLay.getComponent(i)).setShiftX(0);
00177         }
00178             
00179     
00180         // La taille des displays est probablement différente de ceux qui étaient
00181         // précédemment. On demande alors le recalcul des display ancêtres.
00182         displayToLay.computeAncestorsAttributes();
00183     }
00184 
00185 }