package org.apache.log4j.lf5.viewer; 

 

import java.awt.BorderLayout; 

import java.awt.Color; 

import java.awt.Component; 

import java.awt.Dimension; 

import java.awt.FlowLayout; 

import java.awt.Font; 

import java.awt.GraphicsEnvironment; 

import java.awt.Toolkit; 

import java.awt.event.ActionEvent; 

import java.awt.event.ActionListener; 

import java.awt.event.WindowAdapter; 

import java.awt.event.WindowEvent; 

import java.io.File; 

import java.io.IOException; 

import java.io.InputStream; 

import java.net.MalformedURLException; 

import java.net.URL; 

import java.util.ArrayList; 

import java.util.HashMap; 

import java.util.Iterator; 

import java.util.List; 

import java.util.Map; 

import java.util.StringTokenizer; 

import java.util.Vector; 

 

import javax.swing.BorderFactory; 

import javax.swing.ImageIcon; 

import javax.swing.JButton; 

import javax.swing.JCheckBoxMenuItem; 

import javax.swing.JColorChooser; 

import javax.swing.JComboBox; 

import javax.swing.JFileChooser; 

import javax.swing.JFrame; 

import javax.swing.JLabel; 

import javax.swing.JMenu; 

import javax.swing.JMenuBar; 

import javax.swing.JMenuItem; 

import javax.swing.JOptionPane; 

import javax.swing.JPanel; 

import javax.swing.JScrollPane; 

import javax.swing.JSplitPane; 

import javax.swing.JTextArea; 

import javax.swing.JToolBar; 

import javax.swing.KeyStroke; 

import javax.swing.SwingUtilities; 

 

import org.apache.log4j.lf5.LogLevel; 

import org.apache.log4j.lf5.LogRecord; 

import org.apache.log4j.lf5.LogRecordFilter; 

import org.apache.log4j.lf5.util.DateFormatManager; 

import org.apache.log4j.lf5.util.LogFileParser; 

import org.apache.log4j.lf5.viewer.categoryexplorer.CategoryExplorerTree; 

import org.apache.log4j.lf5.viewer.categoryexplorer.CategoryPath; 

import org.apache.log4j.lf5.viewer.configure.ConfigurationManager; 

import org.apache.log4j.lf5.viewer.configure.MRUFileManager; 

 

/**

 * LogBrokerMonitor 

 *. 

 * @author Michael J. Sikorsky 

 * @author Robert Shaw 

 * @author Brad Marlborough 

 * @author Richard Wan 

 * @author Brent Sprecher 

 * @author Richard Hurst 

 */ 

 

// Contributed by ThoughtWorks Inc. 

 

public class LogBrokerMonitor { 

  //-------------------------------------------------------------------------- 

  //   Constants: 

  //-------------------------------------------------------------------------- 

 

  public static final String DETAILED_VIEW = "Detailed"; 

//    public static final String STANDARD_VIEW = "Standard"; 

//    public static final String COMPACT_VIEW = "Compact"; 

  //-------------------------------------------------------------------------- 

  //   Protected Variables: 

  //-------------------------------------------------------------------------- 

  protected JFrame _logMonitorFrame; 

  protected int _logMonitorFrameWidth = 550; 

  protected int _logMonitorFrameHeight = 500; 

  protected LogTable _table; 

  protected CategoryExplorerTree _categoryExplorerTree; 

  protected String _searchText; 

  protected String _NDCTextFilter = ""; 

  protected LogLevel _leastSevereDisplayedLogLevel = LogLevel.DEBUG; 

 

  protected JScrollPane _logTableScrollPane; 

  protected JLabel _statusLabel; 

  protected Object _lock = new Object(); 

  protected JComboBox _fontSizeCombo; 

 

  protected int _fontSize = 10; 

  protected String _fontName = "Dialog"; 

  protected String _currentView = DETAILED_VIEW; 

 

  protected boolean _loadSystemFonts = false; 

  protected boolean _trackTableScrollPane = true; 

  protected Dimension _lastTableViewportSize; 

  protected boolean _callSystemExitOnClose = false; 

  protected List _displayedLogBrokerProperties = new Vector(); 

 

  protected Map _logLevelMenuItems = new HashMap(); 

  protected Map _logTableColumnMenuItems = new HashMap(); 

 

  protected List _levels = null; 

  protected List _columns = null; 

  protected boolean _isDisposed = false; 

 

  protected ConfigurationManager _configurationManager = null; 

  protected MRUFileManager _mruFileManager = null; 

  protected File _fileLocation = null; 

 

  //-------------------------------------------------------------------------- 

  //   Private Variables: 

  //-------------------------------------------------------------------------- 

 

  //-------------------------------------------------------------------------- 

  //   Constructors: 

  //-------------------------------------------------------------------------- 

 

  /**

   * Construct a LogBrokerMonitor. 

   */ 

  public LogBrokerMonitor(List logLevels) { 

 

    _levels = logLevels; 

    _columns = LogTableColumn.getLogTableColumns(); 

    // This allows us to use the LogBroker in command line tools and 

    // have the option for it to shutdown. 

 

    String callSystemExitOnClose = 

        System.getProperty("monitor.exit"); 

    if (callSystemExitOnClose == null) { 

      callSystemExitOnClose = "false"; 

    } 

    callSystemExitOnClose = callSystemExitOnClose.trim().toLowerCase(); 

 

    if (callSystemExitOnClose.equals("true")) { 

      _callSystemExitOnClose = true; 

    } 

 

    initComponents(); 

 

 

    _logMonitorFrame.addWindowListener( 

        new LogBrokerMonitorWindowAdaptor(this)); 

 

  } 

 

  //-------------------------------------------------------------------------- 

  //   Public Methods: 

  //-------------------------------------------------------------------------- 

 

  /**

   * Show the frame for the LogBrokerMonitor. Dispatched to the 

   * swing thread. 

   */ 

  public void show(final int delay) { 

    if (_logMonitorFrame.isVisible()) { 

      return; 

    } 

    // This request is very low priority, let other threads execute first. 

    SwingUtilities.invokeLater(new Runnable() { 

      public void run() { 

        Thread.yield(); 

        pause(delay); 

        _logMonitorFrame.setVisible(true); 

      } 

    }); 

  } 

 

  public void show() { 

    show(0); 

  } 

 

  /**

   * Dispose of the frame for the LogBrokerMonitor. 

   */ 

  public void dispose() { 

    _logMonitorFrame.dispose(); 

    _isDisposed = true; 

 

    if (_callSystemExitOnClose == true) { 

      System.exit(0); 

    } 

  } 

 

