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.*;
   
   /***
   * This layout manager lays unary operators.
  *
  * @author © 1999 DIRAT Laurent
  * @version 2.0  14/12/1999
  */
  public abstract class UnaryOperatorLayout extends HorizontalLayout implements OperatorDisplayCreator {
      /***
      * 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
          //display.add(stringDisplay, stringDisplay, 0); 
          // A priori, display ne contient rien, donc un add(stringDisplay) 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 le display de l'opÈrateur ou si le display de l'opÈrande est
          // sÈlectionnÈ, on sÈlectionne tout le display.
          Display op = (Display) displayToLay.getComponent(0);
          Display opRand = (Display) displayToLay.getComponent(1);
          if (op.isSelected() || opRand.isSelected()) {
              displayToLay.select();
              // On purge la liste des ÈlÈments sÈlectionnÈs.
              selEvt.setAction(SelectionEvent.PURGE, null);
              displayToLay.fireSelectionEvent(selEvt);
              // On y ajoute l'instance dans la liste des sÈlectionnÈs
              selEvt.setAction(SelectionEvent.ADD, displayToLay);
              displayToLay.fireSelectionEvent(selEvt);
          }
          
          // On a vÈrifiÈ la validitÈ de la sÈlection de l'opÈrateur. On doit maitenant
          // la contrÙler au niveau supÈrieur, au niveau du pËre.
          Display display = displayToLay;
          if (displayToLay.getParent() instanceof Display) {
              display = (Display) displayToLay.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) {
          // father est le display de l'opÈrateur unaire.
          Display father = displayToLay;
          Display tmp;
          SelectionEvent selEvt = new SelectionEvent(father);
          
          // Si l'opÈrateur en entier est sÈlectionnÈ, il faut le dÈsÈlectionner
          if (father.isSelected()) {
              father.deselect();
              // On enlËve le display pËre de la liste des display sÈlectionnÈs.
              selEvt.setAction(SelectionEvent.REMOVE, father);
              father.fireSelectionEvent(selEvt);
             
             // 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();
     }
 }