Re: How to send the logs from my application directly to a jpanel of it

Mark Space wrote:


I made a few changes and got something self-contained that seems to work
OK. I'd cannot guarantee everything is 100% tested though. The first
class is LogWindowHandler and you use it just like a regular log
handler. Just add it to an existing logger and you are done.
LogWindowHandler creates a new JFrame for each logger, so you may wish
to just add one to some top level logger. LogWindowHandler should be
100% thread safe.

The second class is just a JFrame that supports the LogWindowHandler.
It's pretty simple and LogWindowHandler already deals correctly with the
Swing invocation issues (thread safety) so you don't need to worry about
those.

/*
  * To change this template, choose Tools | Templates
  * and open the template in the editor.
  */
package local.logwindow;

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.logging.Handler;
import java.util.logging.Level;
import java.util.logging.Logger;
import java.util.logging.LogRecord;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.SwingUtilities;

/** A handler that sends its output to a Swing window.
  *
  * @author Brenden
  */
public class LogWindowHandler extends java.util.logging.Handler
{
     private volatile LogWindow debugWindow;
     private String name;
     private Map<String, Level> levelsMap =
             new HashMap<String, Level>();

     public LogWindowHandler( String title )
     {
         init( title );
     }

     private void init( final String title )
     {
         name = title;
         levelsMap.put( "Info", Level.INFO );
         levelsMap.put( "Finest", Level.FINEST );
         try {
             SwingUtilities.invokeAndWait( new Runnable()
             {
                 @Override
                 public void run()
                 {
                     initLogWindow( title );
                 }
             } );
         }
         catch( InterruptedException ex ) {
             Logger.getLogger( LogWindowHandler.class.getName() ).
                     log( Level.SEVERE, null, ex );
         }
         catch( InvocationTargetException ex ) {
             Logger.getLogger( LogWindowHandler.class.getName() ).
                     log( Level.SEVERE, null, ex );
         }
     }

     private void initLogWindow( String title )
     {
         // MUST BE CALLED ON THE EDT!!
         debugWindow = LogWindow.newInstance( title );

         JMenu levels = new JMenu( "Level" );

         JMenuBar mb = debugWindow.getJMenuBar();
         if( mb == null ) {
             mb = new JMenuBar();
             debugWindow.setJMenuBar( mb );
         }
         mb.add( levels );

         LevelListener lev = new LevelListener();

         Set<String> keys = levelsMap.keySet();
         for( String key : keys ) {
             JMenuItem jmi = new JMenuItem();
             jmi.setText( key );
             jmi.addActionListener( lev );
             levels.add( jmi );
         }
         debugWindow.setVisible( true );
     }

     private class LevelListener implements ActionListener
     {
         @Override
         public void actionPerformed( ActionEvent e )
         {
// Object source = e.getSource();
// System.err.println( "Source: " + source );
// String actionCommand = e.getActionCommand();
// System.err.println( "ActionCommand: "+actionCommand );
             Level level = levelsMap.get( e.getActionCommand() );
             setLevel( level );
         }
     }

     @Override
     public void publish( LogRecord record )
     {
         StringBuilder sb = new StringBuilder( 160 );
         sb.append( record.getLevel() + ":" );
         sb.append( record.getSourceClassName() + ":" );
         sb.append( record.getSourceMethodName() + ":" );
         sb.append( "<" + record.getMessage() + ">" );
         sb.append( "\n" );
         debugWindow.addMessage( sb.toString() );
     }

     @Override
     public void flush()
     {
         // nothing to do.
     }

     @Override
     public void close()
     {
         debugWindow.setVisible( false );
         debugWindow.dispose();
         debugWindow = null;
     }

     public static void main( String[] args )
     {
         Logger testLog = Logger.getLogger( "test.log" );
         Handler h = new LogWindowHandler( "test.log" );
         testLog.addHandler( h );
         testLog.setLevel( Level.ALL );
         testLog.fine( "fine" );
         testLog.finer( "finer" );
         testLog.finest( "finest" );
         testLog.severe( "severe" );
         testLog.warning( "warning" );
         testLog.config( "config" );
         testLog.info( "info" );
     }
}

------8< ---- cut here ---- 8< ------------

/*
  * To change this template, choose Tools | Templates
  * and open the template in the editor.
  */
package local.logwindow;

import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;

/** A visible Swing window for logging messages from a
  * java.util.logging.Handler.
  *
  * This class is not thread safe. Please review the appropriate
  * Swing documentation, and see the individual method documentation
  * of this class for more information.
  *
  * @author Brenden
  */
public class LogWindow extends JFrame// implements ItemListener
{

     private final String windowName;
     private final JTextArea messages;

     /**
      * Creates a new Log Window.
      *
      * NOT THREAD SAFE.
      * This method creates a Swing GUI object and must be called on
      * the Event
      * Dispatch Thread.
      *
      * @param title The title of the JFrame window.
      * @return A new LogWindow.
      */
     public static LogWindow newInstance( String title )
     {
         LogWindow temp = new LogWindow( title );
// LogWindowManager.getInstance().addLogWindow( temp );
         return temp;
     }

     private LogWindow( String title )
     {
         super( title );
         windowName = title;
         messages = new JTextArea( 10, 20 );
         init( title );
     }

     private void init( String title )
     {
         getContentPane().add( new JScrollPane( messages ) );
         setDefaultCloseOperation( JFrame.DISPOSE_ON_CLOSE );
         pack();
     }

     /** Adds a message to the LogWindow.
      *
      * This method is thread safe and may be called by any thread.
      *
      * @param message String message to be added to the LogWindow's
      * display area.
      */
     public void addMessage( final String message )
     {
         messages.append( message );
     }

     /** Returns this LogWindow's name (window title).
      *
      * This method is thread safe and may be called by any thread.
      *
      * @return
      */
     public String getWindowName()
     {
         return windowName;
     }

     public static void main( String... args )
     {
         LogWindow w = LogWindow.newInstance( "Test" );
         w.setVisible( true ); // NOT THREAD SAFE, test only
         w.addMessage( "Test 1" );
     }

}