Back to index

wims  3.65+svn20090927
MapsToSigmaLayout.java
Go to the documentation of this file.
00001 /*
00002 $Id: MapsToSigmaLayout.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.Display;
00033 import fr.ove.openmath.jome.ctrlview.bidim.DisplayLayout;
00034 import fr.ove.openmath.jome.ctrlview.bidim.HorizontalLayout;
00035 import fr.ove.openmath.jome.ctrlview.bidim.selection.events.SelectionEvent;
00036 import fr.ove.openmath.jome.model.*;
00037 
00054 public abstract class MapsToSigmaLayout extends HorizontalLayout  implements OperatorDisplayCreator {
00063     public void initDisplay(Display displayToLay) {
00064         super.initDisplay(displayToLay);
00065         
00066         Display sigma = createOperatorDisplay();
00067         sigma.addControlListener(this.displayToLay.getListener());
00068         this.displayToLay.add(sigma);
00069     }
00070     
00075     public void updateLevel(int level) {
00076         Display tmp;
00077         
00078         if (displayToLay.getUpdateLevel()) {            
00079             displayToLay.updateChildrenLevel();
00080             
00081             // On met à jour le niveau du display géré par le LM.
00082             displayToLay.setLevel(level);
00083             displayToLay.setUpdateLevel(false);
00084             
00085             // Le symbole a le même niveau que le display
00086             tmp = (Display) displayToLay.getComponent(0);
00087             ((DisplayLayout) tmp.getLayout()).updateLevel(level);
00088             tmp.setUpdateLevel(false);
00089             
00090             // L'expression de la somme a le même niveau que le display
00091             tmp = (Display) displayToLay.getComponent(1);
00092             ((DisplayLayout) tmp.getLayout()).updateLevel(level);
00093             tmp.setUpdateLevel(false);
00094             
00095             int count = displayToLay.getComponentCount();
00096             
00097             if (count > 2) {
00098                 // La borne inférieure a le niveau du dispay +1
00099                 tmp = (Display) displayToLay.getComponent(2);
00100                 ((DisplayLayout) tmp.getLayout()).updateLevel(level+1);
00101                 tmp.setUpdateLevel(false);
00102 
00103                 if (count > 3) {
00104                     // La borne supérieure a le niveau du dispay +1
00105                     tmp = (Display) displayToLay.getComponent(3);
00106                     ((DisplayLayout) tmp.getLayout()).updateLevel(level+1);
00107                     tmp.setUpdateLevel(false);
00108                 }
00109             }
00110         }
00111     }
00112 
00117     public void validateSelection() {
00118         Display symbol = (Display) displayToLay.getComponent(0);
00119         Display expression = (Display) displayToLay.getComponent(1);
00120         
00121         int count = displayToLay.getComponentCount();
00122         
00123         // Si le symbole est sélectionné, on sélectionne tout le display
00124         if (symbol.isSelected())
00125             displayToLay.select();
00126         else if (count > 2) {
00127             Display lower = (Display) displayToLay.getComponent(2);
00128             Display upper;
00129             
00130             if (lower.gotSelectedElements()) {
00131                 if (expression.gotSelectedElements())
00132                     displayToLay.select();
00133                 else if (count > 3) {
00134                     upper = (Display) displayToLay.getComponent(3);
00135                     if (upper.gotSelectedElements())
00136                         displayToLay.select();
00137                 }
00138             }
00139             else if (count > 3) {
00140                 upper = (Display) displayToLay.getComponent(3);
00141                 if (upper.gotSelectedElements()) {
00142                     if (expression.gotSelectedElements())
00143                         displayToLay.select();
00144                 }
00145             }
00146         }
00147         
00148         // Quand on est ici, si display est sélectionné, alors c'est qu'on a validé un des tests
00149         // ci-dessus. On doit alors mettre à jour le gestionnaire de sélections, et y ajouter display
00150         if (displayToLay.isSelected()) {
00151             SelectionEvent selEvt = new SelectionEvent(displayToLay);
00152             // On purge la liste des éléments sélectionnés.
00153             selEvt.setAction(SelectionEvent.PURGE, null);
00154             displayToLay.fireSelectionEvent(selEvt);
00155             // On y ajoute notre puissance.
00156             selEvt.setAction(SelectionEvent.ADD, displayToLay);
00157             displayToLay.fireSelectionEvent(selEvt);
00158         }
00159 
00160         // On a vérifié la validité de la sélection de la puissance. On doit maitenant
00161         // la contrôler au niveau supérieur, au niveau du père.
00162         Display display = displayToLay;
00163         if (display.getParent() instanceof Display) {
00164             display = (Display) display.getParent();
00165             //if (!(display.getListener() instanceof Formula))
00166             FormulaTreeStructure fts = (FormulaTreeStructure) display.getListener();
00167             if (fts.getFather() != null)
00168                 ((DisplayLayout) display.getLayout()).validateSelection();
00169         }
00170 
00171         // On met à jour l'affichage.
00172         display.repaint();
00173     }
00174     
00179     public void validateDeselection(Display display) {
00180         Display father = displayToLay;
00181         SelectionEvent selEvt = new SelectionEvent(father);
00182         
00183         if (father.isSelected()) {
00184             father.setNotSelected();
00185             // On enlève le display père de la liste des display sélectionnés.
00186             selEvt.setAction(SelectionEvent.REMOVE, father);
00187             father.fireSelectionEvent(selEvt);
00188             
00189             Display expression = (Display) father.getComponent(1);
00190             int count = father.getComponentCount();
00191             if (display != expression) {
00192                 // quand on désélectionne un élément de la somme, autre que l'expression, l'expression
00193                 // reste sélectionnée.
00194                 selEvt.setAction(SelectionEvent.ADD, expression);
00195                 father.fireSelectionEvent(selEvt);
00196             }
00197             
00198             ((Display) father.getComponent(0)).setNotSelected();// On désélectionne le symbole.
00199             if (count > 2) {
00200                 ((Display) father.getComponent(2)).deselect();// On désélectionne la borne inf.
00201                 if (count > 3) 
00202                     ((Display) father.getComponent(3)).deselect();// On désélectionne la borne sup.
00203             }
00204             
00205             // Comme pour la sélection, on contrôle la validité de la désélection.
00206             if (father.getParent() instanceof Display) {
00207                 father = (Display) father.getParent();
00208                 FormulaTreeStructure fts = (FormulaTreeStructure) father.getListener();
00209                 if (fts.getFather() != null)
00210                     ((DisplayLayout) father.getLayout()).validateDeselection(displayToLay);
00211             }
00212             // Hé oui, on contrôle la validité de la sélection... dans une désélection.
00213             // Toujours le même pb, est-ce que le nouvel état de la sélection (après
00214             // désélection donc) est syntaxiquement cohérent ?
00215             validateSelection();
00216             
00217             // On met à jour l'affichage.
00218             father.repaint();
00219         }        
00220     }
00221 
00227     public Dimension computeAttributes() {
00228         int ascent = 0;
00229         int descent = 0;
00230 
00231         updateLevel(displayToLay.getLevel());
00232 
00233         int width = 0;
00234         int height = 0;
00235         
00236         Display symbol, lower, expression, upper;
00237         int gap = 2;
00238         
00239         // On calcule la taille du symbole
00240         symbol = (Display) displayToLay.getComponent(0);
00241         symbol.setSize(symbol.getPreferredSize());
00242         
00243         // On calcule la taille de l'expression de la somme
00244         expression = (Display) displayToLay.getComponent(1);
00245         expression.setSize(expression.getPreferredSize());
00246         
00247         int width1 = symbol.getWidth();
00248         
00249         int count = displayToLay.getComponentCount();
00250         if (count > 2) {
00251             // On calcule la taille de la borne inférieure
00252             lower = (Display) displayToLay.getComponent(2);
00253             lower.setSize(lower.getPreferredSize());
00254             lower.setShiftY(symbol.getDescent() + lower.getAscent() + gap);
00255             
00256             width1 = Math.max(lower.getWidth(), width1);
00257             
00258             if (count > 3 ) {
00259                 // On calcule la taille de la borne supérieure
00260                 upper = (Display) displayToLay.getComponent(3);
00261                 upper.setSize(upper.getPreferredSize());
00262                 
00263                 width1 = Math.max(upper.getWidth(), width1);
00264             
00265                 upper.setShiftX(-(lower.getWidth() + upper.getWidth()) / 2);
00266                 upper.setShiftY(-(symbol.getAscent() + upper.getDescent() + gap));
00267                 
00268                 ascent = symbol.getAscent() + upper.getHeight() + gap;
00269             }
00270             else {
00271                 ascent = symbol.getAscent();
00272             }
00273             
00274             symbol.setShiftX((width1 - symbol.getWidth()) / 2);
00275             expression.setShiftX(gap + (width1 - symbol.getWidth())/2);
00276             
00277             lower.setShiftX(-(symbol.getWidth() + lower.getWidth())/2 - (expression.getWidth() + expression.getShiftX()));
00278             
00279             descent = symbol.getDescent() + lower.getHeight() + gap;
00280         }
00281         else {
00282             ascent = symbol.getAscent();
00283             descent = symbol.getDescent();
00284         }
00285                 
00286         displayToLay.setAscent(ascent);
00287         displayToLay.setDescent(descent);
00288         
00289         width += width1 + expression.getWidth() + 4*gap; // 1 gap entre symbole et expression, et 3 après expression  
00290         
00291         height += ascent + descent;
00292         displayToLay.setSize(width , height);
00293         
00294         displayToLay.setComputeAttributes(false);
00295         return new Dimension(width, height);
00296     }
00297     
00301     public void rebuildDisplay() {
00302         
00303         //Faudra faire ce qui faut !!!!
00304         
00305         // La taille des displays est probablement différente de ceux qui étaient
00306         // précédemment. On demande alors le recalcul des display ancêtres.
00307         displayToLay.computeAncestorsAttributes();
00308     }
00309    
00310 }