Completely updated to cover Motif Release 1.2 and 2.0, this second edition shows how to design reusable user interface components based on Motif, and how C++ and Motif can be used together effectively. Part I introduces the mechanics of using C++ and Motif with an emphasis on object- oriented techniques. Part II explores additional ideas for using Motif and C++, while developing a small library of useful classes that support applications based on Motif. For application programmers.
"synopsis" may belong to another edition of this title.
Completely updated to cover Motif Release 1.2 and 2.0, this second edition shows how to design reusable user interface components based on Motif, and how C++ and Motif can be used together effectively.From the Inside Flap:
This book grew out of a simple question: "How do I use the Motif user interface toolkit when programming in C++?"
The most direct answer to this question, one that provides only the mechanics of the solution, is fairly simple. But fully addres sing all the surrounding issues is a more complex task. In particular, a complete answer must include ways to coordinate the programming model supported by X and Motif with the C++ object-oriented programming model. This is the central topic of this book.This revised edition updates and expands the material presented in the original book to take into account current versions of X and Motif, with their increasing level of C++ support. However, the material in this book is largely independent of a ny specific version of X or Motif.
While most Motif books necessarily dwell on explanations of how to use the features of individual widgets, this book concentrates on how Motif can be used within the context of an object-oriented architecture. This includes not only the mechanics of using C++ with Motif, but also includes stylistic and design issues. These issues tend to remain the same from version to version of Motif.
This book has another underlying theme that is at least as important as how to use Motif with C++. In the past few years there has been a fundamental shift in the type of software programmers develop. The textbooks we study in school often focus on algorithms and basic data structures. While no one would dispute that data st ructures and algorithms are the heart of any application, most modern programs cannot be considered complete without additional elements. For most applications written today, choosing appropriate data structures and determining the right algorithms a re only the beginning. Much of the emphasis in contemporary applications is on interactive user interfaces based on window systems such as the X Window System, the Macintosh Toolbox, Microsoft Windows, NeXTStep, and others.
Estimates of the effort required to develop the user interface portion of a window-based application range from 50 to 90 percent of the total effort, which leaves only a small remainder to the task of developing the computational portion of the program. This does not diminish the importance of algorithms, it simply provides one measure of the additional complexity introduced by the interface component of contemporary interactive software.
Programmers sometimes find it difficult to develop these new types of programs, partly because developing a good interactive interface is inherently difficult, but also because interactive programs require a different type of architecture than many programmers are accustomed to.
Programmers who have never developed interactive applications before may be unsure where to begin. The type of algorithm usually studied in school generally involves a single function that takes some data as input and returns other data as output. Interactive programs are different.
First, modern interactive programs are real-time applications. In addition, modern applications are often expected to coordinate the presentation of data in multiple areas of the screen, recover from errors in a user-friendly way, provide an appropriate interface for both expert and novice users, and much more. One of the goals of this book is to help the reader understand how to structure applications to address some of these issues and how using C++ can help. Simply understanding how to display and manipulate user interface components such as Motif widgets is only the beginning.
It is also necessary to understand the subtle constraints X and Motif impose on an application's architecture as well as the way an object-oriented approach affects an application's design and implementation. Object- oriented programming matches the needs of modern interactive systems very well. Using C++ to implement Motif applications provides tools for structuring programs in a way that would be very difficult to do in C. However, object-oriented programming also requires programmers to alter the way they think about developing software. In object- oriented programming, much of the emphasis is on structure.
Programmers who use object-oriented techniques are generally more co ncerned with defining interfaces and relationships between objects than developing algorithms. Programmers usually find that they need to approach such programs with a completely different mindset. One of the goals of this book is to demonstrate an o bject-oriented approach within the context of interactive Motif applications. Someone is sure to ask, "Why should I use an Xt-based toolkit like Motif with C++ in the first place? If I am writing an object-oriented program, shouldn't I use a `true' ob ject-oriented toolkit?" There are many X-based, object-oriented user interface toolkits available to those who feel that object-oriented software must use nothing but pure object- oriented libraries. For example, the Interviews toolkit and its success or, Fresco, as well as the OI toolkit developed by Solbourne are all written in C++. Each of these toolkits has strong points and may be useful to C++ programmers. Some may have promising futures.
But for now, none of these have Xt's and Motif's mome ntum, support, and wide acceptance by both programmers and users. There are some who will maintain that it is sacrilege to use a C-based toolkit like Motif with C++. If you fall into that camp, I can only say that this book is not written for you. Th ere are literally hundreds of user interface toolkits available today, supporting a variety of languages and programming styles. You must decide which toolkit you want to use, based on your needs and the merits of each. There is much more to consider than the implementation language used internally by a toolkit.
Issues such as present and future availability, acceptance by users and programmers, support, reliability, and so on must be considered. You must also consider the environment in which your application will be used and whether the user interface style supported by any given toolkit will be compatible with other applications in that environment. In many cases, or perhaps even most cases, these issues will be the most critical factors in your decision. This book is written for those who decide to use Motif and would also like to take advantage of the object-oriented facilities offered by C++. For those who choose C++ and Motif, I hope this book is useful.All software in this book was tested on a Silicon Graphics Indy workstation running IRIX 5.3. The examples were compiled using Silicon Graphic's native C++ compiler. All examples were tested with the X11R6 Xlib and Xt Intrinsics and Motif 1.2.3. The examples are designed to be self- sufficient and depend on nothing but standard UNIX and C++ libraries, X, and Motif. Notice that self-sufficiency places some limitations on the design of any software. For example, many of the classes described in this book could be improved or simplified by using a good library of general-purpose data structures. For those examples that could use such generic data structures, my available choices were to diverge from the central topic of the book to implement the necessary classes, to use a library that might not be available to the reader, or to implement the examples without the benefit of such classes. Because the topic of reusable classes that implement common data structures could be a book in itself, I chose the last approach in most cases.
For the purposes of this book, the internal implementation of any individual class is of less interest than the external behavior of each class and the collective architecture of all classes in a system. Writing a book is very much lik e developing a large piece of software. In both cases, the idea that one can ever find the "last bug" is an illusion. I have tried to make this book as error-free as possible, and I am grateful for the assistance of many people, mentioned below, who helped in that effort. However, I have no doubt that errors and deficiencies remain, in spite of my best efforts.
Readers, of course, have an uncanny knack for immediately spotting errors that the author has overlooked repeatedly! My primary goal has been to produce a book that conveys useful information. I hope this book achieves that goal in spite of any errors you encounter.
I would like to thank the many people who helped me with this book. Jolly Chen, Jean-Daniel Fekete, Ken F ischer, Steve Friedl, Oliver Jones, Rick Kelly, David Lewis, Howard Look, Anil Pal, Michael Portuesi, Kim Rachmeler, and Rebecca Wirfs-Brock helped by reviewing early drafts. Their suggestions were invaluable in defining the final form of this book. My wife, Teresa, helped by copy-editing at all stages. I owe a special thanks to Shiz Kobara, who provided the visual design of the TicTacToe game described in Chapter 4. The portions of Chapters 4 and 5 that address the interface design of TicTacToe are based on his work and our discussions.
"About this title" may belong to another edition of this title.
Book Description Prentice Hall, 2017. Paperback. Book Condition: New. Never used! This item is printed on demand. Bookseller Inventory # P110132092557
Book Description Prentice Hall, 1995. Paperback. Book Condition: New. 2. Bookseller Inventory # DADAX0132092557
Book Description Pearson Education, 1995. PAP. Book Condition: New. New Book. Delivered from our UK warehouse in 3 to 5 business days. THIS BOOK IS PRINTED ON DEMAND. Established seller since 2000. Bookseller Inventory # IQ-9780132092555
Book Description Prentice Hall, 1995. Paperback. Book Condition: New. book. Bookseller Inventory # M0132092557
Book Description Pearson Education (US), United States, 1995. Paperback. Book Condition: New. 2nd edition. Language: English . Brand New Book ***** Print on Demand *****.Completely updated to cover Motif Release 1.2 and 2.0, this Second Edition shows how to design reusable user interface components based on Motif, and how C++ and Motif can be used together effectively. Part One introduces the mechanics of using C++ and Motif with an emphasis on object-oriented techniques. Part Two explores additional ideas for using Motif and C+, while developing a small library of useful classes that support applications based on Motif. Bookseller Inventory # APC9780132092555
Book Description Book Condition: New. Bookseller Inventory # ria9780132092555_ing
Book Description Pearson Education Limited, United Kingdom, 1995. Paperback. Book Condition: New. 2nd Revised edition. Language: English . Brand New Book ***** Print on Demand *****. Completely updated to cover Motif Release 1.2 and 2.0, this Second Edition shows how to design reusable user interface components based on Motif, and how C++ and Motif can be used together effectively. Part One introduces the mechanics of using C++ and Motif with an emphasis on object-oriented techniques. Part Two explores additional ideas for using Motif and C+, while developing a small library of useful classes that support applications based on Motif. Bookseller Inventory # APC9780132092555
Book Description Prentice-Hall. Book Condition: New. pp. 464. Bookseller Inventory # 5265661
Book Description Prentice Hall. Paperback. Book Condition: New. Paperback. 464 pages. Dimensions: 9.2in. x 7.0in. x 0.9in.Completely updated to cover Motif Release 1. 2 and 2. 0, this second edition shows how to design reusable user interface components based on Motif, and how C and Motif can be used together effectively. Part I introduces the mechanics of using C and Motif with an emphasis on object- oriented techniques. Part II explores additional ideas for using Motif and C, while developing a small library of useful classes that support applications based on Motif. For application programmers. This item ships from multiple locations. Your book may arrive from Roseburg,OR, La Vergne,TN. Paperback. Bookseller Inventory # 9780132092555
Book Description Prentice Hall. PAPERBACK. Book Condition: New. 0132092557 Special order direct from the distributor. Bookseller Inventory # ING9780132092555