**   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             **

**                                                                          **

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

* <p>

* TODO The underlying TreeViewer is not yet supporting contributed

* Label-Decorator, because the used LabelProvider is not extending

* ILabelProvider. Add this code to provide the decorations from contributions:

* <code>

* ILabelDecorator decorator = PlatformUI.getWorkbench().getDecoratorManager().getLabelDecorator();

* fViewer.setLabelProvider(new DecoratingLabelProvider(new BookMarkLabelProvider(), decorator);

* </code>

* </p>

*

* @author bpasero

*/

  /** ID of this View */

  public static final String VIEW_ID = "org.rssowl.ui.BookMarkExplorer"; //$NON-NLS-1$

  /** IDs of Action: Next Bookmark-Set */

  public static final String NEXT_SET_ACTION = "org.rssowl.ui.internal.views.explorer.NextSetAction"; //$NON-NLS-1$

  /** IDs of Action: Previous Bookmark-Set */

  public static final String PREVIOUS_SET_ACTION = "org.rssowl.ui.internal.views.explorer.PreviousSetAction"; //$NON-NLS-1$

  /* Local Setting Constants */

  private static final String PREF_SELECTED_FOLDER_CHILD = "org.rssowl.ui.internal.views.explorer.SelectedFolderChild"; //$NON-NLS-1$

  private static final String PREF_SELECTED_BOOKMARK_SET = "org.rssowl.ui.internal.views.explorer.SelectedBookMarkSet"; //$NON-NLS-1$

  private static final String PREF_EXPANDED_NODES = "org.rssowl.ui.internal.views.explorer.ExpandedNodes"; //$NON-NLS-1$

  /* Local Actions */

  private static final String GROUP_ACTION = "org.rssowl.ui.internal.views.explorer.GroupAction"; //$NON-NLS-1$

  private static final String FILTER_ACTION = "org.rssowl.ui.internal.views.explorer.FilterAction"; //$NON-NLS-1$

  /* Settings */

  private IPreferenceScope fGlobalPreferences;

  private List<Long> fExpandedNodes;

  private boolean fBeginSearchOnTyping;

  private boolean fAlwaysShowSearch;

  private boolean fSortByName;

  private BookMarkFilter.Type fFilterType;

  private BookMarkGrouping.Type fGroupingType;

  private IFolder fSelectedBookMarkSet;

  private boolean fLinkingEnabled;

  private boolean fFaviconsEnabled;

  private long fLastSelectedFolderChild;

  /* Viewer Classes */

  private TreeViewer fViewer;

  private BookMarkContentProvider fContentProvider;

  private BookMarkLabelProvider fLabelProvider;

  private BookMarkSorter fBookMarkComparator;

  private BookMarkFilter fBookMarkFilter;

  private BookMarkGrouping fBookMarkGrouping;

  /* Widgets */

  private Label fSeparator;

  private Composite fSearchBarContainer;

  private BookMarkSearchbar fSearchBar;

  private IToolBarManager fToolBarManager;

  /* BookMark Sets */

  private Set<IFolder> fRootFolders;

  /* Misc. */

  private IViewSite fViewSite;

  private IStructuredSelection fLastSelection;

  private FolderListener fFolderListener;

  private IPartListener2 fPartListener;

  private IPreferenceDAO fPrefDAO;

  private IPropertyChangeListener fPropertyChangeListener;

  private boolean fBlockSaveState;

  private BookMarkFilter.Type fLastFilterType;

  private BookMarkGrouping.Type fLastGroupType;

  /**

   * Returns the preferences key for the selected bookmark set for the given

   * workbench window.

   *

   * @param window the active workbench window.

   * @return the preferences key for the selected bookmark set for the given

   * workbench window.

   */

  public static String getSelectedBookMarkSetPref(IWorkbenchWindow window) {

    int windowIndex = OwlUI.getWindowIndex(window);

    return PREF_SELECTED_BOOKMARK_SET + windowIndex;

  }

  /*

   * @see org.eclipse.ui.part.WorkbenchPart#createPartControl(org.eclipse.swt.widgets.Composite)

   */

  @Override

  public void createPartControl(Composite parent) {

    /* Update Parent */

    GridLayout layout = new GridLayout(1, false);

    layout.marginWidth = 0;

    layout.marginHeight = 0;

    layout.verticalSpacing = 0;

    parent.setLayout(layout);

    parent.setBackground(parent.getDisplay().getSystemColor(SWT.COLOR_LIST_BACKGROUND));

    /* Create TreeViewer */

    createViewer(parent);

    /* Restore Expanded Elements */

    restoreExpandedElements();

    /* Restore Selection if linking is disabled */

    if (fLastSelectedFolderChild > 0 && !fLinkingEnabled)

      fViewer.setSelection(new StructuredSelection(new BookMarkReference(fLastSelectedFolderChild)), true);

    /* Hook into Statusline */

    fViewer.addSelectionChangedListener(new StatusLineUpdater(getViewSite().getActionBars().getStatusLineManager()));

    /* Hook into Global Actions */

    hookGlobalActions();

    /* Hook contextual Menu */

    hookContextualMenu();

    /* Hook into Toolbar */

    hookToolBar();

    /* Hook into View Dropdown */

    hookViewMenu();

    /* Register Listeners */

    registerListeners();

    /* Propagate Selection Events */

    fViewSite.setSelectionProvider(fViewer);

    /* Create the Search Bar */

    createSearchBar(parent);

    /* Show Busy when reload occurs */

    IWorkbenchSiteProgressService service = (IWorkbenchSiteProgressService) fViewSite.getAdapter(IWorkbenchSiteProgressService.class);

    service.showBusyForFamily(Controller.getDefault().getReloadFamily());

  }

  private void createViewer(Composite parent) {

    /* TreeViewer */

    fViewer = new BookMarkViewer(this, parent, SWT.MULTI | SWT.H_SCROLL | SWT.V_SCROLL);

    fViewer.getControl().setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true));

    fViewer.getControl().setData(ApplicationWorkbenchWindowAdvisor.FOCUSLESS_SCROLL_HOOK, new Object());

    fViewer.getControl().setFont(OwlUI.getThemeFont(OwlUI.BKMRK_EXPLORER_FONT_ID, SWT.NORMAL));

    /* Setup Drag & Drop Support */

    initDragAndDrop();

    /* Add a custom Comparer */

    fViewer.setComparer(getComparer());

    fViewer.setUseHashlookup(true);

    /* Create ContentProvider */

    fContentProvider = new BookMarkContentProvider();

    fViewer.setContentProvider(fContentProvider);

    /* Create LabelProvider */

    fLabelProvider = new BookMarkLabelProvider();

    fLabelProvider.setUseFavicons(fFaviconsEnabled);

    fViewer.setLabelProvider(fLabelProvider);

    /* Apply Sorter */

    fBookMarkComparator = new BookMarkSorter();

    if (fSortByName)

      fBookMarkComparator.setType(BookMarkSorter.Type.SORT_BY_NAME);

    fViewer.setComparator(fBookMarkComparator);

    /* Apply Filter */

    fBookMarkFilter = new BookMarkFilter();

    fBookMarkFilter.setType(fFilterType);

    fViewer.addFilter(fBookMarkFilter);

    /* Create Grouper */

    fBookMarkGrouping = new BookMarkGrouping();

    fBookMarkGrouping.setType(fGroupingType);

    /* Let the ContentProvider know */

    fContentProvider.setBookmarkFilter(fBookMarkFilter);

    fContentProvider.setBookmarkGrouping(fBookMarkGrouping);

    /* Set the initial Input based on selected Bookmark Set */

    fViewer.setInput(fSelectedBookMarkSet);

    /* Update Saved Searches if not yet done */

    JobRunner.runInBackgroundThread(50, new Runnable() {

      public void run() {

        Controller.getDefault().getSavedSearchService().updateSavedSearches(false);

      }

    });

    /* Enable "Link to FeedView" */

    fViewer.addPostSelectionChangedListener(new ISelectionChangedListener() {

      public void selectionChanged(SelectionChangedEvent event) {

        onSelectionChanged(event);

      }

    });

    /* Hook Doubleclick Support */

    fViewer.addDoubleClickListener(new IDoubleClickListener() {

      public void doubleClick(DoubleClickEvent event) {

        onDoubleClick(event);

      }

    });

    /* Hook Open Support */

    fViewer.addOpenListener(new IOpenListener() {

      public void open(OpenEvent event) {

        OwlUI.openInFeedView(fViewSite.getPage(), (IStructuredSelection) fViewer.getSelection());

      }

    });

    /* Aggregate Folder on Mouse Middle Click */

    fViewer.getTree().addMouseListener(new MouseAdapter() {

      @Override

      public void mouseUp(MouseEvent e) {

        if (e.button == 2)

          onMouseMiddleClick(fViewer.getTree().getItem(new Point(e.x, e.y)));

      }

    });

    /* Custom Owner Drawn for Groups */

    if (!OwlUI.isHighContrast()) {

      fViewer.getControl().addListener(SWT.EraseItem, new Listener() {

        public void handleEvent(Event event) {

          Object element = event.item.getData();

          fLabelProvider.erase(event, element);

        }

      });

    }

    /* Update List of Expanded Nodes */

    fViewer.addTreeListener(new ITreeViewerListener() {

      public void treeExpanded(TreeExpansionEvent event) {

        onTreeEvent(event.getElement(), true);

      }

      public void treeCollapsed(TreeExpansionEvent event) {

        onTreeEvent(event.getElement(), false);

      }

    });

    /* Link if enabled */

    if (fLinkingEnabled) {

      IWorkbenchPart activePart = fViewSite.getPage().getActivePart();

      if (activePart instanceof IEditorPart)

        editorActivated((IEditorPart) activePart);

    }

  }

  private void initDragAndDrop() {

    int ops = DND.DROP_COPY | DND.DROP_MOVE | DND.DROP_LINK;

    Transfer[] transfers = new Transfer[] { LocalSelectionTransfer.getTransfer(), TextTransfer.getInstance(), URLTransfer.getInstance() };

    BookMarkDNDImpl bookmarkDND = new BookMarkDNDImpl(this, fViewer);

    /* Drag Support */

    fViewer.addDragSupport(ops, transfers, bookmarkDND);

    /* Drop Support */

    fViewer.addDropSupport(ops, transfers, bookmarkDND);

  }

  private void onSelectionChanged(SelectionChangedEvent event) {

    fLastSelection = (IStructuredSelection) event.getSelection();

    if (fLinkingEnabled)

      linkToFeedView(fLastSelection);

  }

  private void onDoubleClick(DoubleClickEvent event) {

    IStructuredSelection selection = (IStructuredSelection) event.getSelection();

    Object firstElem = selection.getFirstElement();

    /* Expand / Collapse Folders */

    if (firstElem instanceof IFolder || firstElem instanceof EntityGroup) {

      boolean expandedState = !fViewer.getExpandedState(firstElem);

      fViewer.setExpandedState(firstElem, expandedState);

      onTreeEvent(firstElem, expandedState);

    }

  }

  private void onMouseMiddleClick(TreeItem item) {

    if (item != null && item.getData() instanceof IFolder) {

      AggregateFolderAction action = new AggregateFolderAction();

      action.setActivePart(null, this);

      action.selectionChanged(null, new StructuredSelection(item.getData()));

      action.run(null);

    }

  }

  private void onTreeEvent(Object element, boolean expanded) {

    /* Element expanded - add to List of expanded Nodes */

    if (expanded) {

      if (element instanceof IFolder)

        fExpandedNodes.add(((IFolder) element).getId());

      else if (element instanceof EntityGroup)

        fExpandedNodes.add(((EntityGroup) element).getId());

    }

    /* Element collapsed - remove from List of expanded Nodes */

    else {

      if (element instanceof IFolder)

        fExpandedNodes.remove(((IFolder) element).getId());

      else if (element instanceof EntityGroup)

        fExpandedNodes.remove(((EntityGroup) element).getId());

    }

  }

  /*

   * This Comparer is used to optimize some operations on the Viewer being used.

   * When deleting Entities, the Delete-Event is providing a reference to the

   * deleted Entity, which can not be resolved anymore. This Comparer will

   * return <code>TRUE</code> for a reference compared with an Entity that has

   * the same ID and is belonging to the same Entity. At any time, it _must_ be

   * avoided to call add, update or refresh with passing in a Reference!

   */

  private IElementComparer getComparer() {

    return new IElementComparer() {

      public boolean equals(Object a, Object b) {

        /* Quickyly check this common case */

        if (a == b && a != null)

          return true;

        /* Specially handle this reference */

        if (a instanceof FeedLinkReference || b instanceof FeedLinkReference) {

          FeedLinkReference ref1 = null;

          FeedLinkReference ref2 = null;

          if (a instanceof IBookMark)

            ref1 = ((IBookMark) a).getFeedLinkReference();

          else if (a instanceof FeedLinkReference)

            ref1 = ((FeedLinkReference) a);

          if (b instanceof IBookMark)

            ref2 = ((IBookMark) b).getFeedLinkReference();

          else if (b instanceof FeedLinkReference)

            ref2 = ((FeedLinkReference) b);

          if (ref1 != null)

            return ref1.equals(ref2);

          return false;

        }

        /* Handle Non Feed-Link-Reference */

        long id1 = 0;

        long id2 = 0;

        if (a instanceof IEntity)

          id1 = ((IEntity) a).getId();

        else if (a instanceof ModelReference)

          id1 = ((ModelReference) a).getId();

        else if (a instanceof EntityGroup)

          id1 = ((EntityGroup) a).getId();

        if (b instanceof IEntity)

          id2 = ((IEntity) b).getId();

        else if (b instanceof ModelReference)

          id2 = ((ModelReference) b).getId();

        else if (b instanceof EntityGroup)

          id2 = ((EntityGroup) b).getId();

        return id1 == id2;

      }

      public int hashCode(Object element) {

        return element.hashCode();

      }

    };

  }

  private void linkToFeedView(IStructuredSelection selection) {

    /* Only Link if this is the active Part */

    if (this != fViewSite.getPage().getActivePart())

      return;

    /* Only Link for Single Selections */

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

      Object element = selection.getFirstElement();

      /* Find the Editor showing given Selection */

      IWorkbenchPage activePage = PlatformUI.getWorkbench().getActiveWorkbenchWindow().getActivePage();

      IEditorReference[] editorReferences = activePage.getEditorReferences();

      IEditorReference reference = EditorUtils.findEditor(editorReferences, element);

      if (reference != null)

        activePage.bringToTop(reference.getPart(true));

    }

  }

  private void editorActivated(IEditorPart part) {

    if (!fLinkingEnabled || part == null)

      return;

    /* Try to select and reveal editor input in the Explorer */

    IEditorInput editorInput = part.getEditorInput();

    if (editorInput instanceof FeedViewInput)

      reveal(((FeedViewInput) editorInput).getMark(), false);

  }

  /**

   * @return <code>true</code> if the explorer is linked to the feed view and

   * <code>false</code> otherwise.

   */

  public boolean isLinkingEnabled() {

    return fLinkingEnabled;

  }

  /**

   * @param element the folder child to make visible and select.

   * @param expand if <code>true</code> expand the element, <code>false</code>

   * otherwise.

   */

  public void reveal(IFolderChild element, boolean expand) {

    /* Return early if hidden */

    if (!fViewSite.getPage().isPartVisible(this))

      return;

    /* Change Set if required */

    IFolderChild child = element;

    while (child.getParent() != null)

      child = child.getParent();

    if (!fSelectedBookMarkSet.equals(child))

      changeSet((IFolder) child);

    /* Set Selection */

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

    /* Expand if Set */

    if (expand) {

      fViewer.setExpandedState(element, true);

      fExpandedNodes.add(element.getId());

    }

  }

  void changeSet(IFolder folder) {

    /* Save Expanded Elements */

    saveExpandedElements();

    /* Set new Input */

    fSelectedBookMarkSet = folder;

    fViewer.setInput(fSelectedBookMarkSet);

    /* Restore Expanded Elements */

    fExpandedNodes.clear();

    loadExpandedElements();

    fViewer.getControl().setRedraw(false);

    try {

      restoreExpandedElements();

    } finally {

      fViewer.getControl().setRedraw(true);

    }

    /* Update Set Actions */

    fViewSite.getActionBars().getToolBarManager().find(PREVIOUS_SET_ACTION).update(IAction.ENABLED);

    fViewSite.getActionBars().getToolBarManager().find(NEXT_SET_ACTION).update(IAction.ENABLED);

    /* Save the new selected Set in Preferences */

    IPreference pref = fPrefDAO.loadOrCreate(getSelectedBookMarkSetPref(fViewSite.getWorkbenchWindow()));

    pref.putLongs(fSelectedBookMarkSet.getId());

    fPrefDAO.save(pref);

  }

  private void createSearchBar(final Composite parent) {

    /* Add Separator between Tree and Search Bar */

    fSeparator = new Label(parent, SWT.SEPARATOR | SWT.HORIZONTAL);

    fSeparator.setLayoutData(new GridData(SWT.FILL, SWT.BEGINNING, true, false));

    /* Container for the SearchBar */

    fSearchBarContainer = new Composite(parent, SWT.NONE);

    fSearchBarContainer.setLayoutData(new GridData(SWT.FILL, SWT.BEGINNING, true, false));

    /* Hide Searchbar in case settings tell so */

    ((GridData) fSeparator.getLayoutData()).exclude = !fAlwaysShowSearch;

    ((GridData) fSearchBarContainer.getLayoutData()).exclude = !fAlwaysShowSearch;

    /* Apply Layout */

    GridLayout searchBarLayout = new GridLayout(1, false);

    searchBarLayout.marginHeight = 2;

    searchBarLayout.marginWidth = 2;

    fSearchBarContainer.setLayout(searchBarLayout);

    /* Create the SearchBar */

    fSearchBar = new BookMarkSearchbar(fViewSite, fSearchBarContainer, fViewer, fBookMarkFilter);

    /* Show the SearchBar on Printable Key pressed */

    fViewer.getControl().addKeyListener(new KeyAdapter() {

      @Override

      public void keyPressed(KeyEvent e) {

        /* Feature not Used, return */

        if (!fBeginSearchOnTyping)

          return;

        /* Transfer typed key into SearchBar */

        if (e.character > 0x20 && e.character != SWT.DEL) {

          setSearchBarVisible(true);

          fSearchBar.getControl().append(String.valueOf(e.character));

          fSearchBar.getControl().setFocus();

          /* Consume the Event */

          e.doit = false;

        }

        /* Reset any Filter if set */

        else if (e.keyCode == SWT.ESC && fSearchBar.getControl().getText().length() != 0) {

          fSearchBar.setFilterText(""); //$NON-NLS-1$

          setSearchBarVisible(fAlwaysShowSearch);

          setFocus();

        }

      }

    });

    /* Hide SearchBar if search is done */

    fSearchBar.getControl().addModifyListener(new ModifyListener() {

      public void modifyText(ModifyEvent e) {

        /* Feature not Used, return */

        if (fAlwaysShowSearch)

          return;

        /* Search is Done */

        if (fSearchBar.getControl().getText().length() == 0) {

          setSearchBarVisible(false);

          setFocus();

        }

      }

    });

  }

  void setSearchBarVisible(boolean visible) {

    /* Return if no State Change */

    if (visible != ((GridData) fSeparator.getLayoutData()).exclude)

      return;

    /* Update LayoutData and layout Parent */

    ((GridData) fSeparator.getLayoutData()).exclude = !visible;

    ((GridData) fSearchBarContainer.getLayoutData()).exclude = !visible;

    fSearchBarContainer.getParent().layout();

  }

  private void hookViewMenu() {

    IMenuManager menuManager = fViewSite.getActionBars().getMenuManager();

    menuManager.setRemoveAllWhenShown(true);

    menuManager.addMenuListener(new IMenuListener() {

      public void menuAboutToShow(IMenuManager manager) {

        /* Manage Bookmark Sets */

        IAction manageSets = new Action(Messages.BookMarkExplorer_MANAGE_SETS) {

          @Override

          public void run() {

            ManageSetsDialog instance = ManageSetsDialog.getVisibleInstance();

            if (instance == null) {

              ManageSetsDialog dialog = new ManageSetsDialog(fViewSite.getShell(), fSelectedBookMarkSet);

              dialog.open();

            } else {

              instance.getShell().forceActive();

            }

          }

        };

        manager.add(manageSets);

        /* Available Bookmark Sets */

        manager.add(new Separator());

        for (final IFolder rootFolder : fRootFolders) {

          IAction selectBookMarkSet = new Action(rootFolder.getName(), IAction.AS_RADIO_BUTTON) {

            @Override

            public void run() {

              if (!fSelectedBookMarkSet.equals(rootFolder) && isChecked())

                changeSet(rootFolder);

            }

          };

          selectBookMarkSet.setImageDescriptor(OwlUI.BOOKMARK_SET);

          if (fSelectedBookMarkSet.equals(rootFolder))

            selectBookMarkSet.setChecked(true);

          manager.add(selectBookMarkSet);

        }

        /* Search Bar */

        manager.add(new Separator());

        MenuManager searchMenu = new MenuManager(Messages.BookMarkExplorer_FIND);

        manager.add(searchMenu);

        /* Search Bar - Always Show Bar */

        IAction alwaysShow = new Action(Messages.BookMarkExplorer_ALWAYS_SHOW, IAction.AS_CHECK_BOX) {

          @Override

          public void run() {

            fAlwaysShowSearch = !fAlwaysShowSearch;

            /* Only Update if the Filter is not Active */

            if (fSearchBar.getControl().getText().length() == 0)

              setSearchBarVisible(fAlwaysShowSearch);

          }

        };

        alwaysShow.setChecked(fAlwaysShowSearch);

        searchMenu.add(alwaysShow);

        /* Search Bar - Begin Search when Typing */

        IAction beginWhenTyping = new Action(Messages.BookMarkExplorer_BEGIN_WHEN_TYPING, IAction.AS_CHECK_BOX) {

          @Override

          public void run() {

            fBeginSearchOnTyping = !fBeginSearchOnTyping;

          }

        };

        beginWhenTyping.setChecked(fBeginSearchOnTyping);

        searchMenu.add(beginWhenTyping);

        /* Misc. Settings */

        manager.add(new Separator());

        IAction sortByName = new Action(Messages.BookMarkExplorer_SORT_BY_NAME, IAction.AS_CHECK_BOX) {

          @Override

          public void run() {

            fSortByName = !fSortByName;

            if (fSortByName)

              fBookMarkComparator.setType(BookMarkSorter.Type.SORT_BY_NAME);

            else

              fBookMarkComparator.setType(BookMarkSorter.Type.DEFAULT_SORTING);

            fViewer.refresh(false);

            /* Save directly to global scope */

            fGlobalPreferences.putBoolean(DefaultPreferences.BE_SORT_BY_NAME, fSortByName);

          }

        };

        sortByName.setChecked(fSortByName);

        manager.add(sortByName);

        IAction showFavicons = new Action(Messages.BookMarkExplorer_SHOW_FAVICONS, IAction.AS_CHECK_BOX) {

          @Override

          public void run() {

            fFaviconsEnabled = isChecked();

            fLabelProvider.setUseFavicons(fFaviconsEnabled);

            fViewer.getTree().setRedraw(false);

            try {

              fViewer.refresh(true);

            } finally {

              fViewer.getTree().setRedraw(true);

            }

          }

        };

        showFavicons.setChecked(fFaviconsEnabled);

        manager.add(showFavicons);

        /* Allow Contributions */

        manager.add(new Separator());

        IAction linkFeedView = new Action(Messages.BookMarkExplorer_LINKING, IAction.AS_CHECK_BOX) {

          @Override

          public void run() {

            fLinkingEnabled = isChecked();

            /* Link if enabled */

            if (fLinkingEnabled) {

              IEditorPart editor = fViewSite.getPage().getActiveEditor();

              if (editor != null)

                editorActivated(editor);

            }

          }

        };

        linkFeedView.setChecked(fLinkingEnabled);

        linkFeedView.setImageDescriptor(OwlUI.getImageDescriptor("icons/etool16/synced.gif")); //$NON-NLS-1$

        manager.add(linkFeedView);

        /* Allow Contributions */

        manager.add(new Separator(IWorkbenchActionConstants.MB_ADDITIONS));

      }

    });

    /* Dummy Entry to show Menu in View */

    menuManager.add(new Action("") {}); //$NON-NLS-1$

  }

  private void hookToolBar() {

    fToolBarManager = fViewSite.getActionBars().getToolBarManager();

    /* BookMark Filter */

    final IAction bookmarkFilter = new Action(Messages.BookMarkExplorer_FILTER_ELEMENTS, IAction.AS_DROP_DOWN_MENU) {

      @Override

      public void run() {

        /* Restore Default */

        if (fBookMarkFilter.getType() != BookMarkFilter.Type.SHOW_ALL)

          doFilter(BookMarkFilter.Type.SHOW_ALL);

        /* Toggle to Previous */

        else if (fLastFilterType != null)

          doFilter(fLastFilterType);

        /* Show Menu */

        else if (fToolBarManager instanceof ToolBarManager)

          OwlUI.positionDropDownMenu(this, (ToolBarManager) fToolBarManager);

      }

      @Override

      public ImageDescriptor getImageDescriptor() {

        if (fBookMarkFilter.getType() == BookMarkFilter.Type.SHOW_ALL)

          return OwlUI.FILTER;

        return OwlUI.getImageDescriptor("icons/etool16/filter_active.gif"); //$NON-NLS-1$

      }

    };

    bookmarkFilter.setId(FILTER_ACTION);

    bookmarkFilter.setMenuCreator(new ContextMenuCreator() {

      @Override

      public Menu createMenu(Control parent) {

        Menu menu = new Menu(parent);

        /* Filter: None */

        final MenuItem showAll = new MenuItem(menu, SWT.RADIO);

        showAll.setText(Messages.BookMarkExplorer_SHOW_ALL);

        showAll.setSelection(BookMarkFilter.Type.SHOW_ALL == fBookMarkFilter.getType());

        menu.setDefaultItem(showAll);

        showAll.addSelectionListener(new SelectionAdapter() {

          @Override

          public void widgetSelected(SelectionEvent e) {

            if (showAll.getSelection() && fBookMarkFilter.getType() != BookMarkFilter.Type.SHOW_ALL)

              doFilter(BookMarkFilter.Type.SHOW_ALL);

          }

        });

        /* Separator */

        new MenuItem(menu, SWT.SEPARATOR);

        /* Filter: New */

        final MenuItem showNew = new MenuItem(menu, SWT.RADIO);

        showNew.setText(Messages.BookMarkExplorer_SHOW_NEW);

        showNew.setSelection(BookMarkFilter.Type.SHOW_NEW == fBookMarkFilter.getType());

        showNew.addSelectionListener(new SelectionAdapter() {

          @Override

          public void widgetSelected(SelectionEvent e) {

            if (showNew.getSelection() && fBookMarkFilter.getType() != BookMarkFilter.Type.SHOW_NEW)

              doFilter(BookMarkFilter.Type.SHOW_NEW);

          }

        });

        /* Filter: Unread */

        final MenuItem showUnread = new MenuItem(menu, SWT.RADIO);

        showUnread.setText(Messages.BookMarkExplorer_SHOW_UNREAD);

        showUnread.setSelection(BookMarkFilter.Type.SHOW_UNREAD == fBookMarkFilter.getType());

        showUnread.addSelectionListener(new SelectionAdapter() {

          @Override

          public void widgetSelected(SelectionEvent e) {

            if (showUnread.getSelection() && fBookMarkFilter.getType() != BookMarkFilter.Type.SHOW_UNREAD)

              doFilter(BookMarkFilter.Type.SHOW_UNREAD);

          }

        });

        /* Filter: Sticky */

        final MenuItem showSticky = new MenuItem(menu, SWT.RADIO);

        showSticky.setText(Messages.BookMarkExplorer_SHOW_STICKY);

        showSticky.setSelection(BookMarkFilter.Type.SHOW_STICKY == fBookMarkFilter.getType());

        showSticky.addSelectionListener(new SelectionAdapter() {

          @Override

          public void widgetSelected(SelectionEvent e) {

            if (showSticky.getSelection() && fBookMarkFilter.getType() != BookMarkFilter.Type.SHOW_STICKY)

              doFilter(BookMarkFilter.Type.SHOW_STICKY);

          }

        });

        /* Separator */

        new MenuItem(menu, SWT.SEPARATOR);

        /* Filter: Erroneous */

        final MenuItem showErroneous = new MenuItem(menu, SWT.RADIO);

        showErroneous.setText(Messages.BookMarkExplorer_SHOW_ERROR);

        showErroneous.setSelection(BookMarkFilter.Type.SHOW_ERRONEOUS == fBookMarkFilter.getType());

        showErroneous.addSelectionListener(new SelectionAdapter() {

          @Override

          public void widgetSelected(SelectionEvent e) {

            if (showErroneous.getSelection() && fBookMarkFilter.getType() != BookMarkFilter.Type.SHOW_ERRONEOUS)

              doFilter(BookMarkFilter.Type.SHOW_ERRONEOUS);

          }

        });

        /* Filter: Never Visited */

        final MenuItem showNeverVisited = new MenuItem(menu, SWT.RADIO);

        showNeverVisited.setText(Messages.BookMarkExplorer_SHOW_NEVER_VISITED);

        showNeverVisited.setSelection(BookMarkFilter.Type.SHOW_NEVER_VISITED == fBookMarkFilter.getType());

        showNeverVisited.addSelectionListener(new SelectionAdapter() {

          @Override

          public void widgetSelected(SelectionEvent e) {

            if (showNeverVisited.getSelection() && fBookMarkFilter.getType() != BookMarkFilter.Type.SHOW_NEVER_VISITED)

              doFilter(BookMarkFilter.Type.SHOW_NEVER_VISITED);

          }

        });

        return menu;

      }

    });

    fToolBarManager.add(bookmarkFilter);

    /* Bookmark Group */

    fToolBarManager.add(new Separator());

    final IAction bookmarkGroup = new Action(Messages.BookMarkExplorer_GROUP_ELEMENTS, IAction.AS_DROP_DOWN_MENU) {

      @Override

      public void run() {

        /* Restore Default */

        if (fBookMarkGrouping.getType() != BookMarkGrouping.Type.NO_GROUPING)

          doGrouping(BookMarkGrouping.Type.NO_GROUPING);

        /* Toggle to previous */

        else if (fLastGroupType != null)

          doGrouping(fLastGroupType);

        /* Show Menu */

        else if (fToolBarManager instanceof ToolBarManager)

          OwlUI.positionDropDownMenu(this, (ToolBarManager) fToolBarManager);

      }

      @Override

      public ImageDescriptor getImageDescriptor() {

        if (fBookMarkGrouping.getType() == BookMarkGrouping.Type.NO_GROUPING)

          return OwlUI.getImageDescriptor("icons/etool16/group.gif"); //$NON-NLS-1$

        return OwlUI.getImageDescriptor("icons/etool16/group_active.gif"); //$NON-NLS-1$

      }

    };

    bookmarkGroup.setId(GROUP_ACTION);

    bookmarkGroup.setMenuCreator(new ContextMenuCreator() {

      @Override

      public Menu createMenu(Control parent) {

        Menu menu = new Menu(parent);

        /* Group: None */

        final MenuItem noGrouping = new MenuItem(menu, SWT.RADIO);

        noGrouping.setText(Messages.BookMarkExplorer_NO_GROUPING);

        noGrouping.setSelection(BookMarkGrouping.Type.NO_GROUPING == fBookMarkGrouping.getType());

        menu.setDefaultItem(noGrouping);

        noGrouping.addSelectionListener(new SelectionAdapter() {

          @Override

          public void widgetSelected(SelectionEvent e) {

            if (noGrouping.getSelection() && fBookMarkGrouping.getType() != BookMarkGrouping.Type.NO_GROUPING)

              doGrouping(BookMarkGrouping.Type.NO_GROUPING);

          }

        });

        /* Separator */

        new MenuItem(menu, SWT.SEPARATOR);

        /* Group: By Type */

        final MenuItem groupByType = new MenuItem(menu, SWT.RADIO);

        groupByType.setText(Messages.BookMarkExplorer_GROUP_BY_TYPE);

        groupByType.setSelection(BookMarkGrouping.Type.GROUP_BY_TYPE == fBookMarkGrouping.getType());

        groupByType.addSelectionListener(new SelectionAdapter() {

          @Override

          public void widgetSelected(SelectionEvent e) {

            if (groupByType.getSelection() && fBookMarkGrouping.getType() != BookMarkGrouping.Type.GROUP_BY_TYPE)

              doGrouping(BookMarkGrouping.Type.GROUP_BY_TYPE);

          }

        });

        /* Group: By State */

        final MenuItem groupByState = new MenuItem(menu, SWT.RADIO);