package fr.ove.openmath.jome.ctrlview.bidim;
   
   import java.awt.*;
   import fr.ove.openmath.jome.ctrlview.bidim.*;
   import fr.ove.openmath.jome.ctrlview.bidim.selection.events.SelectionEvent;
   import fr.ove.openmath.jome.model.*;
   import fr.ove.utils.FontInfo;
   
   /***
  * Layout manager that lays the display of an operator whose symbol is superposed to its operand.
  *
  * @author © 1999 DIRAT Laurent
  * @version 2.0 15/12/1999
  */
  public abstract class SuperposedOperatorLayout extends VerticalCenteredLayout implements OperatorDisplayCreator {
      /***
      * 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() {
          // C'est strictement la mÍme chose, sauf que VerticalCenteredLayout place l'ascent comme Ètant la moitiÈ
          // de la hauteur du display. Or dans le cas qui nous occupe, l'ascent du display doit ce trouver sur celui
          // de l'opÈrande
          Dimension dim = super.computeAttributes();
      
          displayToLay.setAscent(((Display) displayToLay.getComponent(0)).getShiftY() +
                    ((Display) displayToLay.getComponent(0)).getHeight() + 
                    ((Display) displayToLay.getComponent(1)).getShiftY() +
                    ((Display) displayToLay.getComponent(1)).getAscent());
                    
          displayToLay.setDescent(displayToLay.getHeight() - displayToLay.getAscent());
      
          return dim;
      }
      
      /***
      * 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);
          
          // On rÈcupËre le fts associÈ (listener) au display.
          FormulaTreeStructure fts = (FormulaTreeStructure) displayToLay.getListener();
          
          Display displayOperator = createOperatorDisplay();
          
          // On met un listener ? l'opÈrateur.
          // 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.
          displayOperator.addControlListener(fts);
          
          // On ajoute le display d'opÈrateur en premiËre position
          // A priori, display ne contient rien, donc un add(displayOperator) suffit.
          this.displayToLay.add(displayOperator);
          
          this.displayToLay.computeAncestorsAttributes();
      }
      
      /***
      * Checks the validity of the selection.
      */
      public void validateSelection() {
          SelectionEvent selEvt = new SelectionEvent(displayToLay);
  
          // La validitÈ de la sÈlection est triviale.
          // Si l'opÈrateur est slÈectionnÈ, alors on sÈlectionne tout.
          Display displayOperator = (Display) displayToLay.getComponent(0);
          if (displayOperator.isSelected()) {
              // SÈlectionne le display.
              displayToLay.select();
              // On purge la liste des ÈlÈments sÈlectionnÈs.
              selEvt.setAction(SelectionEvent.PURGE, null);
              displayToLay.fireSelectionEvent(selEvt);
              // On y ajoute os parenthËses
              selEvt.setAction(SelectionEvent.ADD, displayToLay);
              displayToLay.fireSelectionEvent(selEvt);
          }
  
          // On a vÈrifiÈ la validitÈ de la sÈlection de la puissance. On doit maitenant
          // la contrÙler au niveau supÈrieur, au niveau du pËre.
          Display display = displayToLay;
          if (display.getParent() instanceof Display) {
              display = (Display) display.getParent();
              FormulaTreeStructure fts = (FormulaTreeStructure) display.getListener();
              if (fts.getFather() != null)
                  ((DisplayLayout) display.getLayout()).validateSelection();
          }
  
         // On met ? jour l'affichage.
         display.repaint();
     }
     
     /***
     * Checks the validity of the deselection.
     * @param display the display to deselect.
     */
     public void validateDeselection(Display display) {
         Display father = displayToLay;
         SelectionEvent selEvt = new SelectionEvent(father);
         
         // Si l'opÈrateur est sÈlectionnÈ, alors il faut le dÈselectionner.
         if (father.isSelected()) {
             father.setNotSelected();
             // On enlËve le display pËre de la liste des display sÈlectionnÈs.
             selEvt.setAction(SelectionEvent.REMOVE, father);
             father.fireSelectionEvent(selEvt);
             
             Display displayOperator = (Display) displayToLay.getComponent(0);
             Display argument = (Display) displayToLay.getComponent(1);
             
             if (display == displayOperator) {
                 displayOperator.setNotSelected();
                 selEvt.setAction(SelectionEvent.ADD, argument);
                 father.fireSelectionEvent(selEvt);
             }
             else {
                 displayOperator.setNotSelected();
                 argument.deselect();
             }
 
             // Comme pour la sÈlection, on contrÙle la validitÈ de la dÈsÈlection.
             if (father.getParent() instanceof Display) {
                 father = (Display) father.getParent();
                 FormulaTreeStructure fts = (FormulaTreeStructure) father.getListener();
                 if (fts.getFather() != null)
                     ((DisplayLayout) father.getLayout()).validateDeselection(displayToLay);
             }
             
             // HÈ oui, on contrÙle la validitÈ de la sÈlection... dans une dÈsÈlection.
             // Toujours le mÍme pb, est-ce que le nouvel Ètat de la sÈlection (aprËs
             // dÈsÈlection donc) est syntaxiquement cohÈrent ?
             validateSelection();
             
             // On met ? jour l'affichage.
             father.repaint();
         }        
 
     }
     
     /***
     * 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();
     }
 }