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

**                                                                          **

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

* The FeedView is an instance of <code>EditorPart</code> capable of displaying

* News in a Table-Viewer and Browser-Viewer. It offers controls to Filter and

* Group them.

*

* @author bpasero

*/

  /* Delay in millies to Mark *new* News to *unread* on Part-Deactivation */

  private static final int HANDLE_NEWS_SEEN_DELAY = 100;

  /* Millies before news seen are handled */

  private static final int HANDLE_NEWS_SEEN_BLOCK_DELAY = 800;

  /* Delay in millies to safely operate on the browser content */

  private static final int BROWSER_OPERATIONS_DELAY = 100;

  /* Millies before the next clean up is allowed to run again */

  private static final int CLEAN_UP_BLOCK_DELAY = 1000;

  /* System Property indicating the separator to use for CSV files */

  private static final String CSV_SEPARATOR_PROPERTY = "csvSeparator"; //$NON-NLS-1$

  /* The last visible Feedview */

  private static FeedView fgLastVisibleFeedView = null;

  /* Flag to indicate if feed change events should be blocked or not */

  private static boolean fgBlockFeedChangeEvent;

  /** ID of this EditorPart */

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

  /** List of UI-Events interesting for the FeedView */

  public enum UIEvent {

    /** Other Feed Displayed */

    FEED_CHANGE,

    /** Application Minimized */

    MINIMIZE,

    /** Application Closing */

    CLOSE,

    /** Tab Closed */

    TAB_CLOSE

  }

  /* Editor Data */

  private FeedViewInput fInput;

  private IEditorSite fEditorSite;

  private IFeedViewSite fFeedViewSite;

  /* Part to display News in Table */

  private NewsTableControl fNewsTableControl;

  /* Part to display News in Browser */

  private NewsBrowserControl fNewsBrowserControl;

  /* Bars */

  private FilterBar fFilterBar;

  private BrowserBar fBrowserBar;

  /* Shared Viewer classes */

  private NewsFilter fNewsFilter;

  private NewsGrouping fNewsGrouping;

  private NewsContentProvider fContentProvider;

  /* Container for the News Table Viewer */

  private Composite fNewsTableControlContainer;

  /* Container for the Browser Viewer */

  private Composite fBrowserViewerControlContainer;

  /* Listeners */

  private IPartListener2 fPartListener;

  private BookMarkListener fBookMarkListener;

  private SearchMarkAdapter fSearchMarkListener;

  private FeedAdapter fFeedListener;

  private SearchConditionListener fSearchConditionListener;

  private NewsBinListener fNewsBinListener;

  private FolderAdapter fFolderListener;

  private BookMarkLoadListener fBookMarkLoadListener;

  /* Settings */

  NewsFilter.Type fInitialFilterType;

  NewsGrouping.Type fInitialGroupType;

  NewsFilter.SearchTarget fInitialSearchTarget;

  Layout fLayout;

  private int fInitialWeights[];

  private int fCacheWeights[];

  /* Global Actions */

  private IAction fReloadAction;

  private IAction fSelectAllAction;

  private IAction fDeleteAction;

  private IAction fCutAction;

  private IAction fCopyAction;

  private IAction fPasteAction;

  private IAction fPrintAction;

  private IAction fUndoAction;

  private IAction fRedoAction;

  private IAction fFindAction;

  /* Misc. */

  private Composite fParent;

  private Composite fRootComposite;

  private SashForm fSashForm;

  private Label fHorizontalTableBrowserSep;

  private Label fVerticalTableBrowserSep;

  private LocalResourceManager fResourceManager;

  private IPreferenceScope fPreferences;

  private long fOpenTime;

  private boolean fCreated;

  private final Object fCacheJobIdentifier = new Object();

  private ImageDescriptor fTitleImageDescriptor;

  private Label fHorizontalFilterTableSep;

  private Label fHorizontalBrowserSep;

  private Label fVerticalBrowserSep;

  private final INewsDAO fNewsDao = Owl.getPersistenceService().getDAOService().getNewsDAO();

  private boolean fIsDisposed;

  private AtomicLong fLastCleanUpRun = new AtomicLong();

  /*

   * @see org.eclipse.ui.part.EditorPart#doSave(org.eclipse.core.runtime.IProgressMonitor)

   */

  @Override

  public void doSave(IProgressMonitor monitor) {

    /* Not Supported */

  }

  /*

   * @see org.eclipse.ui.part.EditorPart#doSaveAs()

   */

  @Override

  public void doSaveAs() {

    if (fIsDisposed || Controller.getDefault().isShuttingDown())

      return;

    /* Ask user for File */

    FileDialog dialog = new FileDialog(getSite().getShell(), SWT.SAVE);

    dialog.setOverwrite(true);

    List<String> extensions = new ArrayList<String>();

    extensions.add("*.html"); //$NON-NLS-1$

    if (fInput.getMark() instanceof IBookMark)

      extensions.add("*.xml"); //$NON-NLS-1$

    if (isTableViewerVisible())

      extensions.add("*.csv"); //$NON-NLS-1$

    dialog.setFilterExtensions(extensions.toArray(new String[extensions.size()]));

    String proposedName = Application.IS_WINDOWS ? CoreUtils.getSafeFileNameForWindows(fInput.getName()) : fInput.getName();

    proposedName += ".html"; //$NON-NLS-1$

    dialog.setFileName(proposedName);

    String fileName = dialog.open();

    if (fileName == null)

      return;

    if (fileName.endsWith(".xml")) //$NON-NLS-1$

      saveAsXml(fileName);

    else if(fileName.endsWith(".csv")) //$NON-NLS-1$

      saveAsCsv(fileName);

    else

      saveAsHtml(fileName);

  }

  @SuppressWarnings("restriction")

  private void saveAsXml(final String fileName) {

    final IBookMark bm = (IBookMark) fInput.getMark();

    final URI feedLink = bm.getFeedLinkReference().getLink();

    try {

      final IProtocolHandler handler = Owl.getConnectionService().getHandler(feedLink);

      if (handler instanceof org.rssowl.core.internal.connection.DefaultProtocolHandler) {

        Job downloadJob = new Job(Messages.FeedView_DOWNLOADING_FEED) {

          @Override

          protected IStatus run(IProgressMonitor monitor) {

            monitor.beginTask(bm.getName(), IProgressMonitor.UNKNOWN);

            InputStream in = null;

            FileOutputStream out = null;

            boolean canceled = false;

            Exception error = null;

            try {

              byte[] buffer = new byte[8192];

              in = handler.openStream(feedLink, monitor, null);

              out = new FileOutputStream(fileName);

              while (true) {

                /* Check for Cancellation and Shutdown */

                if (monitor.isCanceled() || Controller.getDefault().isShuttingDown()) {

                  canceled = true;

                  return Status.CANCEL_STATUS;

                }

                /* Read from Stream */

                int read = in.read(buffer);

                if (read == -1)

                  break;

                out.write(buffer, 0, read);

              }

            } catch (FileNotFoundException e) {

              error = e;

              Activator.safeLogError(e.getMessage(), e);

            } catch (IOException e) {

              error = e;

              Activator.safeLogError(e.getMessage(), e);

            } catch (ConnectionException e) {

              error = e;

              Activator.safeLogError(e.getMessage(), e);

            } finally {

              monitor.done();

              if (out != null) {

                try {

                  out.close();

                } catch (IOException e) {

                  Activator.safeLogError(e.getMessage(), e);

                }

              }

              if (in != null) {

                try {

                  if ((canceled || error != null) && in instanceof IAbortable)

                    ((IAbortable) in).abort();

                  else

                    in.close();

                } catch (IOException e) {

                  Activator.safeLogError(e.getMessage(), e);

                }

              }

            }

            return Status.OK_STATUS;

          }

        };

        downloadJob.schedule();

      }

    } catch (ConnectionException e) {

      Activator.safeLogError(e.getMessage(), e);

    }

  }

  /* Build Content as String from Feed */

  private void saveAsHtml(String fileName) {

    StringBuilder content = new StringBuilder();

    NewsBrowserLabelProvider labelProvider = (NewsBrowserLabelProvider) fNewsBrowserControl.getViewer().getLabelProvider();

    URI base = null;

    if (fInput.getMark() instanceof IBookMark) {

      try {

        base = URIUtils.toHTTP(new URI(((IBookMark) fInput.getMark()).getFeedLinkReference().getLinkAsText()));

      } catch (URISyntaxException e) {

        /* Ignore and fallback to not using a Base at all */

      }

    }

    /* Save from Table */

    if (isTableViewerVisible()) {

      Tree tree = fNewsTableControl.getViewer().getTree();

      TreeItem[] items = tree.getItems();

      if (items.length > 0) {

        List<INews> newsToSave = new ArrayList<INews>();

        /* Ungrouped */

        if (items[0].getItemCount() == 0) {

          for (TreeItem item : items) {

            if (item.getData() instanceof INews)

              newsToSave.add((INews) item.getData());

          }

        }

        /* Grouped */

        else {

          for (TreeItem parentItem : items) {

            TreeItem[] childItems = parentItem.getItems();

            for (TreeItem item : childItems) {

              if (item.getData() instanceof INews)

                newsToSave.add((INews) item.getData());

            }

          }

        }

        /* Render Elements */

        String text = labelProvider.render(newsToSave.toArray(), base, false);

        content.append(text);

      }

    }

    /* Save from Browser */

    else {

      NewsBrowserViewer viewer = fNewsBrowserControl.getViewer();

      Object[] elements = fContentProvider.getElements(fInput.getMark().toReference());

      elements = viewer.getFlattendChildren(elements, false);

      /* Render Elements */

      String text = labelProvider.render(elements, base, false);

      content.append(text);

    }

    /* Write into File */

    if (content.length() > 0)

      CoreUtils.write(fileName, content);

  }

  private void saveAsCsv(final String fileName) {

    StringBuilder content = new StringBuilder();

    String separator = System.getProperty(CSV_SEPARATOR_PROPERTY);

    if (separator == null || separator.length() == 0)

      separator = ";"; //$NON-NLS-1$

    else if (separator.equals("\\t")) //$NON-NLS-1$

      separator = "\t"; //$NON-NLS-1$

    Tree tree = fNewsTableControl.getViewer().getTree();

    TreeItem[] items = tree.getItems();

    if (items.length > 0) {

      List<TreeItem> itemsToSave = new ArrayList<TreeItem>();

      /* Ungrouped */

      if (items[0].getItemCount() == 0) {

        for (TreeItem item : items) {

          if (item.getData() instanceof INews)

            itemsToSave.add(item);

        }

      }

      /* Grouped */

      else {

        for (TreeItem parentItem : items) {

          TreeItem[] childItems = parentItem.getItems();

          for (TreeItem item : childItems) {

            if (item.getData() instanceof INews)

              itemsToSave.add(item);

          }

        }

      }

      /* Get header */

      for (int order : tree.getColumnOrder()) {

        TreeColumn column = tree.getColumn(order);

        String text = column.getText();

        if (text.length() > 0)

          content.append(toCSVEntry(text, separator)).append(separator);

      }

      if (content.length() > 0) {

        content.delete(content.length() - separator.length(), content.length());

        content.append('\n');

      }

      /* Get contents */

      for (TreeItem item : itemsToSave) {

        boolean lineAdded = false;

        for (int order : tree.getColumnOrder()) {

          if (tree.getColumn(order).getText().length() > 0) {

            String text = item.getText(order);

            content.append(toCSVEntry(text, separator)).append(separator);

            lineAdded = true;

          }

        }

        if (lineAdded) {

          content.delete(content.length() - separator.length(), content.length());

          content.append('\n');

        }

      }

    }

    /* Write into File */

    if (content.length() > 0)

      CoreUtils.write(fileName, content);

  }

  private String toCSVEntry(String value, String separator) {

    if (value.contains(separator)) {

      /* Values that contain the separator and quotes need to escape quotes */

      if (value.contains("\"")) { //$NON-NLS-1$

        value = StringUtils.replaceAll(value, "\"", "\"\""); //$NON-NLS-1$ //$NON-NLS-2$

      }

      /* Values that contain the separator needs to be surrounded by quotes */

      return "\"" + value + "\""; //$NON-NLS-1$ //$NON-NLS-2$

    }

    return value;

  }

  /*

   * @see org.eclipse.ui.part.EditorPart#init(org.eclipse.ui.IEditorSite,

   * org.eclipse.ui.IEditorInput)

   */

  @Override

  public void init(IEditorSite site, IEditorInput input) {

    Assert.isTrue(input instanceof FeedViewInput);

    fEditorSite = site;

    fFeedViewSite = new FeedViewSite(this, site);

    setSite(site);

    fResourceManager = new LocalResourceManager(JFaceResources.getResources());

    /* Load Settings */

    fPreferences = Owl.getPreferenceService().getGlobalScope();

    loadSettings((FeedViewInput) input);

    /* Apply Input */

    setInput(input);

    /* Hook into Global Actions */

    createGlobalActions();

    setGlobalActions();

    /* Register Listeners */

    registerListeners();

  }

  private boolean justOpened() {

    return System.currentTimeMillis() - fOpenTime < HANDLE_NEWS_SEEN_BLOCK_DELAY;

  }

  private void registerListeners() {

    fPartListener = new IPartListener2() {

      /* Mark *new* News as *unread* or *read* */

      public void partHidden(IWorkbenchPartReference partRef) {

        /* Return early if event is too close after opening the feed */

        if (justOpened())

          return;

        /* Remember this feedview as being the last visible one */

        if (FeedView.this.equals(partRef.getPart(false)))

          fgLastVisibleFeedView = FeedView.this;

      }

      /* Hook into Global Actions for this Editor */

      public void partBroughtToTop(IWorkbenchPartReference partRef) {

        if (FeedView.this.equals(partRef.getPart(false))) {

          setGlobalActions();

          OwlUI.updateWindowTitle(fInput != null ? fInput.getMark() : null);

          /* Notify last visible feedview about change */

          if (fgLastVisibleFeedView != null && fgLastVisibleFeedView != FeedView.this && !fgLastVisibleFeedView.fIsDisposed) {

            fgLastVisibleFeedView.notifyUIEvent(UIEvent.FEED_CHANGE);

            fgLastVisibleFeedView = null;

          }

        }

        /* Any other editor was brought to top, reset last visible feedview */

        else if (!ID.equals(partRef.getId()))

          fgLastVisibleFeedView = null;

      }

      public void partClosed(IWorkbenchPartReference partRef) {

        IEditorReference[] editors = partRef.getPage().getEditorReferences();

        boolean equalsThis = FeedView.this.equals(partRef.getPart(false));

        if (editors.length == 0 && equalsThis)

          OwlUI.updateWindowTitle((String) null);

        if (equalsThis) {

          if (fgLastVisibleFeedView == FeedView.this) //Avoids duplicate UI Event handling

            fgLastVisibleFeedView = null;

          notifyUIEvent(UIEvent.TAB_CLOSE);

        }

      }

      public void partDeactivated(IWorkbenchPartReference partRef) {}

      public void partActivated(IWorkbenchPartReference partRef) {

        if (FeedView.this.equals(partRef.getPart(false)))

          OwlUI.updateWindowTitle(fInput != null ? fInput.getMark() : null);

      }

      public void partInputChanged(IWorkbenchPartReference partRef) {

        if (FeedView.this.equals(partRef.getPart(false)))

          OwlUI.updateWindowTitle(fInput != null ? fInput.getMark() : null);

      }

      public void partOpened(IWorkbenchPartReference partRef) {

        if (FeedView.this.equals(partRef.getPart(false)) && isVisible()) {

          fOpenTime = System.currentTimeMillis();

          OwlUI.updateWindowTitle(fInput != null ? fInput.getMark() : null);

        }

      }

      public void partVisible(IWorkbenchPartReference partRef) {

        if (FeedView.this.equals(partRef.getPart(false)))

          OwlUI.updateWindowTitle(fInput != null ? fInput.getMark() : null);

      }

    };

    fEditorSite.getPage().addPartListener(fPartListener);

    /* React on Bookmark Events */

    fBookMarkListener = new BookMarkAdapter() {

      @Override

      public void entitiesDeleted(Set<BookMarkEvent> events) {

        onNewsMarksDeleted(events);

      }

      @Override

      public void entitiesUpdated(Set<BookMarkEvent> events) {

        onNewsMarksUpdated(events);

      }

    };

    DynamicDAO.addEntityListener(IBookMark.class, fBookMarkListener);

    /* React on Folder Events */

    fFolderListener = new FolderAdapter() {

      @Override

      public void entitiesDeleted(Set<FolderEvent> events) {

        onFoldersDeleted(events);

      }

      @Override

      public void entitiesUpdated(Set<FolderEvent> events) {

        onNewsFoldersUpdated(events);

      }

    };

    DynamicDAO.addEntityListener(IFolder.class, fFolderListener);

    /* React on Searchmark Events */

    fSearchMarkListener = new SearchMarkAdapter() {

      @Override

      public void entitiesDeleted(Set<SearchMarkEvent> events) {

        onNewsMarksDeleted(events);

      }

      @Override

      public void entitiesUpdated(Set<SearchMarkEvent> events) {

        onNewsMarksUpdated(events);

      }

    };

    DynamicDAO.addEntityListener(ISearchMark.class, fSearchMarkListener);

    /* Refresh on Condition Changes if SearchMark showing */

    fSearchConditionListener = new SearchConditionListener() {

      public void entitiesAdded(Set<SearchConditionEvent> events) {

        refreshIfRequired(events);

      }

      public void entitiesDeleted(Set<SearchConditionEvent> events) {

        /* Ignore Due to Bug 1140 (http://dev.rssowl.org/show_bug.cgi?id=1140) */

      }

      public void entitiesUpdated(Set<SearchConditionEvent> events) {

        /* Ignore Due to Bug 1140 (http://dev.rssowl.org/show_bug.cgi?id=1140) */

      }

      /* We rely on the implementation detail that updating a SM means deleting/adding conditions */

      private void refreshIfRequired(Set<SearchConditionEvent> events) {

        if (fInput.getMark() instanceof ISearchMark) {

          ISearchMarkDAO dao = DynamicDAO.getDAO(ISearchMarkDAO.class);

          for (SearchConditionEvent event : events) {

            ISearchCondition condition = event.getEntity();

            ISearchMark searchMark = dao.load(condition);

            if (searchMark != null && searchMark.equals(fInput.getMark())) {

              JobRunner.runUIUpdater(new UIBackgroundJob(fParent) {

                @Override

                protected void runInBackground(IProgressMonitor monitor) {

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

                    fContentProvider.refreshCache(monitor, fInput.getMark());

                }

                @Override

                protected void runInUI(IProgressMonitor monitor) {

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

                    refresh(true, true);

                }

                @Override

                public boolean belongsTo(Object family) {

                  return fCacheJobIdentifier.equals(family);

                }

              });

              break;

            }

          }

        }

      }

    };

    DynamicDAO.addEntityListener(ISearchCondition.class, fSearchConditionListener);

    /* React on Newsbin Events */

    fNewsBinListener = new NewsBinAdapter() {

      @Override

      public void entitiesDeleted(Set<NewsBinEvent> events) {

        onNewsMarksDeleted(events);

      }

      @Override

      public void entitiesUpdated(Set<NewsBinEvent> events) {

        onNewsMarksUpdated(events);

      }

    };

    DynamicDAO.addEntityListener(INewsBin.class, fNewsBinListener);

    /* Listen if Title Image is changing */

    fFeedListener = new FeedAdapter() {

      @Override

      public void entitiesUpdated(Set<FeedEvent> events) {

        /* Only supported for BookMarks */

        if (!(fInput.getMark() instanceof IBookMark) || events.size() == 0)

          return;

        /* Check if Feed-Event affecting us */

        for (FeedEvent event : events) {

          FeedLinkReference feedRef = ((IBookMark) fInput.getMark()).getFeedLinkReference();

          if (feedRef.references(event.getEntity())) {

            ImageDescriptor imageDesc = fInput.getImageDescriptor();

            /* Title Image Change - Update! */

            if (!fTitleImageDescriptor.equals(imageDesc)) {

              fTitleImageDescriptor = imageDesc;

              JobRunner.runInUIThread(fParent, new Runnable() {

                public void run() {