java left logo
java middle logo
java right logo
 

Home arrow Book Reviews arrow SWT/JFace in Action : GUI Design with Eclipse 3.0
 
 
Main Menu
Home
Java Tutorials
Book Reviews
Java SE Tips
Java ME Tips
Java EE Tips
Other API Tips
Java Applications
Java Libraries
Java Games
Java Network
Java Forums
Java Blog




Most Visited Tips
Java SE Tips
Java ME Tips
Java EE Tips
Other API Tips
Java Applications
Java Libraries
Java Games
Book Reviews
Top Rated Tips
Java SE Tips
Java ME Tips
Java EE Tips
Other API Tips
Java Applications
Java Libraries
Java Games
Book Reviews


Statistics
Registered Users: 4091
Java SE Tips: 614
Java ME Tips: 202
Java EE Tips: 183
Other API Tips: 779
Java Applications: 298
Java Libraries: 209
Java Games: 16
Book Reviews:
 
 
 
SWT/JFace in Action : GUI Design with Eclipse 3.0 E-mail
User Rating: / 19
PoorBest 
 Book Information

Image

Authors: Matthew Scarpino, Stephen Holder, Stanford Ng, Laurent Mihalkovic
Paperback: 496 pages
Publisher: Manning Publications (November 28, 2004)
Language: English
ISBN: 1932394273
Product Dimensions: 9.2 x 7.3 x 0.9 inches
ImageAmazon.com Link


 Book Review

Introduction and Target Audiences:

Making the readers well acquainted with SWT and JFace toolsets in an easiest and simplest manner is the main goal with which this book had been written. Although the book is primarily meant for the intermediate and advanced Java programmers but this doesn’t mean that beginners need to go empty handed. There is a lot more in the book than just some advanced topics on SWT/JFace. Author had taken good care of beginners by his timely reference to the basic topics as and when needed. Readers who are comfortable with basic Java syntax will find learning of SWT/JFace much easier than others. Experienced Graphical application developers will get great help from this book. Author had packed all the relevant and required stuff in nearly half the number of pages as compared to other related books in the market. Readers can very well feel this difference when they will almost run through the concepts while reading this book. Author’s attractive style of narrating the concepts together with some efficient examples keep the readers hooked to this book. Infact with each passing page, developers will themselves feel as if they had gained something new.

Organization of book:

Organization of this book had been done in an interesting way where author had structured the concepts around a sample application. All the SWT and JFace topics had been written and explained with reference to this sample application. This gives its readers a more practical approach while learning. Author’s efforts in finding a sample application are clearly visible as the chosen application shows details of each component included in SWT/JFace. The book itself gets divided into virtually two parts. One being the development of the foundation application and other being the usage of this application to play with the code and to see the effect of different parameters on each component.Latter being an independent aspect does not require the help from initial chapters.

Overall various concepts had been spread over thirteen chapters in this book. Each chapter in itself brings a new learning for the reader along with its simple but effective examples. Starting the book with an expected introductory session says nothing new about the book. But this rather traditional introduction helps the readers to go for a surprise later when they get to learn many things that too in a very short notice of time. All this is due to the excellent and noticeable organization of the book. While chapter one says much about the history of SWT and JFace. Next chapter pleases the developers by directly taking them into implementation phase. This chapter although doesn’t go much deep into the implementation concepts but it do succeed in giving the readers a basic know how of the SWT and JFace implementation concepts. It also highlights some of the important classes of SWT like Display and Shell. Chapter three takes the implementation concepts a little more further and tells the reader one of the most important programming aspect of SWT and JFace: the inheritance hierarchy. Beginners can readily learn and implement the above said concept in their application, thereby making their original application more efficient using this book. Some basic common widgets such as buttons and labels had also been discussed in an effective manner.

Once the basic discussion on creation of application is over, author takes over the event handling next in the book. Reaction of the application to different user actions is the centre of discussion in the fourth chapter. Role and effect of different events like typed and un-typed listeners, mouse and keyboard events etc had been taken care of in the best of possible ways. Both the low level event classes and the higher level Action framework had been equally talked about by the author. Moving on to Chapter five author tries to give the readers an added knowledge of some more Widgets which once used can make the application more robust and efficient apart from making it user friendly. SWT Widgets, JFace widgets, combo boxes, Toolbars, sliders etc. are the various components which found author’s attention here. Developers not getting sufficient implementation help from other books will definitely feel the difference here.

Feeding the readers with enough of SWT application creation, individual widget details etc. the author now turns the focus towards the organization of widgets on the screen. Chapter six covers most of the built-in layout managers of SWT including the Row, Grid and Form Layouts and then also offers the developers with their own customized layout managers. Having said nothing regarding the Graphic edition author tries to capture certain Graphic related issues in chapter seven. Apart from explaining some low level SWT facilities for drawing graphics by hand this chapter also shows the programmatically manipulation of colors, fonts and images from within SWT. Presence of this chapter relieves the Graphic developers to a great extent as this short but impressive discussion over the graphic capability of SWT seems to be sufficient enough for the readers to grasp the concept.

