I am wondering if there is any simple way for creating a console that
outputs an application
results using java graphical interface.I don't wanna use netbeans or
a stuff like that,just a
standard way.
help me please......
Here is one that provides a scrollable table to display the log.
package xxxx;
import java.awt.BorderLayout;
import java.awt.Dimension;
import javax.swing.JFrame;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
/*
* Logs both to a Swing console and the DOS console.
* Since we are in an Applet, we cannot also log to a file.
*/
public class Log
{
/**
* severity of message
*/
public final static int INFO = 0;
public final static int WARNING = 1;
public final static int ERROR = 2;
public final static int FATAL = 3;
public final static int BUG = 4;
/**
* JFrame, but do not allow close
*/
private static JFrame console;
/**
* data for the log. Drops off data after a while.
*/
private static LogTableModel tableModel;
/**
* GUI visible console log
*/
private static JTable jtable;
/**
* Open the log.
*/
public static void open()
{
console = new JFrame("Console Log");
/* make it so the user can't close the Frame */
console.setDefaultCloseOperation( JFrame.DO_NOTHING_ON_CLOSE );
tableModel = new LogTableModel();
jtable = new JTable( tableModel );
jtable.setBackground( Config.LOG_BACKGROUND );
jtable.setForeground( Config.LOG_FOREGROUND );
TimestampRenderer.install( jtable, 0 );
SeverityRenderer.install( jtable, 1 );
// pad the message column out a bit
TableColumnModel tcm = jtable.getColumnModel();
TableColumn tc = tcm.getColumn( 2 );
tc.setPreferredWidth( 300 );
jtable.setPreferredScrollableViewportSize( new Dimension(300,
300) );
//Create the scroll pane and add the table to it.
JScrollPane scrollPane = new JScrollPane(jtable);
//Add the scroll pane to this window.
console.getContentPane().add( scrollPane, BorderLayout.CENTER );
console.pack();
console.setLocation( 300, 300 );
console.setVisible( true );
if ( false )
{
// sample test
println ( ERROR, "dummy test " );
println ( WARNING , "a much much bigger test
abcdefghijklmnopqrstuvwxyz " );
println ( INFO, "dummy info" );
println ( FATAL, "if the world were ending");
println ( BUG, "test of bug shower.");
}
}
/**
* close the log.
*/
public static void close ()
{
console.dispose();
console = null;
tableModel = null;
jtable = null;
}
/**
* log the string
*
* @param severity Severity of error: INFORMATIONAL, WARNING,
* ERROR, FATAL, BUG
*
* @param s string to log
*
* @exception IOException
*/
public static void println( int severity, String s )
{
tableModel.addRow ( severity, s );
String level;
switch ( severity )
{
case INFO:
level = "info: ";
break;
case WARNING:
level = "warning: ";
break;
case ERROR:
level = "error: ";
break;
case FATAL:
level = "FATAL: ";
break;
default:
case BUG:
level = "BUG: ";
break;
}
System.out.println ( level + s );
}
/**
* log the INFO string both to the Swing and DOS console.
*
* @param s string to log.
*
* @exception IOException
*/
public static void println( String s )
{
println ( INFO, s );
}
} // end class Log
-----------------------------
package xxxx;
import java.util.Date;
import java.util.Vector;
import javax.swing.table.AbstractTableModel;
import javax.swing.table.TableModel;
/**
* TableModel for a streaming Activity Table.
*/
public class LogTableModel extends AbstractTableModel implements
TableModel
{
/**
* Each element of the Vector is one row.
* Data are Date, Integer(severity), String Messaage.
* Vector because we fill the model from various threads.
*/
private Vector data = new Vector( Config.LOG_SIZE );
/**
* number of columns in the table
*/
private final int numCols = 3;
/**
* column titles
*/
private String[] columnNames = {"Time", "Severity", "Message"};
/**
* constructor
* Just saves column names, does not fetch any data.
*
* @param columnNames column titles, 0-based
* @param binarizer Contains data types of the various columns
*/
public LogTableModel( )
{
// just went from 0 to 3 cols, headers now defined,
fireTableStructureChanged();
}
/**
* Returns the number of row in the model. A
* <code>JTable</code> uses this method to determine how many
columns it
* should create and display by default.
*
* @return the number of rows in the model
*/
public int getRowCount()
{
return data.size();
}
/**
* Returns the number of columns in the model. A
* <code>JTable</code> uses this method to determine how many
columns it
* should create and display by default.
*
* @return the number of columns in the model
*/
public int getColumnCount()
{
return numCols;
}
/**
* get title of for column.
*
* @param col zero-based column number
*
* @return String, no embedded \n
*/
public String getColumnName(int col)
{
return columnNames[col];
}
/**
* get value at point in table grid
*
* @param row zero-based row number
* @param col zero-based column number
* @return Object, will be String, Integer or Float.
*/
public Object getValueAt(int row, int col)
{
try
{
Object[] rowData = (Object[]) data.elementAt(row);
return rowData[col];
}
catch ( ArrayIndexOutOfBoundsException e )
{
// can happen if we shrink table in one thread
// right after Swing gets size in another.
// This element will disappear entirely to Swing
// on the next look.
return null;
}
}
/**
* set value at point in table grid.
*
* @param value will be String, Integer or Float ...
* @param row zero-based row number
* @param col zero-based column number
*/
public void setValueAt(Object value, int row, int col)
{
throw new IllegalArgumentException("LogTableModel:setValueAt not
implemented");
}
/**
* No items are editable.
*
* @param row zero-based row number
* @param col zero-based column number
* @return false, to indicate no edits are possible.
*/
public boolean isCellEditable(int row, int col)
{
return false;
}
/**
* insert a new row, sliding existing rows
* out the way. Does no duplicate avoidance processing or sorting.
*
* @param rowData row of Object data to add.
* @param quietly true if should not do any FiretableRowChanged
*/
public synchronized void addRow( int severity , String message )
{
if ( data.capacity() == data.size() )
{
data.removeElementAt( 0 );
fireTableRowsDeleted( 0, 0 );
}
data.add( new Object[] { new Date(), new Integer( severity ),
message} );
int row = data.size()-1;
fireTableRowsInserted( row, row );
}
/**
* Returns <code>class</code> of column.
*
* @param columnIndex the column being queried
* @return the class
*/
public Class getColumnClass( int columnIndex )
{
switch ( columnIndex )
{
case 0: return Date.class; /* timestamp */
case 1: return Integer.class; /* severity */
default:
case 2: return String.class; /* message */
}
}
}
