/projects/rssowl-2.0.5/org.rssowl.ui/src/org/rssowl/ui/internal/views/explorer/BookMarkContentProvider.java

/*   **********************************************************************  **

 **   Copyright notice                                                       **

 **                                                                          **

 **   (c) 2005-2009 RSSOwl Development Team                                  **

 **   http://www.rssowl.org/                                                 **

 **                                                                          **

 **   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.rssowl.org/legal/epl-v10.html                               **

 **                                                                          **

 **   A copy is found in the file epl-v10.html and important notices to the  **

 **   license from the team is found in the textfile LICENSE.txt distributed **

 **   in this package.                                                       **

 **                                                                          **

 **   This copyright notice MUST APPEAR in all copies of the file!           **

 **                                                                          **

 **   Contributors:                                                          **

 **     RSSOwl Development Team - initial API and implementation             **

 **                                                                          **

 **  **********************************************************************  */



package org.rssowl.ui.internal.views.explorer;



import org.eclipse.core.runtime.Assert;

import org.eclipse.jface.viewers.ISelection;

import org.eclipse.jface.viewers.ITreeContentProvider;

import org.eclipse.jface.viewers.StructuredSelection;

import org.eclipse.jface.viewers.TreeViewer;

import org.eclipse.jface.viewers.Viewer;

import org.rssowl.core.persist.IBookMark;

import org.rssowl.core.persist.IEntity;

import org.rssowl.core.persist.IFolder;

import org.rssowl.core.persist.IFolderChild;

import org.rssowl.core.persist.IMark;

import org.rssowl.core.persist.INews;

import org.rssowl.core.persist.INewsBin;

import org.rssowl.core.persist.ISearchMark;

import org.rssowl.core.persist.dao.DynamicDAO;

import org.rssowl.core.persist.dao.IBookMarkDAO;

import org.rssowl.core.persist.dao.INewsBinDAO;

import org.rssowl.core.persist.event.BookMarkEvent;

import org.rssowl.core.persist.event.BookMarkListener;

import org.rssowl.core.persist.event.FolderEvent;

import org.rssowl.core.persist.event.FolderListener;

import org.rssowl.core.persist.event.MarkEvent;

import org.rssowl.core.persist.event.NewsAdapter;

import org.rssowl.core.persist.event.NewsBinEvent;

import org.rssowl.core.persist.event.NewsBinListener;

import org.rssowl.core.persist.event.NewsEvent;

import org.rssowl.core.persist.event.NewsListener;

import org.rssowl.core.persist.event.SearchMarkEvent;

import org.rssowl.core.persist.event.SearchMarkListener;

import org.rssowl.core.persist.reference.FeedLinkReference;

import org.rssowl.core.persist.service.PersistenceException;

import org.rssowl.core.util.CoreUtils;

import org.rssowl.ui.internal.Controller;

import org.rssowl.ui.internal.EntityGroup;

import org.rssowl.ui.internal.util.JobRunner;



import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collection;

import java.util.Collections;

import java.util.HashMap;

import java.util.HashSet;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.Map.Entry;



/**

 * @author bpasero

 */

public class BookMarkContentProvider implements ITreeContentProvider {



  /* Delay in ms before updating Selection on Events */

  private static final int SELECTION_DELAY = 20;



  /* Listener */

  private FolderListener fFolderListener;

  private BookMarkListener fBookMarkListener;

  private NewsBinListener fNewsBinListener;

  private SearchMarkListener fSearchMarkListener;

  private NewsListener fNewsListener;



  /* Viewer Related */

  private IFolder fInput;

  private TreeViewer fViewer;

  private BookMarkFilter fBookmarkFilter;

  private BookMarkGrouping fBookmarkGrouping;



  /* Misc. */

  private IBookMarkDAO fBookMarkDAO = DynamicDAO.getDAO(IBookMarkDAO.class);



  /*

   * @see org.eclipse.jface.viewers.IStructuredContentProvider#getElements(java.lang.Object)

   */

  public Object[] getElements(Object inputElement) {

    if (inputElement instanceof IFolder) {

      IFolder rootFolder = (IFolder) inputElement;



      /* No Grouping */

      if (!fBookmarkGrouping.isActive()) {

        Collection<IFolderChild> elements = rootFolder.getChildren();



        /* Return Children */

        return elements.toArray();

      }



      /* Grouping Enabled */

      List<IMark> marks = new ArrayList<IMark>();

      getAllMarks(rootFolder, marks);



      return fBookmarkGrouping.group(marks);

    }



    return new Object[0];

  }



