Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    * Licensed to the Apache Software Foundation (ASF) under one or more
    * contributor license agreements.  See the NOTICE file distributed with
    * this work for additional information regarding copyright ownership.
    * The ASF licenses this file to You under the Apache License, Version 2.0
    * (the "License"); you may not use this file except in compliance with
    * the License.  You may obtain a copy of the License at
    * 
    *      http://www.apache.org/licenses/LICENSE-2.0
   * 
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  package org.apache.log4j.lf5.viewer;
  
  import java.awt.Color;
  import java.awt.Font;
  import java.awt.Toolkit;
  import java.io.File;
  import java.net.URL;
  import java.util.HashMap;
  import java.util.List;
  import java.util.Map;
  import java.util.Vector;
  
  import javax.swing.JMenu;
  
LogBrokerMonitor .

Author(s):
Michael J. Sikorsky
Robert Shaw
Brad Marlborough
Richard Wan
Brent Sprecher
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 String _searchText;
   protected String _NDCTextFilter = "";
 
   protected JLabel _statusLabel;
   protected Object _lock = new Object();
   protected JComboBox _fontSizeCombo;
 
   protected int _fontSize = 10;
   protected String _fontName = "Dialog";
   protected String _currentView = ;
 
   protected boolean _loadSystemFonts = false;
   protected boolean _trackTableScrollPane = true;
   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 MRUFileManager _mruFileManager = null;
   protected File _fileLocation = null;
 
   //--------------------------------------------------------------------------
   //   Private Variables:
   //--------------------------------------------------------------------------
 
   //--------------------------------------------------------------------------
   //   Constructors:
   //--------------------------------------------------------------------------
 
  
Construct a LogBrokerMonitor.
 
   public LogBrokerMonitor(List logLevels) {
 
      = logLevels;
      = 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")) {
        = true;
     }
 
     initComponents();
 
 
         new LogBrokerMonitorWindowAdaptor(this));
 
   }
 
   //--------------------------------------------------------------------------
   //   Public Methods:
   //--------------------------------------------------------------------------
 
  
Show the frame for the LogBrokerMonitor. Dispatched to the swing thread.
 
   public void show(final int delay) {
     if (.isVisible()) {
       return;
     }
     // This request is very low priority, let other threads execute first.
     SwingUtilities.invokeLater(new Runnable() {
       public void run() {
         Thread.yield();
         pause(delay);
         .setVisible(true);
       }
     });
   }
 
   public void show() {
     show(0);
   }

  
Dispose of the frame for the LogBrokerMonitor.
 
   public void dispose() {
      = true;
 
     if ( == true) {
       System.exit(0);
     }
   }

  
Hide the frame for the LogBrokerMonitor.
 
   public void hide() {
   }

  
Get the DateFormatManager for formatting dates.
 
     return .getDateFormatManager();
   }

  
Set the date format manager for formatting dates.
 
   public void setDateFormatManager(DateFormatManager dfm) {
   }

  
Get the value of whether or not System.exit() will be called when the LogBrokerMonitor is closed.
 
   public boolean getCallSystemExitOnClose() {
     return ;
   }

  
