C++ GUI Programming with Qt 4, Second Edition by Jasmin Blanchette; Mark Summerfield Publisher: Prentice Hall Pub Date: February 04, 2008 Print ISBN-10: 0-13-235416-0 Print ISBN-13: 978-0-13-235416-5 eText ISBN-10: 0-13-714397-4 eText ISBN-13: 978-0-13-714397-9 Pages: 752 Table of Contents | Index Overview The Only Official, Best-Practice Guide to Qt 4.3 Programming Using Trolltech's Qt you can build industrial-strength C++ applications that run natively on Windows, Linux/Unix, Mac OS X, and embedded Linux without source code changes. Now, two Trolltech insiders have written a start-to-finish guide to getting outstanding results with the latest version of Qt: Qt 4.3. Packed with realistic examples and in-depth advice, this is the book Trolltech uses to teach Qt to its own new hires. Extensively revised and expanded, it reveals today's best Qt programming patterns for everything from implementing model/view architecture to using Qt 4.3's improved graphics support. You'll find proven solutions for virtually every GUI development task, as well as sophisticated techniques for providing database access, integrating XML, using subclassing, composition, and more. Whether you're new to Qt or upgrading from an older version, this book can help you accomplish everything that Qt 4.3 makes possible. Completely updated throughout, with significant new coverage of databases, XML, and Qtopia embedded programming• Covers all Qt 4.2/4.3 changes, including Windows Vista support, native CSS support for widget styling, and SVG file generation • Contains separate 2D and 3D chapters, coverage of Qt 4.3's new graphics view classes, and an introduction to QPainter's OpenGL back-end • Includes new chapters on look-and-feel customization and application scripting• Illustrates Qt 4's model/view architecture, plugin support, layout management, event processing, container classes, and much more • Presents advanced techniques covered in no other bookâ€from creating plugins to interfacing with native APIs• Includes a new appendix on Qt Jambi, the new Java version of Qt• 1 C++ GUI Programming with Qt 4, Second Edition by Jasmin Blanchette; Mark Summerfield Publisher: Prentice Hall Pub Date: February 04, 2008 Print ISBN-10: 0-13-235416-0 Print ISBN-13: 978-0-13-235416-5 eText ISBN-10: 0-13-714397-4 eText ISBN-13: 978-0-13-714397-9 Pages: 752 Table of Contents | Index Copyright Series Editor's Note Foreword Preface Acknowledgments A Brief History of Qt Part I: Basic Qt Chapter 1. Getting Started Hello Qt Making Connections Laying Out Widgets Using the Reference Documentation Chapter 2. Creating Dialogs Subclassing QDialog Signals and Slots in Depth Rapid Dialog Design Shape-Changing Dialogs Dynamic Dialogs Built-in Widget and Dialog Classes Chapter 3. Creating Main Windows Subclassing QMainWindow Creating Menus and Toolbars Setting Up the Status Bar Implementing the File Menu Using Dialogs Storing Settings Multiple Documents Splash Screens Chapter 4. Implementing Application Functionality The Central Widget Subclassing QTableWidget Loading and Saving Implementing the Edit Menu Implementing the Other Menus Subclassing QTableWidgetItem Chapter 5. Creating Custom Widgets Customizing Qt Widgets Subclassing QWidget Integrating Custom Widgets with Qt Designer Double Buffering Part II: Intermediate Qt Chapter 6. Layout Management Laying Out Widgets on a Form Stacked Layouts Splitters Scrolling Areas Dock Windows and Toolbars Multiple Document Interface Chapter 7. Event Processing Reimplementing Event Handlers Installing Event Filters Staying Responsive during Intensive Processing Chapter 8. 2D Graphics Painting with QPainter Coordinate System Transformations High-Quality Rendering with QImage Item-Based Rendering with Graphics View Printing Chapter 9. Drag and Drop Enabling Drag and Drop Supporting Custom Drag Types Clipboard Handling 2 Chapter 10. Item View Classes Using the Item View Convenience Classes Using Predefined Models Implementing Custom Models Implementing Custom Delegates Chapter 11. Container Classes Sequential Containers Associative Containers Generic Algorithms Strings, Byte Arrays, and Variants Chapter 12. Input/Output Reading and Writing Binary Data Reading and Writing Text Traversing Directories Embedding Resources Inter-Process Communication Chapter 13. Databases Connecting and Querying Viewing Tables Editing Records Using Forms Presenting Data in Tabular Forms Chapter 14. Multithreading Creating Threads Synchronizing Threads Communicating with the Main Thread Using Qt's Classes in Secondary Threads Chapter 15. Networking Writing FTP Clients Writing HTTP Clients Writing TCP Clientâ€Server Applications Sending and Receiving UDP Datagrams Chapter 16. XML Reading XML with QXmlStreamReader Reading XML with DOM Reading XML with SAX Writing XML Chapter 17. Providing Online Help Tooltips, Status Tips, and "What's This?" Help Using a Web Browser to Provide Online Help Using QTextBrowser as a Simple Help Engine Using Qt Assistant for Powerful Online Help Part III: Advanced Qt Chapter 18. Internationalization Working with Unicode Making Applications Translation-Aware Dynamic Language Switching Translating Applications Chapter 19. Look and Feel Customization Using Qt Style Sheets Subclassing QStyle Chapter 20. 3D Graphics Drawing Using OpenGL Combining OpenGL and QPainter Doing Overlays Using Framebuffer Objects Chapter 21. Creating Plugins Extending Qt with Plugins Making Applications Plugin-Aware Writing Application Plugins Chapter 22. Application Scripting Overview of the ECMAScript Language Extending Qt Applications with Scripts Implementing GUI Extensions Using Scripts Automating Tasks through Scripting Chapter 23. Platform-Specific Features Interfacing with Native APIs Using ActiveX on Windows Handling X11 Session Management Chapter 24. Embedded Programming Getting Started with Qt/Embedded Linux Customizing Qt/Embedded Linux Integrating Qt Applications with Qtopia Using Qtopia APIs Part IV: Appendixes Appendix A. Obtaining and Installing Qt A Note on Licensing 3 Installing Qt/Windows Installing Qt/Mac Installing Qt/X11 Appendix B. Building Qt Applications Using qmake Using Third-Party Build Tools Appendix C. Introduction to Qt Jambi Getting Started with Qt Jambi Using Qt Jambi in the Eclipse IDE Integrating C++ Components with Qt Jambi Appendix D. Introduction to C++ for Java and C# Programmers Getting Started with C++ Main Language Differences The Standard C++ Library About the Authors Jasmin Blanchette Mark Summerfield Production Index 4 Copyright In association with Trolltech Press Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in this book, and the publisher was aware of a trademark claim, the designations have been printed with initial capital letters or in all capitals. The authors and publisher have taken care in the preparation of this book, but make no expressed or implied warranty of any kind and assume no responsibility for errors or omissions. No liability is assumed for incidental or consequential damages in connection with or arising out of the use of the information or programs contained herein. The publisher offers excellent discounts on this book when ordered in quantity for bulk purchases or special sales, which may include electronic versions and/or custom covers and content particular to your business, training goals, marketing focus, and branding interests. For more information, please contact: U.S. Corporate and Government Sales (800) 382-3419 corpsales@pearsontechgroup.com For sales outside the United States, please contact: International Sales international@pearsoned.com Visit us on the Web: www.prenhallprofessional.com Library of Congress Cataloging-in-Publication Data Blanchette, Jasmin. C++ GUI programming with Qt 4 / Jasmin Blanchette, Mark Summerfield 2nd ed. p. cm. Includes index. ISBN-13: 978-0-13-235416-5 (hardcover : alk. paper) 1. Qt (Electronic resource) 2. Graphical user interfaces (Computer systems) 3. C++ (Computer program language) I. Summerfield, Mark. II. Title. QA76.9.U83B532 2008 005.13'3â€dc22 2008000243 Copyright © 2008 Trolltech ASA All rights reserved. Printed in the United States of America. This publication may only be distributed subject to the terms and conditions set forth in the Open Publication License, v1.0 or later (the latest version is available at http://www.opencontent.org/openpub/). Trolltech ® , Qt ® , Qtopia ® , and the Trolltech and Qtopia logos are registered trademarks of Trolltech ASA. ISBN-13: 978-0-13-235416-5 Text printed in the United States on recycled paper at Courier in Westford, Massachusetts. First printing, February 2008 5 Series Editor's Note Dear Reader, As a working programmer, I use Qt every day, and I am really impressed by the organization, design, and power that Qt brings to the C++ programmer. While Qt began life as a cross-platform GUI toolkit, it has expanded to include portable facilities for just about every aspect of day-to-day programming: files, processes, networking, and database access, to name just a few. Because of Qt's broad applicability, you really can write your code once and just recompile it on a different platform in order to have it work out of the box. This is extraordinarily valuable when your customer base requires your product to run on different platforms. Of course, because Qt is also available with an open source license, if you're an open source developer, you too can benefit from everything Qt has to offer. While Qt comes with extensive online help, that help is primarily reference oriented. The example programs are useful, but it can be hard to reverse engineer correct use of Qt for your programs just by reading the examples. And that is where this book comes into the picture. This is a really neat book. First, it's the official book on Qt from Trolltech, which says a lot. But it's also a great book: well organized, well written, and easy to follow and learn from. The combination of a great book about a great technology makes for a real winner, and that is why I am very proud and excited to have this book in the Prentice Hall Open Source Software Development Series. I hope you will enjoy reading this book and that you will learn a lot from it; I certainly did. Arnold Robbins Nof Ayalon, Israel November 2007 6 Foreword Why Qt? Why do programmers like us choose Qt? Sure, there are the obvious answers: Qt's single-source compatibility, its feature richness, its C++ performance, the availability of the source code, its documentation, the high-quality technical support, and all the other items mentioned in Trolltech's glossy marketing materials. This is all very well, but it misses the most important point: Qt is successful because programmers like it. How come programmers like one technology, but dislike another? Personally, I believe software engineers enjoy technology that feels right, but dislike everything that doesn't. How else can we explain that some of the brightest programmers need help to program a video recorder, or that most engineers seem to have trouble operating the company's phone system? I for one am perfectly capable of memorizing sequences of random numbers and commands, but if these are required to control my answering machine, I'd prefer not to have one. At Trolltech, our phone system forces us to press the '*' for two seconds before we are allowed to enter the other person's extension number. If you forget to do this and start to enter the extension immediately, you have to dial the entire number again. Why '*'? Why not '#', or '1', or '5', or any of the other 20 keys on the phone? Why two seconds and not one, or three, or one and a half? Why anything at all? I find the phone so irritating that I avoid using it whenever I can. Nobody likes having to do random things, especially when those random things apparently depend on some equally random context you wish you didn't have to know about in the first place. Programming can be a lot like using our phone system, only worse. And this is where Qt comes to the rescue. Qt is different. For one thing, Qt makes sense. And for another, Qt is fun. Qt lets you concentrate on your tasks. When Qt's original architects faced a problem, they didn't just look for a good solution, or a quick solution, or the simplest solution. They looked for the right solution, and then they documented it. Granted, they made mistakes, and granted, some of their design decisions didn't pass the test of time, but they still got a lot of things right, and what wasn't right could and can be corrected. You can see this by the fact that a system originally designed to bridge Windows 95 and Unix/Motif now unifies modern desktop systems as diverse as Windows Vista, Mac OS X, and GNU/Linux, as well as small devices such as mobile phones. Long before Qt became so popular and so widely used, the dedication of Qt's developers to finding the right solutions made Qt special. That dedication is just as strong today and affects everyone who maintains and develops Qt. For us, working on Qt is a responsibility and a privilege. We are proud of helping to make your professional and open source lives easier and more enjoyable. One of the things that makes Qt a pleasure to use is its online documentation. But the documentation's focus is primarily on individual classes, with little said about how to build sophisticated real-world applications. This excellent book fills that gap. It shows you what Qt has to offer, how to program Qt the "Qt way", and how to get the best from Qt. The book will teach a C++, Java, or C# programmer how to program Qt, and provides enough advanced material to satisfy experienced Qt programmers. The book is packed with good examples, advice, and explanationsâ€and it is the text that we use to induct all new programmers who join Trolltech. Nowadays, a vast number of commercial and free Qt applications are available for purchase or download. Some are specialized for particular vertical markets, while others are aimed at the mass-market. Seeing so many applications built with Qt fills us with pride and inspires us to make Qt even better. And with the help of this book, there will be more and higher-quality Qt applications than ever before. Matthias Ettrich Berlin, Germany November 2007 7 Preface Qt is a comprehensive C++ application development framework for creating cross-platform GUI applications using a "write once, compile anywhere" approach. Qt lets programmers use a single source tree for applications that will run on Windows 98 to Vista, Mac OS X, Linux, Solaris, HP-UX, and many other versions of Unix with X11. The Qt libraries and tools are also part of Qt/Embedded Linux, a product that provides its own window system on top of embedded Linux. The purpose of this book is to teach you how to write GUI programs using Qt 4. The book starts with "Hello Qt" and quickly progresses to more advanced topics, such as creating custom widgets and providing drag and drop. The text is complemented by a set of examples that you can download from the book's web site, http://www.informit.com/title/0132354160. Appendix A explains how to download and install the software, including a free C++ compiler for those using Windows. The book is divided into three parts. Part I covers all the fundamental concepts and practices necessary for programming GUI applications using Qt. Knowledge of this part alone is sufficient to write useful GUI applications. Part II covers central Qt topics in greater depth, and Part III provides more specialized and advanced material. You can read the chapters of Parts II and III in any order, but they assume familiarity with the contents of Part I. The book also includes several appendixes, with Appendix B showing how to build Qt applications and Appendix C introducing Qt Jambi, the Java version of Qt. The first Qt 4 edition of the book built on the Qt 3 edition, although it was completely revised to reflect good idiomatic Qt 4 programming techniques and included new chapters on Qt 4's model/view architecture, the new plugin framework, embedded programming with Qt/Embedded Linux, and a new appendix. This extended and revised second edition has been thoroughly updated to take advantage of features introduced in Qt versions 4.2 and 4.3, and includes new chapters on look and feel customization and application scripting as well as two new appendixes. The original graphics chapter has been split into separate 2D and 3D chapters, which between them now cover the new graphics view classes and QPainter's OpenGL back-end. In addition, much new material has been added to the database, XML, and embedded programming chapters. This edition, like its predecessors, emphasizes explaining Qt programming and providing realistic examples, rather than simply rehashing or summarizing Qt's extensive online documentation. Because the book teaches solid Qt 4 programming principles and practices, readers will easily be able to learn the new Qt modules that come out in Qt 4.4, Qt 4.5, and later Qt 4.x versions. If you are using one of these later versions, be sure to read the "What's New in Qt 4.x" documents in the reference documentation to get an overview of the new features that are available. We have written the book with the assumption that you have a basic knowledge of C++, Java, or C#. The code examples use a subset of C++, avoiding many C++ features that are rarely needed when programming Qt. In the few places where a more advanced C++ construct is unavoidable, it is explained as it is used. If you already know Java or C# but have little or no experience with C++, we recommend that you begin by reading Appendix D, which provides sufficient introduction to C++ to be able to use this book. For a more thorough introduction to object-oriented programming in C++, we recommend C++ How to Program by P. J. Deitel and H. M. Deitel (Prentice Hall, 2007), and C++ Primer by Stanley B. Lippman, Josée Lajoie, and Barbara E. Moo (Addison-Wesley, 2005). Qt made its reputation as a cross-platform framework, but thanks to its intuitive and powerful API, many organizations use Qt for single-platform development. Adobe Photoshop Album is just one example of a mass-market Windows application written in Qt. Many sophisticated software systems in vertical markets, such as 3D animation tools, digital film processing, electronic design automation (for chip design), oil and gas exploration, financial services, and medical imaging, are built with Qt. If you are making a living with a successful Windows product written in Qt, you can easily create new markets in the Mac OS X and Linux worlds simply by recompiling. Qt is available under various licenses. If you want to build commercial applications, you must buy a commercial Qt license from Trolltech; if you want to build open source programs, you can use the open source (GPL) edition. The K Desktop Environment (KDE) and most of the open source applications that go with it are built on Qt. In addition to Qt's hundreds of classes, there are add-ons that extend Qt's scope and power. Some of these products, like the Qt Solutions components, are available from Trolltech, while others are supplied by other companies and by the open source community; see http://www.trolltech.com/products/qt/3rdparty/ for a list of available add-ons. Trolltech's developers also have their own web site, Trolltech Labs (http://labs.trolltech.com/), where they put unofficial code that they have written because it is fun, interesting, or useful. Qt has a well-established and thriving user community that uses the qt-interest mailing list; see http://lists.trolltech.com/ for details. If you spot errors in the book, have suggestions for the next edition, or want to give us feedback, we would be delighted to hear from you. You can reach us at qt-book@trolltech.com. The errata will be placed on the book's web site (http://www.prenhallprofessional.com/title/0132354160). 8 Acknowledgments Our first acknowledgment is of Eirik Chambe-Eng, Trolltech's Chief Troll and one of Trolltech's two founders. Eirik not only enthusiastically encouraged us to write the Qt 3 edition of the book, he also allowed us to spend a considerable amount of our work time writing it. Eirik and Trolltech CEO Haavard Nord both read the manuscript and provided valuable feedback. Their generosity and foresight were aided and abetted by Matthias Ettrich, who cheerfully accepted our neglect of duty as we obsessed over the writing of this book, and gave us a lot of advice on good Qt programming style. For the Qt 3 edition, we asked two Qt customers, Paul Curtis and Klaus Schmidinger, to be our external reviewers. Both are Qt experts with an amazing attention to technical detail, which they proved by spotting some very subtle errors in our manuscript and suggesting numerous improvements. And within Trolltech, alongside Matthias, our most stalwart reviewer was Reginald Stadlbauer. His technical insight was invaluable, and he taught us how to do some things in Qt that we didn't even know were possible. For this Qt 4 edition, we have continued to benefit from the unstinting help and support of Eirik, Haavard, and Matthias. Klaus Schmidinger continued to give valuable feedback, and we also benefitted from Qt customer Paul Floyd's careful reviewing of some of the new material. Thanks also to David García Garzón for help on SCons in Appendix B. Within Trolltech, our key reviewers were Carlos Manuel Duclos Vergara, Andreas Aardal Hanssen, Henrik Hartz, Martin Jones, Vivi Glückstad Karlsen, Trond Kjernåsen, Trenton Schulz, Andy Shaw, Gunnar Sletta, and Pål de Vibe. In addition to the reviewers mentioned above, we received expert help from Eskil Abrahamsen Blomfeldt (Qt Jambi), Frans Englich (XML), Harald Fernengel (databases), Kent Hansen (application scripting), Volker Hilsheimer (ActiveX), Bradley Hughes (multithreading), Lars Knoll (2D graphics and internationalization), Anders Larsen (databases), Sam Magnuson (qmake), Marius Bugge Monsen (item view classes), Dimitri Papadopoulos (Qt/X11), Girish Ramakrishnan (style sheets), Samuel Rødal (3D graphics), Rainer Schmid (networking and XML), Amrit Pal Singh (introduction to C++), Paul Olav Tvete (custom widgets and embedded programming), Geir Vattekar (Qt Jambi), and Thomas Zander (build systems). Extra thanks are due to Trolltech's documentation and support teams for handling documentation-related issues while the book consumed so much of our time, and to Trolltech's system administrators for keeping our machines running and our networks communicating throughout the project. On the production side, Jeff Kingston, author of the Lout typesetting tool, continued to add enhancements to the tool, many in response to our feedback. Also thanks to James Cloos for providing a condensed version of the DejaVu Mono font that we used as the basis for our monospaced font. Trolltech's Cathrine Bore handled the contracts and legalities on our behalf. Thanks also to Nathan Clement for the troll illustrations, and to Audrey Doyle for her careful proofreading. And finally, thanks to our editor, Debra Williams-Cauley, both for her support and for making the process as hassle-free as possible, and to Lara Wysong for handling the production practicalities so well. 9 Part I: Basic Qt 1. Getting Started Hello Qt• Making Connections• Laying Out Widgets• Using the Reference Documentation• This chapter shows how to combine basic C++ with the functionality provided by Qt to create a few small graphical user interface (GUI) applications. This chapter also introduces two key Qt ideas: "signals and slots" and layouts. In Chapter 2, we will go into more depth, and in Chapter 3, we will start building a more realistic application. If you already know Java or C# but have limited experience with C++, you might want to start by reading the C++ introduction in Appendix D. Hello Qt Let's start with a very simple Qt program. We will first study it line by line, and then see how to compile and run it. 1 #include <QApplication> 2 #include <QLabel> 3 int main(int argc, char *argv[]) 4 { 5 QApplication app(argc, argv); 6 QLabel *label = new QLabel("Hello Qt!"); 7 label->show(); 8 return app.exec(); 9 } Lines 1 and 2 include the definitions of the QApplication and QLabel classes. For every Qt class, there is a header file with the same name (and capitalization) as the class that contains the class's definition. Line 5 creates a QApplication object to manage application-wide resources. The QApplication constructor requires argc and argv because Qt supports a few command-line arguments of its own. Line 6 creates a QLabel widget that displays "Hello Qt!". In Qt and Unix terminology, a widget is a visual element in a user interface. The term stems from "window gadget" and is the equivalent of both "control" and "container" in Windows terminology. Buttons, menus, scroll bars, and frames are all examples of widgets. Widgets can contain other widgets; for example, an application window is usually a widget that contains a QMenuBar, a few QToolBars, a QStatusBar, and some other widgets. Most applications use a QMainWindow or a QDialog as the application window, but Qt is so flexible that any widget can be a window. In this example, the QLabel widget is the application window. Line 7 makes the label visible. Widgets are always created hidden so that we can customize them before showing them, thereby avoiding flicker. Line 8 passes control of the application on to Qt. At this point, the program enters the event loop. This is a kind of stand-by mode where the program waits for user actions such as mouse clicks and key presses. User actions generate events (also called "messages") to which the program can respond, usually by executing one or more functions. For example, when the user clicks a widget, a "mouse press" and a "mouse release" event are generated. In this respect, GUI applications differ drastically from conventional batch programs, which typically process input, produce results, and terminate without human intervention. For simplicity, we don't bother calling delete on the QLabel object at the end of the main() function. This memory leak is harmless in such a small program, since the memory will be reclaimed by the operating system when the program terminates. 10 [...]... #include 2 #include "finddialog.h" First, we include , a header file that contains the definition of Qt' s GUI classes Qt consists of several modules, each of which lives in its own library The most important modules are QtCore, QtGui, QtNetwork, QtOpenGL, QtScript, QtSql, QtSvg, and QtXml The header file contains the definition of all the classes that are part of the QtCore and QtGui... #include 2 #include "finddialog.h" First, we include , a header file that contains the definition of Qt' s GUI classes Qt consists of several modules, each of which lives in its own library The most important modules are QtCore, QtGui, QtNetwork, QtOpenGL, QtScript, QtSql, QtSvg, and QtXml The header file contains the definition of all the classes that are part of the QtCore and QtGui... while for ten long months no one bought a commercial Qt license In March 1996, the European Space Agency became the second Qt customer, with a purchase of ten commercial licenses With unwavering faith, Eirik and Haavard hired another developer Qt 0.97 was released at the end of May, and on September 24, 1996, Qt 1.0 came out By the end of the year, Qt had reached version 1.1; eight customers, each in... project, led by Matthias Ettrich Qt 1.2 was released in April 1997 Matthias Ettrich's decision to use Qt to build KDE helped Qt become the de facto standard for C++ GUI development on Linux Qt 1.3 was released in September 1997 Matthias joined Trolltech in 1998, and the last major Qt 1 release, 1.40, was made in September of that year Qt 2.0 was released in June 1999 Qt 2 had a new open source license,... where they both graduated with master's degrees in computer science Haavard's interest in C++ GUI development began in 1988 when he was commissioned by a Swedish company to develop a C++ GUI framework A couple of years later, in the summer of 1990, Haavard and Eirik were working together on a C++ database application for ultrasound images The system needed to be able to run with a GUI on Unix, Macintosh,... and Qtopia 13 Qt has long been available to non -C++ programmers through the availability of unofficial language bindings, in particular PyQt for Python programmers In 2007, the Qyoto unofficial bindings were released for C# programmers Also in 2007, Trolltech launched Qt Jambi, an officially supported Java version of the Qt API Appendix C provides an introduction to Qt Jambi Since Trolltech's birth, Qt' s... new QLabel("Hello Qt! "); with QLabel *label = new QLabel("Hello " "Qt! "); and rebuild the application When run, it should look like Figure 1.2 As the example illustrates, it's easy to brighten up a Qt application's user interface using some simple HTML-style formatting Figure 1.2 A label with basic HTML formatting 11 12 A Brief History of Qt The Qt framework first... how to combine basic C++ with the functionality provided by Qt to create a few small graphical user interface (GUI) applications This chapter also introduces two key Qt ideas: "signals and slots" and layouts In Chapter 2, we will go into more depth, and in Chapter 3, we will start building a more realistic application If you already know Java or C# but have limited experience with C++, you might want... QLabel("Hello Qt! "); with QLabel *label = new QLabel("Hello " "Qt! "); and rebuild the application When run, it should look like Figure 1.2 As the example illustrates, it's easy to brighten up a Qt application's user interface using some simple HTML-style formatting Figure 1.2 A label with basic HTML formatting 16 17 Part I: Basic Qt 1 Getting Started • Hello Qt • Making... how to combine basic C++ with the functionality provided by Qt to create a few small graphical user interface (GUI) applications This chapter also introduces two key Qt ideas: "signals and slots" and layouts In Chapter 2, we will go into more depth, and in Chapter 3, we will start building a more realistic application If you already know Java or C# but have limited experience with C++, you might want . bookâ€from creating plugins to interfacing with native APIs• Includes a new appendix on Qt Jambi, the new Java version of Qt 1 C++ GUI Programming with Qt 4, Second Edition by Jasmin Blanchette; Mark. C++ GUI Programming with Qt 4, Second Edition by Jasmin Blanchette; Mark Summerfield Publisher: Prentice Hall Pub Date: February 04, 2008 Print ISBN-10: 0-13-235416-0 Print. Jambi Getting Started with Qt Jambi Using Qt Jambi in the Eclipse IDE Integrating C++ Components with Qt Jambi Appendix D. Introduction to C++ for Java and C# Programmers Getting Started with C++ Main Language