Qt for Symbian

by Newebug 1. October 2010 02:15

Qt for Symbian
Edited by Frank H.P. Fitzek, Tony Torp, Tommi Mikkonen

ISBN 978-0-470-75010-0

Qt for Symbian

Scope of the Book
  To make it clear from the outset, this book does not serve as a compendium either for Qt or for Symbian development. The main scope of this book is to explain to the reader how Qt applications can be created in an easy and efficient way on Symbian devices. The reader will be made familiar with how to install the development environment and use it. Additionally, the book explains in detail the Symbian support available for Qt development in terms of APIs and the possibility to extend Qt applications with native Symbian. Throughout the book the authors link the reader to the appropriate sources, such as web pages or books.

Qt for Symbian Download:

qt-for-symbian.rar (1.34 MB)


Tags:

QT

Advanced Qt Programming: Creating Great Software with C++ and Qt 4

by Newebug 25. August 2010 14:32

Advanced Qt Programming: Creating Great Software with C++ and Qt 4
by Mark Summerfield

ISBN-13: 978-0-321-63590-7
ISBN-10: 0-321-63590-6

Advanced Qt Programming: Creating Great Software with C++ and Qt 4

Contents at a Glance
List of Tables xiii
Foreword xv
Introduction 1
 1. Hybrid Desktop/Internet Applications 5
 2. Audio and Video 53
 3. Model/View Table Models 87
 4. Model/View Tree Models 129
 5. Model/View Delegates 185
 6. Model/View Views 207
 7. Threading with QtConcurrent 245
 8. Threading with QThread 287
 9. Creating Rich Text Editors 317
 10. Creating Rich Text Documents 359
 11. Creating Graphics/View Windows 389
 12. Creating Graphics/View Scenes 409
 13. The Animation and State Machine Frameworks 469
Epilogue 491
Selected Bibliography 495
Index 499

Advanced Qt Programming: Creating Great Software with C++ and Qt 4 Download:

advanced-qt-programming-creating-great-software-with-c-and-qt-4.rar (3.76 MB)


Tags:

QT

Foundations of Qt Development

by Newebug 4. April 2010 04:32

Foundations of Qt Development
by Johan Thelin

 

Foreword xv
About the Author xvii
About the Technical Reviewer xix
Acknowledgments xxi
PART 1 Getting to Know Qt
  CHAPTER 1 The Qt Way of C++ 3
  CHAPTER 2 Rapid Application Development Using Qt 33
  CHAPTER 3 Widgets and Layouts 55
  CHAPTER 4 The Main Window 95
PART 2 The Qt Building Blocks
  CHAPTER 5 The Model-View Framework 123
  CHAPTER 6 Creating Widgets 157
  CHAPTER 7 Drawing and Printing 183
  CHAPTER 8 Files, Streams, and XML 235
  CHAPTER 9 Providing Help. 257
  CHAPTER 10 Internationalization and Localization 279
  CHAPTER 11 Plugins 303
  CHAPTER 12 Doing Things in Parallel. 333
  CHAPTER 13 Databases. 371
  CHAPTER 14 Networking. 403
  CHAPTER 15 Building Qt Projects. 445
  CHAPTER 16 Unit Testing 471
PART 3 Appendixes
  APPENDIX A Third-Party Tools 501
  APPENDIX B Containers, Types, and Macros. 507
INDEX 513

Foundations of Qt Development Download

foundations-of-qt-development.rar (5.20 MB)


Tags:

QT

C++ GUI Programming with Qt 4, Second Edition

by Newebug 26. March 2010 16:46

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
  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
    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

Download <C++ GUI Programming with Qt 4, Second Edition>:

Due to a copyright reason, we removed this download link, please follow below link to buy the book from Amazon:

http://www.emarkstore.com/Books_B0013TX6YE_C%2b%2b+GUI+Programming+with+Qt4.htm


Tags: , ,

QT

The Book of Qt 4: The Art of Building Qt Applications

by Newebug 27. February 2010 06:46

The Book of Qt 4
The Art of Building Qt Applications

QT4 编程艺术

目录

Introduction 19
Preparations 23

