|
Your search returned 14 matching documents
Swing
by
Matthew Robinson and Pavel Vorobiev,
Matthew Robinson and Pavel Vorobiev
|
Manning Publications
1 edition
December 1999
917 pages
|
Reviewed by Annmarie Ziegler, September 2001
          (10 of 10)
Looking for a book on Swing with in-depth coverage of the how's and whys? Then Swing by Matthew Robinson and Pavel Vorobiev is it.
The authors use the first few chapters to cover an overview of Swing with an emphasis on what goes on behind the scenes. This may seem intimidating to those less familiar with Swing, but it does prove to be an excellent introduction to the concepts of Swing. The authors then turn their attention to the basics of Swing, including frames, panels, layout managers, splitpanes, scrolling panes, combos and list boxes, dialogs, progress bars, sliders, and scroll bars, buttons and labels, among others.
Next are advanced topics including the use of layered panes to enhance interfaces, MDI, text, internal frames and a comprehensive discussion on the complex and often complicated topic of Trees and Tables. Developers looking for the "Hello World" application won't find it here. In its place are exhaustive coding samples with detailed explanations. The authors take great care to discuss the importance of threads in Swing, focusing on multi-threading and how to build thread-safe methods. Throughout the book the authors also make it a point to include UI delegation examples and when to use the default implementations and when to override them. The last couple of chapters focus on the special topics of printing and a brief introduction to Java2D.
Overall this is an excellent book, and I would recommend it for the intermediate to advanced Swing developer.
Discuss book in the Saloon —
More info at Amazon.com
|
Manning Publications
second edition
February 2003
912 pages
|
Reviewed by Thomas Paul, March 2003
(10 of 10)
Two years ago, the JavaRanch reviewer, Anmarie Ziegler, wrote this about the first edition: "Overall this is an excellent book, and I would recommend it for the intermediate to advanced Swing developer." The same can be said of the second edition of "Swing". This edition has been updated to bring it up to Java 1.4 with new examples, new components, and three new chapters. You should note that this book is not for beginners. If "threads", "anonymous classes", or "event handling" are foreign words to you then you should go over the basic Swing chapters in a Java intro book such as "Beginning Java 2" by Ivor Horton. If you consider yourself at least an intermediate Java programmer and are comfortable with the basics of the AWT and you want to learn Swing very well then you are ready for this book. The authors have written the Bible of Swing. This book covers not just the basics of Swing but goes beyond that to teach you how to build your own Swing components. The cover states that the book contains, "production quality code" and this is exactly what it contains. You will find no simple "Hello World" examples but instead demonstrations of how to make use of the real power of Swing. The coding samples you will find in this book are extremely detailed and well commented. If you want to learn how to be a competent Swing developer then you should get this book.
Discuss book in the Saloon —
More info at Amazon.com
|
Java 3D Programming
by
Daniel Selman
|
Manning Publications
1 edition
February 2002
400 pages
|
Reviewed by Thomas Paul, April 2002
(9 of 10)
The Java 3D API from Sun provides an object oriented abstraction around OpenGL and DirectX functions. Sun provides a fairly good introduction to Java 3D in their documentation. However, it can be difficult to find more advanced information on Java 3D as some of the best information can only be found in newsgroups. This book provides the information that anyone working with Java 3D absolutely needs. The author has covered all the bugs, workarounds, pitfalls, design problems etc. that aren't found in the Sun documentation. Starting with the basics of 3D graphics programming, the book moves quickly on to the heart of the Java 3D API, the Scenegraph. The author does a good job of explaining this key class and how to use it to create 3D scenes. The book then moves on, to explain creating of geometric shapes, defining light sources, creating textures, attaching behavior to objects, interacting with objects, and much more. Each chapter contains code samples highlighting the topics of that chapter. As a novice to Java 3D, I was overwhelmed for a little while but the code samples and the author's excellent explanations of the code kept me from becoming lost. This is definitely a book that should be read in front of the computer while working on the examples. Any experienced Java developer (even if you have no experience in graphics programming) who is interested in developing 3D games or scientific or architectural 3D applications should get this book.
Discuss book in the Saloon —
More info at Amazon.com
|
Core Swing: Advanced Programming
by
Kim Topley
|
Pearson Education
unknown edition
December 1999
960 pages
|
Reviewed by Paul Stevens, November 2001
(9 of 10)
This book gets into the details behind some of the swing components. It covers editors, highlighters, documents, renderers and drag and drop.
The author does a good job of getting behind the scenes explaining and showing with code real world examples. There are examples of validating textfields, formatted textfields, using HTML in JEditorPane, JTables and drag and drop.
This is definitely not a beginner book. You must have a good understanding of Swing. The only drawback to the book was the long explanations of what not to do (told at the end of the explanation).
Discuss book in the Saloon —
More info at Amazon.com
|
Professional Java Custom UI Components
by
Kenneth F. Krutsch, David S. Cargo, Virginia Howlett
|
Peer Information
1 edition
August 2001
500 pages
|
Reviewed by Bill Nicolai, September 2001
(8 of 10)
Professional Java Custom UI Components takes the reader through a planning, design, and implementation philosophy for creating custom user interface components. Hints and tips are discussed, giving important insight for creating components. The authors concentrated on the basic principles of design without creating another reference book. Also, rather than laying out all the nitty gritty code detail, the most interesting portions are highlighted and discussed. A handful of custom components are built to demonstrate these principles. Both the source code and documentation can be downloaded from WROX, and are copyrighted by Krutsch Associates, Inc.
The book tour starts with a discussion of the user interface design, the importance of a good interface that is intuitive to use, and the attention to detail required for a UI component. The authors take the reader through the planning and implementation of a toggle switch and LED component, implementing the event model, specifying the parent container interaction, and rendering strategy. Many tips are provided so that the reader may avoid common pit falls. More complex components are discussed and implemented.
The book ends with an overall software development process and component maintenance. Until this point, the focus has been the "how" of building custom components, now the discussion shifts into a larger context. The authors stress the importance of both before and after the initial implementation.
I recommend reading this book for anyone designing and implementing custom UI components.
Discuss book in the Saloon —
More info at Amazon.com
|
Definitive Guide to Swing for Java 2, Second Edition
by
John Zuklowski
|
Apress
second edition
January 2000
890 pages
|
Reviewed by Madhav Lakkapragada, June 2001
(8 of 10)
This book gives a very exhaustive analysis of various Swing components with explanations of most classes used. The author describes the various LnF for each component. In my view this book does a very detailed analysis of the components, their drawbacks and workarounds. The author also depicts the use of components with appropriate examples and illustrates the components in the three most common LnF's. Available properties and their use for each component can be found very useful. Each class description includes an elaborate explanation of the various Constructors, Properties, Listeners where applicable and the appropriate Data Models with UML diagrams. The chapters also provide some explanation on how additional Data Model customization and/or the LnF customization can be achieved. As the chapters progress, the author also identifies the differences between the Swing component and its equivalent AWT component.The side notes and tips highlight some of the drawbacks with appropriate workarounds. Also included are some future-looking statements about new behavior as applicable in Swing 1.3. The new additions in Swing 1.3 are detailed in the Appendix. I would be lying if I don't mention that there are some typos in the book. Overall I think this is a very good resource on Swing.
Discuss book in the Saloon —
More info at Amazon.com
|
Java 2D Graphics
by
Jonathan Knudsen
|
O'Reilly
1 edition
May 1999
366 pages
|
Reviewed by Paul Wheaton, January 2000
(8 of 10)
Java 2D used to be a separate library and is now included in the java core libraries. It adds a lot of functionality and can be hard to work with unless you have a guide. This book is the best of the 2D books out there. I tried to do 2D without this book and did a lot of struggling. The book made things seem pretty simple.
Discuss book in the Saloon —
More info at Amazon.com
|
Java Swing
by
Marc Loy, Robert Eckstein, Dave Wood, James Elliott, Brian Cole,
Robert Eckstein, Marc Loy, and Dave Wood
|
O'Reilly
second edition
November 2002
1280 pages
|
Reviewed by Jason Menard, April 2003
(7 of 10)
"Java Swing" is an in-depth look at the features and components of Java's popular Swing API. The much-anticipated second edition of O'Reilly's classic brings the book up-to-date with the changes made in SDKs 1.3 and 1.4. Each Swing component is covered in detail, providing information on constructors, methods, and properties. There is of course a plethora of example code clearly demonstrating how to use the various components and features.
While "Java Swing" is quite a hefty book, it does not cover the Java event model introduced in JDK 1.1, the AWT layout managers, or relevant AWT components such as Component that are subclassed by Swing components. Instead references are given to pdf files containing chapters of O'Reilly's out-of-print AWT book. While this may have been an acceptable omission for the first edition in 1998, where it might be assumed that developers had some experience with AWT, I do not feel this is a valid assumption today.
If you can look past the book's omissions, or if you have a companion reference covering those features, "Java Swing" has much to offer and will serve as a treasured reference. If you are unfamiliar with AWT and looking to learn how to develop user interfaces in Java, you may wish to look elsewhere first.
Discuss book in the Saloon —
More info at Amazon.com
|
O'Reilly
1 edition
September 1998
1252 pages
|
Reviewed by Thomas Paul, March 2001
(8 of 10)
For visual programming, Swing is a vast improvement over the AWT. Using Swing you can create virtually any user interface. At the same time, Swing is much more complex and contains far more components than the AWT. This book provides an in-depth introduction into the complexities of Swing. The authors start with a discussion of some of the features of Swing and the Model-View-Controller architecture which helps to make Swing so much more powerful than the AWT. The authors then discuss some of the simpler Swing objects (JLabel, JButton) leading us into a deeper understanding of the Swing architecture and preparing us for the more complex objects that follow. Each Swing class (JLabel, JInternalFrame, JDialog, JTree, and more) is explained in detail with numerous examples for each class. As the topics become more complex, the authors spend more time on the topic and provide more examples. The authors spend 6 chapters explaining the Swing text framework and make this complex topic almost simple to understand. The authors are not content to merely explain how to use the Swing classes but they spend time showing us how to create our own objects derived from the Swing classes. Java Swing is a huge book (more than 1,200 pages), especially by O'Reilly standards, but there are no pages wasted on a "quick reference". The authors have provided us with a well written, complete, easy to understand, and ultimately indispensable guide to Java Swing.
Discuss book in the Saloon —
More info at Amazon.com
|
O'Reilly
1 edition
September 1998
1252 pages
|
Reviewed by Paul Wheaton, January 2000
(8 of 10)
Widely considered the best book on Swing. With the help of this book, I've made a mountain of my own lightweight components and have exploited a great deal of Swing. I have another Swing book that came out before this one did, but it just gathers dust now.
Discuss book in the Saloon —
More info at Amazon.com
|
Pure JFC Swing
by
Dr. Satyaraj Pantham
|
Sams
1 edition
February 1999
832 pages
|
Reviewed by Thomas Paul, March 2001
(5 of 10)
Although "Pure JFC Swing" is 800 pages, more than half the book is a reference to the Swing API. As a reference it is mostly useless. The pages are not labeled and the classes are listed by package so it is almost impossible to find a class without using the index. Each class contains only the signature of each method with no explanation as to how the method might be used which limits its usefulness. The Sun online API is a much better reference. The first half of the book is an introduction to Swing and this is what makes the book worth its very reasonable price. The book starts off with a nice introduction to Swing and the MVC architecture. The author then discusses some of the basic Swing classes. This section of the book features a good discussion of panes but like most of this section it leaves you wanting more. The author has an excellent writing style and gives good, clear examples for each of the classes but each topic ends too soon. Also, too many topics are not included in this book. This book could have been an excellent book. If the publisher had abandoned the idea of supplying a reference and had let Dr. Pantham have the entire 800 pages, this would have been a much better book. If you plan on doing a little work with Swing and you're looking for a light introduction, this book may serve that purpose.
Discuss book in the Saloon —
More info at Amazon.com
|
Java Foundation Classes
by
Matthew Nelsdon
|
Computing Mcgraw-Hill
unknown edition
May 1998
576 pages
|
Reviewed by Paul Wheaton, January 2000
(5 of 10)
I used this book when I started with Swing in early 1998. It was okay at helping with transitioning from AWT to Swing, but I didn't care for it as a reference.
Discuss book in the Saloon —
More info at Amazon.com
|
The JFC Swing Tutorial: A Guide to Constructing GUIs
by
Kathy Walrath, Mary Campione
|
Addison-Wesley Professional
unknown edition
June 1999
976 pages
|
Reviewed by Joseph B Cohen, September 2002
(9 of 10)
This is a volume in the series of very well written tutorials from the horse's mouth, i.e., very qualified Sun technical writers. The book flows well, the examples are thorough and meaningful. A solid basic knowledge of Java will get you thru this book. You can really pick-and-choose items of interest, you do not really need to read it end-to-end. A CD-ROM is included. You cannot do better (my opinion) than to start out with this book.
Discuss book in the Saloon —
More info at Amazon.com
|
SWT/JFace in Action
by
Matthew Scarpino, Stephen Holder, Stanford Ng, Laurent Mihalkovic
|
Manning Publications
1 edition
November 2004
496 pages
|
Reviewed by Ernest Friedman-Hill, February 2005
(8 of 10)
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.
Discuss book in the Saloon —
More info at Amazon.com
|
Manning Publications
1 edition
November 2004
496 pages
|
Reviewed by Thomas Paul, December 2004
(8 of 10)
SWT and JFace are the graphical libraries developed by IBM as an alternative to Swing to improve performance of GUI applications 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.
Discuss book in the Saloon —
More info at Amazon.com
|
Desktop Java Live
by
Scott Delap
|
LL
1 edition
2005
pages
|
Reviewed by Gregg Bolinger, August 2005
(10 of 10)
Desktop Java Live by Scott Delap isn't your typical "how-to java book full of API references and JButtons. DJL is a pioneering book that teaches you how to write desktop applications using best practices and how to use a plethora of open source libraries to enhance and ease the development of applications.
Chapter One introduces you to desktop applications all over again. Scott talks about the shift from rich desktop apps to browser based applications over the past several years and how to determine if your application is right for the desktop.
Chapter 5 introduces you to the Event Dispatching Thread and discusses common threading pitfalls in Swing applications. Scott then shows you several different freely available API's that have been made available to help Swing developers deal with threads more effectively. You can search the web for weeks and not find the culmination of useful information available in this single chapter of Scott's book
Coming up are chapters on Java WebStart, Installers, Obfuscators, and Testing. Scott writes in a way that that is easy to follow and understand but does not water down the topics. Scott knows what he is talking about and that shows throughout the book. If you've never written a Swing application this book won't explain how to do that. But if you are even remotely familiar with how to develop Swing applications this book will help your next application be the best it can be.
Discuss book in the Saloon —
More info at Amazon.com
|
Swing Hacks: Tips and Tools for Building Killer GUIs
by
Joshua Marinacci, Chris Adamson
|
O'Reilly
1 edition
June 2005
542 pages
|
Reviewed by Ernest Friedman-Hill, November 2005
(8 of 10)
Most Java programmers, if they use Swing at all, use it in a fairly superficial way, accepting default configurations for most components and letting the built-in "look and feel" supply the appearance and behavior. The more knowledgeable programmer might know how to adopt the platform-specific look and feels on each platform. But it's quite rare for a Swing programmer to customize things much beyond that.
All of which is really a shame. Swing is like that cliched iceberg: just the top of it floats above the surface, with the vast bulk of possibility submerged in the depths. In this clever book, Marinacci and Adamson show you how to mine those depths and come up with GUIs that don't look like Java applications at all.
The book is a collection of recipes for achieving spectacular effects. A lot of thought seems to have been put into making the examples small enough for a book. There are only a few multi-page listings among the 100 recipes between these covers.
If I have a complaint, it's that the book has a fairly obvious slant toward the Mac OS X platform. Many of the hacks are devoted to making your application emulate a Macintosh feature. In a way, this is justifiable -- after all, OS X's GUI includes many innovations not included in Swing by default -- but it's likely to leave those folks primarily interested in making Swing fit in better on Windows a little jealous.
Discuss book in the Saloon —
More info at Amazon.com
|
Filthy Rich Clients
by
Chet Haase, Romain Guy
|
Prentice Hall PTR
1 edition
August 2007
608 pages
|
Reviewed by Gregg Bolinger, September 2007
(9 of 10)
This review will be in two parts. I was contacted about reviewing Filthy Rich Clients by Chet Haase and Romain Guy and at the same time asked to review Safari's "Rough Cuts" subscription. So first, let's get the not so good out of the way.
Safari's Rough Cuts is similar to Manning's MEAP (Manning Early Access Program). If you aren't familiar with either one it's basically a way to read a book as chapters are made available online. The difference, as far as I can tell, between MEAP and Rough Cuts is that chapters released through MEAP are complete whereas chapters released through Rough Cuts often times are incomplete. That isn't to say that reading the final draft of a book versus the Rough Cut version is significantly different but there were things missing like diagrams that are referred to in the text. I may be in the minority here but I actually find them useful in most cases and when a book is talking about a diagram its nice to be able to see it. Add that to my dislike of Safari's interface for reading books online and I give it a thumbs down. I'd rather just read the book when it is complete than have incomplete chapters made available.
And now on to some good news. FRC is a great book. The community has needed a book like this for a long time and I can't think of any better folks to write this kind of book than Chet and Romain. I've been following their blogs for a long time and am a big fan of all the cool things Romain has done with Swing.
FRC is a book about "Developing Animated and Graphical Effects for Desktop Java Applications". Yes, that is on the cover but I couldn't think of a better way to describe this book. FRC gives some much needed insight into the inner workings of Swing, AWT, and Java2D and how they all interact. Sure, you can scower the web and locate a lot of articles and blogs that talk about this but its nice to finally have this in one place. But don't worry, its not that deep. Its just enough to help you understand when things start getting cool later on.
The book does assume a basic understanding of desktop development with Java. If you are new to Swing you might want to get a few basics down before delving into FRC. The book reads very well, even going between the two authors, which you can easily tell who wrote what. If its technical it was probably Chet. If it was pretty it was probably Romain. Not to say that Romain isn't technical in his own right.
There are plenty of code fragments in the book to help convey the author's points. In fact, there is a lot. More than I expected. On a sad note, even though all the examples are available on the book's web site they are Netbeans projects. I download a few and tried to compile them with Ant from the command line but they always complained about Netbeans dependencies. Granted, I didn't research this much so the problem may have easily been resolved.
The book is fun and results are immediate. I've already started trying to come up with a side project for myself just to try out a lot of the techniques described in FRC. I'd recommend this book to anyone looking to spruce up their existing desktop applications or design something entirely new and original. Great work Chet and Romain!!
Discuss book in the Saloon —
More info at Amazon.com
|
|