  /*

   * @see org.eclipse.jface.viewers.ITreeContentProvider#getChildren(java.lang.Object)

   */

  public Object[] getChildren(Object parentElement) {



    /* Return Children of Folder */

    if (parentElement instanceof IFolder) {

      IFolder parent = (IFolder) parentElement;

      Collection<IFolderChild> children = parent.getChildren();



      return children.toArray();

    }



    /* Return Children of Group */

    else if (parentElement instanceof EntityGroup) {

      List<IEntity> children = ((EntityGroup) parentElement).getEntities();

      return children.toArray();

    }



    return new Object[0];

  }



  /*

   * @see org.eclipse.jface.viewers.ITreeContentProvider#getParent(java.lang.Object)

   */

  public Object getParent(Object element) {



    /* Handle Grouping specially */

    if (fBookmarkGrouping.isActive() && element instanceof IEntity) {

      IEntity entity = (IEntity) element;

      EntityGroup[] groups = fBookmarkGrouping.group(Collections.singletonList(entity));

      if (groups.length == 1)

        return groups[0];

    }



    /* Grouping not enabled */

    else {



      /* Parent Folder of Folder */

      if (element instanceof IFolder) {

        IFolder folder = (IFolder) element;

        return folder.getParent();

      }



      /* Parent Folder of Mark */

      else if (element instanceof IMark) {

        IMark mark = (IMark) element;

        return mark.getParent();

      }

    }



    return null;

  }



  /*

   * @see org.eclipse.jface.viewers.ITreeContentProvider#hasChildren(java.lang.Object)

   */

  public boolean hasChildren(Object element) {

    if (element instanceof IFolder) {

      IFolder folder = (IFolder) element;

      return folder.getChildren().size() > 0;

    }



    else if (element instanceof EntityGroup)

      return ((EntityGroup) element).size() > 0;



    return false;

  }



  /*

   * @see org.eclipse.jface.viewers.IContentProvider#dispose()

   */

  public void dispose() {

    unregisterListeners();

  }



  /*

   * @see org.eclipse.jface.viewers.IContentProvider#inputChanged(org.eclipse.jface.viewers.Viewer,

   * java.lang.Object, java.lang.Object)

   */

  public void inputChanged(Viewer viewer, Object oldInput, Object newInput) {

    Assert.isTrue(newInput instanceof IFolder || newInput == null);

    fViewer = (TreeViewer) viewer;

    fInput = (IFolder) newInput;



    /* Register Listeners if Input is available */

    if (newInput != null && oldInput == null)

      registerListeners();



    /* If new Input is NULL, unregister Listeners */

    else if (newInput == null && oldInput != null)

      unregisterListeners();

  }



  /* The ContentProvider needs to know about this Filter */

  void setBookmarkFilter(BookMarkFilter bookmarkFilter) {

    fBookmarkFilter = bookmarkFilter;

  }



  /* The ContentProvider needs to know about this Grouping */

  void setBookmarkGrouping(BookMarkGrouping bookmarkGrouping) {

    fBookmarkGrouping = bookmarkGrouping;

  }



