All Classes and Interfaces

Class
Description
Some basic plumbing for Preference related dialogs.
 
Net based entities that 'work with' an Address should consider implementing this interface so that they can be treated generically.
Encapsulates the Chainsaw Application wide properties
A panel used by the user to modify any application-wide preferences.
Helper class that helps delegate the work of loading and saving the values of the ApplicationPreferenceModel, allowing that class to remain a simple bean.
All of the Preferences panels used in this class extend from this, it is used to provide standard L&F required by all.
A simple About box telling people stuff about this project
ChainsawAppender receives LoggingEvents from the local Log4J environment, and appends them into a model that can be used inside a Swing GUI
A handler class that either extends a particular appender hierarchy or can be bound into the Log4j appender framework, and queues events, to be later dispatched to registered/interested parties.
 
Constants used throught Chainsaw.
A CyclicBuffer implementation of the EventContainer.
A container class that contains a group of events split up into branches based on Identifiers
 
A simple splash screen to be used at startup, while everything get's initialized.
A general purpose status bar for all Frame windows
The only reason this class is needed is because of a stupid 'issue' with the JTabbedPane.
Encapsulates the full Toolbar, and menus and all the actions that can be performed from it.
Chainsaw compatible gui viewers must implement this interface in order to be opened and configured by the ChainsawAppender class.
A ListCellRenderer that display a check box if the value has been "checked".
Given a LoggingEvent, can determine an appropriate Color to use based on whatever this implementation has been coded.
Panel which updates a RuleColorizer, allowing the user to build expression-based color rules.
 
 
A common interface shared by log4j components.
Most log4j components derive from this class.
The ConnectionSource interface provides a pluggable means of transparently obtaining JDBC Connections for log4j classes that require the use of a Connection.
 
Constants used internally throughout log4j.
 
Converts log data stored in a database into LoggingEvents.
CyclicBuffer implementation that is Object generic, and implements the List interface.
The DataSourceConnectionSource is an implementation of ConnectionSource that obtains the Connection in the recommended JDBC manner based on a DataSource.
The DBAppender inserts loggin events into three database tables in a format independent of the Java programming language.
 
 
Actual retrieval of data is made by the instance of DBReceiverJob associated with DBReceiver.
Allow LoggingEvents to be reconstructed from a different format (usually XML).
Factory class to load and cache Layout information from resources.
Extends the functionality of a JPanel by providing a 'docked' state.
The DriverManagerConnectionSource is an implementation of ConnectionSource that obtains the Connection in the traditional JDBC manner based on the connection URL.
Used to store special log4j errors which cannot be logged using internal logging.
Implementations of this interface like to be notified of arriving batches of LoggingEvents, but may only be interested in those coming from a particular source
To allow pluggable TableModel implementations for Chainsaw, this interface has been factored out.
Listeners can be notified when the # of events in a particular model changes
This layout is used for formatting HTML text for use inside the Chainsaw Event Detail Panel, and the tooltip used when mouse-over on a particular log event row.
A Container class used to hold unique LoggingEvent values and provide them as unique ListModels.
A popup menu which assists in building expression rules.
This class provides all the functionality to work out when files are dragged onto a particular JComponent instance, and then notifies listeners via the standard PropertyChangesListener semantics to indicate that a list of files have been dropped onto the target.
Allows the user to specify a particular file to open and import the events into a new tab.
The complete File Menu for the main GUI, containing the Load, Save, Close Welcome Tab, and Exit actions
Allows the user to specify a particular file to which the current tab's displayed events will be saved.
This class is used as a Model for Filtering, and retains the unique entries that come through over a set of LoggingEvents
Class designed to stress, and/or test the Chainsaw GUI by sending it lots of Logging Events.
A BeanInfo class to be used as meta-data about the Generator plugin
 
A helper class that assists the HelpManager by serving as a collection of Class loaders based on URL roots.
 
