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.*;
   
   /***
   * A layout manager that lays components for the variables of differentiation.<BR>
  * We assume the display laid out contains what should be a variable for the visualisation of a differentiation,
  * i.e. a variable (differentiation of first order) or a power of a variable (differentiation of higher order).<BR>
  * According to the type of differentiation, either the symbol "d" is added (differentiation) or the symbol delta (the
  * greek letter) is added (partial differentiation) to the display laid out, for correct rendering.
  *
  * @author © 1999 DIRAT Laurent
  * @version 2.0 15/10/1999
  */
  public class VarDiffLayout extends HorizontalLayout {
      /***
      * <CODE>true</CODE> if we are dealing with a partial derivative. <CODEW>false</CODE> otherwise.
      */
      private boolean isPartial;
      
      /***
      * The constructor.
      * @param isPartial <CODE>true</CODE> if we have a partial differentiation. <CODE>false</CODE> otherwise.
      */
      public VarDiffLayout(boolean isPartial) {
          this.isPartial = isPartial;
      }
      
      /***
      * 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);
  
          FormulaTreeStructure fts = (FormulaTreeStructure) this.displayToLay.getListener();
          
          Display d;
          // Si dÈriveÈ partielle, on ajoute un SymbolDisplay avec un delta. Sinon, un StringDisplay avec un "d"
          if (isPartial) {
              d = new SymbolDisplay(this.displayToLay.getGraphicContext(), new ImageSymbol("delta", this.displayToLay));
              // Le display est le display d'un opÈrateur (on peut le considÈrer comme tel)
              d.setIsSymbolOperatorDisplay(true);
          }
          else {
              d = new StringDisplay(this.displayToLay.getGraphicContext(), "d", true);
          }
          
          this.displayToLay.add(d, d, 0);
          
          // On met un listener au display du d/delta
          // 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.
          d.addControlListener(fts);
      }
      
      /***
      * Checks the validity of the selection.
      */
      public void validateSelection() {
          SelectionEvent selEvt = new SelectionEvent(displayToLay);
  
          // La validitÈ de la sÈlection est triviale.
          // Si un des displays est sÈlectionnÈ alors on sÈlectionne tout.
          Display d = (Display) displayToLay.getComponent(0);
          Display v = (Display) displayToLay.getComponent(1);
          if (d.isSelected() || v.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();
              //if (!(display.getListener() instanceof Formula))
              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;
         Display tmp;
         SelectionEvent selEvt = new SelectionEvent(father);
         
         // En fait, comme quand "d/delta" ou la variable (puissance ou pas) est sÈlectionnÈ on sÈlectionne tout,
         // quand on dÈsÈlectionne l'un ou l'autre, on dÈsÈlectionne tout.
         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();
                 //if (!(display.getListener() instanceof Formula))
                 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();
     }
 
 }