Set the value of whether or not System.exit() will be called when the LogBrokerMonitor is closed.
 
   public void setCallSystemExitOnClose(boolean 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 ( == true) {
       // If the frame has been disposed of, do not log any more
       // messages.
       return;
     }
 
     SwingUtilities.invokeLater(new Runnable() {
       public void run() {
         .getFilteredLogTableModel().addLogRecord(lr); // update table
         updateStatusLabel(); // show updated counts
       }
     });
   }
 
   public void setMaxNumberOfLogRecords(int maxNumberOfLogRecords) {
     .getFilteredLogTableModel().setMaxNumberOfLogRecords(maxNumberOfLogRecords);
   }
 
   public JFrame getBaseFrame() {
     return ;
   }
 
   public void setTitle(String title) {
     .setTitle(title + " - LogFactor5");
   }
 
   public void setFrameSize(int widthint height) {
     Dimension screen = Toolkit.getDefaultToolkit().getScreenSize();
     if (0 < width && width < screen.width) {
        = width;
     }
     if (0 < height && height < screen.height) {
        = height;
     }
     updateFrameSize();
   }
 
   public void setFontSize(int fontSize) {
     changeFontSizeCombo(fontSize);
     // setFontSizeSilently(actualFontSize); - changeFontSizeCombo fires event
     // refreshDetailTextArea();
   }
 
   public void addDisplayedProperty(Object messageLine) {
     .add(messageLine);
   }
 
   public Map getLogLevelMenuItems() {
     return ;
   }
 
     return ;
   }
 
     return getLogTableColumnMenuItem(column);
   }
 
     return ;
   }
 
   // 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 ;
   }
 
   // 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) {
         setLogRecordFilter(createNDCLogRecordFilter(textFilter));
   }
   //--------------------------------------------------------------------------
   //   Protected Methods:
   //--------------------------------------------------------------------------
 
   protected void setSearchText(String text) {
      = 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) {
        = "";
     } else {
        = 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 = ;
     if (text == null || text.length() == 0) {
       return;
     }
 
     // Use new NDC filter
   }
 
   protected void findSearchText() {
     String text = ;
     if (text == null || text.length() == 0) {
       return;
     }
     int startRow = getFirstSelectedRow();
     int foundRow = findRecord(
         startRow,
         text,
     );
     selectRow(foundRow);
   }
 
   protected int getFirstSelectedRow() {
   }
 
   protected void selectRow(int foundRow) {
     if (foundRow == -1) {
       String message =  + " not found.";
       JOptionPane.showMessageDialog(
           ,
           message,
           "Text not found",
           .
       );
       return;
     }
     LF5SwingUtils.selectRow(foundRow);
   }
 
   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 = startRowi < leni++) {
       if (matches((LogRecordrecords.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 < leni++) {
       if (matches((LogRecordrecords.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 recordString 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() {
   }
 
   protected void clearDetailTextArea() {
   }

  
Changes the font selection in the combo box and returns the size actually selected.

Returns:
-1 if unable to select an appropriate font
 
   protected int changeFontSizeCombo(JComboBox boxint 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 < leni++) {
       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;
     setFontSize(.fontSize);
     selectRow(0);
     setFontSize(fontSize);
   }
 
   protected void setFontSize(Component componentint fontSize) {
     Font oldFont = component.getFont();
     Font newFont =
         new Font(oldFont.getFontName(), oldFont.getStyle(), fontSize);
     component.setFont(newFont);
   }
 
   protected void updateFrameSize() {
   }
 
   protected void pause(int millis) {
     try {
       Thread.sleep(millis);
     } catch (InterruptedException e) {
 
     }
   }
 
   protected void initComponents() {
     //
     // Configure the Frame.
     //
      = new JFrame("LogFactor5");
 
 
     String resource =
         "/org/apache/log4j/lf5/viewer/images/lf5_small_icon.gif";
     URL lf5IconURL = getClass().getResource(resource);
 
     if (lf5IconURL != null) {
       .setIconImage(new ImageIcon(lf5IconURL).getImage());
     }
     updateFrameSize();
 
     //
     // Configure the LogTable.
     //
     JTextArea detailTA = createDetailTextArea();
     JScrollPane detailTAScrollPane = new JScrollPane(detailTA);
      = new LogTable(detailTA);
 
     if () {
           new TrackingAdjustmentListener()
       );
     }
 
 
     // Configure the SplitPane between the LogTable & DetailTextArea
     //
 
     JSplitPane tableViewerSplitPane = new JSplitPane();
     tableViewerSplitPane.setOneTouchExpandable(true);
     tableViewerSplitPane.setOrientation(.);
     tableViewerSplitPane.setLeftComponent();
     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
     //
 
 
 
     JScrollPane categoryExplorerTreeScrollPane =
         new JScrollPane();
     categoryExplorerTreeScrollPane.setPreferredSize(new Dimension(130, 400));
 
     // Load most recently used file list
      = 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.
     //
         .);
         .);
 
 
     //
     // Configure ConfigurationManager
     //
 
   }
 
     LogRecordFilter result = new LogRecordFilter() {
       public boolean passes(LogRecord record) {
         CategoryPath path = new CategoryPath(record.getCategory());
         return
             getMenuItem(record.getLevel()).isSelected() &&
       }
     };
     return result;
   }
 
   // Added in version 1.2 - Creates a new filter that sorts records based on
   // an NDC string passed in by the user.
      = text;
     LogRecordFilter result = new LogRecordFilter() {
       public boolean passes(LogRecord record) {
         String NDC = record.getNDC();
         CategoryPath path = new CategoryPath(record.getCategory());
         if (NDC == null ||  == null) {
           return false;
         } else if (NDC.toLowerCase().indexOf(.toLowerCase()) == -1) {
           return false;
         } else {
           return getMenuItem(record.getLevel()).isSelected() &&
               .getExplorerModel().isCategoryPathActive(path);
         }
       }
     };
 
     return result;
   }
 
 
   protected void updateStatusLabel() {
   }
 
   protected String getRecordsDisplayedMessage() {
     return getStatusText(model.getRowCount(), model.getTotalRowCount());
   }
 
   protected void addTableModelProperties() {
 
     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 displayedRowsint 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) {
         updateStatusLabel();
       }
     };
   }
 
   protected JPanel createStatusArea() {
     JPanel statusArea = new JPanel();
     JLabel status =
         new JLabel("No log records to display.");
      = status;
 
     statusArea.setBorder(BorderFactory.createEtchedBorder());
     statusArea.setLayout(new FlowLayout(., 0, 0));
     statusArea.add(status);
 
     return (statusArea);
   }
 
   protected JTextArea createDetailTextArea() {
     JTextArea detailTA = new JTextArea();
     detailTA.setFont(new Font("Monospaced"., 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((LogLevellevels.next()));
     }
 
     result.addSeparator();
     result.add(createAllLogLevelsMenuItem());
     result.add(createNoLogLevelsMenuItem());
     result.addSeparator();
     result.add(createLogLevelColorMenu());
 
     return result;
   }
 
     JMenuItem result = new JMenuItem("Show all LogLevels");
     result.setMnemonic('s');
     result.addActionListener(new ActionListener() {
       public void actionPerformed(ActionEvent e) {
         selectAllLogLevels(true);
         updateStatusLabel();
       }
     });
     return result;
   }
 
     JMenuItem result = new JMenuItem("Hide all LogLevels");
     result.setMnemonic('h');
     result.addActionListener(new ActionListener() {
       public void actionPerformed(ActionEvent e) {
         selectAllLogLevels(false);
         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((LogLevellevels.next()));
     }
 
     return colorMenu;
   }
 
     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
       }
     });
     return result;
   }
 
   protected void selectAllLogLevels(boolean selected) {
     Iterator levels = getLogLevels();
     while (levels.hasNext()) {
       getMenuItem((LogLevellevels.next()).setSelected(selected);
     }
   }
 
   protected JCheckBoxMenuItem getMenuItem(LogLevel level) {
     if (result == null) {
       result = createMenuItem(level);
       .put(levelresult);
     }
     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(resultlogLevel);
       }
     });
 
     return result;
 
   }
 
   protected void showLogLevelColorChangeDialog(JMenuItem resultLogLevel level) {
     JMenuItem menuItem = result;
     Color newColor = JColorChooser.showDialog(
         ,
         "Choose LogLevel Color",
         result.getForeground());
 
     if (newColor != null) {
       // set the color for the record
       level.setLogLevelColorMap(levelnewColor);
     }
 
   }
 
   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) {
         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((LogTableColumncolumns.next()));
     }
 
     result.addSeparator();
     return result;
   }
 
     if (result == null) {
       result = createLogTableColumnMenuItem(column);
       .put(columnresult);
     }
     return result;
   }
 
     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();
         .setView(selectedColumns);
       }
     });
     return result;
   }
 
   protected List updateView() {
     ArrayList updatedList = new ArrayList();
     Iterator columnIterator = .iterator();
     while (columnIterator.hasNext()) {
       LogTableColumn column = (LogTableColumncolumnIterator.next();
       JCheckBoxMenuItem result = getLogTableColumnMenuItem(column);
       // check and see if the checkbox is checked
       if (result.isSelected()) {
         updatedList.add(column);
       }
     }
 
     return updatedList;
   }
 
     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();
         .setView(selectedColumns);
       }
     });
     return result;
   }
 
     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();
         .setView(selectedColumns);
       }
     });
     return result;
   }
 
   protected void selectAllLogTableColumns(boolean selected) {
     Iterator columns = getLogTableColumns();
     while (columns.hasNext()) {
       getLogTableColumnMenuItem((LogTableColumncolumns.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 = .getMRUFileList();
    if (files != null) {
      menu.addSeparator();
      for (int i = 0; i < files.lengthi++) {
        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;
  }
    JMenuItem result = new JMenuItem("Set Max Number of Records");
    result.setMnemonic('m');
    result.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
      }
    });
    return result;
  }
  protected void saveConfiguration() {
  }
  protected void resetConfiguration() {
  }
  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.");
      }
    }
  }
  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(
        ,
        title,
    );
  }
  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