package fr.ove.openmath.jome.ctrlview.bidim;
   
   import java.awt.*;
   import java.util.*;
   import fr.ove.openmath.jome.ctrlview.bidim.*;
   import fr.ove.openmath.jome.model.*;
   
   /***
   * A layout manager that lays components horizontally and inserts between
  * them, the display of the operator that the layout manager lays.
  *
  * @author © 1999 DIRAT Laurent
  * @version 2.0  13/12/1999
  */
  public abstract class InfixOperatorLayout extends HorizontalLayout implements OperatorDisplayCreator {    
      /***
      * Do we need to insert an operator display ?
      */
      protected boolean insertOperatorDisplay = true;
      
      /***
      * The number of the components already present before an other insertion
      * or removal. This is necessary to keep in mind this, in order to know if 
      * we must parse the list of components to check if we have to insert symbol
      * display or not.
      */
      protected int prevNbComponent = 0;
      
      /***
      * Inserts a display of the operator symbol that the display
      * laid by the instance represents.
      */
      protected void insertOperatorDisplay() {
          Display current, next, displayOperator;
          FormulaTreeStructure fatherFts = (FormulaTreeStructure) displayToLay.getListener();
          FormulaTreeStructure fts;
          int nbComponent = displayToLay.getComponentCount();
          
          // On parcourre tous les components prÈsents dans le display.
          for (int i = 1; i < nbComponent; i++) {
              // la rÈfÈrence sur le component courant
              current = (Display) displayToLay.getComponent(i - 1);
              // la rÈfÈrence sur le suivant
              next = (Display) displayToLay.getComponent(i);
              
              // Si le courant est un display d'opÈrateur alors on continue
              if (current.isSymbolOperatorDisplay())
                  continue;
                  
              // Si le suivant n'est pas un display d'opÈrateur alors 2 cas
              if (!next.isSymbolOperatorDisplay()) {
                  // On ajoute un display d'opÈrateur.
                  displayOperator = createOperatorDisplay();
                  displayToLay.add(displayOperator, displayOperator, i);
                  
                  // 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(fatherFts);
                  i++;
                  nbComponent++;
              }
          }
          
          // Mise ? jour des rangs des displays
          displayToLay.adjustRank();
          // Mise ? jour du nombre de components prÈsents dans le display.
          prevNbComponent = displayToLay.getComponentCount();
          // On n'a plus besoin d'insÈrer des displays d'opÈrateur.
          insertOperatorDisplay = false;
          // On fait en sorte que la mise ? niveau des displays (opÈrateurs) soit faite.
          displayToLay.setUpdateLevel(true);
          // On a rajoutÈ un display, on demande le recalcul de tous les ancÍtres
          // de l'instance.
          displayToLay.computeAncestorsAttributes();
      }
      
      /***
      * 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() {
          // On regarde si le nombre de component dans le display a changÈ depuis
          // la derniËre fois. Si oui, il faut contrÙler s'il ne faut pas ajouter
          // des display d'opÈrateur.
          if (insertOperatorDisplay || (prevNbComponent != displayToLay.getComponentCount()))
              insertOperatorDisplay();
              
          return super.computeAttributes();
      }
          
      /***
      * The display needs to be rebuilt. We do this.
     */
     public void rebuildDisplay() {
         Display tmp;
         int nbDisplay = ((FormulaTreeStructure) displayToLay.getListener()).getNbChildren();
         Display listDisplay[] = new Display[nbDisplay];
         
         int count = displayToLay.getComponentCount();
         for (int i = 0; i < count; i++) {
             tmp = (Display) displayToLay.getComponent(i);
             if (!tmp.isSymbolOperatorDisplay()) {
                 // A voir !!!!!
                 // Mais il semblerai que bon, sinon ? la (re)construction du display il se base
                 // sur des anciennes valeurs, et donc pas terrible niveau affichage.
                 tmp.setLocation(0, 0);
                 listDisplay[((FormulaTreeStructure) tmp.getListener()).getRank()] = tmp;
             }
         }
         
         // ATTENTION : ici, on enlËve les displays fils de display, mais on ne les enlËve pas de la liste
         // des listeners de la fts qu'il sont en train d'Ècouter. Exception faite pour les displays d'opÈrateur.
         displayToLay.removeAllDisplays();
                 
         for (int i = 0; i < nbDisplay; i++)
             displayToLay.add(listDisplay[i]);
             
         // On a reconstruit le display, il faut maintenant insÈrer les displays d'opÈrateur.
         insertOperatorDisplay = true;
         
         // 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();
     }
 }