Making the application development easier for the developer, author tries to give them some quality knowledge over the SWT and JFace trees and lists in chapter eight. It includes the Viewer framework and the related classes showing the easiness working with trees and list widgets. Continuing the discussion further in chapter nine, author tries to capture some of the advanced features of the Viewer framework. Here the readers get to know how these advanced features enable them to create editable tables. In this way author had devoted sufficient time for the trees, lists and menus in these two chapters. Developers can very well take advantage of this by applying the said concepts in their application. One more noticeable thing in the book is that one cannot differentiate if it is a beginner’s book or had it been written keeping the requirements of advance developers in mind. The flow and content are so simple yet knowledgeable that one feels himself immediately attached to the book. Overall the book satisfies everyone from early developer to an experienced person.

Moving on to chapter ten, author takes up yet another important aspect of SWT and JFace, the Dialogs.Here an extensive discussion occurs on various ways to create dialog boxes in SWT and JFace. The chapter also discusses the creation of customized dialogs where a developer can make a dialog according to his needs. Chapter eleven is about “Wizards”, the user’s guide telling him various helping steps as needed. It tells the readers how to use the JFace framework to create a wizard. Last two chapters of the book are required to achieve a full mastery of the SWT and JFace application but they aren’t the essential topics to get a basic application running. These two chapters (atleast chapter twelve) can be skipped by the readers but then I would recommend that it is better not learn something only rather than learning it incomplete. Where chapter twelve covers various advance SWT features which the readers can readily take advantage of in making their application more robust and attractive. Last chapter of the book deals mainly in the building of custom workbench applications containing editors and views. It also extensively discuss regarding the Eclipse Forms Toolset. Apart from this the chapter also highlights the classes that make Rich Client Platform operation possible with an obvious introduction to theory behind the RCP. In this way starting from the introduction to ending with some advance topics the author had tried to capture every single and important aspect of the SWT and JFace.

Finally