Singleton help manager where objects can register to display Help for something, an independant viewer can register to be notified when the requested Help URL changes and can display it appropriately.
The HSQLDB dialect.
JMSReceiver receives a remote logging event on a configured JSM topic and "posts" it to a LoggerRepository as if the event was generated locally.
BeanInfo class for the JMSReceiver.
The JNDIConnectionSource is an implementation of ConnectionSource that obtains a DataSource from a JNDI provider and uses it to obtain a Connection.
Job is a very simple interface.
A Sortable JTable implementation that allows a user to click on a specific Column and have the row information sorted by that column.
Apply system font and size (normal size + 1) rule if the JEditorPane document contains html.
An editor Pane that allows a user to Edit a Pattern Layout and preview the output it would generate with an example LoggingEvent
 
A simple factory/facade for creating some of the standard Icons that are based on line drawings
A nice and simple 'X' style icon that is used to indicate a 'close' operation.
A nice and simple 'X' style icon that is used to indicate a 'close' operation.
A very basic appender that takes the events and stores them in to a ListModel for late retrieval.
 
An implementation of ULogger on org.apache.log4j.Logger.
 
LogFilePatternReceiver can parse and tail log files, converting entries into LoggingEvents.
BeanInfo class for the meta-data of the LogFilePatternReceiver.
LogFileXMLReceiver will read an xml-formated log file and make the events in the log file available to the log4j framework.
Interface used to listen for Logger related events such as add/remove appender or changing levels.
Implementations are notified when new Logger names are added to the related LoggerNameModel instance.
Implementations of this model contain all the known Logger names within it's model space.
An implementation of LoggerNameModel which can be used as a delegate
LoggerNameTree is used to display a TreeModel of LoggerNames.
A panel that encapsulates the Logger Name tree, with associated actions and implements the Rule interface so that it can filter in/out events that do not match the users request for refining the view based on Loggers.
Interface used to listen for LoggerRepository related events such as startup, reset, and shutdown.
A LoggerRepository is used to create and retrieve Loggers.
This class implements LoggerRepositoryEx by wrapping an existing LoggerRepository implementation and implementing the newly added capabilities.
Proxy that implements HierarchyEventListener and delegates to LoggerEventListener.
Implementation of RendererSupportImpl if not provided by LoggerRepository.
Wrap access to a LoggingEvent.
A LogPanel provides a view to a collection of LoggingEvents.

As events are received, the keywords in the 'tab identifier' application preference are replaced with the values from the received event.
A TreeModel that represents the Loggers for a given LogPanel
 
Used to encapsulate all the preferences for a given LogPanel
GUI panel used to manipulate the PreferenceModel for a Log Panel
The main entry point for Chainsaw, this class represents the first frame that is used to display a Welcome panel, and any other panels that are generated because Logging Events are streamed via a Receiver, or other mechanism.
This policy rewrites events where the message of the original event implementes java.util.Map.
The MessageCenter is central place for all elements within Chainsaw to notify the user of important information.
This class simply renders an event by delegating the effort to a Log4j layout instance.
Formats messages according to very simple rules.
 
 
Loads/Saves the MRU lists from preferences
The MS SQL Server dialect is untested.
Multicast-based Appender.
Multicast-based receiver.
BeanInfo class for the meta-data of the MulticastReceiver.
 
The parent of all the Network based interfaces.
An event representing when a Key has arrived inside a Chainsaw model that has not been seen previously.
Interested parties are notified when a MDC/Property key has arrived that has not been seen before by the source Model
A panel that allows a user to configure a new Plugin, and view that plugins javadoc at the same time
A no operation (NOP) implementation of ULogger.
 
The Oracle dialect.
This class leverages the 'Desktop' awt API in order to follow Mac-specific UI guidelines.
Instances of this interface can be paused, and resumed.
Defines the required interface for all Plugin objects.
A factory class to create a Classloader that can refenerence jars/classes/resources within a users plugin directory.
All Plugin events are encapsulated in this class, which simply contains the source Plugin, but may in future include more information.
PluginListeners are notified when plugins are started or stopped by the PluginRegistry.
A panel that allows the user to edit a particular Plugin, by using introspection this class discovers the modifiable properties of the Plugin
This is a registry for Plugin instances.
A convienent abstract class for plugin subclasses that implements the basic methods of the Plugin interface.
Ensures that a specific popupMenu is displayed when the relevant mouse events are trapped.
Net based entities that 'work with' a Port should consider implementing this interface so that they can be treated generically.
 
