/*
    * Copyright 1999-2006 Faculty of Mathematics, Physics and Informatics, Comenius
    * University, Bratislava. This file is protected by the Mozilla Public License
    * version 1.1 (the License); you may not use this file except in compliance
    * with the License. You may obtain a copy of the License at
    * http://euromath2.sourceforge.net/license.html Unless required by applicable
    * law or agreed to in writing, software distributed under the License is
    * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
    * KIND, either express or implied. See the License for the specific language
   * governing permissions and limitations under the License.
   */
  package sk.uniba.euromath.editor.xmlEditor.viewers;
  
  import java.util.ArrayList;
  import java.util.List;
  import java.util.Set;
  
  import org.eclipse.gef.EditPart;
  import org.eclipse.gef.ui.parts.ScrollingGraphicalViewer;
  
  import sk.baka.ikslibs.ids.IDManager;
  import sk.baka.ikslibs.interval.DOMIntervalSet;
  import sk.uniba.euromath.document.XMLAccess;
  import sk.uniba.euromath.editor.selections.DOMSelectionChangedEvent;
  import sk.uniba.euromath.editor.selections.IDOMSelectionChangedListener;
  import sk.uniba.euromath.editor.xmlEditor.IXMLEditPart;
  import sk.uniba.euromath.editor.xmlEditor.IdVisualInfo;
  import sk.uniba.euromath.editor.xmlEditor.XMLEditDomain;
  import sk.uniba.euromath.editor.xmlEditor.XMLEditPartFactory;
  import sk.uniba.euromath.editor.xmlEditor.XMLEditor;
  
  /***
   * Scrolling graphical viewer capable of performing selections over XML.
   * Selection object is {@link DOMIntervalSet}.
   * 
   * @author Martin Kollar
   */
  public class XMLScrollingGraphicalViewer extends ScrollingGraphicalViewer
                  implements IXMLGraphicalViewer {
  
          private List<IDOMSelectionChangedListener> selectionChangedListeners = new ArrayList<IDOMSelectionChangedListener>();
  
          /***
           * Guards selection listening. Prevents event-listen loops. Can listen
           * only when equals zero.
           */
          private int canSelectionChangeListen = 0;
  
          /***
           * Local selection for this viewer.
           */
          protected DOMIntervalSet selection = new DOMIntervalSet();
  
          /***
           * Associated editor.s
           */
          private XMLEditor editor;
  
          /***
           * Contructor.
           * 
           * @param editor
           *                XMLEditor that uses this GraphicalViewer
           */
          public XMLScrollingGraphicalViewer(XMLEditor editor) {
                  super();
                  this.editor = editor;
          }
  
          /***
           * @param listener
           *                new listener to be add from selectionChangedListeners
           */
          public void addSelectionChangedListener(
                          IDOMSelectionChangedListener listener) {
                  if (!(this.selectionChangedListeners.contains(listener)))
                          this.selectionChangedListeners.add(listener);
          }
  
          /***
           * @param listener
           *                listener to be removed from selectionChangedListeners
           */
          public void removeSelectionChangedListener(
                          IDOMSelectionChangedListener listener) {
                  this.selectionChangedListeners.remove(listener);
          }
  
          /***
           * @return globalSelection
           */
          public DOMIntervalSet getDOMSelection() {
                  return this.editor.getDOMSelection();
          }
  
          /***
           * Deselects editparts with Ids, that were in previous selection and
           * select editparts that are in DOMIntervalSet and sends this selection
           * to IDOMSelectionListeners
          * 
          * @param selection
          *                DOMIntervalSet containing DOMInetervals, that have to
          *                be selected
          */
         public void setSelection(DOMIntervalSet selection) {
                 // compute what should be deselected, what selected, and what
                 // remains selected as is
                 DOMIntervalSet noChange = new DOMIntervalSet(this.selection).intersect(selection, null);
                 DOMIntervalSet deselect = new DOMIntervalSet(this.selection).subtract(noChange, null);
                 DOMIntervalSet select = new DOMIntervalSet(selection).subtract(noChange, null);
 
                 IdVisualInfo visualInfo = ((XMLEditPartFactory) getEditPartFactory())
                                 .getVisualInfo();
 
                 // deselect
                 Set<IXMLEditPart> deselectParts = visualInfo
                                 .getVisualParts(deselect
                                                 .getContentIds(getIDManager()));
                 for (IXMLEditPart editPart : deselectParts)
                         deselect(editPart);
 
                 // select
                 Set<IXMLEditPart> selectParts = visualInfo.getVisualParts(select
                                 .getContentIds(getIDManager()));
                 for (IXMLEditPart editPart : selectParts)
                         select(editPart);
 
                 this.selection = selection;
                 // fire selection change event
                 fireSelectionChanged();
         }
 
         /***
          * Selection changed in some synchronized selection provider.
          * Synchronize selection - set in this viewer same selection.
          * 
          * @param event
          *                DOMSelectionChangedEvent that contains source of new
          *                selection, that should be some XMLEditor and
          *                DOMIntervalSet as selection
          */
         public void selectionChanged(DOMSelectionChangedEvent event) {
                 // guards listening
                 if (this.canSelectionChangeListen != 0)
                         return;
                 setSelection(event.getDOMSelection());
         }
 
         /***
          * Stops listening to selection change events.
          */
         protected void stopSelectionListening() {
                 this.canSelectionChangeListen++;
         }
 
         /***
          * Starts listening to selection change events.
          */
         protected void startSelectionListening() {
                 if (this.canSelectionChangeListen == 0)
                         throw new IllegalArgumentException();
                 this.canSelectionChangeListen--;
         }
 
         /***
          * Fires event to listeners when selection was changed.
          */
         @Override
         protected void fireSelectionChanged() {
                 // stop listening to avoid to receive by loop own event
                 stopSelectionListening();
                 DOMSelectionChangedEvent event = new DOMSelectionChangedEvent(
                                 this, this.selection);
                 for (IDOMSelectionChangedListener listener : this.selectionChangedListeners)
                         listener.selectionChanged(event);
                 startSelectionListening();
         }
 
         /***
          * Selects editpart.
          * 
          * @param editpart
          *                EditPart that is going to be selected
          */
         @SuppressWarnings("unchecked")
         @Override
         public void select(EditPart editpart) {
                 // super.select(editpart);
                 editpart.setSelected(EditPart.SELECTED);
 
                 if (!(primGetSelectedEditParts().contains(editpart))) {
                         primGetSelectedEditParts().add(editpart);
                         // editpart.showSourceFeedback(new SelectionRequest());
                 }
 
         }
 
         /***
          * Deselects edit part.
          * 
          * @param editpart
          *                EditPart that is going to be deselected
          */
         @Override
         public void deselect(EditPart editpart) {
                 // super.deselect(editpart);
                 editpart.setSelected(EditPart.SELECTED_NONE);
 
                 if (primGetSelectedEditParts().contains(editpart)) {
                         primGetSelectedEditParts().remove(editpart);
                 }
 
         }
 
         /***
          * Helper getter.
          * 
          * @return IDManager instance
          */
         protected IDManager getIDManager() {
                 return ((XMLEditDomain) getEditDomain()).getXMLEditor()
                                 .getXMLAccess().getIDManager();
         }
 
         /***
          * Helper getter.
          * 
          * @return XMLAccess instance
          */
         protected XMLAccess getXMLAccess() {
                 return ((XMLEditDomain) getEditDomain()).getXMLEditor()
                                 .getXMLAccess();
         }
 }