  /**

   * Hide the frame for the LogBrokerMonitor. 

   */ 

  public void hide() { 

    _logMonitorFrame.setVisible(false); 

  } 

 

  /**

   * Get the DateFormatManager for formatting dates. 

   */ 

  public DateFormatManager getDateFormatManager() { 

    return _table.getDateFormatManager(); 

  } 

 

  /**

   * Set the date format manager for formatting dates. 

   */ 

  public void setDateFormatManager(DateFormatManager dfm) { 

    _table.setDateFormatManager(dfm); 

  } 

 

  /**

   * Get the value of whether or not System.exit() will be called 

   * when the LogBrokerMonitor is closed. 

   */ 

  public boolean getCallSystemExitOnClose() { 

    return _callSystemExitOnClose; 

  } 

 

  /**

   * Set the value of whether or not System.exit() will be called 

   * when the LogBrokerMonitor is closed. 

   */ 

  public void setCallSystemExitOnClose(boolean callSystemExitOnClose) { 

    _callSystemExitOnClose = callSystemExitOnClose; 

  } 

 

  /**

   * Add a log record message to be displayed in the LogTable. 

   * This method is thread-safe as it posts requests to the SwingThread 

   * rather than processing directly. 

   */ 

  public void addMessage(final LogRecord lr) { 

    if (_isDisposed == true) { 

      // If the frame has been disposed of, do not log any more 

      // messages. 

      return; 

    } 

 

    SwingUtilities.invokeLater(new Runnable() { 

      public void run() { 

        _categoryExplorerTree.getExplorerModel().addLogRecord(lr); 

        _table.getFilteredLogTableModel().addLogRecord(lr); // update table 

        updateStatusLabel(); // show updated counts 

      } 

    }); 

  } 

 

  public void setMaxNumberOfLogRecords(int maxNumberOfLogRecords) { 

    _table.getFilteredLogTableModel().setMaxNumberOfLogRecords(maxNumberOfLogRecords); 

  } 

 

  public JFrame getBaseFrame() { 

    return _logMonitorFrame; 

  } 

 

  public void setTitle(String title) { 

    _logMonitorFrame.setTitle(title + " - LogFactor5"); 

  } 

 

  public void setFrameSize(int width, int height) { 

    Dimension screen = Toolkit.getDefaultToolkit().getScreenSize(); 

    if (0 < width && width < screen.width) { 

      _logMonitorFrameWidth = width; 

    } 

    if (0 < height && height < screen.height) { 

      _logMonitorFrameHeight = height; 

    } 

    updateFrameSize(); 

  } 

 

  public void setFontSize(int fontSize) { 

    changeFontSizeCombo(_fontSizeCombo, fontSize); 

    // setFontSizeSilently(actualFontSize); - changeFontSizeCombo fires event 

    // refreshDetailTextArea(); 

  } 

 

  public void addDisplayedProperty(Object messageLine) { 

    _displayedLogBrokerProperties.add(messageLine); 

  } 

 

  public Map getLogLevelMenuItems() { 

    return _logLevelMenuItems; 

  } 

 

  public Map getLogTableColumnMenuItems() { 

    return _logTableColumnMenuItems; 

  } 

 

  public JCheckBoxMenuItem getTableColumnMenuItem(LogTableColumn column) { 

    return getLogTableColumnMenuItem(column); 

  } 

 

  public CategoryExplorerTree getCategoryExplorerTree() { 

    return _categoryExplorerTree; 

  } 

 

  // Added in version 1.2 - gets the value of the NDC text filter 

  // This value is set back to null each time the Monitor is initialized. 

  public String getNDCTextFilter() { 

    return _NDCTextFilter; 

  } 

 

  // Added in version 1.2 - sets the NDC Filter based on 

  // a String passed in by the user.  This value is persisted 

  // in the XML Configuration file. 

  public void setNDCLogRecordFilter(String textFilter) { 

    _table.getFilteredLogTableModel(). 

        setLogRecordFilter(createNDCLogRecordFilter(textFilter)); 

  } 

  //-------------------------------------------------------------------------- 

  //   Protected Methods: 

  //-------------------------------------------------------------------------- 

 

  protected void setSearchText(String text) { 

    _searchText = text; 

  } 

 

  // Added in version 1.2 - Sets the text filter for the NDC 

  protected void setNDCTextFilter(String text) { 

    // if no value is set, set it to a blank string 

    // otherwise use the value provided 

    if (text == null) { 

      _NDCTextFilter = ""; 

    } else { 

      _NDCTextFilter = text; 

    } 

  } 

 

  // Added in version 1.2 - Uses a different filter that sorts 

  // based on an NDC string passed in by the user.  If the string 

  // is null or is an empty string, we do nothing. 

  protected void sortByNDC() { 

    String text = _NDCTextFilter; 

    if (text == null || text.length() == 0) { 

      return; 

    } 

 

    // Use new NDC filter 

    _table.getFilteredLogTableModel(). 

        setLogRecordFilter(createNDCLogRecordFilter(text)); 

  } 

 

  protected void findSearchText() { 

    String text = _searchText; 

    if (text == null || text.length() == 0) { 

      return; 

    } 

    int startRow = getFirstSelectedRow(); 

    int foundRow = findRecord( 

        startRow, 

        text, 

        _table.getFilteredLogTableModel().getFilteredRecords() 

    ); 

    selectRow(foundRow); 

  } 

 

  protected int getFirstSelectedRow() { 

    return _table.getSelectionModel().getMinSelectionIndex(); 

  } 

 

  protected void selectRow(int foundRow) { 

    if (foundRow == -1) { 

      String message = _searchText + " not found."; 

      JOptionPane.showMessageDialog( 

          _logMonitorFrame, 

          message, 

          "Text not found", 

          JOptionPane.INFORMATION_MESSAGE 

      ); 

      return; 

    } 

    LF5SwingUtils.selectRow(foundRow, _table, _logTableScrollPane); 

  } 

 

  protected int findRecord( 

      int startRow, 

      String searchText, 

      List records 

      ) { 

    if (startRow < 0) { 

      startRow = 0; // start at first element if no rows are selected 

    } else { 

      startRow++; // start after the first selected row 

    } 

    int len = records.size(); 

 

    for (int i = startRow; i < len; i++) { 

      if (matches((LogRecord) records.get(i), searchText)) { 

        return i; // found a record 

      } 

    } 

    // wrap around to beginning if when we reach the end with no match 

    len = startRow; 

    for (int i = 0; i < len; i++) { 

      if (matches((LogRecord) records.get(i), searchText)) { 

        return i; // found a record 

      } 

    } 

    // nothing found 

    return -1; 

  } 

 

