package fr.ove.openmath.jome.ctrlview.bidim;
   
   import java.awt.*;
   import java.util.*;
   import fr.ove.openmath.jome.ctrlview.bidim.Display;
   import fr.ove.openmath.jome.ctrlview.bidim.DisplayLayout;
   import fr.ove.openmath.jome.ctrlview.bidim.selection.events.SelectionEvent;
   import fr.ove.openmath.jome.model.*;
   import fr.ove.utils.FontInfo;
  
  /***
  * Temporaire
  *
  * @author © 1999 DIRAT Laurent
  * @version 2.0 06/09/1999
  */
  public class IntervalLayout extends EnclosingLayout {
      /***
      * According to the operator, the layout manager has to add some components (e.g. brackets, ...)
      * or has to perform some "re-oganisation" before rendering.<BR>
      * As soon as the layout manager is set to the display, this mehtod MUST be called with the display laid out
      * as parameter. This method serves as well as a registering method. So all sub-classes of the instance MUST
      * call super.initDisplay(displayToLay).
      * @param displayToLay the display laid by the instance
      */
      public void initDisplay(Display displayToLay) {
          super.initDisplay(displayToLay);  // Par cet appel, on ajoute dans displayToLay les crochets
          // On va maintenant y rajouter un display, dans lequel on va mettre les displays correspondants
          // aux bornes de l'intervalle, display ? qui on va affecter un SeparatorOperatorLayout, qui va se charger
          // d'afficher entre chacun des ÈlÈments une virgule (un sÈparateur)
          Display boundsDisplay = new BidimDisplay(displayToLay.getGraphicContext());
          // On met un listener ? boundsDisplay
          // En fait, il n'y en a pas besoin, dans le sens o? il n'y a pas spÈcifiquement de fts qui
          // Ècoute le comportement de ce display. NÈanmoins, il s'avËre nÈcessaire qu'il en ait
          // un, par exemple lors de l'iconification, car c'est le display qui reÁoit la demande
          // d'iconification qui envoie l'ÈvÈnement correspondant ? la FTS. Or si ce display n'a pas
          // d'Ècouteur, alors pb. Par cohÈrence, l'Ècouteur du display d'opÈrateur, est le fts qui
          // reprÈsente cette opÈration. Par contre, la fts en question, n'Ècoute pas le display
          // d'opÈrateur.
          boundsDisplay.addControlListener((FormulaTreeStructure) displayToLay.getListener());
          
          SeparatorOperatorLayout layout = new SeparatorOperatorLayout();
          layout.initDisplay(boundsDisplay);
          boundsDisplay.setLayout(layout);
          
          // On l'ajoute comme fils ? display
          this.displayToLay.add(boundsDisplay);
      }
      
      /***
      * Returns the opening
      */
      public SymbolDisplay createOpening() {
          // On rÈcupËre le fts associÈ (listener) au display.
          KaryOperator fts = (KaryOperator) displayToLay.getListener();
          
          SymbolDisplay bracket = new SymbolDisplay(displayToLay.getGraphicContext(), 
                                                    new SquaredBracketSymbol(fts.getTheOperator(), displayToLay));            
          // Le display de l'accolade est le display d'un opÈrateur (on peut le considÈrer comme tel)
          bracket.setIsSymbolOperatorDisplay(true);
          
          return bracket;
      }
      
      /***
      * Returns the closing
      */
      public SymbolDisplay createClosing() {
          // On rÈcupËre le fts associÈ (listener) au display.
          KaryOperator fts = (KaryOperator) displayToLay.getListener();
          
          SymbolDisplay bracket = new SymbolDisplay(displayToLay.getGraphicContext(), 
                                                    new SquaredBracketSymbol(fts.getEnding(), displayToLay));            
          // Le display de l'accolade est le display d'un opÈrateur (on peut le considÈrer comme tel)
          bracket.setIsSymbolOperatorDisplay(true);
          
          return bracket;
      }    
      
      /***
      * Computes the size of the display according to its children size (if any),
      * and its different attributes.
      * @return the size of the display.
      */
      public Dimension computeAttributes() {
          Display display = null;
          
          if (displayToLay.getComponentCount() > 3) {
              Display boundsDisplay = (Display) displayToLay.getComponent(2);
              Display d;
              for (int i = 3; i < displayToLay.getComponentCount(); ) {
                  d = (Display) displayToLay.getComponent(i);
                  // elementsDisplay.add(d) appelle un displayToLay.remove(d).
                  // remove(d), enlËve Ègalement d de la liste des listeners de l'objet (fts) qu'il Ècoutait.
                  // Ce qu'on ne veut pas, puisqu'il s'agit d'un simple dÈplacement de display. 
                  d.setDoRemoveFromListListeners(false);
                  boundsDisplay.add(d);
                  // On remet le comportement de suppression par dÈfault.
                  d.setDoRemoveFromListListeners(true);
             }
         }
         
         SymbolDisplay leftBracket = (SymbolDisplay) displayToLay.getComponent(0);
         SquaredBracketSymbol leftSymbol = (SquaredBracketSymbol) leftBracket.getSymbol();
         SymbolDisplay rightBracket = (SymbolDisplay) displayToLay.getComponent(1);
         SquaredBracketSymbol rightSymbol = (SquaredBracketSymbol) rightBracket.getSymbol();
         
         // On met la hauteur ? 0, pour que dans tous les cas, le super.computeAttributes() ne soit pas
         // biaisÈe par une Èventuelle nouvelle taille des ÈlÈments qui composent la liste.
         // Comme c'est plus loin qu'on leur fixe la taille....
         leftSymbol.setHeight(0);
         rightSymbol.setHeight(0);
         
         Dimension dim = super.computeAttributes();
         
         // Par contre, par rapport ? comment est calculÈe la taille des accolades, dim comprend
         // dÈj? la taille des accolades
         int ascent = displayToLay.getAscent();
         int descent = displayToLay.getDescent();
         int height =  displayToLay.getHeight();
         int thickness = FontInfo.getLineThickness(displayToLay, displayToLay.getFont());
         
         leftSymbol.setAscent(ascent);
         leftSymbol.setDescent(descent);
         leftSymbol.setHeight(height);
         leftSymbol.setThickness(thickness);
         leftBracket.setComputeAttributes(true);
         leftBracket.invalidate();
         leftBracket.setSize(leftBracket.getPreferredSize());
 
         rightSymbol.setAscent(ascent);
         rightSymbol.setDescent(descent);
         rightSymbol.setHeight(height);
         rightSymbol.setThickness(thickness);
         rightBracket.setComputeAttributes(true);
         rightBracket.invalidate();
         rightBracket.setSize(rightBracket.getPreferredSize());
         
         // Cette taille l? correspond au dÈcalage qu'il faut appliquer ? la derniËre accolade
         rightBracket.setShiftX(dim.width - 2*rightBracket.getWidth());
         // Mais il faut l'enlever au premier terme de la liste qui doit Ítre contre la premiËre
         // accolade (because HonrizontalLayout)
         ((Display) displayToLay.getComponent(2)).setShiftX(-rightBracket.getShiftX() - rightBracket.getWidth());
         
         return dim;
     }
     
     /***
     * The display needs to be rebuilt. We do this.
     */
     public void rebuildDisplay() {
         // La taille des displays est probablement diffÈrente de ceux qui Ètaient
         // prÈcÈdemment. On demande alors le recalcul des display ancÍtres.
         displayToLay.computeAncestorsAttributes();
     }
    
 }