  private void registerListeners() {



    /* Folder Listener */

    fFolderListener = new FolderListener() {



      /* Folders got updated */

      public void entitiesUpdated(final Set<FolderEvent> events) {

        JobRunner.runInUIThread(fViewer.getControl(), new Runnable() {

          public void run() {

            Set<IFolder> updatedFolders = null;

            Map<IFolder, IFolder> reparentedFolders = null;



            /* Retrieve Updated Folders */

            for (FolderEvent event : events) {

              if (event.isRoot()) {



                /* Folder got reparented */

                if (event.getOldParent() != null) {

                  if (reparentedFolders == null)

                    reparentedFolders = new HashMap<IFolder, IFolder>();

                  reparentedFolders.put(event.getEntity(), event.getOldParent());

                }



                /* Normal Update */

                else {

                  if (updatedFolders == null)

                    updatedFolders = new HashSet<IFolder>();

                  updatedFolders.add(event.getEntity());

                }

              }

            }



            /* Event not interesting for us or we are disposed */

            if (updatedFolders == null && reparentedFolders == null)

              return;



            /* Ask Filter */

            if (fBookmarkFilter.needsRefresh(IFolder.class, events))

              fViewer.refresh(false);



            /* Ask Group */

            else if (fBookmarkGrouping.needsRefresh(IFolder.class))

              fViewer.refresh(false);



            /* Handle reparented Folders */

            else if (reparentedFolders != null) {

              Set<Entry<IFolder, IFolder>> entries = reparentedFolders.entrySet();

              Set<IFolder> parentsToUpdate = new HashSet<IFolder>();

              List<Object> expandedElements = new ArrayList<Object>(Arrays.asList(fViewer.getExpandedElements()));

              try {

                fViewer.getControl().getParent().setRedraw(false);

                for (Entry<IFolder, IFolder> entry : entries) {

                  IFolder reparentedFolder = entry.getKey();

                  IFolder oldParent = entry.getValue();



                  /* Reparent while keeping the Selection / Expansion */

                  ISelection selection = fViewer.getSelection();

                  boolean expand = expandedElements.contains(reparentedFolder);

                  fViewer.remove(oldParent, new Object[] { reparentedFolder });

                  fViewer.refresh(reparentedFolder.getParent(), false);

                  fViewer.setSelection(selection);



                  if (expand)

                    fViewer.setExpandedState(reparentedFolder, expand);



                  /* Remember to update parents */

                  parentsToUpdate.add(oldParent);

                  parentsToUpdate.add(reparentedFolder.getParent());

                }

              } finally {

                fViewer.getControl().getParent().setRedraw(true);

              }



              /* Update old Parents of Reparented Bookmarks */

              for (IFolder folder : parentsToUpdate)

                updateFolderAndParents(folder);

            }



            /* Handle Updated Folders */

            if (updatedFolders != null) {

              for (IFolder folder : updatedFolders) {

                if (fInput.equals(folder))

                  fViewer.refresh(fInput);

                else

                  fViewer.refresh(folder);

              }

            }

          }

        });

      }



      /* Folders got deleted */

      public void entitiesDeleted(final Set<FolderEvent> events) {

        JobRunner.runInUIThread(fViewer.getControl(), new Runnable() {

          public void run() {



            /* Retrieve Removed Folders */

            Set<IFolder> removedFolders = null;

            for (FolderEvent event : events) {

              if (event.isRoot() && event.getEntity().getParent() != null) {

                if (removedFolders == null)

                  removedFolders = new HashSet<IFolder>();

                removedFolders.add(event.getEntity());

              }

            }



            /* Event not interesting for us or we are disposed */

            if (removedFolders == null || removedFolders.size() == 0)

              return;



            /* Ask Filter */

            if (fBookmarkFilter.needsRefresh(IFolder.class, events))

              fViewer.refresh(false);



            /* Ask Group */

            else if (fBookmarkGrouping.needsRefresh(IFolder.class))

              fViewer.refresh(false);



            /* React normally then */

            else

              fViewer.remove(removedFolders.toArray());



            /* Update Read-State counters on Parents */

            if (!fBookmarkGrouping.isActive()) {

              for (FolderEvent event : events) {

                IFolder eventParent = event.getEntity().getParent();

                if (eventParent != null && eventParent.getParent() != null)

                  updateFolderAndParents(eventParent);

              }

            }

          }

        });

      }



      /* Folders got added */

      public void entitiesAdded(final Set<FolderEvent> events) {

        JobRunner.runInUIThread(SELECTION_DELAY, fViewer.getControl(), new Runnable() {

          public void run() {



            /* Reveal and Select added Folders */

            final List<IFolder> addedFolders = new ArrayList<IFolder>();

            for (FolderEvent folderEvent : events) {

              IFolder addedFolder = folderEvent.getEntity();

              if (addedFolder.getParent() != null)

                addedFolders.add(addedFolder);

            }



            if (addedFolders.size() == 1)

              fViewer.setSelection(new StructuredSelection(addedFolders), true);

          }

        });

      }

    };



    /* BookMark Listener */

    fBookMarkListener = new BookMarkListener() {



      /* BookMarks got Updated */

      public void entitiesUpdated(final Set<BookMarkEvent> events) {

        onMarksUpdated(events);

      }



      /* BookMarks got Deleted */

      public void entitiesDeleted(final Set<BookMarkEvent> events) {

        onMarksRemoved(events);

      }



      /* BookMarks got Added */

      public void entitiesAdded(Set<BookMarkEvent> events) {

        onMarksAdded(events);

      }

    };



    /* SearchMark Listener */

    fSearchMarkListener = new SearchMarkListener() {



      /* SearchMarks got Updated */

      public void entitiesUpdated(final Set<SearchMarkEvent> events) {

        onMarksUpdated(events);

      }



      /* SearchMarks got Deleted */

      public void entitiesDeleted(final Set<SearchMarkEvent> events) {

        onMarksRemoved(events);

      }



      /* SearchMarks got Added */

      public void entitiesAdded(Set<SearchMarkEvent> events) {

        onMarksAdded(events);

      }



      /* SearchMark result changed */

      public void resultsChanged(final Set<SearchMarkEvent> events) {

        JobRunner.runInUIThread(fViewer.getControl(), new Runnable() {

          public void run() {



            /* Ask Filter for a refresh */

            if (fBookmarkFilter.needsRefresh(ISearchMark.class, events, true))

              fViewer.refresh(false);



            /* Update SearchMarks */

            Set<ISearchMark> updatedSearchMarks = new HashSet<ISearchMark>(events.size());

            for (SearchMarkEvent event : events) {

              updatedSearchMarks.add(event.getEntity());

            }



            fViewer.update(updatedSearchMarks.toArray(), null);



            /* Update Parents */

            for (ISearchMark searchMark : updatedSearchMarks)

              updateFolderAndParents(searchMark.getParent());

          }

        });

      }

    };



    /* NewsBin Listener */

    fNewsBinListener = new NewsBinListener() {



      /* NewsBins got Updated */

      public void entitiesUpdated(final Set<NewsBinEvent> events) {

        onMarksUpdated(events);

      }



      /* NewsBins got Deleted */

      public void entitiesDeleted(final Set<NewsBinEvent> events) {

        onMarksRemoved(events);

      }



      /* Newsbins got Added */

      public void entitiesAdded(Set<NewsBinEvent> events) {

        onMarksAdded(events);

      }

    };



    /* News Listener */

    fNewsListener = new NewsAdapter() {



      @Override

      public void entitiesAdded(final Set<NewsEvent> events) {

        JobRunner.runInUIThread(fViewer.getControl(), new Runnable() {

          public void run() {



            /* Return on Shutdown */

            if (Controller.getDefault().isShuttingDown())

              return;



            /* Ask Filter */

            if (fBookmarkFilter.needsRefresh(INews.class, events))

              fViewer.refresh(false);



            /* Ask Group */

            else if (fBookmarkGrouping.needsRefresh(INews.class))

              fViewer.refresh(false);



            /* Updated affected Types on read-state if required */

            if (requiresUpdate(events))

              updateParents(events);

          }

        });

      }



      @Override

      public void entitiesUpdated(final Set<NewsEvent> events) {

        JobRunner.runInUIThread(fViewer.getControl(), new Runnable() {

          public void run() {



            /* Return on Shutdown */

            if (Controller.getDefault().isShuttingDown())

              return;



            /* Ask Filter */

            if (fBookmarkFilter.needsRefresh(INews.class, events))

              fViewer.refresh(false);



            /* Ask Group */

            else if (fBookmarkGrouping.needsRefresh(INews.class))

              fViewer.refresh(false);



            /* Updated affected Types on read-state if required */

            if (requiresUpdate(events))

              updateParents(events);

          }

        });

      }

    };



    /* Register Listeners */

    DynamicDAO.addEntityListener(IFolder.class, fFolderListener);

    DynamicDAO.addEntityListener(IBookMark.class, fBookMarkListener);

    DynamicDAO.addEntityListener(INewsBin.class, fNewsBinListener);

    DynamicDAO.addEntityListener(ISearchMark.class, fSearchMarkListener);

    DynamicDAO.addEntityListener(INews.class, fNewsListener);

  }



