Project: Swing or SWT

[Gregg Bolinger]

Ok, so here is a good topic for conversation. I have a project that I am going to start working on in the very near future. This is a personal project of mine and a friends.

Part of the project requires an IDE of sorts for our toolset. I thought that writing my own from the ground up would be a good learning experience. I know I could use Eclipse and write a plugin or I could use JEdit or Netbeans foundation. But those aren't really options.

So now it comes down to which GUI library to use. I know Swing better than I know SWT. But with some of the things I need to do (syntax highlighting, etc) Swing can be a real pain. SWT has some nice classes for dealing with IDE features because the library was written to create an IDE. The problem with SWT is a) documentation, b) not knowing it as well as swing, and c) customizing and/or creating custom components is not as simple as it is with Swing.

So taking some of that into consideration, I would like to hear some arguments for and against both Swing and SWT. Which would you choose for a similar project and especially, why.

Thanks.

[Ernest Friedman-Hill]

I'm now delivering the first alpha versions of an IDE based on Eclipse. My original prototype was a Swing-based implementation that used JEditorPane for an editor. I think I'm pretty well qualified to speak to this!

SWT, and especially JFace, are plenty powerful, but not many people appreciate all the capabilities of JEditorPane. Once you learn to implement your own EditorKit, you can make JEditorPane do some amazing stuff. The truth is, there's nothing you can do with one that you can't do with the other. The famous speed difference is just nonsense, and in fact, very big trees and tables actually perform better in Swing, due to the clever way Swing implements them. Anything you gain by using native painting is lost due to the overhead of calling native methods. So it's not about speed, not at all.

The main difference, as I see it, is this: say you want to implement what I call "parenthesis bouncing", that feature of an editor where typing a close paren or brace makes the cursor momentarily flash on the matching open paren or brace. If you're using JEditorPane, you know that you're going to have to implement it yourself. You use a JTimer and a KeyListener and you've got something working and tested in less an hour. But it doesn't look precisely like anybody else's parenthesis bouncing, and that bothers you a little. Still, it works, and you're ready to move on to the next feature.

In Eclipse/SWT/JFace, your first task is to figure out what they call parenthesis bouncing, so you can use their implementation. Depending on how similar your thought processes are to those of the Eclipse Foundation folks, this can take a long time. Eventually, you figure out you need to implement an ICharacterPairMatcher. That's easy enough to do, and in less time than it took to do the Swing version, you have something which works just like everything else on the Eclipse platform, and handles edge cases you might not even think of. But that lead time where you figure out what it's called is a killer.

So if you write using Swing, you'll write more code, but you'll know what you're doing. You'll probably be done faster, too. If you use JFace, you'll spend more time doing research and write fewer lines of code in the end. You'll also end up with something that has a more standardized look and feel, and you'll get some minor features "for free".

[Gregg Bolinger]

That was one of the longest non-answers I have ever read. Ok, not the longest. Kidding aside, thanks for the info. It did help. I of course am a Swing proponent so have been leaning that direction. But I don't ever want to count something out just because of my ignorance of it. I think that possibly, if this project were even less serious than what it is, I might consider it an opportunity to use SWT/JFace as a learning experience.

However, considering that I have a fairly high-level understanding of Swing it can still be a learning experience for me to do it using Swing. Speed has never even been an issue. I know exactly what you are talking about in that regard.

I actually did find a class in Swing that is used for the "parenthesis bouncing" in some apps. Basically it just highlights the pair when closing them. There is actually an Interface called Highlight in J2SE. I'm not sure what it's orginal purpose is/was, but I know it's used for that now.

Something that concerns me with both libraries is documentation. Swing has better docs than SWT/JFace (with the exception of the book I won a few weeks ago). The problem is, and has been talked about over and over, is the lack of definitive answers to questions. I can always find a "way" to do something. But no one seems to know if it is the preferred or correct way. It's always just "one way". It might make for a good weblog series though to discuss my trials and tribulations with this as it is being developed. I'll be sure and keep tabs and notes on problems I run into and solutions I might find. Maybe I can at least help someone else in the process.

I would still like to hear some other opinions on this. Thanks Ernest for the info.
[ October 05, 2004: Message edited by: Gregg Bolinger ]

[Jez Nicholson]

Gregg, why is creating it as an Eclipse plug-in not an option?

[Gregg Bolinger]

Originally posted by Jeremy Nicholson:
Gregg, why is creating it as an Eclipse plug-in not an option?

Because I don't want to.

[Nigel Browne]

Originally posted by Gregg Bolinger:
[QB]
I actually did find a class in Swing that is used for the "parenthesis bouncing" in some apps. Basically it just highlights the pair when closing them. There is actually an Interface called Highlight in J2SE. I'm not sure what it's orginal purpose is/was, but I know it's used for that now.
[QB]

Do you mean Highlighter ?
Have you got any examples of how to implement the interface on a JTextComponent ?