1 Basics, Tools, and First Code 25
1.1 Our First Qt Program                           25
1.1.1 Compiling a Qt Program                    27
1.2 Layouts, Object Hierarchy, and Memory Management         29
1.2.1 How to Arrange Widgets Automatically            29
1.2.2 Memory Management in Object Hierarchies         31
1.2.3 Other Layout Types                       33
1.3 Signals and Slots                             35
1.3.1 The Simplest Case: A Slot Responds to a Signal       35
1.3.2 Signals Carrying Additional Information and How They Are Processed 36
1.4 Base Classes in Qt                            39
1.4.1 Classes Derived from QObject                 39
1.4.2 QString and Other Classes not Derived from QObject    40
1.4.3 The Qt Inheritance Hierarchy                 41
1.5 Qt at a Glance                              42
1.5.1 The Qt Libraries                         42
1.5.2 Tools and Utilities                       47
1.5.3 Examples and Demos                      58
1.6 How to Use the Documentation                    59

2 The Tools Needed to Create Dialogs 61
2.1 What’s the Difference Between Dialogs and Widgets?        62
2.1.1 Inheriting from QObject                    64
2.1.2 More Complex Layouts                     65
2.1.3 Increasing Usability                      68
2.1.4 Implementing Slots                      70
2.2 Separation of GUI and Processing Logic                74
2.2.1 Alternative Design                       74
2.2.2 Declaring and Sending Out Signals              76
2.2.3 Using Your Own Signals                    79

3 GUI Design Using the Qt Designer 81
3.1 Dialogs “By Mouse Click”                        81
3.1.1 Making Layouts With the Designer              84
3.1.2 The Property Editor                       85
3.1.3 The Preview                           88
3.1.4 Signal/Slot Connections                    88
3.1.5 The Tab Sequence                       89
3.1.6 Shortcuts and Buddies                     90
3.2 Integrating Designer-generated Files into Your Qt Project      91
3.2.1 Using Designer-generated Classes as Helper Classes     92
3.2.2 Always Having Designer-generated Widgets Available    94
3.2.3 Multiple Inheritance                      95
3.3 Automatic Signal/Slot Connections                   97
3.4 Including Derived Classes in the Designer               99
3.5 The Resource Editor                           99

4 Developing a GUI Application Based on a Main Window 101
4.1 The Anatomy of the Main Window                   101
4.2 Deriving from QMainWindow                      103
4.3 Creating a Main Window with the Qt Designer            106
4.3.1 Adding Menu Bars                       107
4.3.2 Recycling Actions in the Toolbar               108
4.3.3 Integrating the Main Window with Your Source Code    110
4.4 Making the Most of the Status Bar                   118
4.4.1 Temporary Messages                      120
4.4.2 Normal Messages                        120
4.4.3 Permanent Messages                      121
4.5 Toolbars                                 125
4.6 How Do Actions Work?                         126
4.6.1 How to Instantiate QAction Manually             127
4.6.2 Selectable Actions                       128
4.6.3 Grouped Actions                        128
4.7 Dock Windows                              130
4.7.1 Positioning Dock Windows                   131
4.7.2 ADock Window for Our Editor                133
4.8 Saving Preferences                            136
4.8.1 Extending CuteEdit                       139

5 Laying Out Widgets 141
5.1 Manual Layout                              141
5.2 Automatic Layout                            143
5.2.1 Horizontal and Vertical Layout                144
5.2.2 Grid Layout                           148
5.2.3 Nested Layouts                         149
5.3 Splitter                                  150
5.3.1 Behavior During Size Changes                 150
5.3.2 Saving Splitter Positions and Determining the Widget Size 151
5.3.3 Defining Relative Sizes                     152
5.3.4 Customizing Handles                      153
5.3.5 Layout for Languages Written from Right to Left      156
5.4 Stacked Layouts                             157
5.4.1 The Alternative: Stacked Widgets               157
5.4.2 When to Use Stacked Layouts and Widgets          157