As the title “SWT JFace in Action” appropriately says, the book can be considered as another feather in Manning Publications cap. Being informative enough right from theoretical introduction, overviews to practical how-to examples this book surely lives up to the expectations of its readers in every respect. Following the tradition of “In Action” books, this book also enables its readers to remember the things which they discover and learn while exploring various new and interesting concepts through the book. One attractive aspect which I had noticed in this book is that users especially developers can instantly refer this book for doing some job or for solving some of their problems. The organization of the book had been done in such a way that users can readily get help for their various practical problems without going through the entire book. Being Manning’s book that too one from their “In Action” series, nothing more should a developer look out for while searching an aid. Overall, full marks to the author for creating a masterpiece like this!!


 Table of Contents
  1. Chapter 1 Overview of SWT and JFace

    • What is SWT/JFace?
    • Looking under the hood
    • SWT/JFace: licensing and platform support
    • The WidgetWindow

  2. Chapter 2 Getting started with SWT and JFace

    • Programming in SWT
    • Programming in SWT/JFace
    • Beginning the WidgetWindow application

  3. Chapter 3 Widgets: part 1

    • Introducing the Widget and Control classes
    • Labels
    • Involving the user with buttons
    • Containing components with Composites
    • Updating WidgetWindow Beginning the WidgetWindow application

  4. Chapter 4 Working with events

    • Event processing in SWT
    • Event processing in JFace
    • Updating the WidgetWindow

  5. Chapter 5 More widgets

    • Editing text with SWT
    • JFace text support
    • The Combo widget
    • ToolBarManager
    • CoolBar
    • Slider
    • ProgressBar
    • ProgressIndicator

  6. Chapter 6 Layouts

    • The fill layout
    • The row layout
    • The grid layout
    • The form layout
    • Custom layouts

  7. Chapter 7 Graphics

    • The graphic context
    • Programming with colors
    • Displaying text with fonts
    • Incorporating images in graphics
    • Updating the WidgetWindow

  8. Chapter 8 Working with trees and lists

    • Viewers and the Viewer framework
    • Trees
    • Using the List widget
    • Updating WidgetWindow

  9. Chapter 9 Tables and menus

    • Tables
    • Creating menus
    • Updating WidgetWindow

  10. Chapter10 Dialogs

    • SWT dialogs
    • JFace dialogs
    • Updating WidgetWindow

  11. Chapter11 Wizards

    • Multipage dialogs
    • The wizard
    • Putting it all together
    • Combining wizards
    • Persistent wizard data
    • Updating WidgetWindow

  12. Chapter12 Advanced features

    • Transferring data
    • Preferences
    • Label decorators
    • The Browser widget

  13. Chapter13 Looking beyond SWT/JFace: the Rich Client Platform

    • Understanding RCP workbenches
    • RCP: Looking under the hood
    • Adding views and perspectives
    • Populating forms with Eclipse Forms widgets
    • Building a standalone RCP application

  14. Appendix A : Creating projects with SWT/JFace

    • A.1 Eclipse-based SWT/JFace development
    • A.2 SWT/JFace in standalone applications

  15. Appendix B : OLE and ActiveX in SWT/JFace

    • B.1 COM simplified
    • B.2 The SWT COM library
    • B.3 Doing COM with SWT

  16. Appendix C : Changeable GUIs with Draw2D

    • C.1 Understanding Draw2D
    • C.2 Draw2D Figures
    • C.3 Using LayoutManagers and panes
    • C.4 Using the Graphics class to create Shapes
    • C.5 Understanding Connections
    • C.6 Putting it all together

  17. Appendix D : The Graphical Editing Framework (GEF)

    • D.1 A GEF overview
    • D.2 Creating the FlowchartProject
    • D.3 Creating the editor’s PaletteViewer
    • D.4 The Model aspect: Model classes
    • D.5 Changing Model properties with Commands
    • D.6 The Controller aspect: EditPart classes
    • D.7 Creating Commands with EditPolicy objects
    • D.8 Adding Actions to the editor
    • D.9 Editing with GEF: two examples
    • D.10 Introducing the EditorPart
    • D.11 Other GEF aspects

 Overview of Chapters
  1. Chapter 1 Overview of SWT and JFace

    • What is SWT/JFace.
    • The purpose of SWT and JFace
    • What are the reasons for SWT and JFace creation.
    • How the two libraries differ from Swing
    • Licensing and platform support for SWT/JFace.

  2. Chapter 2 Getting started with SWT and JFace

    • What are the important classes of SWT: Display and Shell.
    • An SWT programming example.
    • The important class of JFace: ApplicationWindow.
    • An SWT/JFace programming example.

  3. Chapter 3 Widgets: part 1

    • An introduction of Widgets and control classes.
    • Labels
    • How you can achieve user involvement using Buttons.
    • How you can contain components with Composites.
    • Updating WidgetWindow.

  4. Chapter 4 Working with events

    • Event processing with SWT
    • Typed and untyped listeners
    • Mouse and keyboard events
    • Event processing with JFace
    • Actions and contributions
    • Updating WidgetWindow.

  5. Chapter 5 More widgets

    • How you can edit text with SWT text widgets.
    • SWT Text widgets
    • JFace Text widgets
    • Combo boxes
    • Toolbars
    • How you can combine controls with coolbars
    • Sliders.
    • Progress indicators

  6. Chapter 6 Layouts

    • Fill layouts
    • Row layouts
    • Grid layouts
    • Form layouts
    • Creating custom layouts

  7. Chapter 7 Graphics

    • The graphic context
    • How you can work as well as program with colors
    • Programming with fonts
    • How you can manipulate and incorporate images in graphics.

  8. Chapter 8 Working with trees and lists

    • The Viewer framework
    • SWT trees
    • JFace trees
    • How you can use the List Widgets.
    • SWT lists
    • JFace lists
    • How you can update the Widget Window.

  9. Chapter 9 Tables and menus

    • SWT tables
    • JFace tables
    • Editing table data
    • Creating menus
    • How you can update the Widget Window.

  10. Chapter10 Dialogs

    • Dialogs included by SWT
    • Dialogs included by JFace
    • Progress indicators
    • Creating custom dialogs in JFace
    • How you can update the Widget Window.

  11. Chapter11 Wizards

    • Multipage dialogs
    • The JFace wizard framework
    • How you can combine wizards.
    • Persisting dialog settings
    • How you can update the Widget Window.

  12. Chapter12 Advanced features

    • Interacting with the system clipboard
    • Implementing drag and drop
    • Storing user preferences
    • Adding images to labels
    • Embedding a web browser within your application

  13. Chapter13 Looking beyond SWT/JFace: the Rich Client Platform

    • The theory behind the Rich Client Platform (RCP)
    • The classes that make RCP operation possible
    • How you can add views and perspectives.
    • The Eclipse Forms toolset
    • How you can Populate forms with Eclipse Forms widgets.
    • Building an example RCP application

Reviewer: Sumit Kulshreshtha


 Related Tips

 
< Prev   Next >

Page 1 of 0 ( 0 comments )

You can share your information about this topic using the form below!

Please do not post your questions with this form! Thanks.


Name (required)


E-Mail (required)

Your email will not be displayed on the site - only to our administrator
Homepage(optional)



Comment Enable HTML code : Yes No



 
       
         
     
 
 
 
   
 
 
java bottom left
java bottom middle
java bottom right
RSS 0.91 FeedRSS 1.0 FeedRSS 2.0 FeedATOM FeedOPML Feed

Home - About Us - Privacy Policy
Copyright 2005 - 2008 www.java-tips.org
Java is a trademark of Sun Microsystems, Inc.