All of these are included in the Compositor jar.
They are listed them in rough order of usefulness, but obviously that's subjective.
-
ActionDelayer
This can be helpful for grouping together user inputs.
For example, the NameBug example waits for a pause in user input before it starts drawing.
Responding to each individual input would make the app slow to repsond.
You pass the required action as a Runnable to the ActionDelayer, but it waits for a specified time until it executes.
If another action arrives within that time, the previous one is discarded.
So only the last one of a series is acted upon.
It's up to you to set a suitable delay, and to send suitable actions to the delayer.
The action is taken on another thread, so if your action will update the UI, consider the usual threading issues.
You should probably use invokeLater.
In this example, frame main contains list.
private ActionDelayer m_selectDelayer =
new ActionDelayer( 500 );
public void main_list_onSelect() {
m_selectDelayer.delay (
new Runnable() {
public void run() {
invokeLater( "delayedListSelect" );
}
}
);
}
public void delayedListSelect() {
}
-
ResourceLoader
This class finds resources such as images and text files from the class path or from the file system.
It also can have a simple attempt at guessing a file type.
switch( ResourceLoader.guessFileType( filePath ) ) {
case IMAGE:
final Image image = ResourceLoader.getImage( filePath );
break;
case HTML:
final String content = ResourceLoader.readUTF8File( filePath );
break;
}
Resources are found by name, first by looking on the class path (or more strictly, wherever the class loader looks, but that's almost always the same thing).
If nothing was found, then the requested name is used as a file path.
-
FileTree
This represents the file system as a tree component.
Declare it in your descriptor something like this:
<components>
<component
name='c:fileTree'
generator='net.sf.compositor.FileTreeGenerator'
class='net.sf.compositor.FileTree'
/>
</components>
Then use it something like this:
<scrollpane>
<c:fileTree
name='tree'
showHiddenFiles='false'
/>
</scrollpane>
-
FileOps
This class gives a simple API for file system operations: copy, move, rename, mkdir and delete.
Its advantage is that these operations use java.nio from Java 1.7 on wards, but java.io for earlier versions.
Its disadvantage is that it doesn't fully implement all those operations (yet).
-
SelectableLabel
Displaying text in a JLabel doesn't let the user select or copy the text.
This class fixes that by extending JTextField and disabling editing.
Declare it in your descriptor something like this:
<components>
<component
name='c:selectablelabel'
generator='net.sf.compositor.TextFieldGenerator'
class='net.sf.compositor.util.SelectableLabel'
/>
</components>
Then use it something like this:
<c:selectablelabel
name='myLabel'
cols='15'>Initial text</c:selectablelabel>
In most look and feel implementations, this class renders like JLabel, but on some it has a different colour background and/or a border.
That probably counts as a bug...
-
Config
This class represents a configuration file.
It extends Properties with convenience methods for getting integers, boolean values, and so on, and with indexed properties.
Reading and writing files with this class will preserve the original sequence of properties, and preserve comments.
This means hand editing of config files can be less painful.
Here's a way to set one up with some defaults, and make sure it's read and written at the right time.
private static final MyAppConfig s_config = new MyAppConfig();
@Override
protected void beforeUIBuilt() {
readWriteConfig(
Env.USER_HOME + Env.FILE_SEP + "myapp.properties",
s_config,
VERSION
);
}
private static class MyAppConfig
extends Config {
private static final String SOME_PROPERTY_NAME = "somePropertyName";
private MyAppConfig() {
super(
new Config() {{
setIntProperty( SOME_PROPERTY_NAME, "SomeValue" );
}}
);
}
}
-
This class formats things in human-readable ways.
You can format:
-
a byte count as kb, Mb, etc (not ISO friendly)
-
the amount of time elapsed between to instants
-
integers as hex
-
integers as fixed width
Some of this can nowadays be done with String.format.
-
ImageComparer
This class compares images.
It's useful in tests.
-
Env
This is a large set of values that represent the runtime environment.
Many of them are system properties, but I suggest that...
Env.NL
...is better than...
System.getProperty( "line.separator" )
There is also a method javaVersionAtLeast that allows you to tailor code to the JVM on which it's running.
-
Info
This is a short hand way of constructing an information dialog in code.
An example will help.
public void doAbout() {
new Info (
getFrame( "main" ),
"About " + getAppName(),
new String[][] {
{ "This app", getAppName(), Info.BOLD },
{ "Explanation", "Does some handy thing", },
{ Info.SPACER },
{ "", "Some useful information might go here", Info.NO_COLON },
{ "", "if you want to say stuff to users...", Info.NO_COLON },
},
new Info.Extras (
"Showing \"About\" box...",
this,
mapToShowOnDialog,
getSysProps(),
new ImageIcon( getFrame( "main" ).getIconImage() )
)
);
}
The resulting dialog would look something like this (on Windows XP, classic theme):
![[dialog image]](resources/infodialog.png)
-
Log
The logger used by Compositor is simple.
It's home-grown because it pre-dates other logging options.
An instance of this logger, s_log, is available in every Compositor app.
But if you want to use another log framework in your app, you can persuade this logger to delegate to it.
An example is LogApiJdk which uses the built-in Java logging system.
To use this, first call s_log.setApiClass(...), then s_log.setDestination(Log.TO_API).
-
NativeEditor
This class allows you to open a file in a native text editor.
The algorithm used is pretty simplistic, and only understands Windows, OS X, and Linux distributions that have xdg.
Here's an example of how to use it to implement an action:
public void doEditor() {
try {
NativeEditor.open( new File( someFileName ) );
} catch ( final IOException x ) {
msgBox( x_main, "Oops: " + x );
}
}
See also NativeBrowser
-
NativeBrowser
This class allows you to open a file in a native text editor.
The algorithm used is pretty simplistic, and only understands Windows, OS X, and Linux distributions that have xdg.
try {
NativeBrowser.open( someUrl );
} catch ( final IOException x ) {
msgBox( x_main, "Could no open URL:" + Env.NL + x.getMessage () );
}
See also NativeEditor
-
RotatedLabel
This class is a label that displays text reading up or down, so you could lean your head over to see it the usual way up.
The SideTabs example uses this.
Declare it in your descriptor something like this:
<components>
<component
name='c:rotatedlabel'
generator='net.sf.compositor.RotatedLabelGenerator'
class='net.sf.compositor.RotatedLabel'
/>
</components>
Then use it something like this:
<c:rotatedlabel direction='up'>Label goes upwards!</c:rotatedlabel>
-
PropertiesIgnoreCase
This class represents a property map where the case of the keys is unimportant.
A case where this is useful is HTTP headers.
This class relies on String.toLowerCase() which uses the default locale.
-
Throttler
A throttler prevents too many threads processing a section of code at once.
I wrote this for a case where image processing operations that required lots of memory where being run in parallel.
Beyond a certain number of threads I found that performance dropped dramatically because useful processing was replaced by disk thrashing.
Throttling the threads so that only a few could run in parallel improved the speed from dozens of minutes to a few seconds.
You make a Throttler, specifying how many threads are allowed in.
Then you pass Throttleable instances to it that execute the throttled code.
If too many threads arrive, they queue up.
-
MapMaker
This class will turn a semi-colon separated string into a map.
It is used by Compositor to read CSS-style attributes.
-
StackProbe
To find the current class you can say this.getClass().
But in a static method there is no this.
Instead you can say StackPropbe.getMyClass().
Similarly, StackPropbe.getMyClassName().
-
Unwinder
Finding the root cause of a chain of exceptions may be useful.
For example, InvocationTargetException will always have some other cause.
Unwinder.unwind(x) finds the original exception wrapped by x.
-
MutInt
This is a wrapper around an integer value.
If you increment an int parameter inside a method, the caller doesn't see the change (which is usually a good thing).
But if you pass a MutInt and call myMutInt.value++ then the caller will see that change.
This class makes functional programmers weep.
-
PadImageFilter
This class adds empty space to an image to make it larger.
It's used by Compositor to make sure that mouse cursor images are big enough.
-
Logging
-
ExifReader
Most JPG images include lots of data about how the image was created.
This class extracts that information in a usable form.
-
ThreadPool/ImmortalThread
This is probably redundant nowadays.
You should probably use NIO thread pooling instead.
-
SmokeDoc
I like Javadoc but I always thought that the presentation was ugly.
This is a doclet that I think makes nicer looking documentation.
It includes a few different colour schemes.