6 Dialogs 161
6.1 Modal Dialogs                              161
6.2 Non-modal Dialogs                           163
6.2.1 Usability Problems                       163
6.3 Semi-modal Dialogs                           164
6.4 Avoiding Bloated Dialogs                        164
6.5 Ready-made Dialogs in Qt                       166
6.5.1 Message Dialogs                        166
6.5.2 Error Messages That Are Only Visible Once          174
6.5.3 File Selection Dialogs                      175
6.5.4 Input Dialogs                          179
6.5.5 Font Selection Dialog                     182
6.5.6 Color Selection and Printing Dialog              183

7 Events, Drag and Drop, and the Clipboard 185
7.1 Event Loop and Event Handler                     185
7.2 Handling Events                             186
7.2.1 Using Specialized Event Handlers               186
7.2.2 Using the General Event Handler               189
7.3 Using Event Filters                            190
7.4 Drag and Drop                              194
7.4.1 MIME Types                           194
7.4.2 The Drag Side                          196
7.4.3 The Drop Side                          198
7.5 The Clipboard                              201

8 Displaying Data Using “Interview” 207
8.1 Underlying Concepts                          208
8.1.1 The View Classes                        210
8.1.2 The Model Classes                       211
8.2 Displaying Directory Hierarchies                    212
8.2.1 Using View Classes in the Designer              214
8.2.2 Implementing the Functionality of the File Selection Dialog 216
8.3 The String Lists Model                          221
8.4 Implementing Your Own Models                    222
8.4.1 An Address Book Model                    222
8.4.2 Making Your Own Models Writable              227
8.5 Sorting and Filtering Data with Proxy Models             231
8.5.1 Adjustments to the User Interface              232
8.6 Making Entries Selectable with Checkboxes              234
8.7 Designing Your Own Proxy Models                   237
8.8 Implementing Drag and Drop in Models                241
8.9 Your Own Delegates                           245
8.10 Without Your Own Data Source: The Standard Model         249
8.11 Element-based Views Without Model Access             251
8.11.1 Items                              251
8.11.2 The List View                          251
8.11.3 The Tree View                          252
8.11.4 The Table View                         253
8.11.5 Cloning Items                          254

9 The QtSql Module 257
9.1 Structure of the QtSql Module                     257
9.2 Selecting the Appropriate Driver                    258
9.3 Making a Connection                          260
9.4 Making Queries                             261
9.5 Transactions                               264
9.6 Embedded Databases                          264
9.7 Using SQL Model Classes with Interview                265
9.7.1 Displaying SQL Tables Without Foreign Keys in Table and Tree Views  265
9.7.2 Resolving Foreign Key Relations                266
9.7.3 Displaying Query Results                    267
9.7.4 Editing Strategies                        268
9.7.5 Errors in the Table Model                    270

10 The Graphics Library “Arthur” 271
10.1 Colors                                   271
10.1.1 The RGB Color Space                      272
10.1.2 Other Color Spaces                       273
10.1.3 Color Selection Dialog                     275
10.2 Painting with Qt                             276
10.3 Geometrical Helper Classes                       278
10.4 How to Paint on Widgets                        280
10.4.1 How to Prevent Monitor Flicker                282
10.5 Using QPainter in Practice                        283
10.5.1 Drawing a Pie Chart                      284
10.5.2 Defining the Widget Size                   289
10.5.3 The Diagram Application                    290
10.6 Transformations of the Coordinate System              290
10.6.1 Transformations in Practice                  293
10.7 QImage                                  297
10.7.1 Storage Formats, Transparency, and Color Palettes      297
10.7.2 Reading out Pixels Line by Line                298
10.8 SVG Support                               300
10.9 Printing with QPrinter                          302
10.9.1 Digression: Making Screenshots                304
10.9.2 Printing an Image File                     305
10.9.3 Generating PDFs                        306
10.9.4 The Test Application                      306
10.10 Complex Graphics                            307
10.10.1 Clipping                             307
10.10.2 Painter Paths                          309
10.10.3 Composition Modes                      310

