The Definitive Guide to Swt and Jface

Rating:
Summary: An Excellent SWT Book
Review:
This is an excellent book for both the beginner and the professional developer. If you need to write an application and are planning to use SWT but are not a guru, you will want to get this book. It does a great job of explaining SWT, what it is, why it is that way, and how to use it.

Each section of the book provides a topic for discussion, a code example and a complete description of all the classes and methods used. I particularly appreciated the code examples and the tips for real world implementation. The code is clean, complete, and easy to understand.

I found this book easy to read. The author interspersed just the right amount of theory, history, and commentary to break up the details and keep me interested. It is obvious that he has a comprehensive understanding of the subject matter. The surprising part is how adept he is at communicating this knowledge to the reader.


Rating:
Summary: Good on Visual Design, Virtually Zilch on Event Handling
Review: If your main question is how to place widgets on your screens, then this book is excellent. But if, however, you would like those widgets to actually trigger events, then this book is a damned disappointment. They have a general chapter on events but for widget after widget, their examples show you how to place the widget on the page but not how to get its events. You can write code to trigger events but try to do something useful with those events and you will be greatly disappointed.
Also, if you were hoping for some guidance or examples on how to use the 'asyncExec()' or 'syncExec()' methods, you will be disappointed. There is nothing. So, if you need anything beyond the basics, don't waste your money.

Rating:
Summary: Great choice for starting your SWT learning path
Review: I won't be needing another SWT book in a while... "The Definitive Guide to SWT and JFace" is indeed definitive and proved to be a nearly perfect choice for starting my journey inside Eclipse's much hyped GUI toolkit(s).

The book starts from scratch, explaining the history and motivation for a different approach to a GUI toolkit (SWT's native peer widgets vs. the emulated widgets of Swing, etc.), proceeding to your typical Hello World app with a single window and a single label, and ends up covering most everything I can think of needing to build even a relatively complex GUI using SWT and JFace. The book is a huge tome, partly because it includes listings of all the various methods provided by the classes introduced along the way. On one hand, it's a good thing because the book is pretty much all you need (i.e. a decent replacement for Google;), and on the other hand, the book would be a lot more pleasant to read if you'd drop a few hundred pages...

One thing I specifically liked about the book is that the authors have done a good job employing screenshots where needed -- especially in the chapter about layouts.

I'll definitely recommend this book for anyone looking to learn SWT. I'm not really a GUI developer (only having done Swing for personal stuff) and the book works for me as an introduction, tutorial, and a reference.

Rating:
Summary: Better than AWT or Swing
Review: Java has two major families of widgets. The first was AWT. But it suffered from many drawbacks. The second is Swing. Much nicer. But still slower than native applications. And when native GUI libraries change, you have to wait for someone to explicitly code in these changes into the Swing library.

The authors show here the alternative of SWT. It grew out of Eclipse. But SWT was so well received that it now ranks as an independent effort. The length of the book is a reflection of how SWT is a full graphics library. Anyone who has dealt with any other graphics library will be unsurprised by this. The nitty gritty of going through and explaining all the widgets. I am not going to attempt to cover these. Except to say that if you are already programming in AWT or Swing, then, roughly, once you understand SWT, you should be able to quickly convert to the new classes.

Another reason for the book's length is that there are many code listings. Good for learning. But a lot of these are entire programs in their own right, complete with "static void main" entry points and numerous import statements. Nice for users needing runnable examples. But you can well imagine what all the necessary boilerplate does to the text's heft!

The book also offers JFace. An elegant abstraction that can be used on top of SWT. If you are learning SWT, then it might be easier to skip JFace on a first reading. After gaining fluency in SWT, consider adopting JFace to ease future development. A purist might say you should try it all together from the start. I demur. SWT has enough raw material to keep you busy. Pragmatically, attend to it first.

Rating:
Summary: good book for getting into swt programming
Review: This book starts with the basics and goes through fairly advanced topics without being boring. It is a fairly easy read and can be jumped into at various points depending on your skill level. SWT is better in many cases than the Swing or AWT toolkits and this book will give you the tools to produce robust SWT code for eclipse plugins or regular applications.

Rating:
Summary: Best book on SWT yet
Review: This is the second book that I have read on SWT. The other was Addison Wesley's book "SWT: The Standard Widget Toolkit", which is in the Eclipse series. That was a short book that flew through the topic. This is a much more in-depth work.

Both books share the same introductory style. They walk through the toolkit from front-to-back and demonstrate each concept and widget by showing code and screen shots. Each book suffers from the same long term problem in that it cannot be used as reference material since neither book provides an appendix that would serve that purpose.

That being said, I still prefer this book because it is much more in-depth and presents a shallower longer learning curve than the Addison-Wesley book.