  private void onMarksAdded(Set<? extends MarkEvent> events) {



    /* Reveal and Select if single Entity added */

    if (events.size() == 1) {

      final MarkEvent event = events.iterator().next();

      JobRunner.runInUIThread(fViewer.getControl(), new Runnable() {

        public void run() {

          expand(event.getEntity().getParent());

        }

      });

    }

  }



  private void onMarksRemoved(final Set<? extends MarkEvent> events) {

    if (events.isEmpty())

      return;



    JobRunner.runInUIThread(fViewer.getControl(), new Runnable() {

      public void run() {



        /* Retrieve Removed Marks */

        Class<? extends IMark> clazz = null;

        Set<IMark> removedMarks = null;

        for (MarkEvent event : events) {

          if (event.isRoot()) {

            if (removedMarks == null)

              removedMarks = new HashSet<IMark>();

            removedMarks.add(event.getEntity());

          }



          if (clazz == null)

            clazz = event.getEntity().getClass();

        }



        /* Event not interesting for us or we are disposed */

        if (removedMarks == null || removedMarks.size() == 0)

          return;



        /* Ask Filter */

        if (fBookmarkFilter.needsRefresh(clazz, events))

          fViewer.refresh(false);



        /* Ask Group */

        else if (fBookmarkGrouping.needsRefresh(clazz))

          fViewer.refresh(false);



        /* React normally then */

        else

          fViewer.remove(removedMarks.toArray());



        /* Update Read-State counters on Parents */

        if (!fBookmarkGrouping.isActive()) {

          for (MarkEvent event : events) {

            IFolder eventParent = event.getEntity().getParent();

            if (eventParent != null && eventParent.getParent() != null)

              updateFolderAndParents(eventParent);

          }

        }

      }

    });

  }



