/*
    * Copyright (c) 2007 Creative Sphere Limited.
    * All rights reserved. This program and the accompanying materials
    * are made available under the terms of the Eclipse Public License v1.0
    * which accompanies this distribution, and is available at
    * http://www.eclipse.org/legal/epl-v10.html
    *
    * Contributors:
    *
   *   Creative Sphere - initial API and implementation
   *
   */
  package org.abstracthorizon.aequo.file;
  
  import java.io.File;
  import java.io.FileFilter;
  import java.io.IOException;
  import java.util.ArrayList;
  import java.util.Arrays;
  import java.util.HashMap;
  import java.util.HashSet;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Map;
  import java.util.Set;
  import java.util.regex.Pattern;
  
  import javax.swing.DefaultListSelectionModel;
  import javax.swing.ListSelectionModel;
  import javax.swing.event.ListDataEvent;
  import javax.swing.event.ListDataListener;
  import javax.swing.event.TableModelEvent;
  import javax.swing.event.TableModelListener;
  import javax.swing.table.TableModel;
  
  import org.abstracthorizon.aequo.CompareEntry;
  import org.abstracthorizon.aequo.CompareModel;
  import org.abstracthorizon.aequo.util.filters.Filter;
  
  /**
   * Files model.
   *
   * @author Daniel Sendula
   */
  public class FilesModel extends FileCompareEntry implements TableModel, CompareModel<File, FileCompareEntry> {
  
      /** Table change listeners */
      protected ArrayList<TableModelListener> tableListeners = new ArrayList<TableModelListener>();
  
      /** List change listeners */
      protected ArrayList<ListDataListener> listListeners = new ArrayList<ListDataListener>();
  
      /** Entry being processed (refreshed) listeners */
      protected ArrayList<RefreshListener> refreshListeners = new ArrayList<RefreshListener>();
  
      /** All visible entries */
      protected List<FileCompareEntry> visibleEntries = new ArrayList<FileCompareEntry>();
  
      /** Selection model */
      protected DefaultListSelectionModel selectionModel = new DefaultListSelectionModel();
  
      /** Slow down for debug flag */
      private static final boolean SLOWDOWN_FOR_DEBUG = false;
  
      /** Filters to be applied */
      protected Filter filter;
  
      /** Shell model automatically expand folder where there are differences */
      protected boolean expandDifferences = true;
      /**
       * Constructor
       * @param leftDir left dir
       * @param rightDir right dir
       */
      public FilesModel(File leftDir, File rightDir) {
          super(null, new File[]{leftDir, rightDir});
          filter = new Filter();
      }
  
      /**
       * Constructor
       * @param leftDir left dir
       * @param rightDir right dir
       * @param filter filters to be applied
       */
      public FilesModel(File leftDir, File rightDir, Filter filter) {
          super(null, new File[]{leftDir, rightDir});
          this.filter = filter;
      }
  
      /**
       * Returns left dir
       * @return left dir
       */
      public File getLeftFile() {
          return data[0];
      }
  
      /**
      * Returns right dir
      * @return right dir
      */
     public File getRightFile() {
         return data[1];
     }
 
     /**
      * Returns filters
      * @return filters
      */
     public Filter getFilter() {
         return filter;
     }
 
     /**
      * Sets filters filters. Note: this won't really refresh model - you need to call {@link #refresh()} method.
      * @param filter new filters
      */
     public void setFilter(Filter filter) {
         this.filter = filter;
     }
 
     /**
      * Returns <code>true</code> if model will automatically expand differences
      * @return <code>true</code> if model will automatically expand differences
      */
     public boolean isExpandDifferences() {
         return expandDifferences;
     }
 
     /**
      * Sets if model will automatically expand differences
      * @param expandDifferences should model automatically expand differences
      */
     public void setExpandDifferences(boolean expandDifferences) {
         this.expandDifferences = expandDifferences;
     }
 
     /**
      * Reads the model from the given dirs
      *
      * @throws IOException
      */
     public void refresh() {
         synchronized (visibleEntries) {
             visibleEntries.clear();
         }
         refresh(this, 1, false);
         if (children != null) {
             for (FileCompareEntry e : children) {
                 e.updateEntryStatus();
             }
             expand(this);
         }
         if (children != null) {
             for (FileCompareEntry e : children) {
                 refresh(e, 2, true);
             }
         }
         notifyRefreshListeners(null);
     }
 
     /**
      * Reads given entry
      * @param entry entry
      * @param level level
      * @param recursively shell it progress recursively
      */
     public void refresh(FileCompareEntry entry, int level, boolean recursively) {
         refreshRecursively(entry, level, recursively);
         if (expandDifferences && entry.hasChildren()) {
             expandChangedRecursively(entry);
         }
     }
 
     /**
      * Expands recursively all elements that have differences
      *
      * @param entry entry
      */
     protected void expandChangedRecursively(FileCompareEntry entry) {
         int i  = 0;
         boolean dontExpand = true;
         while (dontExpand && (i < entry.children.length)) {
             if (entry.children[i].getStatus(0) != CompareEntry.EQUAL) {
                 dontExpand = false;
             }
             i++;
         }
         if (!dontExpand) {
             expand(entry);
         }
         for (FileCompareEntry e : entry.children) {
             if (e.hasChildren()) {
                 expandChangedRecursively(e);
             }
         }
     }
 
     /**
      * Internal refresh method that goes through tree recursively (if <code>recursively</code>
      * is set).
      * @param entry entry
      * @param level level
      * @param recursively shell it progress recursively
      */
     protected void refreshRecursively(FileCompareEntry entry, int level, boolean recursively) {
         boolean hasChanges = false;
         Map<String, FileCompareEntry> entries = new HashMap<String, FileCompareEntry>();
         if (entry.children != null) {
             for (FileCompareEntry e : entry.children) {
                 File[] files = e.getData();
                 for (File f : files) {
                     if (f != null) {
                         entries.put(f.getName(), e);
                         break;
                     }
                 }
             }
         }
 
         File[] files = entry.getData();
         for (File dir : files) {
             if (dir.exists() && dir.isDirectory()) {
                 File[] fs = null;
                 if (filter.isEmpty()) {
                     fs = dir.listFiles();
                 } else {
                     fs = dir.listFiles(new FileFilter() {
                         protected Pattern p = filter.getRegExpPattern();
 
                         public boolean accept(File pathname) {
                             return !p.matcher(pathname.getName()).matches();
                         }
                     });
                 }
 
                 if ((fs != null) && (fs.length > 0)) {
                     for (File f : fs) {
                         String name = f.getName();
                         FileCompareEntry e = entries.get(name);
                         if ((e == null) && (entry.children != null)) {
                             for (int i = 0; (i < entry.children.length)
                                     && (e == null); i++) {
                                 if (name.equals(entry.children[i].getData(0)
                                         .getName())) {
                                     e = entry.children[i];
                                 }
                             }
                         }
                         if (e == null) {
                             File[] nfs = new File[files.length];
                             for (int i = 0; i < nfs.length; i++) {
                                 nfs[i] = new File(files[i], name);
                             }
                             e = new FileCompareEntry(entry, nfs, level);
                             // e.refreshStatus();
                             hasChanges = true;
                             entries.put(name, e);
                         } else {
                             boolean empty = true;
                             int i = 0;
                             File[] dfs = e.getData();
                             while (empty && i < dfs.length) {
                                 if (dfs[i].exists()) {
                                     empty = false;
                                 }
                                 i++;
                             }
                             if (empty) {
                                 entries.remove(e.getData(0).getName());
                                 hasChanges = true;
                             }
                         }
                     }
                 }
             }
         }
         Iterator<FileCompareEntry> it = entries.values().iterator();
         while (it.hasNext()) {
             FileCompareEntry e = it.next();
             boolean notExist = true;
             File[] fs = e.getData();
             int i = 0;
             while (notExist && (i < fs.length)) {
                 if (fs[i].exists()) {
                     notExist = false;
                 }
                 i++;
             }
             if (notExist) {
                 it.remove();
                 hasChanges = true;
             }
         }
 
         if (SLOWDOWN_FOR_DEBUG) {
             try {
                 Thread.sleep(50);
             } catch (Exception ignore) {
             }
         }
         if (hasChanges && entries.size() > 0) {
             notifyRefreshListeners(entry);
 
             entry.children = new FileCompareEntry[entries.size()];
 
             Set<String> set = entries.keySet();
             String[] names = new String[set.size()];
             names = set.toArray(names);
             Arrays.sort(names);
             int i = 0;
             for (String name : names) {
                 entry.children[i] = entries.get(name);
                 i++;
             }
             if (recursively) {
                 for (FileCompareEntry e : entry.children) {
                     refreshRecursively(e, level + 1, true);
                     if (SLOWDOWN_FOR_DEBUG) {
                         try {
                             Thread.sleep(50);
                         } catch (Exception ignore) {
                         }
                     }
                 }
             }
         }
         refreshVisible(entry, entries);
         entry.updateEntryStatus();
     }
 
     /**
      * Filters out existing entries with set filter
      */
     public void filterOut() {
         Pattern p = getFilter().getRegExpPattern();
         filterOut(this, p);
     }
 
     /**
      * Filters out existing entries with given regular expression
      * @param entry entry to start filtering out from
      * @param p pattern compiled from regular expression
      */
     protected void filterOut(FileCompareEntry entry, Pattern p) {
         FileCompareEntry[] children = entry.getChildren();
         if ((children != null) && (children.length > 0)) {
             int first = Integer.MAX_VALUE;
             int last = -1;
 
             boolean removed = false;
             ArrayList<FileCompareEntry> newChildren = new ArrayList<FileCompareEntry>(children.length);
             ArrayList<FileCompareEntry> removedChildren = new ArrayList<FileCompareEntry>();
             for (int i = 0; i < children.length; i++) {
                 FileCompareEntry c = children[i];
                 if (p.matcher(c.getData(0).getName()).matches()) {
                     removed = true;
                     if (c.index >= 0) {
                         removedChildren.add(c);
                         if (c.index < first) {
                             first =  c.index;
                         }
                     }
                 } else {
                     newChildren.add(c);
                 }
             }
             if (removed) {
                 if (removedChildren.size() > 0) {
                     FileCompareEntry lastEntry = removedChildren.get(removedChildren.size() - 1);
 
                     last = findMax(lastEntry);
                 }
 
                 FileCompareEntry[] nc = new FileCompareEntry[newChildren.size()];
                 nc = newChildren.toArray(nc);
                 entry.children = nc;
             }
             children = entry.getChildren();
             for (FileCompareEntry c : children) {
                 if (c.hasChildren()) {
                     filterOut(c, p);
                 }
             }
             if (removed && (last >= 0)) {
                 synchronized (visibleEntries) {
                     for (int i = removedChildren.size() - 1; i >= 0; i--) {
                         FileCompareEntry e  = removedChildren.get(i);
                         if (e.index >= 0) {
                             collapse(e);
                             visibleEntries.remove(e.index);
                         }
                     }
                 }
                 renumber(entry);
             }
             fireChange(TableModelEvent.DELETE, first, last);
         }
     }
 
     /**
      * Returns if entry is expanded or not
      * @param entry entry
      * @return <code>true</code> if entry is expanded
      */
     public boolean isExpanded(FileCompareEntry entry) {
         return (entry.hasChildren() && entry.getChildren()[0].getIndex() >= 0);
     }
 
     /**
      * Returns if entry is collapsed or not
      * @param entry entry
      * @return <code>true</code> if entry is collapsed
      */
     public boolean isCollapsed(FileCompareEntry entry) {
         return !entry.hasChildren() || (entry.hasChildren() && entry.getChildren()[0].getIndex() == -1);
     }
 
     /**
      * Refreshes visible entry for given entry
      *
      * @param entry
      */
     public void refreshVisible(FileCompareEntry entry, Map<String, FileCompareEntry> entries) {
         if ((entry.getIndex() >= 0) || (entry.getLevel() == 0)) {
             int firstChanged = -1;
             int lastChanged = -1;
 
             int level = entry.getLevel() + 1;
 
             boolean added = false;
             boolean removed = false;
             FileCompareEntry[] children = entry.getChildren();
 
             int i = entry.getIndex() + 1;
             int current = i;
             int p = 0;
 
             boolean loop = true;
             boolean changed;
 
             synchronized (visibleEntries) {
                 while (loop) {
                     changed = false;
                     if (i < visibleEntries.size()) {
                         FileCompareEntry e = visibleEntries.get(i);
                         if (e.getLevel() == level) {
                             if (!entries.containsValue(e)) {
                                 visibleEntries.remove(i);
                                 removed = true;
                                 changed = true;
                             } else {
                                 FileCompareEntry f = children[p];
                                 if (e != f) {
                                     visibleEntries.add(i, f);
                                     added = true;
                                     changed = true;
                                     i++;
                                 } else {
                                     // e == f
                                     i++;
                                 }
                                 p++;
                             }
                         } else {
                             if (children != null) {
                                 // e.getLevel() != level
                                 if (p >= children.length) {
                                     loop = false;
                                 } else {
                                     FileCompareEntry f = children[p];
                                     visibleEntries.add(i, f);
                                     added = true;
                                     changed = true;
                                     i++;
                                     p++;
                                 }
                             } else {
                                 loop = false;
                             }
                         }
                     } else {
                         if ((children != null) && (p < children.length)) {
                             FileCompareEntry e = children[p];
                             visibleEntries.add(e);
                             added = true;
                             changed = true;
                             p++;
                             if (p >= children.length) {
                                 loop = false;
                             }
                             i++;
                         } else {
                             loop = false;
                         }
                     }
                     if (changed) {
                         if (firstChanged < 0) {
                             firstChanged = current;
                         }
                         lastChanged = current;
                     }
                     current++;
                 } // loop
                 if (added || removed) {
                     renumber(entry);
                 }
             }
             if (added && removed) {
                 fireChange(TableModelEvent.UPDATE, firstChanged, lastChanged);
             } else if (added) {
                 fireChange(TableModelEvent.INSERT, firstChanged, lastChanged);
             } else if (removed) {
                 fireChange(TableModelEvent.DELETE, firstChanged, lastChanged);
             }
         }
     }
 
     /**
      * Expands given entry
      * @param entry entry
      */
     public void expand(FileCompareEntry entry) {
 
         if (entry.children != null) {
             synchronized (visibleEntries) {
                 int i = entry.index + 1;
                 int level = entry.getLevel() + 1;
                 for (FileCompareEntry e : entry.children) {
                     if (visibleEntries.size() > i) {
                         if (visibleEntries.get(i) != e) {
                             visibleEntries.add(i, e);
                         }
                     } else {
                         visibleEntries.add(e);
                     }
                     i++;
                 }
                 if (visibleEntries.size() > i) {
                     FileCompareEntry e = visibleEntries.get(i);
                     while ((e != null) && (e.getLevel() == level)) {
                         visibleEntries.remove(i);
                         if (visibleEntries.size() > i) {
                             e = visibleEntries.get(i);
                         } else {
                             e = null;
                         }
                     }
                 }
                 renumber(entry);
             }
             int first = entry.children[0].index;
             int last = first + entry.children.length - 1;
             fireChange(TableModelEvent.INSERT, first, last);
         }
     }
 
     /**
      * Expands given entry and all sub-entries
      * @param entry entry
      */
     public void expandAll(FileCompareEntry entry) {
         if (entry.hasChildren()) {
             expand(entry);
             for (FileCompareEntry e : entry.getChildren()) {
                 if (e.hasChildren()) {
                     expandAll(e);
                 }
             }
         }
     }
 
     /**
      * Collapses given entry
      * @param entry entry
      */
     public void collapse(FileCompareEntry entry) {
         if (entry.children != null) {
             int first = entry.index + 1;
             int last = 0;
             boolean notifyChange = false;
             synchronized (visibleEntries) {
                 if (first < visibleEntries.size()) {
                     int i = first;
                     FileCompareEntry e = visibleEntries.get(i);
                     while ((e != null) && (e.level > entry.level)) {
                         e.index = -1;
                         i++;
                         if (i < visibleEntries.size()) {
                             e = visibleEntries.get(i);
                         } else {
                             e = null;
                         }
                     }
                     last = i - 1;
                     for (i = last; i >= first; i--) {
                         visibleEntries.remove(i);
                     }
                     renumber(entry);
                     notifyChange = true;
                 }
             }
             if (notifyChange) {
                 fireChange(TableModelEvent.DELETE, first, last);
             }
         }
     }
 
     /**
      * Removes given entry
      * @param entry entry
      */
     public void remove(FileCompareEntry entry) {
         if (entry.index >= 0) {
             collapse(entry);
             int index = entry.index;
             synchronized (visibleEntries) {
                 visibleEntries.remove(entry.index);
 
                 FileCompareEntry parent = entry.parentEntry;
                 if (parent != null) {
                     if (parent.children.length == 1) {
                         parent.children = null;
                     } else {
                         FileCompareEntry[] newChildren = new FileCompareEntry[parent.children.length - 1];
                         int i = 0;
                         int j = 0;
                         while (i < parent.children.length) {
                             if (entry == parent.children[i]) {
                             } else {
                                 newChildren[j] = parent.children[i];
                                 j++;
                             }
                             i++;
                         }
                         parent.children = newChildren;
                     }
                     parent.updateEntryStatus();
                 }
 
                 renumber(entry);
                 entry.index = -1;
             }
             fireChange(TableModelEvent.DELETE, index, index);
         }
     }
 
     /**
      * Finds maximum index in entry and its all children
      * @param entry entry
      * @return maximum index of entry or all visible children
      */
     protected int findMax(FileCompareEntry entry) {
         if (entry.hasChildren()) {
             FileCompareEntry[] children = entry.getChildren();
             for (int i = children.length - 1; i >= 0; i--) {
                 if (children[i].index >= 0) {
                     return findMax(children[i]);
                 }
             }
         }
         return entry.index;
     }
 
     /**
      * Renumbers indexes of of entries from given entry
      * @param entry entry to start renumbering from
      */
     protected void renumber(FileCompareEntry entry) {
         for (int i = entry.index + 1; i < visibleEntries.size(); i++) {
             visibleEntries.get(i).index = i;
         }
     }
 
     /**
      * Adds refresh listener
      *
      * @param refreshListener listener
      * @see #refreshListeners
      */
     public void addRefreshListener(RefreshListener refreshListener) {
         refreshListeners.add(refreshListener);
     }
 
     /**
      * Removes refresh listener
      * @param refreshListener listener
      * @see #refreshListeners
      */
     public void removeRefreshListener(RefreshListener refreshListener) {
         refreshListeners.remove(refreshListener);
     }
 
     /**
      * Notifies all refresh listeners
      * @param entry entry that is being processes
      */
     protected void notifyRefreshListeners(FileCompareEntry entry) {
         for (RefreshListener refreshListener : refreshListeners) {
             refreshListener.currentlyProcessing(entry);
         }
     }
 
     /* CompareModel implementation */
 
     /**
      * Returns entry at given index
      * @return entry at given index
      */
     public FileCompareEntry get(int index) {
         synchronized (visibleEntries) {
             return visibleEntries.get(index);
         }
     }
 
     /**
      * Returns selection model
      * @return selection model
      */
     public ListSelectionModel getSelectionModel() {
         return selectionModel;
     }
 
     /**
      * Adds list change listener
      * @param l listener
      */
     public void addListDataListener(ListDataListener l) {
         listListeners.add(l);
     }
 
     /**
      * Removes listener
      * @param l listener
      */
     public void removeListDataListener(ListDataListener l) {
         listListeners.remove(l);
     }
 
     /**
      * Returns entry at given index
      * @return entry at given index
      */
     public synchronized Object getElementAt(int index) {
         synchronized (visibleEntries) {
             return visibleEntries.get(index);
         }
     }
 
     /**
      * Returns number of entries
      * @return number of entries
      */
     public synchronized int getSize() {
         synchronized (visibleEntries) {
             return visibleEntries.size();
         }
     }
 
     /* TableModel implementation */
 
     /**
      * Adds table model listener
      * @param l listener
      */
     public void addTableModelListener(TableModelListener l) {
         tableListeners.add(l);
     }
 
     /**
      * Removes table model listener
      * @param l listener
      */
     public void removeTableModelListener(TableModelListener l) {
         tableListeners.remove(l);
     }
 
     /**
      * Returns column class
      * @param columnIndex column index
      * @return column class. It really returns {@link FileCompareEntry} in all cases then index is less then 3.
      */
     public Class<?> getColumnClass(int columnIndex) {
         if (columnIndex < 3) {
             return FileCompareEntry.class;
         } else {
             return null;
         }
     }
 
     /**
      * Returns 3
      * @return 3
      */
     public int getColumnCount() {
         return 3;
     }
 
     /**
      * Returns column names
      * @param columnIndex column index
      */
     public String getColumnName(int columnIndex) {
         if (columnIndex == 0) {
             return "Name";
         } else if (columnIndex == 1) {
             return "Size";
         } else if (columnIndex == 2) {
             return "Modified";
         } else {
             return null;
         }
     }
 
     /**
      * Retruns row count - number of visible rows - number of elements in {@link #visibleEntries}.
      * @return row count
      */
     public synchronized int getRowCount() {
         synchronized (visibleEntries) {
             return visibleEntries.size();
         }
     }
 
     /**
      * Returns value at given row/column index
      * @param rowIndex row index
      * @param columnIndex column index
      * @return value at given row/column index
      */
     public synchronized Object getValueAt(int rowIndex, int columnIndex) {
         if (columnIndex < 3) {
             synchronized (visibleEntries) {
                 FileCompareEntry entry = (FileCompareEntry)visibleEntries.get(rowIndex);
                 return entry;
             }
         } else {
             return null;
         }
     }
 
     /**
      * Returns <code>false</code>
      * @param rowIndex row index
      * @param columnIndex column index
      * @return <code>false</code>
      */
     public boolean isCellEditable(int rowIndex, int columnIndex) {
         return false;
     }
 
     /**
      * Does nothing
      * @param value value
      * @param rowIndex row index
      * @param columnIndex column index
      */
     public void setValueAt(Object value, int rowIndex, int columnIndex) {
     }
 
     /**
      * Fires contents changed event for given entry
      *
      * @param entry entry
      */
     protected void contentsChanged(FileCompareEntry entry) {
         fireChange(TableModelEvent.UPDATE, entry.index, entry.index); // TODO and all children if available
     }
 
     /**
      * Fires contents added event for given entry
      *
      * @param entry entry
      */
     protected void intervalAdded(FileCompareEntry entry) {
         fireChange(TableModelEvent.INSERT, entry.index, entry.index); // TODO and all children if available
     }
 
     /**
      * Fires contents removed event for given entry
      *
      * @param entry entry
      */
     protected void intervalRemoved(FileCompareEntry entry) {
         fireChange(TableModelEvent.DELETE, entry.index, entry.index); // TODO and all children if available
     }
 
     /**
      * Fires contents changed event for entries in given interval
      * @param start starting index
      * @param end ending index
      */
     public void notifyOfChange(int start, int end) {
         fireChange(TableModelEvent.UPDATE, start, end);
     }
 
     /**
      * Fires contents removed event for entries in given interval
      * @param start starting index
      * @param end ending index
      */
     public void notifyOfRemoved(int start, int end) {
         fireChange(TableModelEvent.DELETE, start, end);
     }
 
     /**
      * Fires contents changed inserted for entries in given interval
      * @param start starting index
      * @param end ending index
      */
     public void notifyOfInserted(int start, int end) {
         fireChange(TableModelEvent.INSERT, start, end);
     }
 
     /**
      * Fires change of given type and interval
      * @param type type of change as in {@link TableModelEvent#getType()}
      * @param start starting index
      * @param end ending index
      */
     protected void fireChange(int type, int start, int end) {
         if (tableListeners.size() > 0) {
             TableModelEvent event = new TableModelEvent(this, start, end, TableModelEvent.ALL_COLUMNS, type);
             for (TableModelListener listener : tableListeners) {
                 listener.tableChanged(event);
             }
         }
 
         if (listListeners.size() > 0) {
             ListDataEvent event = null;
             if (type == TableModelEvent.UPDATE) {
                 event = new ListDataEvent(this, ListDataEvent.CONTENTS_CHANGED, start, end);
             } else if (type == TableModelEvent.INSERT) {
                 event = new ListDataEvent(this, ListDataEvent.INTERVAL_ADDED, start, end);
             } else if (type == TableModelEvent.DELETE) {
                 event = new ListDataEvent(this, ListDataEvent.INTERVAL_REMOVED, start, end);
             }
             for (ListDataListener listener : listListeners) {
                 if (type == TableModelEvent.UPDATE) {
                     listener.contentsChanged(event);
                 } else if (type == TableModelEvent.INSERT) {
                     listener.intervalAdded(event);
                 } else if (type == TableModelEvent.DELETE) {
                     listener.intervalRemoved(event);
                 }
             }
         }
     }
 
     /**
      * Method that is called by entries of the model notifying of change of the index. It delays
      * before notifying listeners as these changes can be too frequent
      *
      * @param index index
      */
     protected void notifyEntryChanged(int index) {
 //        notifyOfChange(index, index);
         delayedEventThread.notifyOfChange(index);
     }
 
     // TODO This thread must be stopped when window is disposed!!!
     /** Thread to be used for delayed events */
     protected DelayedEventThread delayedEventThread = new DelayedEventThread();
 
     /**
      * Delayed event notifying thread.
      */
     protected class DelayedEventThread implements Runnable {
 
         /** Indexes of which listeners are to be notified of. */
         protected Set<Integer> indexes = new HashSet<Integer>();
 
         /** Thread's state */
         boolean triggered = false;
 
         /** Thread object itself */
         protected Thread thread;
 
         /**
          * Constructor. It creates and starts the daemon thread
          */
         public DelayedEventThread() {
             thread = new Thread(this);
             thread.setDaemon(true);
             thread.start();
         }
 
         /**
          * Method to be called from outside of this object to trigger
          * the notification cycle.
          *
          * @param index index to be passed to the listeners
          */
         public synchronized void notifyOfChange(int index) {
             indexes.add(index);
             if (!triggered) {
                 triggered = true;
                 notify();
             }
         }
 
         /**
          * Main method that has two states:
          * <ul>
          *   <li><b>triggered</b> - thread that waits for 300ms before notifying the listeners</li>
          *   <li><b>not triggered</b> - sleeping and waiting for the trigger</li>
          * </ul>
          *
          */
         public synchronized void run() {
             while (true) {
                 while (!triggered) {
                     try {
                         wait();
                     } catch (InterruptedException ignore) {
                     }
                 }
                 try {
                     wait(300);
                 } catch (InterruptedException ignore) {
                 }
                 for (int index : indexes) {
                     FilesModel.this.notifyOfChange(index, index);
                 }
                 indexes.clear();
                 triggered = false;
             }
         }
     }
 
     /**
      * Interface to be implemented by refresh listeners
      */
     public interface RefreshListener {
 
         /**
          * Invoked for each entry that is being processed. It is invoked only for
          * folders and not files
          * @param entry entry that is being processed
          */
         public void currentlyProcessing(FileCompareEntry entry);
     }
 }