A component implementing this interface is interested in being able to configure itself.
 
A simple ProgressPanel that can be used, a little more flexible than ProgressMonitor when you want it to be shown REGARDLESS of any timeouts etc.
This policy rewrites events by adding a user-specified list of properties to the event.
Defines the base class for Receiver plugins.
A panel providing receiver configuration options
Helper class to assisit with all the known Receivers.
This panel is used to manage all the Receivers configured within Log4j
A TreeModel that encapsulates the details of all the Receivers and their related information in the Log4j framework
A TreeCellRenderer that can format the information of Receivers and their children
This policy rewrites events by evaluating any JavaBean properties on the message object and adding them to the event properties.
This appender forwards a logging request to another appender after possibly rewriting the logging event.
This interface is implemented to provide a rewrite strategy for RewriteAppender.
A colorizer supporting an ordered collection of ColorRules, including support for notification of color rule changes via a propertyChangeListener and the 'colorrule' property.
A mediator class that implements the Rule interface, by combining several optional rules used by Chainsaw's filtering GUI's into a single Rule.
This class is used to in saving and loading the tab settings of Chainsaw....
 
A simple but still useful implementation of a Scheduler (in memory only).
Represents an entry in job scheduler.
 
Components, or objects, that are interested in being notified when Settings are loaded or being saved, can implement this interface.
SettingManager allows components to register interest in Saving/Loading of general application preferences/settings.
Chainsaw notifies these Listeners when the user has requested it to shutdown.
A simple implementation that logs messages of level INFO or higher on the console (System.out).
A better button class that has nice roll over effects.
A better button class that has nice roll over effects.
Interface used to listen for SocketNode related events.
An Icon that is a Nice arrow to be used for displaying which Column is being used for sorting.
A Table Column header renederer that displays a nice Up/Down arrow depending on whether this column is the current sort column or not, and which way the sort is functioning
An extended TableModel interface that allows Column sorting
 
A collection of standard utility methods for use within Swing.
The Sybase dialect.
 
A specific TableCellRenderer that colourizes a particular cell based on some ColourFilters that have been stored according to the value for the row
XStream Converter implementation that deals with TableColumns settings
An interface that defines the required methods for supporting the setting and getting of a level threshold.
A Slider implementation that allows a user to choose a particular Threshold .
An "editor" that doesn't allow editing, but allows the user to press a "..." for more detail about this Column.
A runnable element that installs into the Log4j environment some fake Receivers which generates events for use as a tutorial.
Sends log information as a UDP datagrams.
Receive LoggingEvents encoded with an XMLLayout, convert the XML data to a LoggingEvent and post the LoggingEvent.
A proxy for org.slf4j.ULogger.
 
An EntityResolver specifically designed to return an empty InputSource for logger.dtd.
An extension of the Level class that provides support for java.util.logging Levels.
Decodes JDK 1.4's java.util.logging package events delivered via XML (using the logger.dtd).
 
A VFS-enabled version of org.apache.log4j.varia.LogFilePatternReceiver.
BeanInfo class for the meta-data of the VFSLogFilePatternReceiver.
If a receiver has a visual component, implement this interface and Chainsaw will call 'setContainer' passing in a container that the receiver can use.
An initial Welcome Panel that is used when Chainsaw starts up, can displays a HTML pages based on URLs.
Decodes Logging Events in XML formated into elements that are used by Chainsaw.
Read LoggingEvent objects sent from a remote client using XML over Sockets (TCP).
XMLSocketReceiver receives a remote logging event via XML on a configured socket and "posts" it to a LoggerRepository as if the event were generated locally.
 
This plugin is designed to detect specific Zeroconf zones (Rendevouz/Bonjour, whatever people are calling it) and allow the user to double click on 'devices' to try and connect to them with no configuration needed.