11 Input/Output Interfaces 317
11.1 The QIODevice Class Hierarchy                     317
11.1.1 Derived Classes                         318
11.1.2 Opening I/O Devices                      319
11.2 Access to Local Files                           320
11.3 Serializing Objects                            322
11.3.1 Defining Serialization Operators                325
11.3.2 Saving Serialized Data to a File and Reading from It     326
11.4 Starting and Controlling Processes                   328
11.4.1 Synchronous Use of QProcess                 328
11.4.2 Asynchronous Use of QProcess                330
11.5 Communication in the Network                    332
11.5.1 Name Resolution with QHostInfo               333
11.5.2 Using QTcpServer and QTcpSocket              333

12 Threading with QThread 337
12.1 Using Threads                              338
12.2 Synchronizing Threads                         341
12.2.1 The Consumer/Producer Pattern                342
12.3 Thread-dependent Data Structures                   345
12.4 Using Signals and Slots Between Threads               347
12.5 Your Own Event Loops for Threads                   350
12.5.1 Communication via Events Without a Thread-based Event Loop   352

13 Handling XML with QtXml 353
13.1 The SAX2 API                               354
13.1.1 How It Works                          354
13.1.2 Reimplementing a Default Handler to Read RSS Feeds   355
13.1.3 Digression: Equipping the RSS Reader with a GUI and Network Capability 361
13.2 The DOM API                               366
13.2.1 Reading in and Processing XML Files             367
13.2.2 Searching for Specific Elements                370
13.2.3 Manipulating the DOM Tree                  371
13.2.4 The DOM Tree as XML Output                 372

14 Internationalization 375
14.1 Translating Applications into Other Languages            375
14.1.1 Preparing the Application                   376
14.1.2 Processing Translation Sources with Linguist         377
14.1.3 Using Translations in the Program               378
14.1.4 Adding Notes for the Translation               380
14.1.5 Specifying the Translation Context              380
14.1.6 Internationalizing Strings Outside Qt Classes         381

Appendixes 383
A Debugging Help 385
A.1 Debugging Functions                          385
A.1.1 Simple Debug Output                     386
A.1.2 Errors and Warnings                      387
A.1.3 Customizing the Output of Debugging Functions      388
A.2 Ways to Eliminate Errors                        390
A.2.1 Checking Assertions                      390
A.2.2 Checking Pointers                       391
A.2.3 Common Linker Errors                     392

B Tulip: Containers and Algorithms 393
B.1 Iterators                                 394
B.1.1 STL-Style Iterators                       395
B.1.2 Java-Style Iterators                       396
B.2 Lists                                    398
B.2.1 Simple List (QList)                       400
B.2.2 Linked List (QLinkedList)                    401
B.2.3 Vectors (QVector)                        401
B.3 Stacks and Queues                            403
B.3.1 Stacks (QStack)                         403
B.3.2 Queues (QQueue)                        404
B.4 Associative Arrays                            404
B.4.1 Dictionaries (QMap)                      404
B.4.2 Allowing Several Identical Keys (QMultiMap)         407
B.4.3 Hash Tables with QHash                    409
B.4.4 Hash-based Amounts with QSet                411
B.5 Algorithms                                412
B.5.1 The foreach Keyword                      412
B.5.2 Sorting                             413
B.5.3 Sorting in Unsorted Containers                414
B.5.4 Copying Container Areas                    415
B.5.5 Binary Search in Sorted Containers              416
B.5.6 Counting the Number of Occurences of Equal Elements   418
B.5.7 Deleting Pointers in Lists                    418
B.5.8 Checking that Data Structures Have Identical Elements   419
B.5.9 Filling Data Structures                     420
B.5.10 Swapping Values                        420
B.5.11 Minimum, Maximum, and Threshold Values         421
B.5.12 Determining Absolute Value                  422
B.6 Qt-specific Type Definitions                       422
B.6.1 Integer types                          422
B.6.2 Floating-point Values                     423
B.6.3 Shortcuts for Common Types                 423
Index 425

QT4 编程艺术 电子书下载:

The-Book-of-QT4-The-Art-of-Building-QT-Applications.rar (5.88 MB)


Tags:

QT

Comments

Comment RSS

About

新网虫电子书重出江湖,分享计算机编程电子书下载。