  private void onMarksUpdated(final Set<? extends MarkEvent> events) {

    if (events.isEmpty())

      return;



    JobRunner.runInUIThread(fViewer.getControl(), new Runnable() {

      public void run() {

        Class<? extends IMark> clazz = null;

        Set<IMark> updatedMarks = null;

        Map<IMark, IFolder> reparentedMarks = null;



        /* Retrieve Updated Marks */

        for (MarkEvent event : events) {

          if (event.isRoot()) {

            IFolder oldParent = event.getOldParent();



            /* Mark got reparented */

            if (oldParent != null) {

              if (reparentedMarks == null)

                reparentedMarks = new HashMap<IMark, IFolder>();

              reparentedMarks.put(event.getEntity(), oldParent);

            }



            /* Normal Update */

            else {

              if (updatedMarks == null)

                updatedMarks = new HashSet<IMark>();

              updatedMarks.add(event.getEntity());

            }

          }



          if (clazz == null)

            clazz = event.getEntity().getClass();

        }



        /* Event not interesting for us or we are disposed */

        if (updatedMarks == null && reparentedMarks == null)

          return;



        /* Ask Filter */

        if (fBookmarkFilter.needsRefresh(clazz, events))

          fViewer.refresh(false);



        /* Ask Group */

        else if (fBookmarkGrouping.needsRefresh(clazz))

          fViewer.refresh(false);



        /* Handle reparented Marks */

        else if (reparentedMarks != null) {

          Set<Entry<IMark, IFolder>> entries = reparentedMarks.entrySet();

          Set<IFolder> parentsToUpdate = new HashSet<IFolder>();

          try {

            fViewer.getControl().getParent().setRedraw(false);

            for (Entry<IMark, IFolder> entry : entries) {

              IMark reparentedMark = entry.getKey();

              IFolder oldParent = entry.getValue();



              /* Reparent while keeping the Selection */

              ISelection selection = fViewer.getSelection();

              fViewer.remove(oldParent, new Object[] { reparentedMark });

              fViewer.refresh(reparentedMark.getParent(), false);

              fViewer.setSelection(selection);



              /* Remember to update parents */

              parentsToUpdate.add(oldParent);

              parentsToUpdate.add(reparentedMark.getParent());

            }

          } finally {

            fViewer.getControl().getParent().setRedraw(true);

          }



          /* Update old Parents of Reparented Marks */

          for (IFolder folder : parentsToUpdate)

            updateFolderAndParents(folder);

        }



        /* Handle Updated Marks */

        if (updatedMarks != null)

          fViewer.update(updatedMarks.toArray(), null);

      }

    });

  }



  private void unregisterListeners() {

    DynamicDAO.removeEntityListener(IFolder.class, fFolderListener);

    DynamicDAO.removeEntityListener(IBookMark.class, fBookMarkListener);

    DynamicDAO.removeEntityListener(INewsBin.class, fNewsBinListener);

    DynamicDAO.removeEntityListener(ISearchMark.class, fSearchMarkListener);

    DynamicDAO.removeEntityListener(INews.class, fNewsListener);

  }



  /* Update Entities that are affected by the given NewsEvents */