I have yet to use SWT, but I must agree that the documentation for Swing is not the best. Still looking for that definitive book on the subject, I'm hoping that Zukowski's latest update due to be published later this year clears up some of the points, where in previous releases I became more confused than I was before reading his book.
[ October 06, 2004: Message edited by: Nigel Browne ]

[Gregg Bolinger]

Here the code example I found. I can't remember where I got it but I didn't write it.

import javax.swing.*;
import javax.swing.text.*;
import javax.swing.event.*;
import java.awt.event.*;
import java.awt.*;
 

/**
 * A class to support highlighting of parenthesis.  To use it, add it as a
 * caret listener to your text component.
 * 
 * It listens for the location of the dot.  If the character before the dot
 * is a close paren, it finds the matching start paren and highlights both
 * of them.  Otherwise it clears the highlighting.
 *
 * This object can be shared among multiple components.  It will only
 * highlight one at a time.
 **/
public class BracketMatcher implements CaretListener
{
    /** The tags returned from the highlighter, used for clearing the
        current highlight. */
    Object start, end;
 
    /** The last highlighter used */
    Highlighter highlighter;
 
    /** Used to paint good parenthesis matches */
    Highlighter.HighlightPainter goodPainter;
 
    /** Used to paint bad parenthesis matches */
    Highlighter.HighlightPainter badPainter;
 
    /** Highlights using a good painter for matched parens, and a bad
        painter for unmatched parens */
    BracketMatcher(Highlighter.HighlightPainter goodHighlightPainter,
   Highlighter.HighlightPainter badHighlightPainter)
    {
this.goodPainter = goodHighlightPainter;
this.badPainter = badHighlightPainter;
    }
 
    /** A BracketMatcher with the default highlighters (cyan and magenta) */
    BracketMatcher()
    {
this(new DefaultHighlighter.DefaultHighlightPainter(Color.cyan),
     new DefaultHighlighter.DefaultHighlightPainter(Color.magenta));
    }
 
    public void clearHighlights()
    {
if(highlighter != null) {
    if(start != null)
highlighter.removeHighlight(start);
    if(end != null)
highlighter.removeHighlight(end);
    start = end = null;
    highlighter = null;
}
    }
 
    /** Returns the character at position p in the document*/
    public static char getCharAt(Document doc, int p) 
throws BadLocationException
    {
return doc.getText(p, 1).charAt(0);
    }
 
    /** Returns the position of the matching parenthesis (bracket,
     * whatever) for the character at paren.  It counts all kinds of
     * brackets, so the "matching" parenthesis might be a bad one.  For
     * this demo, we're not going to take quotes or comments into account
     * since that's not the point.
     * 
     * It's assumed that paren is the position of some parenthesis
     * character
     * 
     * @return the position of the matching paren, or -1 if none is found 
     **/
    public static int findMatchingParen(Document d, int paren) 
throws BadLocationException
    {
int parenCount = 1;
int i = paren-1;
for(; i >= 0; i--) {
    char c = getCharAt(d, i);
    switch(c) {
    case ')':
    case '}':
    case ']':
parenCount++;
break;
    case '(':
    case '{':
    case '[':
parenCount--;
break;
    }
    if(parenCount == 0)
break;
}
return i;
    }
 
    /** Called whenever the caret moves, it updates the highlights */
    public void caretUpdate(CaretEvent e)
    {
clearHighlights();
JTextComponent source = (JTextComponent) e.getSource();
highlighter = source.getHighlighter();
Document doc = source.getDocument();
if(e.getDot() == 0) {
    return;
}

// The character we want is the one before the current position
int closeParen = e.getDot()-1;
try {
    char c = getCharAt(doc, closeParen);
    if(c == ')' ||
       c == ']' ||
       c == '}') {
int openParen = findMatchingParen(doc, closeParen);
if(openParen >= 0) {
    char c2 = getCharAt(doc, openParen);
    if((c2 == '(' && c == ')') ||
       (c2 == '{' && c == '}') ||
       (c2 == '[' && c == ']')) {
start = highlighter.addHighlight(openParen,
 openParen+1,
 goodPainter);
end = highlighter.addHighlight(closeParen,
       closeParen+1,
       goodPainter);
    }
    else {
start = highlighter.addHighlight(openParen,
 openParen+1,
 badPainter);
end = highlighter.addHighlight(closeParen,
       closeParen+1,
       badPainter);
    }
}
else {
    end = highlighter.addHighlight(closeParen,
   closeParen+1,
   badPainter);
}
    
    }
}
catch(BadLocationException ex) {
    throw new Error(ex);
}
    }
 
    /** A demo main */
    public static void main(String a[])
    {
JFrame f = new JFrame();
JEditorPane p = new JEditorPane();
f.getContentPane().add(new JScrollPane(p));
p.setFont(new Font("Monospaced", 0, 12));
p.addCaretListener(new BracketMatcher());
f.setSize(400, 400);
f.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
f.setVisible(true);
    }
}