Karsten said:
Seems we agree that users may still want to look at
well rastered anti-aliased text
<grin>
Mind you, I don't think I've ever seen any such...
Note that the display quality of the screenshots provided
by Rene may significantly lag behind what the native
rasterizer can achieve. The rasterizer must know the physical
structure of your LCD, otherwise subpixel-rendering may fail.
I agree, but experience (mine) suggests that even if the rasterisation had been
done specifically for *this* laptop, then I'd still find the results harder to
read -- always provided, of course, that the fonts themselves were properly
designed and hinted for that resolution.
Let me add that even a pixel-based anti-aliasing often increases
the readability and legibility for larger fonts. Compare for example:
http://www.cs.umd.edu/~pugh/java/bugs/manual/project-dialog.png
http://www.jgoodies.com/freeware/bookfinder/images/bookfinder-0_9.png
I think those are good examples. The text "Find Bugs", and "Project", in the
first example does look ugly, and I'll agree that the smaller text is bad too.
But I don't think that that's because of the absence of anti-aliasing -- it's
because they are bad fonts, poorly adapted for the specific resolution. In
comparison, the second shot is using anti-aliasing for the "AUTHOR: ARNO
SCHMIDT" and the window title-bar. Now I'll agree that it *looks* better, but
that's the point that I think too many programmers miss -- there is a
difference between "looking better" and "being more readable". The big text on
that page is being used for titles, essentially as graphics, not as body text.
Titles are only glanced at and it really doesn't matter too much if they are
such that prolonged study would cause eye-strain. For body-text, OTOH, the
*readability* matters hugely. You'll notice that the second example is *not*
using anti-aliasing for the real text (the small text in the list), and it
looks perfectly fine, and is perfectly readable -- all because its a well
designed font *at that resolution*.
I really think the OP is making a big mistake even considering anti-aliasing
for a text editor (a body-text application, if ever there was one). If the
fonts that come with Java are bad then the solution is to find and use a
quality typeface, not to attempt a programming bodge that makes the text "look"
better (as in a picture) but can and will cause eye strain and headaches
(depending on the users' eyes and monitors -- and it's not only people with
poor eyesight that suffer).
There simply isn't enough resolution on a current display for small typefaces
unless they have been specifically optimised. Algorithmic "fixes" are
misguided; they don't work because they just don't have enough room to work in
(and if they did have enough room, then there'd be much less need for them
anyway). Such fixes are natural for a programmer to think of, I know, but this
is one case where you can't program yourself out of trouble. You can't add
quality afterwards...
-- chris