  /**

   * Check to see if the any records contain the search string. 

   * Searching now supports NDC messages and date. 

   */ 

  protected boolean matches(LogRecord record, String text) { 

    String message = record.getMessage(); 

    String NDC = record.getNDC(); 

 

    if (message == null && NDC == null || text == null) { 

      return false; 

    } 

    if (message.toLowerCase().indexOf(text.toLowerCase()) == -1 && 

        NDC.toLowerCase().indexOf(text.toLowerCase()) == -1) { 

      return false; 

    } 

 

    return true; 

  } 

 

  /**

   * When the fontsize of a JTextArea is changed, the word-wrapped lines 

   * may become garbled.  This method clears and resets the text of the 

   * text area. 

   */ 

  protected void refresh(JTextArea textArea) { 

    String text = textArea.getText(); 

    textArea.setText(""); 

    textArea.setText(text); 

  } 

 

  protected void refreshDetailTextArea() { 

    refresh(_table._detailTextArea); 

  } 

 

  protected void clearDetailTextArea() { 

    _table._detailTextArea.setText(""); 

  } 

 

  /**

   * Changes the font selection in the combo box and returns the 

   * size actually selected. 

   * @return -1 if unable to select an appropriate font 

   */ 

  protected int changeFontSizeCombo(JComboBox box, int requestedSize) { 

    int len = box.getItemCount(); 

    int currentValue; 

    Object currentObject; 

    Object selectedObject = box.getItemAt(0); 

    int selectedValue = Integer.parseInt(String.valueOf(selectedObject)); 

    for (int i = 0; i < len; i++) { 

      currentObject = box.getItemAt(i); 

      currentValue = Integer.parseInt(String.valueOf(currentObject)); 

      if (selectedValue < currentValue && currentValue <= requestedSize) { 

        selectedValue = currentValue; 

        selectedObject = currentObject; 

      } 

    } 

    box.setSelectedItem(selectedObject); 

    return selectedValue; 

  } 

 

  /**

   * Does not update gui or cause any events to be fired. 

   */ 

  protected void setFontSizeSilently(int fontSize) { 

    _fontSize = fontSize; 

    setFontSize(_table._detailTextArea, fontSize); 

    selectRow(0); 

    setFontSize(_table, fontSize); 

  } 

 

  protected void setFontSize(Component component, int fontSize) { 

    Font oldFont = component.getFont(); 

    Font newFont = 

        new Font(oldFont.getFontName(), oldFont.getStyle(), fontSize); 

    component.setFont(newFont); 

  } 

 

  protected void updateFrameSize() { 

    _logMonitorFrame.setSize(_logMonitorFrameWidth, _logMonitorFrameHeight); 

    centerFrame(_logMonitorFrame); 

  } 

 

  protected void pause(int millis) { 

    try { 

      Thread.sleep(millis); 

    } catch (InterruptedException e) { 

 

    } 

  } 

 

  protected void initComponents() { 

    // 

    // Configure the Frame. 

    // 

    _logMonitorFrame = new JFrame("LogFactor5"); 

 

    _logMonitorFrame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE); 

 

    String resource = 

        "/org/apache/log4j/lf5/viewer/images/lf5_small_icon.gif"; 

    URL lf5IconURL = getClass().getResource(resource); 

 

    if (lf5IconURL != null) { 

      _logMonitorFrame.setIconImage(new ImageIcon(lf5IconURL).getImage()); 

    } 

    updateFrameSize(); 

 

    // 

    // Configure the LogTable. 

    // 

    JTextArea detailTA = createDetailTextArea(); 

    JScrollPane detailTAScrollPane = new JScrollPane(detailTA); 

    _table = new LogTable(detailTA); 

    setView(_currentView, _table); 

    _table.setFont(new Font(_fontName, Font.PLAIN, _fontSize)); 

    _logTableScrollPane = new JScrollPane(_table); 

 

    if (_trackTableScrollPane) { 

      _logTableScrollPane.getVerticalScrollBar().addAdjustmentListener( 

          new TrackingAdjustmentListener() 

      ); 

    } 

 

 

    // Configure the SplitPane between the LogTable & DetailTextArea 

    // 

 

    JSplitPane tableViewerSplitPane = new JSplitPane(); 

    tableViewerSplitPane.setOneTouchExpandable(true); 

    tableViewerSplitPane.setOrientation(JSplitPane.VERTICAL_SPLIT); 

    tableViewerSplitPane.setLeftComponent(_logTableScrollPane); 

    tableViewerSplitPane.setRightComponent(detailTAScrollPane); 

    // Make sure to do this last.. 

    //tableViewerSplitPane.setDividerLocation(1.0); Doesn't work 

    //the same under 1.2.x & 1.3 

    // "350" is a magic number that provides the correct default 

    // behaviour under 1.2.x & 1.3.  For example, bumping this 

    // number to 400, causes the pane to be completely open in 1.2.x 

    // and closed in 1.3 

    tableViewerSplitPane.setDividerLocation(350); 

 

    // 

    // Configure the CategoryExplorer 

    // 

 

    _categoryExplorerTree = new CategoryExplorerTree(); 

 

    _table.getFilteredLogTableModel().setLogRecordFilter(createLogRecordFilter()); 

 

    JScrollPane categoryExplorerTreeScrollPane = 

        new JScrollPane(_categoryExplorerTree); 

    categoryExplorerTreeScrollPane.setPreferredSize(new Dimension(130, 400)); 

 

    // Load most recently used file list 

    _mruFileManager = new MRUFileManager(); 

 

    // 

    // Configure the SplitPane between the CategoryExplorer & (LogTable/Detail) 

    // 

 

    JSplitPane splitPane = new JSplitPane(); 

    splitPane.setOneTouchExpandable(true); 

    splitPane.setRightComponent(tableViewerSplitPane); 

    splitPane.setLeftComponent(categoryExplorerTreeScrollPane); 

    // Do this last. 

    splitPane.setDividerLocation(130); 

    // 

    // Add the MenuBar, StatusArea, CategoryExplorer|LogTable to the 

    // LogMonitorFrame. 

    // 

    _logMonitorFrame.getRootPane().setJMenuBar(createMenuBar()); 

    _logMonitorFrame.getContentPane().add(splitPane, BorderLayout.CENTER); 

    _logMonitorFrame.getContentPane().add(createToolBar(), 

        BorderLayout.NORTH); 

