Back to index

wims  3.65+svn20090927
LimitLayout.java
Go to the documentation of this file.
00001 /*
00002 $Id: LimitLayout.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.*;
00033 import fr.ove.openmath.jome.ctrlview.bidim.selection.events.SelectionEvent;
00034 import fr.ove.openmath.jome.model.*;
00035 
00042 public class LimitLayout extends HorizontalLayout {
00051     public void initDisplay(Display displayToLay) {
00052         super.initDisplay(displayToLay);
00053         
00054         KaryOperator limit = (KaryOperator) this.displayToLay.getListener();
00055         
00056         // Allocation d'un display, qui va correspondre à la partie "lim" de la représentation
00057         Display display = new BidimDisplay(displayToLay.getGraphicContext());
00058         // On met un listener à display
00059         // En fait, il n'y en a pas besoin, dans le sens où il n'y a pas spécifiquement de fts qui
00060         // écoute le comportement de ce display. Néanmoins, il s'avère nécessaire qu'il en ait
00061         // un, par exemple lors de l'iconification, car c'est le display qui reçoit la demande
00062         // d'iconification qui envoie l'événement correspondant à la FTS. Or si ce display n'a pas
00063         // d'écouteur, alors pb. Par cohérence, l'écouteur du display d'opérateur, est le fts qui
00064         // représente cette opération. Par contre, la fts en question, n'écoute pas le display
00065         // d'opérateur.
00066         display.addControlListener(limit);
00067         // On lui met dont un SymbolLimLayout
00068         DisplayLayout layout = new SymbolLimLayout();
00069         layout.initDisplay(display);
00070         display.setLayout(layout);
00071         
00072         // On l'ajoute comme fils à display
00073         this.displayToLay.add(display);
00074         
00075         // On met un display pour l'affichage de lim
00076         StringDisplay lim = new StringDisplay(this.displayToLay.getGraphicContext(), "lim", true);
00077         // idem
00078         lim.addControlListener(limit);
00079         display.add(lim);
00080         
00081         // On met un display pour l'affichage de qui tend vers quoi
00082         Display towards = new BidimDisplay(displayToLay.getGraphicContext());
00083         towards.addControlListener(limit);
00084         // On lui met un 
00085         layout = new ImageBinaryInfixOperatorLayout();
00086         layout.initDisplay(towards);
00087         towards.setLayout(layout);
00088         display.add(towards);
00089     }
00090     
00095     public void updateLevel(int level) {
00096         // Pour éviter de refaire le calcul plusieurs fois....
00097         if (displayToLay.getUpdateLevel()) {
00098             super.updateLevel(level);
00099             
00100             // sauf que l'affichage de quoi tend vers quoi est a un niveu supérieur
00101             Display towards = (Display) displayToLay.getComponent(0);
00102             towards = (Display) towards.getComponent(1);
00103             towards.setUpdateLevel(true);
00104             ((DisplayLayout) towards.getLayout()).updateLevel(level+1);
00105             towards = null;
00106         }
00107     }
00108     
00112     public void validateSelection() {
00113         /*
00114         SelectionEvent selEvt = new SelectionEvent(displayToLay);
00115 
00116         Display derivator = (Display) displayToLay.getComponent(0);
00117         Display func = (Display) displayToLay.getComponent(1);
00118         // Si le display de ce qui est la partie fraction de la dérivée (derivator) est sélectionnée,
00119         // alors on sélectionne tout.
00120         // Si la function et dérivator ont qque chose de sélectionné, alors on sélectionne tout.
00121         if (derivator.isSelected() || (func.gotSelectedElements() && derivator.gotSelectedElements())) {
00122             displayToLay.select();
00123             // On purge la liste des éléments sélectionnés.
00124             selEvt.setAction(SelectionEvent.PURGE, null);
00125             displayToLay.fireSelectionEvent(selEvt);
00126             // On y ajoute l'instance dans la liste des sélectionnés
00127             selEvt.setAction(SelectionEvent.ADD, displayToLay);
00128             displayToLay.fireSelectionEvent(selEvt);
00129         }
00130         
00131         // On a vérifié la validité de la sélection de l'opérateur. On doit maitenant
00132         // la contrôler au niveau supérieur, au niveau du père.
00133         Display display = displayToLay;
00134         if (displayToLay.getParent() instanceof Display) {
00135             display = (Display) displayToLay.getParent();
00136             //if (!(display.getListener() instanceof Formula))
00137             FormulaTreeStructure fts = (FormulaTreeStructure) display.getListener();
00138             if (fts.getFather() != null)
00139                 ((DisplayLayout) display.getLayout()).validateSelection();
00140         }
00141 
00142         // On met à jour l'affichage.
00143         display.repaint();
00144         */
00145     }
00146     
00151     public void validateDeselection(Display display) {
00152         /*
00153         // father est le display de l'opérateur unaire.
00154         Display father = displayToLay;
00155         Display tmp;
00156         SelectionEvent selEvt = new SelectionEvent(father);
00157         
00158         // Si l'opérateur en entier est sélectionné, il faut le désélectionner
00159         if (father.isSelected()) {
00160             father.deselect();
00161             // On enlève le display père de la liste des display sélectionnés.
00162             selEvt.setAction(SelectionEvent.REMOVE, father);
00163             father.fireSelectionEvent(selEvt);
00164             
00165             // Si display est l'opérateur (on vient de déselectionner l'opérateur), alors
00166             // on ajoute l'opérande dans la liste des sélectionnés.
00167             if (display == displayToLay.getComponent(0)) {
00168                 ((Display) displayToLay.getComponent(1)).select();
00169                 selEvt.setAction(SelectionEvent.ADD, (Display) displayToLay.getComponent(1));
00170                 father.fireSelectionEvent(selEvt);
00171             }                
00172             
00173             // Comme pour la sélection, on contrôle la validité de la désélection.
00174             if (father.getParent() instanceof Display) {
00175                 father = (Display) father.getParent();
00176                 //((DisplayLayout) father.getLayout()).validateDeselection((Display) display.getParent());
00177                 if (!(father.getListener() instanceof Formula))
00178                     ((DisplayLayout) father.getLayout()).validateDeselection(displayToLay);
00179             }
00180             
00181             // Hé oui, on contrôle la validité de la sélection... dans une désélection.
00182             // Toujours le même pb, est-ce que le nouvel état de la sélection (après
00183             // désélection donc) est syntaxiquement cohérent ?
00184             validateSelection();
00185             
00186             // On met à jour l'affichage.
00187             father.repaint();
00188         } 
00189         */
00190     }
00191         
00192     
00198     public Dimension computeAttributes() {
00199         Display towards = (Display) displayToLay.getComponent(0);
00200         towards = (Display) towards.getComponent(1);
00201         
00202         if (displayToLay.getComponentCount() > 2) {
00203             // Dans l'ordre, displayToLay contient [[lim, []], fct, var, borne]
00204             // Il faut mettre var et borne, comme fils au display frère de lim.
00205             // Ce display a un LM qui rajoutera une --> entre var et borne.
00206             // On aura donc [[lim, [var, rightArrow, borne]], fct]
00207             
00208             Display d;
00209             d = (Display) displayToLay.getComponent(2);
00210             // towards.add(d) appelle un displayToLay.remove(d).
00211             // remove(d), enlève également d de la liste des listeners de l'objet (fts) qu'il écoutait.
00212             // Ce qu'on ne veut pas, puisqu'il s'agit d'un simple déplacement de display. 
00213             d.setDoRemoveFromListListeners(false);
00214             towards.add(d);
00215             d.setDoRemoveFromListListeners(true);
00216             //displayToLay contient [[lim [var]], fct, borne]
00217             
00218             d = (Display) displayToLay.getComponent(2);
00219             // towards.add(d) appelle un displayToLay.remove(d).
00220             // remove(d), enlève également d de la liste des listeners de l'objet (fts) qu'il écoutait.
00221             // Ce qu'on ne veut pas, puisqu'il s'agit d'un simple déplacement de display. 
00222             d.setDoRemoveFromListListeners(false);
00223             towards.add(d);
00224             d.setDoRemoveFromListListeners(true);
00225             //displayToLay contient [[lim [var, borne]], fct]            
00226         }        
00227         
00228         ((Display) displayToLay.getComponent(1)).setShiftX(5);
00229         updateLevel(displayToLay.getLevel());
00230         Dimension dim = super.computeAttributes();
00231         
00232         return new Dimension(dim.width + 5, dim.height);
00233     }
00234     
00238     public void rebuildDisplay() {
00239         // La taille des displays est probablement différente de ceux qui étaient
00240         // précédemment. On demande alors le recalcul des display ancêtres.
00241         displayToLay.computeAncestorsAttributes();
00242     }
00243 }
00244 
00245 
00246 class SymbolLimLayout extends VerticalCenteredLayout {
00252     public Dimension computeAttributes() {
00253         Dimension dim = super.computeAttributes();
00254         
00255         displayToLay.setAscent(((Display) displayToLay.getComponent(0)).getAscent());
00256         displayToLay.setDescent(displayToLay.getHeight() - displayToLay.getAscent());
00257         
00258         return dim;
00259     }
00260     
00264     public void validateSelection() {
00265         // To Do !!!!
00266     }
00271     public void validateDeselection(Display display) {
00272         // To Do !!!!
00273     }
00274     
00278     public void rebuildDisplay() {
00279         // La taille des displays est probablement différente de ceux qui étaient
00280         // précédemment. On demande alors le recalcul des display ancêtres.
00281         displayToLay.computeAncestorsAttributes();
00282     }
00283 }