Customer Reviews

Filthy Rich Clients: Developing Animated and Graphical Effects for Desktop Java Applications

5 star:		(8)
4 star:		(0)
3 star:		(2)
2 star:		(0)
1 star:		(0)

 

 

This is one of those "fun books" on Java that you used to see so much of in the 90's but are pretty much no longer written. This book is about building better desktop applications that employ interesting graphical and animated effects. This book was meant to be worked through from beginning to end, although if you are already familiar with the technology that does not mean you can't skip around. The book has plenty of code and some math. However, as in the example in the section on morphing, the book does not try to get into heavy-duty math. If there are open source libraries that do the trick, as there are in the case of morphing effects, the authors refer you to that library. They do explain math if all it involves is something on the level of fairly simple matrix algebra - blurring for example. The book is not a primer on Swing. It assumes the reader has experience in that area. However, some of the touchier aspects of Swing that may not be self-evident to even experienced Swing programmers are explained in the first couple of chapters of the book. In particular, the authors do a pretty good job of explaining how Swing and Java 2D work together, which is hard to find in books and even in online tutorials. Obviously, there is lots of code involved in such a book, and although there are snippets in the book to the point that you can understand what's going on, you'll want to go to the book's website at O'Reilly & Associates and download the whole thing so you can study it and play with it. The book is divided into four parts as follows:

Part I - Graphics and GUI Fundamentals
Not a fundamental tutorial on building GUI's in Java, it points out the stuff you need to get up to speed with the APIs and techniques that later parts of the book build upon.
Chapter 1. Desktop Java Graphics APIs: Swing, AWT, and Java 2D
Abstract Window Toolkit (AWT);
Java 2D; Swing;
Chapter 2. Swing Rendering Fundamentals
Events; Swing Painting; Swing Rendering; Double-Buffering; Threading;
Chapter 3. Graphics Fundamentals
Java 2D; Rendering;
Chapter 4. Images
Image Types; BufferedImage; Image Scaling;
Chapter 5. Performance
Use the Clip; Compatible Images; Managed Images; Intermediate Images; Optimal Primitive Rendering; Benchmark ;Command-Line Flags;

Part II - Advanced Graphics Rendering
Continues looking at Java 2D and Swing. The first pat talks about composites, gradients, and image processing support in Java. The second part talks about Swing components that support graphical applications - the glass pane, layered panes, and the repaint manager.
Chapter 6. Composites
AlphaComposite; AlphaComposite: The 12 Rules; Creating and Setting Up an AlphaComposite; Common Uses of AlphaComposite; Issues with AlphaComposite; Create Your Own Composite; Summary;
Chapter 7. Gradients
Two-Stops Linear Gradient; Special Effects with Regular Gradients; Multistops Linear Gradient; Radial Gradient; Optimizing Gradients;
Chapter 8. Image Processing
Image Filters; Processing an Image with BufferedImageOp;AffineTransformOp; ColorConvertOp; ConvolveOp; LookupOp; RescaleOp; Custom BufferedImageOp; A Note about Filters Performance; Summary;
Chapter 9. Glass Pane
Painting on the Glass Pane; Blocking Input Events;
Chapter 10. Layered Panes;
Using Layered Pane Layers; Ordering Components within a Single Layer; Layered Panes and Layouts; Alternative to JLayeredPane with Layouts;
Chapter 11. Repaint Manager
When Swing Gets Too Smart; Meet the RepaintManager; A Reflection on RepaintManager; Summary;

Part III - Animation
Discusses the basics of animation in Java and the existing facilities in the core language that make it possible. Covers the Timing Framing library that simplifies Java animation.
Chapter 12. Animation Fundamentals
It's About Time; Fundamental Concepts; Timing (and Platform Timing Utilities); Resolution; Animating Your Swing Application; Summary;
Chapter 13. Smooth Moves
Background: Why Does My Animation Look Bad?; What Makes Animations Choppy, and How to Smooth Them Out; SmoothMoves: The Demo; Summary;
Chapter 14. Timing Framework: Fundamentals
Introduction; Core Concepts; Interpolation; Summary;
Chapter 15. Timing Framework: Advanced Features
Triggers; Property Setters; Summary;

