/* (c) Copyright 2003 Caleigo AB, All rights reserved. 
    * 
    * This library is free software; you can redistribute it and/or
    * modify it under the terms of the GNU Lesser General Public
    * License as published by the Free Software Foundation; either
    * version 2.1 of the License, or (at your option) any later version.
    * 
    * This library is distributed in the hope that it will be useful,
    * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   * 
   * You should have received a copy of the GNU Lesser General Public
   * License along with this library; if not, write to the Free Software
   * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
   *  
   */
  package org.caleigo.core.event;
  
  /*** The CELEventMulticaster uses a variation of the multi caster design used
   * in java.awt package by the AWTEventMulticaster. 
   *
   * @author  Dennis Zikovic
   * @version 1.00
   *
   *//* 
   *
   * WHEN        WHO               WHY & WHAT
   * -----------------------------------------------------------------------------
   * 2001-10-25  Dennis Zikovic    Creation
   */
  public final class CELEventMulticaster implements 
          IEntityListener, 
          IEntityChangeListener, 
          ISelectionListener, 
          IQualifierListener, 
          IProxyListener
  {
      // Data members ------------------------------------------------------------
      private final ICELEventListener first;
      private final ICELEventListener second;
      
      // Static methods ----------------------------------------------------------
      public static ICELEventListener add(ICELEventListener listener1, ICELEventListener listener2)
      {
  	if(listener1==null)  
              return listener2;
          else if(listener2==null)  
              return listener1;
          else
              return new CELEventMulticaster(listener1, listener2);
      }
      
      public static ICELEventListener remove(ICELEventListener existing, ICELEventListener toBeRemoved)
      {
          if(existing==toBeRemoved)
              return null;
          else if(existing instanceof CELEventMulticaster)
              return ((CELEventMulticaster)existing).removeListener(toBeRemoved);
          else
              return existing;            
      }
      
      // Constructors ------------------------------------------------------------
      
      /*** Creates new CELEventMulticaster. Note private scope.
       */
      private CELEventMulticaster(ICELEventListener listener1, ICELEventListener listener2) 
      {
          first = listener1;
          second = listener2;
      }
      
      // IEntityListener implementation ------------------------------------------
      public void storePerformed(EntityEvent event)
      {
          ((IEntityListener)first).storePerformed(event);
          ((IEntityListener)second).storePerformed(event);
      }
      
      public void deletePerformed(EntityEvent event)
      {
          ((IEntityListener)first).deletePerformed(event);
          ((IEntityListener)second).deletePerformed(event);
      }
      
      public void refreshPerformed(EntityEvent event)  
      {
          ((IEntityListener)first).refreshPerformed(event);
          ((IEntityListener)second).refreshPerformed(event);
      }
          
      // IEntityChangeListener implementation ------------------------------------
      public void dataChanged(EntityChangeEvent event)
      {
          ((IEntityChangeListener)first).dataChanged(event);
          ((IEntityChangeListener)second).dataChanged(event);
      }
      
     public void statusChanged(EntityChangeEvent event)
     {
         ((IEntityChangeListener)first).statusChanged(event);
         ((IEntityChangeListener)second).statusChanged(event);
     }
     
     // IEntityCollectionListener implementation --------------------------------
     
     /*** Called when an unspecified change of the content or order of the
      * entities in the observed ISelection object has occured.
      */
     public void contentsChanged(SelectionEvent event)
     {
         ((ISelectionListener)first).contentsChanged(event);
         ((ISelectionListener)second).contentsChanged(event);
     }
     
     /*** Call when a single entity in the observed ISelection object has been
      * added.
      */
     public void entityAdded(SelectionEvent event)
     {
         ((ISelectionListener)first).entityAdded(event);
         ((ISelectionListener)second).entityAdded(event);
     }
     
     /*** Call when a single entity in the observed ISelection object has been
      * removed.
      */
     public void entityRemoved(SelectionEvent event)
     {
         ((ISelectionListener)first).entityRemoved(event);
         ((ISelectionListener)second).entityRemoved(event);
     }
     
     // IQualifierListener implemntation ----------------------------------------
     
     /*** Called whenever the structure of a qualifier has changed.
      * Typically this is when a CompositeQualifier has had change in the
      * contained Qualifier list.
      */
     public void structureChanged(QualifierEvent event)
     {
         ((IQualifierListener)first).structureChanged(event);
         ((IQualifierListener)second).structureChanged(event);
     }
     
     /*** Called whenever the content of a qualifier has changed.
      * Typically this is when a RelationQualifier has had change in it's
      * data content.
      */
     public void contentChanged(QualifierEvent event)
     {
         ((IQualifierListener)first).contentChanged(event);
         ((IQualifierListener)second).contentChanged(event);
     }
     
     // IProxyListener implemntation --------------------------------------------
     
     /*** Called when the remote object that have changed been replaced by
      * another object or been set to null.
      */
     public void remoteChanged(ProxyEvent event)
     {
         ((IProxyListener)first).remoteChanged(event);
         ((IProxyListener)second).remoteChanged(event);
     }
     
     /*** Called when the remote object that have changes state from a
      * placeholder to an actual object.
      */
     public void remoteExpanded(ProxyEvent event)
     {
         ((IProxyListener)first).remoteExpanded(event);
         ((IProxyListener)second).remoteExpanded(event);
     }
     
     // Action methods ----------------------------------------------------------
     private ICELEventListener removeListener(ICELEventListener listener)
     {
         // Check for internal match.
 	if(listener==first)  
             return second;
         else if(listener==second)  
             return first;
         
         // Else recurse and check children.
         ICELEventListener newFirst = CELEventMulticaster.remove(first, listener);
         ICELEventListener newSecond = CELEventMulticaster.remove(second, listener);
         if(first!=newFirst || second!=newSecond)
             return CELEventMulticaster.add(newFirst, newSecond);
         else
             return this; 
     }
 }