Usually to add new a shortcut you can modify a component's InputMap, by adding a KeyStroke that maps to any key, for example the string "cut".
Then you modify the component's action map by adding a mapping from this key to an instance of an Action.
Unfortunately it is problematic to do so in a generic way for all instances and all types of text components.
After some discussion on the javadesktop forum it turned out that for text component you can use a shortcut: Simply add the action itself to the input map and it will be used directly.
Windows-style Cut/Copy/Paste shortcuts
I discovered these quite late, but have been using it alot. Guess it's because with my personal system of writing with four and a half fingers I almost never use the right modifier keys and typing ctrl-x with using the left control key is awkward.
These are quite easy to implement, because we can just reuse the existing actions and only need new bindings.
Delete to start/end of word
Interestingly the first two editors I tried handle Ctrl-Delete slightly differently: UltraEdit deletes all characters up the the start of the next word while Idea deletes only up to the end of the current word.
I decided to implement the latter because it's consistent with the next two editors I checked: Both OpenOffice and MS Word only delete to end of word.
These were a little harder to implement, because custom actions are needed.
References
Keyboard Bindings in Swing [Sun Developer Network]Implementation
To add the shortcuts to the text components in your swing application, simply add a single line that is executed during startup:SwingUtils.addTextComponentActions();Without further ado, here is the complete code, together with a simple ui that let's you test it:
package com.eekboom.xswing; import javax.swing.*; import javax.swing.text.*; import java.awt.event.InputEvent; import java.awt.event.KeyEvent; import java.awt.event.ActionEvent; import java.awt.*; public class SwingUtils { // See http://forums.java.net/jive/thread.jspa?threadID=8503 public static void addTextComponentActions() { // note: we can safely register all keystrokes even for password fields: // the cut/copy actions won't work (unless the client property // "JPasswordField.cutCopyAllowed" has been set on the component) // and the deleteTpPrevious/NextAction explicitly check for password fields. String[] keys = {"TextField", "FormattedTextField", "PasswordField", "TextArea", "TextPane", "EditorPane"}; registerActions(keys); } private static void registerActions(String[] propertyPrefixes) { DeleteToEndOfWordAction deleteToEndOfWordAction = new DeleteToEndOfWordAction(); DeleteToStartOfWordAction deleteToStartOfWordAction = new DeleteToStartOfWordAction(); DefaultEditorKit.CopyAction copyAction = new DefaultEditorKit.CopyAction(); DefaultEditorKit.CutAction cutAction = new DefaultEditorKit.CutAction(); DefaultEditorKit.PasteAction pasteAction = new DefaultEditorKit.PasteAction(); for(int i = 0; i < propertyPrefixes.length; i++) { String propertyPrefix = propertyPrefixes[i]; UIDefaults defaults = UIManager.getDefaults(); Object o = defaults.get(propertyPrefix + ".focusInputMap"); InputMap inputMap = (InputMap) o; inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_INSERT, InputEvent.SHIFT_MASK, false), pasteAction); inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, InputEvent.SHIFT_MASK, false), cutAction); inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_INSERT, InputEvent.CTRL_MASK, false), copyAction); inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_BACK_SPACE, InputEvent.CTRL_MASK, false), deleteToStartOfWordAction); inputMap.put(KeyStroke.getKeyStroke(KeyEvent.VK_DELETE, InputEvent.CTRL_MASK, false), deleteToEndOfWordAction); } } } class DeleteToStartOfWordAction extends TextAction { public static final String NAME = "delete-to-previous-word"; public DeleteToStartOfWordAction() { super(NAME); } public void actionPerformed(ActionEvent e) { JTextComponent textComponent = getTextComponent(e); if(textComponent == null || !textComponent.isEditable()) { UIManager.getLookAndFeel().provideErrorFeedback(textComponent); return; } try { Document document = textComponent.getDocument(); Caret caret = textComponent.getCaret(); int caretIndex = caret.getDot(); int markIndex = caret.getMark(); int selectionEndIndex = Math.max(caretIndex, markIndex); int selectionStartIndex = Math.min(caretIndex, markIndex); int startIndex = getStartOfWordOffset(textComponent, selectionStartIndex); if(startIndex != selectionEndIndex) { document.remove(startIndex, selectionEndIndex - startIndex); } else if(caretIndex > 0) { UIManager.getLookAndFeel().provideErrorFeedback(textComponent); } } catch(BadLocationException bl) { UIManager.getLookAndFeel().provideErrorFeedback(textComponent); } } private int getStartOfWordOffset(JTextComponent target, int offset) throws BadLocationException { if(target instanceof JPasswordField) { return 0; } Element currentParagraph = Utilities.getParagraphElement(target, offset); int wordOffset = Utilities.getPreviousWord(target, offset); boolean isInPreviousParagraph = wordOffset < currentParagraph.getStartOffset(); if(isInPreviousParagraph) { //noinspection UnnecessaryLocalVariable int endOfPreviousParagraph = Utilities .getParagraphElement(target, wordOffset).getEndOffset() - 1; wordOffset = endOfPreviousParagraph; } return wordOffset; } } class DeleteToEndOfWordAction extends TextAction { public static final String NAME = "delete-to-next-word"; public DeleteToEndOfWordAction() { super(NAME); } public void actionPerformed(ActionEvent e) { JTextComponent textComponent = getTextComponent(e); if(textComponent == null || !textComponent.isEditable()) { UIManager.getLookAndFeel().provideErrorFeedback(textComponent); return; } try { Document document = textComponent.getDocument(); Caret caret = textComponent.getCaret(); int caretIndex = caret.getDot(); int markIndex = caret.getMark(); int selectionEndIndex = Math.max(caretIndex, markIndex); int selectionStartIndex = Math.min(caretIndex, markIndex); int endIndex = getEndOfWordOffset(textComponent, selectionEndIndex); if(endIndex != selectionEndIndex) { document.remove(selectionStartIndex, endIndex - selectionStartIndex); } else if(caretIndex > 0) { UIManager.getLookAndFeel().provideErrorFeedback(textComponent); } } catch(BadLocationException bl) { UIManager.getLookAndFeel().provideErrorFeedback(textComponent); } } private int getEndOfWordOffset(JTextComponent target, int offset) throws BadLocationException { Element currentPararaph = Utilities.getParagraphElement(target, offset); int currentParagraphEndOffset = currentPararaph.getEndOffset(); if(target instanceof JPasswordField) { return currentParagraphEndOffset - 1; } int wordOffset = offset; try { int startOfNextWord = Utilities.getNextWord(target, offset); int endOfCurrentWord = Utilities.getWordEnd(target, offset); boolean isInWhiteSpace = startOfNextWord == endOfCurrentWord; if(isInWhiteSpace) { wordOffset = Utilities.getWordEnd(target, startOfNextWord); } else { wordOffset = endOfCurrentWord; } if(wordOffset >= currentParagraphEndOffset && offset != currentParagraphEndOffset - 1) { wordOffset = currentParagraphEndOffset - 1; } } catch(BadLocationException badLocationException) { int end = target.getDocument().getLength(); if(wordOffset != end) { if(offset != currentParagraphEndOffset - 1) { wordOffset = currentParagraphEndOffset - 1; } else { wordOffset = end; } } else { throw badLocationException; } } return wordOffset; } } class Main extends JFrame { int _rowIndex = 0; private Main() { getContentPane().setLayout(new GridBagLayout()); addLabelAndComponent("Text Field", new JTextField(40), false); addLabelAndComponent("Formatted Text Field", new JFormattedTextField(), false); addLabelAndComponent("Password Field", new JPasswordField(), false); addLabelAndComponent("Text Area", new JTextArea(40, 3), true); addLabelAndComponent("Text Pane", new JTextPane(), true); addLabelAndComponent("Editor Pane", new JEditorPane(), true); setBounds(100, 100, 600, 400); setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); setVisible(true); } private void addLabelAndComponent(String text, JTextComponent component, boolean fillVertically) { addLabel(text); addTextComponent(component, fillVertically); } private void addLabel(String text) { GridBagConstraints c = new GridBagConstraints(0, _rowIndex, 1, 1, 0.0, 0.0, GridBagConstraints.LINE_START, GridBagConstraints.NONE, new Insets(2, 2, 0, 0), 0, 0); getContentPane().add(new JLabel(text), c); } private void addTextComponent(JTextComponent component, boolean fillVertically) { int fill = fillVertically ? GridBagConstraints.BOTH : GridBagConstraints.HORIZONTAL; double weighty = fillVertically ? 1.0 : 0.0; Insets insets = new Insets(2, 2, 0, 0); GridBagConstraints c = new GridBagConstraints(1, _rowIndex, 1, 1, 1.0, weighty, GridBagConstraints.NORTHWEST, fill, insets, 0, 0); if(fillVertically) { getContentPane().add(new JScrollPane(component), c); } else { getContentPane().add(component, c); } ++_rowIndex; } public static void main(String[] args) { SwingUtils.addTextComponentActions(); new Main(); } } ]]>
|
Natural Order
rfc 1.txt
rfc 822.txt
rfc 2086.txt
|
Java's default Order
rfc 1.txt
rfc 2086.txt
rfc 822.txt
|
(Kudos to Martin Pool for the example.) | |
When I needed a natural sort feature in my Java app I started to google and to look in a few other places (like Apache Commons). There should be plenty of code out there that does this, right? Nope. I found a page with a description of the problem and links to implementations in a couple of programming languages: Natural Order String Comparison
There's a single Java implementation, but that one cannot handle texts that contain non-ascii characters.
So it would fail in my German application, where texts contain funny characters such as these:
Im Übrigen macht's mehr Spaß, es selbst zu schreiben.
The code
Consists of a couple of static methods in class Strings: Strings.java
Here is the Javadoc.
Some junit tests: TestStrings.java
Basically there are some variants of methods compareNatural...(String, String) that directly compare
strings and convenience function, if you need a string Comparator: getNaturalComparator...().
The different variants either use either the current default locale's comparison rules, allow to specify a Collator
to use or work on 7-bit ascii characters only.
Java 1.5: There is a little bit of generics used (e.g. Comparator<String>). It's easy to change
if you require the code to work on older Java versions.
Basics and Intricacies
Basically natural comparison works by breaking each string into parts where each part is either a number or text-only.
Number parts are compared according to their corresponding numeric value while text parts are compared lexicographically.
However simple this seems, there are quite some subtleties to handle.
A nice, detailed explanation is also given in this spec from the OpenOffice project:
Natural Sort Option in Sort Dialog
Tokenizing
Exactly how to determine which parts of a text are numbers can be surprisingly difficult. The two complicating issues are non-integer numbers and internationalization.
My implementation handles only integer numbers, so "a 1.3" is considered less than "a 1.11" because each is broken into four parts ("a ", "1", "." and "3" resp. "11") and 3 is less than 11. The need to handle fractional numbers should arise very rarely and trying to handle these opens a can of worms (different decimal point representations in different locales, scientific formats, ...).
Digits are defined differently in different locales. Currently my implementation starts a new token whenever the value of Character.isDigit(c) changes.
Internationalization
My minimum requirement was to compare the text parts of the strings using locale specific rules (which means you can
specify a java.text.Collator).
The code should work fine for any language that uses the number characters '0'...'9'.
Other number systems are not tested (they will probably not work, because I do not really convert the number to a numeric value, but compare each digit separately).
Supplementary characters
Once upon a time it seemed to me that Java's native unicode support was the end of all character set problems. No more, no more: The complete Unicode definition now contains character that cannot be represented by a single (16 bit) char variable, see this article from sun http://java.sun.com/developer/technicalArticles/Intl/Supplementary/
These supplementary characters are simply not handled correctly in my natural comparison implementation.
Numbers with leading zeros
How should the strings "p0002", "p2", "p02" be sorted?
Strictly comparing the numeric values of the number parts would leave the sort order undefined, as each of these strings
will be considered equal.
I have chosen to sort by increasing numbers of leading zeros: "p2", "p02", "p0002". That way Strings.getNaturalComparator().compare(String, String)
and String.equals(String) are still compatible: compare() will return 0 exactly if equals()
returns true.
Whitespace
How do "p4" and "p 3" compare?
I have choosen not to ignore whitespace, so "p4" is less than "p 3". I'd like to be alerted to difference in the naming scheme, so I think this is reasonable. Maybe later I'll add an option to control the handling of whitespace.
Performance
First of all I don't think performance really matters in the typical application of natural comparison. You probably don't have hundreds of thousands of files in the same directory whose names differ only in a number, do you?
Still, the very simple approach of breaking the string into parts (effectively creating two list of strings) and then comparing each string separately might be too costly. So I took care to avoid creating new instances where possible and do all comparisons in place. For many scenarios the natural comparison is about as fast as Java's String.compareTo() method. If there are many strings that have a common prefix and contain a number that differs in trailing digits only the natural comparison is about four times slower.
]]>######### ## ## ## ######### ## ## ## ## ## ## ## ##### ## ## ## ## ## ## #### ## ## ####### ## ## ## ## ##### ###### ## ######## ## ## ## ## ## ## ### ### ## ## ######## #### ## ## ## ## ## ## ## ## ## ####### ## ## ## ## ## ######## ## ## #### ## ## ## ## ## ## ######## ## ## ## ## ## ## ## ## ## ## ## ## ## ### ## ## ## ### ## ### ## ## ######## ## ## ######## ## ###### ## ## #### ## ## ## #### ## ## #### ##
I consider myself a lucky guy, being allowed to work full-time with Java and get paid for it. Only occasionally I do miss the chance to step back a little from business demands and just write some cool, yet more or less useless code.
So I jumped to the occasion when a day's work was almost done and I had the mean idea of putting something cool to use: I just had spent some thirty minutes tracing a bug when I noticed that single message in the enormous log file that revealed useful information. I cursed myself for not noticing earlier that it was logged as "SEVERE" and caught myself thinking "Couldn't the fellow who put that log message in there have done it in 40 pixels big bold face?" Well, of course not, it's plain ascii text, ... but hey, wait - I can do that!
Those of you who have been around long enough probably remember the novelty services that accepted a small photo and handed back to you an ascii print out that let you recognize the photo - if you stepped back far enough for the black and white to get blurred into a gray distribution. We really have come a long way with real-time photo-realistic graphics and powerful APIs like Java 2D and 3D!
Well, right now I could use some very simple, black and white ascii art: Create an image, draw the string to it, get the pixel raster and print out a space for a white pixel and some other character for a black pixel. Ten minutes' job.
In fact, it turned out to be two hours fumbling with Java 2D and the logging system. But that was due to my partial knowledge of those APIs on the one hand, and my inherent desire to go beyond the quick and dirty initial implementation and deal correctly with line breaks, tabs and null text on the other hand. Well, at least I stopped short of trying to support right-to-left, bottom-to-top text. I'm leaving that as an exercise for the reader ;-)
Text to Ascii Art
So let's have a short walk through the most important parts of the code.
I'd like to have something like this:
public static String getAsciiArt(Font font, String text) {Calling getAsciiArt(new Font("SansSerif", Font.PLAIN, 18), "Failure!") should give the string
you see above.
On we go: Before you can do anything sensible with text as graphics, you need a FontRenderContext to
specify exactly how a font is mapped to a pixel raster:
FontRenderContext fontRenderContext = new FontRenderContext(null, false, false);
The output does not need to be transformed in any way (rotated, scaled, ...), so passing null
gets me an IdentityTransform. The two false literals specify no anti-aliasing and
non-fractional metrics (Does not make sense when you think of a pixel as a character, right?)
The usual way to get a FontRenderContext instance is from the Graphics2D object passed into
any paint() method of components, but this isn't the usual paint application, anyway.
Now before the text can be drawn into an image I need to know the image size. That resulted
in some heavy application of the engineering pattern called trial and error:
Most methods (e.g. TextLayout.getBounds()) were not working as expected, e.g. ignoring white
space at the text's start or end (which makes some sense, there's nothing to draw there).
Finally I found that creating a GlyphVector and using its logical bounds did what I wanted:
GlyphVector glyphVector = font.createGlyphVector(fontRenderContext, text);
Rectangle2D bounds = glyphVector.getLogicalBounds();Next, simply create an image to paint to:
BufferedImage image = new BufferedImage((int) bounds.getWidth(),
(int) bounds.getHeight(),
BufferedImage.TYPE_BYTE_BINARY);Drawing into the image is quick, just get a graphics object from the image and use it to draw to the image:
Graphics2D graphics = image.createGraphics();
graphics.drawGlyphVector(glyphVector, 0, ascent);
I haven't explained the "ascent" yet, so what's that about? The drawGlyphVector() method
does not document at all what the x/y position passed into it is relative to. I expected
it to be the baseline, i.e. that line you write on in a lined text book with characters
like "y" extending further down. That assumption was correct, but unfortunately the GlyphVector
class has no easy way to retrieve the baseline.
Well, TextLayout seems to supply what I needed:
TextLayout textLayout = new TextLayout(text, font, fontRenderContext);
Grmpf! textLayout.getBaseline() does not return the actual position of the baseline, but rather
its type - a stupid name for this method. I only learned about different types of baselines
after some unsuccessful attempts to position the text and I'd rather not elaborate on that here.
Still, TextLayout has a nice method called getAscent(), which is just what I need - the delta
from the top of the bounds to the baseline:
float ascent = textLayout.getAscent();
What's left is to get the actual pixel raster and iterate over pixels appending characters to the log:
Raster raster = image.getRaster();
...
raster.getPixel(x, y, ints);
int pixelValue = ints[0];
buffer.append(pixelValue > 0 ? '#' : ' ');
There actually is quite a bit more code, but you can have a look at that for yourself in the complete implementation below.
Logging in Ascii Art
We are using our own wrapper around log4j, but for this blog I'll stick to the standard Java
logging mechanism (from java.util.logging).
Before any text is actually "published" (the log system's lingo for finally outputting it),
it can be formatted. Well, that's nice because our ascii art output can be easily implemented
as a Formatter. On second thought, I make that a Formatter that wraps another Formatter, so
that the usual formatting options (which may include timestamp, thread name etc.) aren't lost.
So let's supply a base formatter instance plus a font used for ascii art and a minimum log level to begin logging in ascii art. Oh yeah, and let those arguments default to something sensible if nulls are passed:
public class AsciiArtFormatter extends Formatter {
public AsciiArtFormatter(Formatter formatter, Level level, Font font) {
this.formatter = (formatter == null ? new SimpleFormatter() : formatter);
this.level = level == null ? Level.SEVERE : level;
this.font = font == null ? new Font("SansSerif", Font.PLAIN, 18) : font;
}
public String format(LogRecord record) {
String message = formatter.format(record);
if(record.getLevel().intValue() >= level.intValue()) {
message = message + getAsciiArt(font, record.getMessage());
}
return message;
}
I have included the complete message (as obtained from the wrapper formatter's format() method) so that
the text can be found if you search the log file using your favorite text editor and then append
the ascii art string to it. The ascii art is indeed graphics - with quite low resolution - so that if
only that were output, you wouldn't be able to find anything if you were searching for some important text.
Code
Finally, here's the complete code, starting with a simple usage example:import java.io.File;
import java.io.IOException;
import java.util.logging.FileHandler;
import java.util.logging.Level;
import java.util.logging.Logger;
public class Main {
public static void main(String[] args) throws IOException {
String userHome = System.getProperty("user.home");
File logFile = new File(userHome, "bigSevereText.log");
String logFilePath = logFile.getPath();
System.out.println("Logging to file " + logFilePath);
Logger logger = Logger.getLogger("default");
logger.setLevel(Level.FINEST);
FileHandler logFileHandler = new FileHandler(logFilePath);
logFileHandler.setFormatter(new AsciiArtFormatter());
logger.addHandler(logFileHandler);
logger.fine("Fox prepares to jump.");
logger.info("Fox is ready to jump.");
logger.severe("Fox failed\nto jump over\nlazy dog.");
logger.info("Dog is chasing fox.");
}
}
I have made the getAsciiArt() method part of the formatter, but you might like to move it to some
other place (it is totally independent from logging after all):
import java.util.logging.Formatter;
import java.util.logging.LogRecord;
import java.util.logging.SimpleFormatter;
import java.util.logging.Level;
import java.util.Arrays;
import java.awt.*;
import java.awt.image.BufferedImage;
import java.awt.image.Raster;
import java.awt.geom.Rectangle2D;
import java.awt.font.FontRenderContext;
import java.awt.font.GlyphVector;
import java.awt.font.TextLayout;
public class AsciiArtFormatter extends Formatter {
private final Formatter formatter;
private final Font font;
private final Level level;
public AsciiArtFormatter() {
this(null);
}
public AsciiArtFormatter(Formatter formatter) {
this(formatter, null, null);
}
/**
* Creates a formatter that will additionally use ascii art to log the message in the
* given font if its log level is at least level.
*
* @param formatter used to format the message before appending ascii art message.
* If null a default SimpleFormatter is used.
* @param level minimum level needed to enable ascii art logging.
* If null Level.SEVERE is used.
* @param font font used for any ascii art output.
* If null a sans serif font of size 18 is used.
*/
public AsciiArtFormatter(Formatter formatter, Level level, Font font) {
this.formatter = (formatter == null ? new SimpleFormatter() : formatter);
this.level = level == null ? Level.SEVERE : level;
this.font = font == null ? new Font("SansSerif", Font.PLAIN, 18) : font;
}
public String format(LogRecord record) {
String message = formatter.format(record);
if(record.getLevel().intValue() >= level.intValue()) {
message = message + getAsciiArt(font, record.getMessage());
}
return message;
}
/**
* @return the text as 'Ascii Art' in the given font using a '#' character for
* each pixel (the text itself if any runtime exception occurs)
*/
public static String getAsciiArt(Font font, String text) {
try {
if(text == null) {
text = "(null)";
}
int tabWidth = 4;
text = text.replaceAll("\\t", repeat(' ', tabWidth));
FontRenderContext fontRenderContext = new FontRenderContext(null, false, false);
StringBuffer buffer = new StringBuffer();
String[] lines = text.split("\n|\r\n", 0);
for(int lineIndex = 0; lineIndex < lines.length; lineIndex++) {
// How stupid: TextLayout does not handle white space like I want to, and
// GlyphVector has no convenient method to calculate overall ascent/descent.
// So just use both...
String line = lines[lineIndex];
GlyphVector glyphVector = font.createGlyphVector(fontRenderContext, line);
Rectangle2D bounds = glyphVector.getLogicalBounds();
int width = (int) bounds.getWidth();
int height = (int) bounds.getHeight();
if(line.length() == 0) {
buffer.append(repeat('\n', height));
continue;
}
TextLayout textLayout = new TextLayout(line, font, fontRenderContext);
float ascent = textLayout.getAscent();
BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_BYTE_BINARY);
Graphics2D graphics = image.createGraphics();
try {
graphics.drawGlyphVector(glyphVector, 0, ascent);
Raster raster = image.getRaster();
int[] ints = new int[1];
for(int y = 0; y < height; ++y) {
for(int x = 0; x < width; ++x) {
raster.getPixel(x, y, ints);
int pixelValue = ints[0];
buffer.append(pixelValue > 0 ? '#' : ' ');
}
buffer.append('\n');
}
}
finally {
graphics.dispose();
}
}
return new String(buffer);
}
catch(RuntimeException e) {
// Don't want anything silly to happen only because using this fun method.
// Revert to plain output ;-(
return text;
}
}
/**
* @return a string consisting of the character c repeated count times.
*/
public static String repeat(char c, int count) {
char[] fill = new char[count];
Arrays.fill(fill, c);
return new String(fill);
}
}