    _logMonitorFrame.getContentPane().add(createStatusArea(), 

        BorderLayout.SOUTH); 

 

    makeLogTableListenToCategoryExplorer(); 

    addTableModelProperties(); 

 

    // 

    // Configure ConfigurationManager 

    // 

    _configurationManager = new ConfigurationManager(this, _table); 

 

  } 

 

  protected LogRecordFilter createLogRecordFilter() { 

    LogRecordFilter result = new LogRecordFilter() { 

      public boolean passes(LogRecord record) { 

        CategoryPath path = new CategoryPath(record.getCategory()); 

        return 

            getMenuItem(record.getLevel()).isSelected() && 

            _categoryExplorerTree.getExplorerModel().isCategoryPathActive(path); 

      } 

    }; 

    return result; 

  } 

 

  // Added in version 1.2 - Creates a new filter that sorts records based on 

  // an NDC string passed in by the user. 

  protected LogRecordFilter createNDCLogRecordFilter(String text) { 

    _NDCTextFilter = text; 

    LogRecordFilter result = new LogRecordFilter() { 

      public boolean passes(LogRecord record) { 

        String NDC = record.getNDC(); 

        CategoryPath path = new CategoryPath(record.getCategory()); 

        if (NDC == null || _NDCTextFilter == null) { 

          return false; 

        } else if (NDC.toLowerCase().indexOf(_NDCTextFilter.toLowerCase()) == -1) { 

          return false; 

        } else { 

          return getMenuItem(record.getLevel()).isSelected() && 

              _categoryExplorerTree.getExplorerModel().isCategoryPathActive(path); 

        } 

      } 

    }; 

 

    return result; 

  } 

 

 

  protected void updateStatusLabel() { 

    _statusLabel.setText(getRecordsDisplayedMessage()); 

  } 

 

  protected String getRecordsDisplayedMessage() { 

    FilteredLogTableModel model = _table.getFilteredLogTableModel(); 

    return getStatusText(model.getRowCount(), model.getTotalRowCount()); 

  } 

 

  protected void addTableModelProperties() { 

    final FilteredLogTableModel model = _table.getFilteredLogTableModel(); 

 

    addDisplayedProperty(new Object() { 

      public String toString() { 

        return getRecordsDisplayedMessage(); 

      } 

    }); 

    addDisplayedProperty(new Object() { 

      public String toString() { 

        return "Maximum number of displayed LogRecords: " 

            + model._maxNumberOfLogRecords; 

      } 

    }); 

  } 

 

  protected String getStatusText(int displayedRows, int totalRows) { 

    StringBuffer result = new StringBuffer(); 

    result.append("Displaying: "); 

    result.append(displayedRows); 

    result.append(" records out of a total of: "); 

    result.append(totalRows); 

    result.append(" records."); 

    return result.toString(); 

  } 

 

  protected void makeLogTableListenToCategoryExplorer() { 

    ActionListener listener = new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

        _table.getFilteredLogTableModel().refresh(); 

        updateStatusLabel(); 

      } 

    }; 

    _categoryExplorerTree.getExplorerModel().addActionListener(listener); 

  } 

 

  protected JPanel createStatusArea() { 

    JPanel statusArea = new JPanel(); 

    JLabel status = 

        new JLabel("No log records to display."); 

    _statusLabel = status; 

    status.setHorizontalAlignment(JLabel.LEFT); 

 

    statusArea.setBorder(BorderFactory.createEtchedBorder()); 

    statusArea.setLayout(new FlowLayout(FlowLayout.LEFT, 0, 0)); 

    statusArea.add(status); 

 

    return (statusArea); 

  } 

 

  protected JTextArea createDetailTextArea() { 

    JTextArea detailTA = new JTextArea(); 

    detailTA.setFont(new Font("Monospaced", Font.PLAIN, 14)); 

    detailTA.setTabSize(3); 

    detailTA.setLineWrap(true); 

    detailTA.setWrapStyleWord(false); 

    return (detailTA); 

  } 

 

  protected JMenuBar createMenuBar() { 

    JMenuBar menuBar = new JMenuBar(); 

    menuBar.add(createFileMenu()); 

    menuBar.add(createEditMenu()); 

    menuBar.add(createLogLevelMenu()); 

    menuBar.add(createViewMenu()); 

    menuBar.add(createConfigureMenu()); 

    menuBar.add(createHelpMenu()); 

 

    return (menuBar); 

  } 

 

  protected JMenu createLogLevelMenu() { 

    JMenu result = new JMenu("Log Level"); 

    result.setMnemonic('l'); 

    Iterator levels = getLogLevels(); 

    while (levels.hasNext()) { 

      result.add(getMenuItem((LogLevel) levels.next())); 

    } 

 

    result.addSeparator(); 

    result.add(createAllLogLevelsMenuItem()); 

    result.add(createNoLogLevelsMenuItem()); 

    result.addSeparator(); 

    result.add(createLogLevelColorMenu()); 

    result.add(createResetLogLevelColorMenuItem()); 

 

    return result; 

  } 

 

  protected JMenuItem createAllLogLevelsMenuItem() { 

    JMenuItem result = new JMenuItem("Show all LogLevels"); 

    result.setMnemonic('s'); 

    result.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

        selectAllLogLevels(true); 

        _table.getFilteredLogTableModel().refresh(); 

        updateStatusLabel(); 

      } 

    }); 

    return result; 

  } 

 

  protected JMenuItem createNoLogLevelsMenuItem() { 

    JMenuItem result = new JMenuItem("Hide all LogLevels"); 

    result.setMnemonic('h'); 

    result.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

        selectAllLogLevels(false); 

        _table.getFilteredLogTableModel().refresh(); 

        updateStatusLabel(); 

      } 

    }); 

    return result; 

  } 

 

  protected JMenu createLogLevelColorMenu() { 

    JMenu colorMenu = new JMenu("Configure LogLevel Colors"); 

    colorMenu.setMnemonic('c'); 

    Iterator levels = getLogLevels(); 

    while (levels.hasNext()) { 

      colorMenu.add(createSubMenuItem((LogLevel) levels.next())); 

    } 

 

    return colorMenu; 

  } 

 

  protected JMenuItem createResetLogLevelColorMenuItem() { 

    JMenuItem result = new JMenuItem("Reset LogLevel Colors"); 

    result.setMnemonic('r'); 

    result.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

        // reset the level colors in the map 

        LogLevel.resetLogLevelColorMap(); 

 

        // refresh the table 

        _table.getFilteredLogTableModel().refresh(); 

      } 

    }); 

    return result; 

  } 

 

  protected void selectAllLogLevels(boolean selected) { 

    Iterator levels = getLogLevels(); 

    while (levels.hasNext()) { 

      getMenuItem((LogLevel) levels.next()).setSelected(selected); 

    } 

  } 

 

  protected JCheckBoxMenuItem getMenuItem(LogLevel level) { 

    JCheckBoxMenuItem result = (JCheckBoxMenuItem) (_logLevelMenuItems.get(level)); 

    if (result == null) { 

      result = createMenuItem(level); 

      _logLevelMenuItems.put(level, result); 

    } 

    return result; 

  } 

 

  protected JMenuItem createSubMenuItem(LogLevel level) { 

    final JMenuItem result = new JMenuItem(level.toString()); 

    final LogLevel logLevel = level; 

    result.setMnemonic(level.toString().charAt(0)); 

    result.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

        showLogLevelColorChangeDialog(result, logLevel); 

      } 

    }); 

 

    return result; 

 

  } 

 

  protected void showLogLevelColorChangeDialog(JMenuItem result, LogLevel level) { 

    JMenuItem menuItem = result; 

    Color newColor = JColorChooser.showDialog( 

        _logMonitorFrame, 

        "Choose LogLevel Color", 

        result.getForeground()); 

 

    if (newColor != null) { 

      // set the color for the record 

      level.setLogLevelColorMap(level, newColor); 

      _table.getFilteredLogTableModel().refresh(); 

    } 

 

  } 

 

  protected JCheckBoxMenuItem createMenuItem(LogLevel level) { 

    JCheckBoxMenuItem result = new JCheckBoxMenuItem(level.toString()); 

    result.setSelected(true); 

    result.setMnemonic(level.toString().charAt(0)); 

    result.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

        _table.getFilteredLogTableModel().refresh(); 

        updateStatusLabel(); 

      } 

    }); 

    return result; 

  } 

 

  // view menu 

  protected JMenu createViewMenu() { 

    JMenu result = new JMenu("View"); 

    result.setMnemonic('v'); 

    Iterator columns = getLogTableColumns(); 

    while (columns.hasNext()) { 

      result.add(getLogTableColumnMenuItem((LogTableColumn) columns.next())); 

    } 

 

    result.addSeparator(); 

    result.add(createAllLogTableColumnsMenuItem()); 

    result.add(createNoLogTableColumnsMenuItem()); 

    return result; 

  } 

 

  protected JCheckBoxMenuItem getLogTableColumnMenuItem(LogTableColumn column) { 

    JCheckBoxMenuItem result = (JCheckBoxMenuItem) (_logTableColumnMenuItems.get(column)); 

    if (result == null) { 

      result = createLogTableColumnMenuItem(column); 

      _logTableColumnMenuItems.put(column, result); 

    } 

    return result; 

  } 

 

  protected JCheckBoxMenuItem createLogTableColumnMenuItem(LogTableColumn column) { 

    JCheckBoxMenuItem result = new JCheckBoxMenuItem(column.toString()); 

 

    result.setSelected(true); 

    result.setMnemonic(column.toString().charAt(0)); 

    result.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

        // update list of columns and reset the view 

        List selectedColumns = updateView(); 

        _table.setView(selectedColumns); 

      } 

    }); 

    return result; 

  } 

 

  protected List updateView() { 

    ArrayList updatedList = new ArrayList(); 

    Iterator columnIterator = _columns.iterator(); 

    while (columnIterator.hasNext()) { 

      LogTableColumn column = (LogTableColumn) columnIterator.next(); 

      JCheckBoxMenuItem result = getLogTableColumnMenuItem(column); 

      // check and see if the checkbox is checked 

      if (result.isSelected()) { 

        updatedList.add(column); 

      } 

    } 

 

    return updatedList; 

  } 

 

  protected JMenuItem createAllLogTableColumnsMenuItem() { 

    JMenuItem result = new JMenuItem("Show all Columns"); 

    result.setMnemonic('s'); 

    result.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

        selectAllLogTableColumns(true); 

        // update list of columns and reset the view 

        List selectedColumns = updateView(); 

        _table.setView(selectedColumns); 

      } 

    }); 

    return result; 

  } 

 

  protected JMenuItem createNoLogTableColumnsMenuItem() { 

    JMenuItem result = new JMenuItem("Hide all Columns"); 

    result.setMnemonic('h'); 

    result.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

        selectAllLogTableColumns(false); 

        // update list of columns and reset the view 

        List selectedColumns = updateView(); 

        _table.setView(selectedColumns); 

      } 

    }); 

    return result; 

  } 

 

  protected void selectAllLogTableColumns(boolean selected) { 

    Iterator columns = getLogTableColumns(); 

    while (columns.hasNext()) { 

      getLogTableColumnMenuItem((LogTableColumn) columns.next()).setSelected(selected); 

    } 

  } 

 

  protected JMenu createFileMenu() { 

    JMenu fileMenu = new JMenu("File"); 

    fileMenu.setMnemonic('f'); 

    JMenuItem exitMI; 

    fileMenu.add(createOpenMI()); 

    fileMenu.add(createOpenURLMI()); 

    fileMenu.addSeparator(); 

    fileMenu.add(createCloseMI()); 

    createMRUFileListMI(fileMenu); 

    fileMenu.addSeparator(); 

    fileMenu.add(createExitMI()); 

    return fileMenu; 

  } 

 

  /**

   * Menu item added to allow log files to be opened with 

   * the LF5 GUI. 

   */ 

  protected JMenuItem createOpenMI() { 

    JMenuItem result = new JMenuItem("Open..."); 

    result.setMnemonic('o'); 

    result.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

        requestOpen(); 

      } 

    }); 

    return result; 

  } 

 

  /**

   * Menu item added to allow log files loaded from a URL 

   * to be opened by the LF5 GUI. 

   */ 

  protected JMenuItem createOpenURLMI() { 

    JMenuItem result = new JMenuItem("Open URL..."); 

    result.setMnemonic('u'); 

    result.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

        requestOpenURL(); 

      } 

    }); 

    return result; 

  } 

 

  protected JMenuItem createCloseMI() { 

    JMenuItem result = new JMenuItem("Close"); 

    result.setMnemonic('c'); 

    result.setAccelerator(KeyStroke.getKeyStroke("control Q")); 

    result.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

        requestClose(); 

      } 

    }); 

    return result; 

  } 

 

  /**

   * Creates a Most Recently Used file list to be 

   * displayed in the File menu 

   */ 

  protected void createMRUFileListMI(JMenu menu) { 

 

    String[] files = _mruFileManager.getMRUFileList(); 

 

    if (files != null) { 

      menu.addSeparator(); 

      for (int i = 0; i < files.length; i++) { 

        JMenuItem result = new JMenuItem((i + 1) + " " + files[i]); 

        result.setMnemonic(i + 1); 

        result.addActionListener(new ActionListener() { 

          public void actionPerformed(ActionEvent e) { 

            requestOpenMRU(e); 

          } 

        }); 

        menu.add(result); 

      } 

    } 

  } 

 

  protected JMenuItem createExitMI() { 

    JMenuItem result = new JMenuItem("Exit"); 

    result.setMnemonic('x'); 

    result.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

        requestExit(); 

      } 

    }); 

    return result; 

  } 

 

  protected JMenu createConfigureMenu() { 

    JMenu configureMenu = new JMenu("Configure"); 

    configureMenu.setMnemonic('c'); 

    configureMenu.add(createConfigureSave()); 

    configureMenu.add(createConfigureReset()); 

    configureMenu.add(createConfigureMaxRecords()); 

 

    return configureMenu; 

  } 

 

  protected JMenuItem createConfigureSave() { 

    JMenuItem result = new JMenuItem("Save"); 

    result.setMnemonic('s'); 

    result.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

        saveConfiguration(); 

      } 

    }); 

 

    return result; 

  } 

 

  protected JMenuItem createConfigureReset() { 

    JMenuItem result = new JMenuItem("Reset"); 

    result.setMnemonic('r'); 

    result.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

        resetConfiguration(); 

      } 

    }); 

 

    return result; 

  } 

 

  protected JMenuItem createConfigureMaxRecords() { 

    JMenuItem result = new JMenuItem("Set Max Number of Records"); 

    result.setMnemonic('m'); 

    result.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

        setMaxRecordConfiguration(); 

      } 

    }); 

 

    return result; 

  } 

 

 

  protected void saveConfiguration() { 

    _configurationManager.save(); 

  } 

 

  protected void resetConfiguration() { 

    _configurationManager.reset(); 

  } 

 

  protected void setMaxRecordConfiguration() { 

    LogFactor5InputDialog inputDialog = new LogFactor5InputDialog( 

        getBaseFrame(), "Set Max Number of Records", "", 10); 

 

    String temp = inputDialog.getText(); 

 

    if (temp != null) { 

      try { 

        setMaxNumberOfLogRecords(Integer.parseInt(temp)); 

      } catch (NumberFormatException e) { 

        LogFactor5ErrorDialog error = new LogFactor5ErrorDialog( 

            getBaseFrame(), 

            "'" + temp + "' is an invalid parameter.\nPlease try again."); 

        setMaxRecordConfiguration(); 

      } 

    } 

  } 

 

 

  protected JMenu createHelpMenu() { 

    JMenu helpMenu = new JMenu("Help"); 

    helpMenu.setMnemonic('h'); 

    helpMenu.add(createHelpProperties()); 

    return helpMenu; 

  } 

 

  protected JMenuItem createHelpProperties() { 

    final String title = "LogFactor5 Properties"; 

    final JMenuItem result = new JMenuItem(title); 

    result.setMnemonic('l'); 

    result.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

        showPropertiesDialog(title); 

      } 

    }); 

    return result; 

  } 

 

  protected void showPropertiesDialog(String title) { 

    JOptionPane.showMessageDialog( 

        _logMonitorFrame, 

        _displayedLogBrokerProperties.toArray(), 

        title, 

        JOptionPane.PLAIN_MESSAGE 

    ); 

  } 

 

  protected JMenu createEditMenu() { 

    JMenu editMenu = new JMenu("Edit"); 

    editMenu.setMnemonic('e'); 

    editMenu.add(createEditFindMI()); 

    editMenu.add(createEditFindNextMI()); 

    editMenu.addSeparator(); 

    editMenu.add(createEditSortNDCMI()); 

    editMenu.add(createEditRestoreAllNDCMI()); 

    return editMenu; 

  } 

 

  protected JMenuItem createEditFindNextMI() { 

    JMenuItem editFindNextMI = new JMenuItem("Find Next"); 

    editFindNextMI.setMnemonic('n'); 

    editFindNextMI.setAccelerator(KeyStroke.getKeyStroke("F3")); 

    editFindNextMI.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

        findSearchText(); 

      } 

    }); 

    return editFindNextMI; 

  } 

 

  protected JMenuItem createEditFindMI() { 

    JMenuItem editFindMI = new JMenuItem("Find"); 

    editFindMI.setMnemonic('f'); 

    editFindMI.setAccelerator(KeyStroke.getKeyStroke("control F")); 

 

    editFindMI.addActionListener( 

        new ActionListener() { 

          public void actionPerformed(ActionEvent e) { 

            String inputValue = 

                JOptionPane.showInputDialog( 

                    _logMonitorFrame, 

                    "Find text: ", 

                    "Search Record Messages", 

                    JOptionPane.QUESTION_MESSAGE 

                ); 

            setSearchText(inputValue); 

            findSearchText(); 

          } 

        } 

 

    ); 

    return editFindMI; 

  } 

 

  // Added version 1.2 - Allows users to Sort Log Records by an 

  // NDC text filter. A new LogRecordFilter was created to 

  // sort the records. 

  protected JMenuItem createEditSortNDCMI() { 

    JMenuItem editSortNDCMI = new JMenuItem("Sort by NDC"); 

    editSortNDCMI.setMnemonic('s'); 

    editSortNDCMI.addActionListener( 

        new ActionListener() { 

          public void actionPerformed(ActionEvent e) { 

            String inputValue = 

                JOptionPane.showInputDialog( 

                    _logMonitorFrame, 

                    "Sort by this NDC: ", 

                    "Sort Log Records by NDC", 

                    JOptionPane.QUESTION_MESSAGE 

                ); 

            setNDCTextFilter(inputValue); 

            sortByNDC(); 

            _table.getFilteredLogTableModel().refresh(); 

            updateStatusLabel(); 

          } 

        } 

 

    ); 

    return editSortNDCMI; 

  } 

 

  // Added in version 1.2 - Resets the LogRecordFilter back to default 

  // filter. 

  protected JMenuItem createEditRestoreAllNDCMI() { 

    JMenuItem editRestoreAllNDCMI = new JMenuItem("Restore all NDCs"); 

    editRestoreAllNDCMI.setMnemonic('r'); 

    editRestoreAllNDCMI.addActionListener( 

        new ActionListener() { 

          public void actionPerformed(ActionEvent e) { 

            _table.getFilteredLogTableModel().setLogRecordFilter(createLogRecordFilter()); 

            // reset the text filter 

            setNDCTextFilter(""); 

            _table.getFilteredLogTableModel().refresh(); 

            updateStatusLabel(); 

          } 

        } 

    ); 

    return editRestoreAllNDCMI; 

  } 

 

  protected JToolBar createToolBar() { 

    JToolBar tb = new JToolBar(); 

    tb.putClientProperty("JToolBar.isRollover", Boolean.TRUE); 

    JComboBox fontCombo = new JComboBox(); 

    JComboBox fontSizeCombo = new JComboBox(); 

    _fontSizeCombo = fontSizeCombo; 

 

    ClassLoader cl = this.getClass().getClassLoader(); 

    if(cl == null) { 

        cl = ClassLoader.getSystemClassLoader(); 

    } 

    URL newIconURL = cl.getResource("org/apache/log4j/lf5/viewer/" + 

        "images/channelexplorer_new.gif"); 

 

    ImageIcon newIcon = null; 

 

    if (newIconURL != null) { 

      newIcon = new ImageIcon(newIconURL); 

    } 

 

    JButton newButton = new JButton("Clear Log Table"); 

 

    if (newIcon != null) { 

      newButton.setIcon(newIcon); 

    } 

 

    newButton.setToolTipText("Clear Log Table."); 

    //newButton.setBorder(BorderFactory.createEtchedBorder()); 

 

    newButton.addActionListener( 

        new ActionListener() { 

          public void actionPerformed(ActionEvent e) { 

            _table.clearLogRecords(); 

            _categoryExplorerTree.getExplorerModel().resetAllNodeCounts(); 

            updateStatusLabel(); 

            clearDetailTextArea(); 

            LogRecord.resetSequenceNumber(); 

          } 

        } 

    ); 

 

    Toolkit tk = Toolkit.getDefaultToolkit(); 

    // This will actually grab all the fonts 

 

    String[] fonts; 

 

    if (_loadSystemFonts) { 

      fonts = GraphicsEnvironment. 

          getLocalGraphicsEnvironment().getAvailableFontFamilyNames(); 

    } else { 

      fonts = tk.getFontList(); 

    } 

 

    for (int j = 0; j < fonts.length; j++) { 

      fontCombo.addItem(fonts[j]); 

    } 

 

    fontCombo.setSelectedItem(_fontName); 

 

    fontCombo.addActionListener( 

 

        new ActionListener() { 

          public void actionPerformed(ActionEvent e) { 

            JComboBox box = (JComboBox) e.getSource(); 

            String font = (String) box.getSelectedItem(); 

            _table.setFont(new Font(font, Font.PLAIN, _fontSize)); 

            _fontName = font; 

          } 

        } 

    ); 

 

    fontSizeCombo.addItem("8"); 

    fontSizeCombo.addItem("9"); 

    fontSizeCombo.addItem("10"); 

    fontSizeCombo.addItem("12"); 

    fontSizeCombo.addItem("14"); 

    fontSizeCombo.addItem("16"); 

    fontSizeCombo.addItem("18"); 

    fontSizeCombo.addItem("24"); 

 

    fontSizeCombo.setSelectedItem(String.valueOf(_fontSize)); 

    fontSizeCombo.addActionListener( 

        new ActionListener() { 

          public void actionPerformed(ActionEvent e) { 

            JComboBox box = (JComboBox) e.getSource(); 

            String size = (String) box.getSelectedItem(); 

            int s = Integer.valueOf(size).intValue(); 

 

            setFontSizeSilently(s); 

            refreshDetailTextArea(); 

            _fontSize = s; 

          } 

        } 

    ); 

 

    tb.add(new JLabel(" Font: ")); 

    tb.add(fontCombo); 

    tb.add(fontSizeCombo); 

    tb.addSeparator(); 

    tb.addSeparator(); 

    tb.add(newButton); 

 

    newButton.setAlignmentY(0.5f); 

    newButton.setAlignmentX(0.5f); 

 

    fontCombo.setMaximumSize(fontCombo.getPreferredSize()); 

    fontSizeCombo.setMaximumSize( 

        fontSizeCombo.getPreferredSize()); 

 

    return (tb); 

  } 

 