  private void updateParents(final Set<NewsEvent> events) {

    INewsBinDAO newsBinDao = DynamicDAO.getDAO(INewsBinDAO.class);



    /* Group by Feed and Bins */

    Set<FeedLinkReference> affectedFeeds = new HashSet<FeedLinkReference>();

    Set<IFolder> affectedBinFolders = new HashSet<IFolder>();

    Set<Long> handledBins = new HashSet<Long>();

    for (NewsEvent event : events) {

      INews news = event.getEntity();

      long parentId = news.getParentId();

      if (parentId != 0) {

        if (!handledBins.contains(parentId)) {

          INewsBin bin = newsBinDao.load(parentId);

          if (bin != null) //Could have been deleted meanwhile

            affectedBinFolders.add(bin.getParent());

          handledBins.add(parentId);

        }

      } else

        affectedFeeds.add(news.getFeedReference());

    }



    /* Return on Shutdown */

    if (Controller.getDefault().isShuttingDown())

      return;



    /* Update related Entities */

    for (FeedLinkReference feedRef : affectedFeeds)

      updateParents(feedRef);



    for (IFolder folder : affectedBinFolders)

      updateFolderAndParents(folder);

  }



  private void updateParents(FeedLinkReference feedRef) throws PersistenceException {



    /* Collect all affected BookMarks */

    Collection<IBookMark> affectedBookMarks = fBookMarkDAO.loadAll(feedRef);



    /* Return on Shutdown */

    if (Controller.getDefault().isShuttingDown())

      return;



    /* Update them including Parents */

    updateMarksAndParents(affectedBookMarks);

  }



  private void updateMarksAndParents(Collection<IBookMark> bookmarks) {

    Set<IEntity> entitiesToUpdate = new HashSet<IEntity>();

    entitiesToUpdate.addAll(bookmarks);



    /* Collect parents */

    for (IBookMark bookmark : bookmarks) {

      List<IFolder> visibleParents = new ArrayList<IFolder>();

      collectParents(visibleParents, bookmark);



      entitiesToUpdate.addAll(visibleParents);



      /* Return on Shutdown */

      if (Controller.getDefault().isShuttingDown())

        return;

    }



    /* Update Entities */

    fViewer.update(entitiesToUpdate.toArray(), null);

  }



  private void collectParents(List<IFolder> parents, IEntity entity) {



    /* Determine Parent Folder */

    IFolder parent = null;

    if (entity instanceof IMark)

      parent = ((IMark) entity).getParent();

    else if (entity instanceof IFolder)

      parent = ((IFolder) entity).getParent();



    /* Root reached */

    if (parent == null)

      return;



    /* Input reached */

    if (fInput.equals(parent))

      return;



    /* Check parent visible */

    parents.add(parent);



    /* Recursively collect visible parents */

    collectParents(parents, parent);

  }



  private void updateFolderAndParents(IFolder folder) {

    Set<IEntity> entitiesToUpdate = new HashSet<IEntity>();

    entitiesToUpdate.add(folder);



    /* Collect parents */

    List<IFolder> parents = new ArrayList<IFolder>();

    collectParents(parents, folder);

    entitiesToUpdate.addAll(parents);



    /* Return on Shutdown */

    if (Controller.getDefault().isShuttingDown())

      return;



    /* Update Entities */

    fViewer.update(entitiesToUpdate.toArray(), null);

  }



  private void getAllMarks(IFolder folder, List<IMark> marks) {



    /* Add all Marks */

    marks.addAll(folder.getMarks());



    /* Go through Subfolders */

    List<IFolder> folders = folder.getFolders();

    for (IFolder childFolder : folders)

      getAllMarks(childFolder, marks);

  }



  private boolean requiresUpdate(Set<NewsEvent> events) {

    for (NewsEvent newsEvent : events) {

      INews oldNews = newsEvent.getOldNews();

      INews currentNews = newsEvent.getEntity();



      /* Check Change in New-State */

      boolean oldStateNew = INews.State.NEW.equals(oldNews != null ? oldNews.getState() : null);

      boolean currentStateNew = INews.State.NEW.equals(currentNews.getState());

      if (oldStateNew != currentStateNew)

        return true;



      /* Check Change in Read-State */

      boolean oldStateUnread = CoreUtils.isUnread(oldNews != null ? oldNews.getState() : null);

      boolean newStateUnread = CoreUtils.isUnread(currentNews.getState());

      if (oldStateUnread != newStateUnread)

        return true;



      /* Check Change in Sticky-State */

      boolean oldStateSticky = oldNews != null ? oldNews.isFlagged() : false;

      boolean newStateSticky = currentNews.isVisible() && currentNews.isFlagged();

      if (oldStateSticky != newStateSticky)

        return true;

    }



    return false;

  }



  /* Recursively expand a folder and all parents */

  private void expand(IFolder folder) {

    IFolder parent = folder.getParent();

    if (parent != null)

      expand(parent);



    if (folder.getParent() != null) //Never expand Set, its visible anyways

      fViewer.setExpandedState(folder, true);

  }

}