Part IV - Effects
Effects are only possible after you really understand parts one through three. Individual effects are covered and explained in detail if not overly mathematically complex. The section ends by showing how an example graphically rich client might be developed from beginning to end.
Chapter 16. Static Effects
Blur; Reflection; Drop Shadows; Highlights; Sharpening; Summary;
Chapter 17. Dynamic Effects
Motion; Fading; Pulse; Spring; Morphing; Summary;
Chapter 18. Animated Transitions
Animating Application State Segues; Animated Transitions: The Library ;Animated Transitions: Under the Hood, or How Do You Get Swing to Do That?; Summary;
Chapter 19. Birth of a Filthy Rich Client
Workflow Paper Design; he Vision; Screen Paper Design; Mockup; From Mockup to Code; But I'm Not an Artist; Choosing Nice Colors; Read Design Books; Summary;

Overall, this is a very interesting book full of useful information both language-wise and effects-wise that I highly recommend.

This book will save you hours of trouble shooting the little things that don't work as intuitively as they should in Java.
I have not found an un-useful idea here.
It also shows you how to make your application more efficient (faster).
The author has already done the timing tests and offer you the results and the routes you should take.
All in all, a fantastic find.

To push java's ui capabilities has in the past been a bit of a struggle due to the many ways of dealing with Swing, repaints, events, animation etc. This book is an absolute life saver in terms of presenting a unified best practice strategy for everything a ui developer would wish to do in java. It creates very simple applications with solid explanations of what the code is doing, from the low level to the high level. It is also written in a very personable style and the book moves easily and logically through the related material. I wish I had read this book 4 years ago.

After years of programming swing data grid based applications. This book is more than a relief to read. The examples are really inspiring and are an invitation to experiment and apply them. I really learned a lot about the inner working of swing and the book kept me keen on performance. Applying animations and effects is not applicable in a lot of cases but is very good to know how to apply them when a chance comes by. For me this book is a must read if you like to program Java Swing applications.

Libraries that cater to Java programmers will find an excellent guide in FILTHY RICH CLIENTS, which refers to rich applications that teach how to build better, more effective desktop applications that enhance user experiences. Graphical and animated effects are the focus here, with a bow to performance: chapters teach how to create, customize and translate special effects with Filthy Rich Clients and come from a client architect of a Java group at Sun Microsystems. Any advanced programming collection needs this.

This book is fantastic - so many tips and tricks that I was unaware of. I want more!! I hope a sequel is in the making!! Check it out!! You won't be disappointed!!

This is a very good book. It can enlighten even your basic knowledge
about java 2d drawing and swing. It is not a book for beginners. If you
love swing/java2d this is the book for you!

This very practical book is full of usefull tips to create your own filthy rich client. Definately worth reading!

Apparently some negative reviews may "ban you from any party in greater San Francisco Metro Area," to coin a vernacular after Mad Money's Jim Cramer. But, I happen to stand by my opinion.

I have also enjoyed this book very much. Many of these techniques, such as using of intermediate images, were known to me, but numerous details escaped my attention. For example, using of 'compatible images.' I had no idea that this notion exists. I also enjoyed the timing experiments with and details of timer granularity, foremost in Windows. Their description of Animators is probably the best and most comprehensive of everything what I saw so far, its a real value-add for me.

I will not repeat the positive accolade summarized here by others, I have one very substantial objection, which is really well summarized in the title used by someone else's comment about this book:

"Practice what you preach."

The book preaches performance, efficiency and style, and yet the authors implement some enormous convoluted scheme around their own code snippets! Of course, being interested in timings and performance of the examples, I wanted to run and to watch them. And... I failed at first. I have spend, or wasted rather if you so want, a lot of time in an attempt to achieve this goal.

