/*
    * $Id$
    *
    * The contents of this file are subject to 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://www.mozilla.org/MPL/ 
    *
    * Software distributed under the License is distributed on an "AS IS" basis, 
   * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License 
   * for the specific language governing rights and limitations under the License.
   *
   * The Original Code is XML Hammer code. (org.xmlhammer.*)
   *
   * The Initial Developer of the Original Code is Edwin Dankert. Portions created 
   * by the Initial Developer are Copyright (C) 2005 - 2006 the Initial Developer. 
   * All Rights Reserved.
   *
   * Contributor(s): Edwin Dankert <edankert@gmail.com>
   */
  package org.xmlhammer.gui;
  
  import java.util.ArrayList;
  
  import javax.swing.event.ChangeEvent;
  import javax.swing.event.ChangeListener;
  import javax.swing.event.EventListenerList;
  import javax.swing.undo.CompoundEdit;
  import javax.swing.undo.UndoManager;
  import javax.swing.undo.UndoableEdit;
  
  import org.apache.log4j.Logger;
  
  public class ProjectUndoManager extends UndoManager {
      private static final long serialVersionUID = -4923400585127602904L;
      private EventListenerList listeners = null;
  
      private UndoableEdit mark = null;
      private UndoManager discardableUndoManager = null;
      private ArrayList<CompoundEdit> compounds = null;
  
      private boolean undoing = false;
      private boolean redoing = false;
      
      public ProjectUndoManager() {
          listeners = new EventListenerList();
          compounds = new ArrayList<CompoundEdit>();
          
          discardableUndoManager = new UndoManager();
      }
  
      @Override
      public boolean addEdit(UndoableEdit edit) {
          boolean result = false;
          
          if (!undoing && !redoing) {
              if (compounds.size() == 0) {
                  Logger.getLogger(getClass()).debug("addEdit("+edit+")");
      
                  discardableUndoManager.discardAllEdits();
                  
                  result = super.addEdit(edit);
                  
                  fireStateChanged();
              } else {
                  result = compounds.get(compounds.size()-1).addEdit( edit);
              }
          }
          
          return result;
      }
      
      public boolean addDiscardableEdit(UndoableEdit edit) {
          boolean result = false;
          
          if (!undoing && !redoing) {
              result = discardableUndoManager.addEdit(edit);
              fireStateChanged();
          }
          
          return result;
      }
  
      @Override
      public void undo() {
          undoing = true;
  
          if (discardableUndoManager.canUndo()) {
              discardableUndoManager.undo();
          } else {
              super.undo();
          }
  
          fireStateChanged();
          undoing = false;
      }
  
      public void startCompound() {
          if (!undoing && !redoing) {
             compounds.add(new CompoundEdit());
         }
     }
 
     public void endCompound() {
         if (compounds.size() > 0) {
             CompoundEdit edit = compounds.remove(compounds.size()-1);
             edit.end();
             
             if (compounds.size() > 0) {
                 compounds.get(compounds.size()-1).addEdit(edit);
             } else {
                 addEdit(edit);
             }
         }
     }
 
     public void discardCompound() {
         if (compounds.size() > 0) {
             compounds.remove(compounds.size()-1);
         }
     }
 
     public boolean isCompound() {
         return compounds.size() > 0;
     }
 
     @Override
     public void redo() {
         redoing = true;
 
         if (discardableUndoManager.canRedo()) {
             discardableUndoManager.redo();
         } else {
             super.redo();
         }
 
         fireStateChanged();
         redoing = false;
     }
     
     public void mark() {
         mark = editToBeUndone();
     }
     
     public boolean isMark() {
         if (!discardableUndoManager.canUndo()) {
             return mark == editToBeUndone();
         }
         
         return false;
     }
     
     public void addChangeListener(ChangeListener listener) {
         listeners.add( ChangeListener.class, listener);
     }
 
     public void removeChangeListener(ChangeListener listener) {
         listeners.remove( ChangeListener.class, listener);
     }
 
     public synchronized boolean canUndo() {
         return discardableUndoManager.canUndo() || super.canUndo();
     }
 
     public synchronized boolean canRedo() {
         return discardableUndoManager.canRedo() || super.canRedo();
     }
     
     public synchronized void discardDiscardableEdits() {
         discardableUndoManager.discardAllEdits();
 
         fireStateChanged();
     }
     
     public synchronized void discardAllEdits() {
         discardableUndoManager.discardAllEdits();
         super.discardAllEdits();
         compounds.clear();
         
         fireStateChanged();
     }
 
     protected void fireStateChanged() {
         // Guaranteed to return a non-null array
         Object[] list = listeners.getListenerList();
         
         // Process the listeners last to first, notifying
         // those that are interested in this event
         for ( int i = list.length-2; i >= 0; i -= 2) {
             if ( list[i] == ChangeListener.class) {
                 ((ChangeListener)list[i+1]).stateChanged( new ChangeEvent( this));
             }
         }
     }
 }