Filthy Rich Clients refers to ultra-graphically rich applications that ooze cool. They suck the user in from the outset and hang on to them with a death grip of. BUDDHA. Similar Free eBooks Why Java and Swing for Filthy Rich Clients? Filthy Rich Clients refers to ultra-graphically rich applications that ooze cool. Filthy Rich Clients refers to ultra-graphically rich applications that ooze cool. They suck the user in from the outset and hang on to them with a.
|Language:||English, Spanish, Arabic|
|Genre:||Health & Fitness|
|ePub File Size:||20.40 MB|
|PDF File Size:||8.75 MB|
|Distribution:||Free* [*Sign up for free]|
This site is a resource for the book Filthy Rich Clients by Romain Guy and download the PDF eBook · download the print version · download the online version · The book in. Read "Filthy Rich Clients Developing Animated and Graphical Effects for Desktop Java¿ Applications" by Chet Haase available from Rakuten Kobo. Sign up. Editorial Reviews. From the Back Cover. "Filthy Rich Clients" refers to ultra- graphically rich eBook features: Highlight, take notes, and search in the book; In this.
They suck the user in from the outset and hang on to them with a death grip of excitement. Filthy Rich Clients: Developing Animated and Graphical Effects for Desktop Java TM Applications shows you how to build better, more effective, cooler desktop applications that intensify the user expe Filthy Rich Clients refers to ultra-graphically rich applications that ooze cool. Filthy Rich Clients: Developing Animated and Graphical Effects for Desktop Java TM Applications shows you how to build better, more effective, cooler desktop applications that intensify the user experience. The keys to Filthy Rich Clients are graphical and animated effects. These kinds of effects provide ways of enhancing the user experience of the application through more attractive GUIs, dynamic effects that give your application a pulse, and animated transitions that keep your user connected to the logical flow of the application. The book also discusses how to do so effectively, making sure to enrich applications in sensible ways. Learn how to maximize the flexibility of these libraries and use them most effectively.
This item in chinese. Sep 17, 10 min read. Andy Roberts. The term "Filthy Rich Clients" was only coined relatively recently by the authors to describe "applications that are so graphically rich that they ooze cool.
With that in mind, the book goes on to explain how to utilise Java2D and Swing in order to enhance your desktop applications. The authors are eminently qualified to explore the topic. Romain Guy never seems to stand still for too long as he was worked in various areas of the IT industry. During his time as an intern at Sun Microsystems be rose to the ranks of Java Rock Star and gained a lot of kudos for developing and presenting two filthy rich clients at the last two JavaOne conferences.
Quite simply, this is for developers who what to make their Java desktop applications look "cool".
It's not just for media players and instant messenger clients. Naturally, there is no substitute for a fully functioning application behaving as the user expects. It is for those who want to take their rich client to the next level and try and create visually appealing interfaces to make users increasingly comfortable.
I've have developed a range of Java Swing applications for several years now. Although relatively content with the average desktop experience, one of my more recent projects met resistance due to its Java roots and unfounded performance "problems". Once I started making it filthy although this was in the pre-filthy rich client era , the detractors were less bothered about the so-called Java problem and actually enjoyed using it because it looked cooler than the alternatives.
I must admit, I don't particularly enjoy getting my hands dirty writing Java2D code and extending JComponents. I'm usually perfectly happy to rely on a decent 3rd party look and feel, such as the rather good Substance Look and Feel to add a bit of glitz to my apps. I just want to write working applications. However, I always enjoy a visually appealing application, so I know I should offer a decent experience to my users also. And now here's a book to teach developers exactly how to do so. For the authors, the "filthy" aspect equates to effects and animations: Gradients, reflections, drop shadows, fades, transitions, etc.
Java is extremely versatile and all the effects are possible; the problem is that there's a lot of groundwork required to achieve them. Firstly there are the fundamental graphic algorithms to grasp. Then these must be translated into something Java2D can compute. This is followed with how to get the images drawn to display and behave properly within Swing. On top of this, there are always performance issues to consider.
In short, there is a real need for some experts to guide developers through the surprisingly complex world of creating graphically rich applications. Although it's only part I with "fundamentals" in its title, in my view, the first three parts are all in fact laying foundations.
Like with The Karate Kid, there's a lot of waxing on and waxing off before you get to kick-ass! Part I lays out the most essential information in the journey to graphical enlightenment. The chapter on Swing and threading is perhaps as good a review of the topic as you'll ever read.
This is followed by a tour through the most applicable parts of the Java2D package that you need to get to grips with. The final area is about understanding 'images' within a Java context: The real bread and butter elements come in Part II, where the reader is introduced to advanced graphics rendering techniques. It is here that you learn how to use composites, create gradients, draw reflections, and apply filters to images.
It is also where you begin to learn the power of the GlassPane in Swing and how to use layered panes. It's within these chapters that you start to realise that there are caveats-a-plenty. Obviously, this is why the book exists in order to show you where potential "gotchas" lie and present best-practice. Part III deals with animation and, speaking personally, was an extremely enjoyable read. This was surprising given that I didn't think I was that interested in the topic! Animation concepts are succinctly covered, as are the key assets within the Java platform that provide the tools for animations, namely timing mechanisms.
The section ends with two chapters presenting Chet's Timing Framework. Its raison d'etre is to make animation and timing as simple as possible. As the book illustrates, there is a lot of boiler-plate code required in order to setup timers and determine the current progress of the animation.
This framework takes all that tedium away, and it also provides many other useful classes for setting up triggers events that cause the animation to begin and interpolation defining how frames progress throughout the animation. As libraries go, this is an extremely good example of a cleanly designed API that is very fit for its purpose and makes a potentially tricky task very easy to handle.
And finally, the climax of the book comes in part IV, which deals with effects. This is ultimately where you bring together the knowledge conveyed in the previous three parts and put it in to practice - it is here that you truly start to build filthy rich clients.
Various static effects are demonstrated, such as blurs for making backgrounds less distracting when popups are visible , drop shadows, reflections and highlights.
There is a follow up chapter on dynamic effects, like fades, pulses, springs and morphs. A chapter on transitions is particularly interesting and presents a strong case for why interfaces should not instantly jump to various screens without making it clear how they relate to each other.
This is also where the reader is introduced to the book's second library called Animated Transitions, written expressly for dealing with transitions. Again, it's another well thought-out API that is really going to make life easier for developers to add this type of functionality.
It facilitates moves, scales, fades and rotations as standard, with the ability to plug-in your own custom transitions if need be. The book is extremely well written and really rather absorbing. It is fairly informal in style, and given that it weighs in at approximately pages, it is probably a good thing. Anyone who reads Chet's blog will know that he's not adverse to the odd corny-joke or two, and the book isn't immune from those - they don't really add a great deal, although they don't detract either.
In fairness this book does not cover terribly trivial topics, and given that the chapters are all easy to digest, it is a great testament to the authors' ability to communicate their field of expertise. The writing is great, the figures are always beneficial and the code snippets are very well utilised. A tricky balance, no doubt. The obvious difficulty is that trying to illustrate animations and dynamic effects by definition is not easy on a static medium.
To make the most of the book you do have to spend some time with the sample demos and source code. The difficulty in writing programming textbooks is getting the right balance in terms of the amount of code to embed with the pages of the book. It all depends on the concept being explained, of course.
In Filthy Rich Clients, they do a pretty good job in this regard. There are many code samples demonstrating how various tasks should be written, which is exactly what you expect, yet each snippet is kept to the bare minimum, and very rarely due listings exceed a page in length.
This is often achieved with substituting blocks of code with a single lined comment when such blocks are not essential for the understanding of the current sample. It's a good technique, and whilst it sometimes means you can't do a verbatim copy from the book's pages, much more digestable, and the reader is fully aware that the full code is available from the companion website.
Most of the source code presented in the book are snippets from taken purposely written demo applications which are available for downloading.
These are bundled in a zip file per chapter, and are aimed at being easily loaded and run using Netbeans. It would have been ideal if the authors had supplied compiled versions, perhaps as WebStart bundles allowing easy execution with just a double-click, although maybe I'm just being picky. At the time of writing not all the examples are available. The demos for chapters are absent there are no samples for chapter 19, in case you were wondering , which is a shame as these are the ones covering the various desktop effects and transitions.
As a consequence, it's not yet possible to obtain a copy of the Animated Transitions library. Figure 8 is wrong. The explicit call to process V You can download the correct figure. On page , note that the getFasterScaledInstance was only intended for downscaling images. If you use the method as written for up-scaling, you may hit an infinite loop problem.
Or simply don't use this method for up-scaling. One page , resultG and resultB should be calculated with srcG and srcB , respectively they incorrectly use srcR in the example code. In order to address a memory leak that comes from adding but never removing PropertySetters to the Animator used for ScreenTransition, there is a new method in Effect:.
This method is a parallel to the existing init Animator method, only this one is called after the transition is complete, and gives the Effect a chance to clean up after itself such as removing targets from the Animator. The cleanup method, then, is responsible for removing ps after the transition is complete:. You may not need to use this method, or know about this detail at all, in your animated transition code.
But if you define any custom effect such as the MoveIn effect in the SearchTransition demo then you may need to override cleanup to avoid memory leaks.
EffectsManager makes it possible to set custom effects for an application, but not until now to remove thoes effects. You could set an effect for a component to null , but you could not actually remove the component from the cached list of components with associated effects. He works with all of the desktop Java technologies, including Swing and Java 2D, and focusing on how to improve the platform.
His passion in software is graphics, and he has spent most of his career apart from a short stint just after college, when he realized just how dull "network analysis" is working with graphics technologies of all kinds, from 2D to 3D and from the application down to the driver level. Chet received his B. Romain wrote this book during his final year at school and while obtaining his M. His passion in software is graphics and graphical user interface development, and he has spent many years working with Java and Swing.
Romain cannot stand still and has worked as a freelance journalist for programming magazines for years, as a book translator for O'Reilly, as a Java teacher in a French university, as a videogame developer, as a freelance developer, as a software engineer on the Swing Team at Sun Microsystems, and as a software engineer at Google. His new passion is digital photography. We are pleased to receive your comments and feedback about the book and its demos.
You can contact us at the following email addresses for any matter concerning the books and its derived material:. Introduction to Filthy Rich Clients Filthy rich clients are applications that are so graphically rich that they ooze cool.
Some of the topics covered in-depth include: Graphics and GUI fundamentals: Learn how to use these libraries correctly and effectively. Follow in-depth discussions and tips throughout the book that will help you learn how to write high-performing GUI applications.
Understand how images are created and used to make better Java applications.
Advanced Graphics: Find out about elements of Swing and Java 2D that may not be in common use but that filthy rich clients benefit from greatly. Discover general concepts of animation, as well as how to use the facilities provided in the Java platform.
Learn about new utilities that vastly simplify animations in Java. Learn how to create and use static and animated effects that are the mainstay of filthy rich clients. Every chapter is filled with code examples which come directly from demos and libraries posted on this web site.
Outline Filthy Rich Clients covers many graphics-related topics. The following outline describes the structure of the book and gives you a clear description of its content: Fundamentals Timing Framework: