package net.logAnalyzer.gui.messages;
   
   import java.awt.BorderLayout;
   import java.awt.Cursor;
   import java.util.Hashtable;
   
   import javax.swing.Icon;
   import javax.swing.JScrollPane;
   import javax.swing.JSplitPane;
  import javax.swing.SwingUtilities;
  
  import net.logAnalyzer.LogAnalyzerGUI;
  import net.logAnalyzer.gui.LAViewContainer;
  import net.logAnalyzer.gui.ViewDefinition;
  import net.logAnalyzer.gui.messages.filters.LAMessagesFilter;
  import net.logAnalyzer.handlers.FilteredLogHandler;
  import net.logAnalyzer.handlers.LALogHandler;
  import net.logAnalyzer.handlers.LALogHandlerListener;
  import net.logAnalyzer.resources.LAResourceBundle;
  import net.logAnalyzer.utils.gui.JStatusBar;
  
  public class FilteredMessagesView extends MessagesView implements
          LALogHandlerListener {
      private static final long serialVersionUID = 1L;
  
      /***
       * Filtered log handler.
       */
      private FilteredLogHandler filteredLogHandler;
  
      /***
       * Filters manager.
       */
      private FiltersManager filters;
  
      /***
       * Table used to display messages.
       */
      private MessagesTable messagesTable;
  
      /***
       * StatusBar.
       */
      private JStatusBar statusbar;
  
      /***
       * Creates a new view with the specified attributes.
       * 
       * @param attributes
       *            View attributes.
       */
      public FilteredMessagesView(ViewDefinition definition, Hashtable attributes) {
          super(definition, attributes);
      }
  
      /***
       * Adds view components. Called by
       * {@link net.logAnalyzer.gui.LAView#setViewContainer(LAViewContainer)}.
       */
      public void addComponents() {
          setLayout(new BorderLayout());
  
          // Adds the filters manager
          filters = new FiltersManager(this, getAttributes());
          // Adds the messages table
          messagesTable = new MessagesTable(this, getAttributes());
          messagesTable.setModel(new MessagesModel(getFilteredLogHandler()));
          // Adds the messages table in a scroll pane
          JScrollPane messagesScrollPane = new JScrollPane(messagesTable);
  
          // Adds the filters manager and the table scoll pane to a splitter
          JSplitPane splitter = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT,
                  false, filters, messagesScrollPane);
          splitter.setDividerLocation(200);
          add(splitter, BorderLayout.CENTER);
  
          // Adds the statusbar
          statusbar = new JStatusBar();
          statusbar.setVisible(false);
          add(statusbar, BorderLayout.SOUTH);
      }
  
      /***
       * Sets filter to apply on the log handler.
       * 
       * @param filter
       *            Filter to apply to accept or not log handler messages.
       */
      public void setFilter(LAMessagesFilter filter) {
          filters.setFilter(filter);
      }
  
      /***
       * Sets filter to apply on the log handler and start filtering in a new
       * thread.
       * 
       * @param filter
       *            Filter to apply to accept or not log handler messages.
       */
     public void startFiltering(LAMessagesFilter filter) {
         getFilteredLogHandler().setFilter(filter);
         messagesTable.setModel(new MessagesModel(filteredLogHandler));
         filteredLogHandler.addLogHandlerListener(this);
         filteredLogHandler.addLogHandlerListener(filters);
         // Filter the log
         SwingUtilities.invokeLater(new Runnable() {
             public void run() {
                 Thread filtering = new Thread(filteredLogHandler);
                 filtering.start();
             }
         });
     }
 
     /***
      * Stop the filtering.
      */
     public void stopFiltering() {
         filteredLogHandler.stopFiltering();
     }
 
     /***
      * Returns the filtered log handler.
      * 
      * @return Filtered log handler.
      */
     public FilteredLogHandler getFilteredLogHandler() {
         if (filteredLogHandler == null) {
             filteredLogHandler = new FilteredLogHandler(LogAnalyzerGUI
                     .getHandler());
             filteredLogHandler.addLogHandlerListener(this);
         }
         return filteredLogHandler;
     }
 
     /***
      * Sets current messageLabel.
      * 
      * @param oldFirstIndex
      *            Old first selected messageLabel index.
      * @param oldLastIndex
      *            Old last selected messageLabel index.
      * @param newFirstIndex
      *            New first selected messageLabel index.
      * @param newLastIndex
      *            New last selected messageLabel index.
      */
     protected void setCurrentMessage(int oldFirstIndex, int oldLastIndex,
             int newFirstIndex, int newLastIndex) {
         // messagesTable.setCurrentMessage(newFirstIndex, newLastIndex);
     }
 
     /***
      * Returns the view icon.
      * 
      * @return View icon.
      */
     public Icon getIcon() {
         return LAResourceBundle.getIcon("FilteredMessagesView.icon");
     }
 
     /***
      * Returns the view title.
      * 
      * @return View title.
      */
     public String getTitle() {
         return LAResourceBundle
                 .getLocalizedString("FilteredMessagesView.title");
     }
 
     /***
      * Used to notify listeners when the current messages selection is changed.
      * 
      * @param firstIndex
      *            First messageLabel index.
      * @param lastIndex
      *            Last messageLabel index.
      */
     public void messageChangedNotify(int firstIndex, int lastIndex) {
         super.messageChangedNotify(getFilteredLogHandler().getRealIndex(
                 firstIndex), getFilteredLogHandler().getRealIndex(lastIndex));
     }
 
     /***
      * Receives a start parsing event.
      * 
      * @param logHander
      *            Log handler used as data source.
      * @see net.logAnalyzer.handlers.LALogHandlerListener#startParsing(LALogHandler)
      */
     public void startParsing(LALogHandler logHander) {
         setCursor(Cursor.getPredefinedCursor(Cursor.WAIT_CURSOR));
         statusbar.setVisible(true);
         statusbar.setMessage(LAResourceBundle.getLocalizedString(
                 "FilteredMessagesView.filtering", Long.toString(logHander
                         .getSize())));
     }
 
     /***
      * Receives a step parsing event.
      * 
      * @param logHandler
      *            Log handler used as data source.
      * @see net.logAnalyzer.handlers.LALogHandlerListener#stepParsing(LALogHandler)
      */
     public void stepParsing(LALogHandler logHandler) {
         int percents = logHandler.getPercentDone();
         statusbar.setMessage(LAResourceBundle.getLocalizedString(
                 "FilteredMessagesView.filtering", Long.toString(logHandler
                         .getSize())));
         statusbar.setProgressBar(percents + "%", percents);
     }
 
     /***
      * Receives an end parsing event.
      * 
      * @see net.logAnalyzer.handlers.LALogHandlerListener#endParsing(LALogHandler)
      */
     public void endParsing(LALogHandler logHander) {
         setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));
         statusbar.setVisible(false);
     }
 }