Customer Reviews

Swt/Jface in Action: GUI Design with Eclipse 3.0

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

 

 

SWT and JFace are the graphical libraries developed by IBM as an alternative to Swing to improve performance of GUI applications (specifically Eclipse) written in Java. This book offers a thorough introduction to SWT/JFace. The authors avoid getting into a Swing vs. SWT/JFace debate although they do provide a comparison of the two libraries.

The book starts with a look at writing a program in SWT and then rewriting it using JFace. The authors compare the two approaches and give a good description of why you would want to use one over the other. The next few chapters look at the basic widgets, layout managers, event handling, and graphics contexts. Later chapters cover more advanced widgets such as trees, viewers, tables, menus, dialogs, and wizards. The last chapter looks at GUI development using Eclipse's Rich Client Platform. The appendices cover development within Eclipse and integrating SWT/JFace applications with OLE and ActiveX.

Overall this book does a great job of explaining SWT/JFace at a good level of detail. The book includes a reasonable amount of code samples as well as UML diagrams that help explain how these libraries work. The authors should have chosen a better sample application to demonstrate use of the libraries and there aren't enough screen shots included which may leave you wondering what some of the widgets look like. Other than these two minor complaints, this is an excellent book to learn how to use SWT/JFace and I can strongly recommend it.

"SWT/JFace in Action" proceeds to build a monolithic UI "application" consisting of a dozen or so widgets. Other than creating the widgets and putting them into an application, the book has little else to offer. Many chapters include tables of descriptions copied verbatim from the SWT/JFace Javadocs, with no additional verbage provided. There is very little coverage of event handling, or layouts. After presenting pages of vacuous descriptions like "setActionDefinitionID(String) - Sets an Action definition identifier" (p.73), each chapter concludes with the absurd statement "Now you are an expert." It would be funny if you had not just wasted $30 on the book.

The silliest chapter is that of image-handling which contains a bizarre program to generate and save animated GIFs as files (why is this important to UIs?). After plodding through the process of generating images pixel-by-pixel (does anyone generate images pixel-by-pixel? doesnt everyone use methods to draw lines, arcs, elipses, & polygons?) the authors present a program to produce animated GIFs as files. The code contains strings of bytes (e.g., new byte[] {56, -67, 98, 54, -4, 2 }) with no explanation. My impression is that the author had this program on his PC and could not think of anything else to do with it but to include it in the book. The highlight is when the animated GIF is placed into the main application and the author comments that unfortunately, SWT does not provide functionality to animate it. LOL.

I recommend that you read the Javadocs before you buy this book. If you need additional help, look for a reference other than this book.

As many people know by now, SWT and JFace are the GUI libraries used to create Eclipse, the popular open-source Java IDE. As fewer people know, these libraries can be used to build other applications as well. This book will teach you how. Its 13 chapters and four fat appendices give you all the information you'll need to create your own GUIs using this exciting new technology.

JFace is built on top of SWT just as Swing is built on AWT. Most books, quite naturally, discuss these layers separately. This book is unusual because it discusses SWT and JFace simultaneously. This is more useful for the reader as she gains an appreciation for all her options at once.

At barely over 450 pages, this is a comparatively small book on this large topic. It doesn't feel like anything is missing, though, although sometimes it feels a little cramped. The book is jam-packed with useful information and lots of code. For a book on graphics, however, there are curiously few screen shots. This, and some odd organizational choices (especially the relegation of GEF to an appendix,) are my only complaints about this otherwise serviceable work.

This book is well written. The narrative flows conversationally and keeps your interest throughout the chapter. This book gives you a fundamental understanding of the architecture of SWT and especially of JFace. It puts the pieces together for you. Whether you are writing desktop gui applications, Eclipse plug-ins, or Eclipse Rich Client Platforms (RCP) applications, this book is an excellent starting point. Unfortunately, the chapter on RCP was full of errors and the application example did not run. But all the other book's examples ran without any errors. And its excellent explanations of the JFace frameworks make the book worth having.

This text may work as a simple introduction to SWT and JFace, but it is a VERY poor reference material for the minutae that is what makes SWT and JFace challenging to use. I would NOT recommend it to anyone.

I read this book and Professional Java Native Interfaces with SWT/JFace (Programmer to Programmer) at the same time. In most ways they are very similar, and most of my comments in the reviews I wrote for both are true for both books. Both give a reasonable introduction to SWT and JFace, but neither goes beyond that level. Getting an introduction from a single source that tries to organize the topic gave me a better starting point than assembling the many beginner tutorials that are available free on the Web.

None of the books I have found go beyond a beginner level. By reading two books in parallel I got a better picture of the JFace event model than from either book alone. I had to learn by experiment how to use the event model and communicate data when you go beyond the tiny tutorials in the books.

The sample project of this book is its weakest part. It strings together samples of the major widget classes, but gives no examples of the architecture or dynamics of a real program.

I am not aware of any good resources beyond the beginner level. In my opinion both this and Professional Java Native Interfaces with SWT/JFace (Programmer to Programmer) are superior to the third easy-to-find book on JFace, The Definitive Guide to SWT and JFACE.

If you've got one of the fantastic bosses that loves buzzwords, and spouts off things like, "Our GUI needs to be more...GUI, you know?" help has arrived.

Once you get past the curiously out-of-place cover (SWT is not Swing.) what you find underneath the hood is an informative volume of work that mixes enough code with theory to allow you to get from "fragment of an idea that your boss had" phase to the compile and build.

The foursome of Holder, Scarpino, Ng, and Mihalkovic have put out some of the best writing of their careers, making the book simple enough to grasp, but never dumbing it down, or taking a "preachy" stance on SWT.

The only complaint I have is that there aren't enough screenshots of the resulting GUIs, and the book in general needs a little bit more "punch"...maybe some little cartoons on the Chapter headings or something. Other than that, probably the definitive SWT book out there. Even comes with an eBook version.

The Standard Widget Toolkit otherwise known as SWT is a library of tools that can be combined to facilitate the programming of Graphical User Interfaces. As such, SWT/JFace is considered by some to be the follow-on to Swing which was the original Sun library for programming GUI's. Others consider that SWT/JFace violates the basic carved in stone commandment about platform independence. SWT/JFace has been tightly integrated into the Eclipse 3.0 integrated development environment, and has become the most popular Java toolset (as voted by Java developers).

The book introduces the SWT/JFace toolsets as simply but thoroughly as possible. It combines both the high-level theory and the low-level details of the tools. The assumption made in this book is that the reader has some experience with Swing. I'd rank this as an intermediate to advanced level book. One very nice thing is the eBook edition and the ask the author capabilities that the publisher has put on their web site.

Someday someone needs to put together a Guide to Java that just contains the names and descriptions of all the Java components, add ons and hanger ons, libraries, tools and whatever. It would also have a dictionary that covered all the funny definitions that the Java community has given to common English words like class, parent/child, beans etc.

To be honest, I only picked this book up because I like having lots of computer books in my bookcase, and I like having as many references on hand as possible. I really didn't expect anyone to know more on the subject than I did.

While I was mostly right, the book did manage to discuss the topic with surprising lucidity without losing a bit of detail. Not a small feat considering the subject matter. It also manages to be very lean, not wasting any time on theory or conceited tangents that just tend to waste the readers valuable time.

The only problem I had with the book is the cover. While programming books are not known for their stylish leather binding or gilded pages, I'd prefer to have a book that didn't look so much like "chicken soup for the GUI" on my shelf.

I recommend the book for anyone interested in working with SWT/JFace.