This sounds so easy nowadays to use Java Webstart, or merely to deliver some *.java or *.class files, either separate or in a *.jar archive.

Not so for Chet and Romain: Their own web page claims that you can download a plugin for Net-Beans and run the examples. Net Beans has proven to be a product, a specific development environment, with which you may, or may not be familiar. I never used it and I cannot operate it. Nor am I interested in learning it, being perfectly happy with my own Java setup. But be it as it may, I installed it in the hope to run these demos. It flooded my disk with some 125Mbytes and thousands of files, the usual mayhem, but we have now Terabytes at home, don't we? I also downloaded the plugin, and started to click around to get anything running. Lost in unfamiliar windows and menus I found nothing, no way to start any demo.

I must be getting old, do I failed the IQ test? All right than, I give up. Lets download the source code, run javac and be happy. What can be so difficult? Nope! The adventure has just begun!

An Example: Click on Chapter 2, Swing Rendering Fundamentals. You will get an archive frc-chapter2.zip, whose root directory has merely two folders and two empty files with the same name. On a hunch, step down into the directory SwingRenderingFundamentals, only to find another set of folders and a set of empty files, each with the same name like one of the directories. On a hunch lets step down into HighlightedButton, where we find a bunch of alien looking files and 3 more directories, with you guessed it, 3 more empty files carrying the names of these directories.

Among them is build.xml. XML eh? Hmm... what do I do with that? None of my systems can do anything with XML, this book is not about XML, I do not need to use XML, do I? It's a practitioners book about a specific aspect of Java. I would be happy to stay with "javac" and "java" only, please.

On several places I see a directory called CVS, this may or may not be a name of some source code managing tool. For example, a CVS directory (accompanied again by an empty file with the same name) contains 3 files. Each seem to have some generated content, like this file called Entries: /HighlightedButton.java/1.1/Tue May 01 22:48:46 2007/-ko/
Hm... It most probably serves a project tool of a sort. But how this relate to the book about programming graphics in Java and to the task at hand?

But one directory name is "src". Source, hurray, the treasury hunt might be close to an end! Indeed, this is how you can 'fish' for Java files, best done with a script of a sort. Simply copy all Java files into one single place. You will be fine. Deviating from the standard, most of them do not has any package specification corresponding to the directory they were found in. Once you get these files filtered out, you will even find among them Java files containing mere 2-3 lines of code, accompanied by a standard some 30-lines Sun copyright notice. Vive la lawyers!

Equally convoluted is the way to access these files on Java.net. In a hope for an easy one-click demo, and not willing to give up just yet, I registered an account with Java.net and dived into filthyrichclients.dev.java.net, only to find the same convoluted way of keeping Java files here and there among "a forest of directories" and sidecar files. Here however, I got finally educated that CVS is a repository system, and the web pages provide some comprehensive help in its use.

Please do not take me wrong: I do not want dismiss usability of any tool, like NetBeans or CVS, but pardon me, I was happy with my own setup. "If it isn't broken, do not fix it," I do not need to get hundreds of megabytes of some unrelated software, in order to find a few demo lines of Java, do I?

Authors wrote really a good book teaching practitioners algorithmic and best practices in using Java to generate well performing user interfaces. They should be focused strictly on the implementation of just such philosophy, and not on their particular development or source file control tools. The beauty of Java is that it can be used without any special environment. One needs only the Java compiler and the Java Virtual Machine. Compare this convoluted delivery with other (official) Sun Java tutorials, and their well conceived one-click demos. I would suggest to the authors of Filthy Rich Clients to follow this convention. At the least, please place the Java files in one single directory, or make one directory per chapter. That would be all what a reader would need.

I want client-side java very much to succeed, especially now that it is open source, but the java.com site itself uses flash instead of applets, and the first author of this book no longer even works for Sun on java stuff - he now works on Adobe Flex:
http://graphics-geek.blogspot.com/2008/02/what-hello-world.html