//    protected void setView(String viewString, LogTable table) { 

//        if (STANDARD_VIEW.equals(viewString)) { 

//            table.setStandardView(); 

//        } else if (COMPACT_VIEW.equals(viewString)) { 

//            table.setCompactView(); 

//        } else if (DETAILED_VIEW.equals(viewString)) { 

//            table.setDetailedView(); 

//        } else { 

//            String message = viewString + "does not match a supported view."; 

//            throw new IllegalArgumentException(message); 

//        } 

//        _currentView = viewString; 

//    } 

 

  protected void setView(String viewString, LogTable table) { 

    if (DETAILED_VIEW.equals(viewString)) { 

      table.setDetailedView(); 

    } else { 

      String message = viewString + "does not match a supported view."; 

      throw new IllegalArgumentException(message); 

    } 

    _currentView = viewString; 

  } 

 

  protected JComboBox createLogLevelCombo() { 

    JComboBox result = new JComboBox(); 

    Iterator levels = getLogLevels(); 

    while (levels.hasNext()) { 

      result.addItem(levels.next()); 

    } 

    result.setSelectedItem(_leastSevereDisplayedLogLevel); 

 

    result.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

        JComboBox box = (JComboBox) e.getSource(); 

        LogLevel level = (LogLevel) box.getSelectedItem(); 

        setLeastSevereDisplayedLogLevel(level); 

      } 

    }); 

    result.setMaximumSize(result.getPreferredSize()); 

    return result; 

  } 

 

  protected void setLeastSevereDisplayedLogLevel(LogLevel level) { 

    if (level == null || _leastSevereDisplayedLogLevel == level) { 

      return; // nothing to do 

    } 

    _leastSevereDisplayedLogLevel = level; 

    _table.getFilteredLogTableModel().refresh(); 

    updateStatusLabel(); 

  } 

 

  /**

   * Ensures that the Table's ScrollPane Viewport will "track" with updates 

   * to the Table.  When the vertical scroll bar is at its bottom anchor 

   * and tracking is enabled then viewport will stay at the bottom most 

   * point of the component.  The purpose of this feature is to allow 

   * a developer to watch the table as messages arrive and not have to 

   * scroll after each new message arrives.  When the vertical scroll bar 

   * is at any other location, then no tracking will happen. 

   * @deprecated tracking is now done automatically. 

   */ 

  protected void trackTableScrollPane() { 

    // do nothing 

  } 

 

  protected void centerFrame(JFrame frame) { 

    Dimension screen = Toolkit.getDefaultToolkit().getScreenSize(); 

    Dimension comp = frame.getSize(); 

 

    frame.setLocation(((screen.width - comp.width) / 2), 

        ((screen.height - comp.height) / 2)); 

 

  } 

 

  /**

   * Uses a JFileChooser to select a file to opened with the 

   * LF5 GUI. 

   */ 

  protected void requestOpen() { 

    JFileChooser chooser; 

 

    if (_fileLocation == null) { 

      chooser = new JFileChooser(); 

    } else { 

      chooser = new JFileChooser(_fileLocation); 

    } 

 

    int returnVal = chooser.showOpenDialog(_logMonitorFrame); 

    if (returnVal == JFileChooser.APPROVE_OPTION) { 

      File f = chooser.getSelectedFile(); 

      if (loadLogFile(f)) { 

        _fileLocation = chooser.getSelectedFile(); 

        _mruFileManager.set(f); 

        updateMRUList(); 

      } 

    } 

  } 

 

  /**

   * Uses a Dialog box to accept a URL to a file to be opened 

   * with the LF5 GUI. 

   */ 

  protected void requestOpenURL() { 

    LogFactor5InputDialog inputDialog = new LogFactor5InputDialog( 

        getBaseFrame(), "Open URL", "URL:"); 

    String temp = inputDialog.getText(); 

 

    if (temp != null) { 

      if (temp.indexOf("://") == -1) { 

        temp = "http://" + temp; 

      } 

 

      try { 

        URL url = new URL(temp); 

        if (loadLogFile(url)) { 

          _mruFileManager.set(url); 

          updateMRUList(); 

        } 

      } catch (MalformedURLException e) { 

        LogFactor5ErrorDialog error = new LogFactor5ErrorDialog( 

            getBaseFrame(), "Error reading URL."); 

      } 

    } 

  } 

 

  /**

   * Removes old file list and creates a new file list 

   * with the updated MRU list. 

   */ 

  protected void updateMRUList() { 

    JMenu menu = _logMonitorFrame.getJMenuBar().getMenu(0); 

    menu.removeAll(); 

    menu.add(createOpenMI()); 

    menu.add(createOpenURLMI()); 

    menu.addSeparator(); 

    menu.add(createCloseMI()); 

    createMRUFileListMI(menu); 

    menu.addSeparator(); 

    menu.add(createExitMI()); 

  } 

 

  protected void requestClose() { 

    setCallSystemExitOnClose(false); 

    closeAfterConfirm(); 

  } 

 

  /**

   * Opens a file in the MRU list. 

   */ 

  protected void requestOpenMRU(ActionEvent e) { 

    String file = e.getActionCommand(); 

    StringTokenizer st = new StringTokenizer(file); 

    String num = st.nextToken().trim(); 

    file = st.nextToken("\n"); 

 

    try { 

      int index = Integer.parseInt(num) - 1; 

 

      InputStream in = _mruFileManager.getInputStream(index); 

      LogFileParser lfp = new LogFileParser(in); 

      lfp.parse(this); 

 

      _mruFileManager.moveToTop(index); 

      updateMRUList(); 

 

    } catch (Exception me) { 

      LogFactor5ErrorDialog error = new LogFactor5ErrorDialog( 

          getBaseFrame(), "Unable to load file " + file); 

    } 

 

  } 

 

  protected void requestExit() { 

    _mruFileManager.save(); 

    setCallSystemExitOnClose(true); 

    closeAfterConfirm(); 

  } 

 

  protected void closeAfterConfirm() { 

    StringBuffer message = new StringBuffer(); 

 

    if (_callSystemExitOnClose == false) { 

      message.append("Are you sure you want to close the logging "); 

      message.append("console?\n"); 

      message.append("(Note: This will not shut down the Virtual Machine,\n"); 

      message.append("or the Swing event thread.)"); 

    } else { 

      message.append("Are you sure you want to exit?\n"); 

      message.append("This will shut down the Virtual Machine.\n"); 

    } 

 

    String title = 

        "Are you sure you want to dispose of the Logging Console?"; 

 

    if (_callSystemExitOnClose == true) { 

      title = "Are you sure you want to exit?"; 

    } 

    int value = JOptionPane.showConfirmDialog( 

        _logMonitorFrame, 

        message.toString(), 

        title, 

        JOptionPane.OK_CANCEL_OPTION, 

        JOptionPane.QUESTION_MESSAGE, 

        null 

    ); 

 

    if (value == JOptionPane.OK_OPTION) { 

      dispose(); 

    } 

  } 

 

  protected Iterator getLogLevels() { 

    return _levels.iterator(); 

  } 

 

  protected Iterator getLogTableColumns() { 

    return _columns.iterator(); 

  } 

 

  /**

   * Loads and parses a log file. 

   */ 

  protected boolean loadLogFile(File file) { 

    boolean ok = false; 

    try { 

      LogFileParser lfp = new LogFileParser(file); 

      lfp.parse(this); 

      ok = true; 

    } catch (IOException e) { 

      LogFactor5ErrorDialog error = new LogFactor5ErrorDialog( 

          getBaseFrame(), "Error reading " + file.getName()); 

    } 

 

    return ok; 

  } 

 

  /**

   * Loads a parses a log file running on a server. 

   */ 

  protected boolean loadLogFile(URL url) { 

    boolean ok = false; 

    try { 

      LogFileParser lfp = new LogFileParser(url.openStream()); 

      lfp.parse(this); 

      ok = true; 

    } catch (IOException e) { 

      LogFactor5ErrorDialog error = new LogFactor5ErrorDialog( 

          getBaseFrame(), "Error reading URL:" + url.getFile()); 

    } 

    return ok; 

  } 

  //-------------------------------------------------------------------------- 

  //   Private Methods: 

  //-------------------------------------------------------------------------- 

 

  //-------------------------------------------------------------------------- 

  //   Nested Top-Level Classes or Interfaces: 

  //-------------------------------------------------------------------------- 

 

  class LogBrokerMonitorWindowAdaptor extends WindowAdapter { 

    protected LogBrokerMonitor _monitor; 

 

    public LogBrokerMonitorWindowAdaptor(LogBrokerMonitor monitor) { 

      _monitor = monitor; 

    } 

 

    public void windowClosing(WindowEvent ev) { 

      _monitor.requestClose(); 

    } 

  }