From be01f8c8e3e09a1c71165640ab722df948c4dfbb Mon Sep 17 00:00:00 2001
From: Michele Calgaro Finally, assuming you are using qmake
+ Finally, assuming you are using tqmake
to generate your makefiles, add this line to your "myapp.pro" file:
Regenerate your makefile and your application. The .exe file will now be
represented with your icon e.g. in Explorer.
- If you do not use qmake, the necessary
+ If you do not use tqmake, the necessary
steps are: first, run the "rc" program on the .rc file, then link your
application with the resulting .res file.
If you are using qmake to generate
+ If you are using tqmake to generate
your make files, you only need to add a single line to your .pro
project file. For example, if the name of your icon file is
myapp.icns, and your project file is myapp.pro, add this line
@@ -106,10 +106,10 @@ to myapp.pro:
RC_FILE = myapp.icns
If you do not use qmake, you must do
+ If you do not use tqmake, you must do
the following manually:
TQt Assistant can be customized by adding and removing documentation from its documentation set. In addition, TQt Assistant introduces the profiles option, which enables its properties to change, for example, the default startup page, and application icon. When it is started without any options, TQt Assistant displays a default set of documentation. When TQt is installed, the default documentation set in TQt Assistant contains the TQt reference documentation as well as the tools that come with TQt, such as TQt Designer and qmake. When it is started without any options, TQt Assistant displays a default set of documentation. When TQt is installed, the default documentation set in TQt Assistant contains the TQt reference documentation as well as the tools that come with TQt, such as TQt Designer and tqmake. Documentation can be added or removed from TQt Assistant by adding and removing the content files. The format of the content files are specified below. To add a content file, type the following command line option: -addContentFile docfile. To remove a content file from the default set, type the following command line option: -removeContentFile docfile. For example: TQt Designer helps you build user interfaces with layout tools that move and scale your widgets (controls in Windows terminology) automatically at runtime. The resulting interfaces are both functional and attractive, comfortably suiting your users' operating environments and preferences. TQt Designer supports TQt's signals and slots mechanism for type-safe communication between widgets. TQt Designer includes a code editor which you can use to embed your own custom slots inside the generated code. Those who prefer to separate generated code from hand crafted code can continue to use the subclassing approach pioneered in the first version of TQt Designer. The manual introduces you to TQt Designer by leading you through the development of example applications. The first seven chapters are tutorials, each designed to be as self-contained as possible. Every chapter, except the first three, assumes that you are familiar with the material in chapters two and three which cover the basics of building a TQt application with TQt Designer. Here's a brief overview of the chapters: Chapter one, Quick Start, is a fast hands-on tutorial that takes you through the creation of a short, simple dialog application. The aim of this chapter is to give you a feel for how TQt Designer works, with explanations and details deferred to later chapters. Chapter two, Creating a Main Window Application, introduces TQt Designer and takes you step by step through the creation of a small but fully functional application. Along the way you will learn how to create a main window with menus, toolbars and a status bar. Most of the application's implementation will be covered, but the custom dialogs are deferred until chapter three. In the course of this chapter you will use the form and property editors to customize the application. You'll also learn how to use TQt's signals and slots mechanism and TQt Designer's built-in code editor to make the application functional. We will also explain how to use qmake to generate a Makefile so that you can compile and run the application. Chapter two, Creating a Main Window Application, introduces TQt Designer and takes you step by step through the creation of a small but fully functional application. Along the way you will learn how to create a main window with menus, toolbars and a status bar. Most of the application's implementation will be covered, but the custom dialogs are deferred until chapter three. In the course of this chapter you will use the form and property editors to customize the application. You'll also learn how to use TQt's signals and slots mechanism and TQt Designer's built-in code editor to make the application functional. We will also explain how to use tqmake to generate a Makefile so that you can compile and run the application. In chapter three, Creating Dialogs, we will create the custom dialogs required by the main window application created in chapter two. In addition to demonstrating various ways of creating dialogs, you will also learn how to lay out forms using the layout tools. Chapter four, The Designer Approach, provides information on the TQt Designer approach to developing applications, and explains some of the rationale behind TQt Designer. Chapter five, Subclassing and Dynamic Dialogs, will show you how to subclass a form; this allows you to clearly separate the user interface from the underlying code that implements its functionality. Additional information on qmake and tquic is included in this chapter. This chapter will also explain how you can dynamically load dialogs from .ui files into your application using TQWidgetFactory and how to access the widgets and sub-widgets of these dialogs. Chapter five, Subclassing and Dynamic Dialogs, will show you how to subclass a form; this allows you to clearly separate the user interface from the underlying code that implements its functionality. Additional information on tqmake and tquic is included in this chapter. This chapter will also explain how you can dynamically load dialogs from .ui files into your application using TQWidgetFactory and how to access the widgets and sub-widgets of these dialogs. Chapter six, Creating Custom Widgets, explains how you can create your own custom widgets. Both the simple method, that was introduced with the first version of TQt Designer, and the new more powerful method using plugins, are explained. Chapter seven, Creating Database Applications introduces TQt's SQL classes and takes you through an example that demonstrates how to execute SQL queries and how to set up master-detail relationships, perform drilldown and handle foreign keys. Chapter eight, Customizing and Integrating TQt Designer, focuses on TQt Designer itself, showing you how to customize Designer, how to integrate Designer with Visual Studio and how to create Makefiles.
Project Settings- C++ Tab Click the C++ Tab to change the qmake options. See the qmake documentation for details on what these options mean. Click the 'Template' combobox and choose application or library to create makefiles for building applications or libraries. Click the 'Config' combobox to select the project configuration and compiler options for all platforms, or specific platforms. Type the Config value in the line edit. Note: Unix defaults to a shared library. If you want a shared library in Windows, type 'dll' at the end of the default config command and make sure you select lib from the Template combobox. Click the 'Libs' combobox to select a platform. Type the libraries in the line edit. Click the 'Defines' combobox and select a platform. 'Defines' values are added as compiler pre-processor macros. Type the 'Defines' values in the line edit. Click the 'Includepath' combobox to select a platform. Includepath specifies the directories that should be searched for include files when compiling the project. Type the 'Includepath' values in the line edit. Click the C++ Tab to change the tqmake options. See the tqmake documentation for details on what these options mean. Click the 'Template' combobox and choose application or library to create makefiles for building applications or libraries. Click the 'Config' combobox to select the project configuration and compiler options for all platforms, or specific platforms. Type the Config value in the line edit. Note: Unix defaults to a shared library. If you want a shared library in Windows, type 'dll' at the end of the default config command and make sure you select lib from the Template combobox. Click the 'Libs' combobox to select a platform. Type the libraries in the line edit. Click the 'Defines' combobox and select a platform. 'Defines' values are added as compiler pre-processor macros. Type the 'Defines' values in the line edit. Click the 'Includepath' combobox to select a platform. Includepath specifies the directories that should be searched for include files when compiling the project. Type the 'Includepath' values in the line edit. Cick OK to accept changes to the project settings. Click Cancel to exit the dialog without making any changes to the project settings. Click Save to save the project. Compiling and Running the Application Start or switch to a console, and navigate to the directory where the project is saved. Run qmake on the project file (metric.pro) by typing qmake -o Makefile metric.pro. Run tqmake on the project file (metric.pro) by typing tqmake -o Makefile metric.pro. Run make (or nmake depending on your system). After the project has compiled, run the application. Creating a Project Whenever you create a new application we recommend that you create a project file and open the project rather than individual .ui files. Using a project has the advantage that all the forms you create for the project are available via a single mouse click rather than having to be loaded individually through file open dialogs. An additional benefit of using project files is that they allow you to store all your images in a single file rather than duplicate them in each form in which they appear. See The Designer Approach chapter's Project management section for detailed information on the benefits of using project files. Project files use the .pro suffix and are used by the qmake tool to create makefiles for the relevant target platforms. Project files use the .pro suffix and are used by the tqmake tool to create makefiles for the relevant target platforms. Create a new project as follows: Click File|New to invoke the New File dialog. This ensures that our application will cleanly terminate. Later we'll revise this function to give the user the opportunity to save any unsaved data. We now have some code in the application and a main.cpp containing the main() function, so we should be able to compile, link and run the application. Click File|Save to ensure that all our work is saved to disk. Open a console (e.g. an xterm or DOS window), change directory to where you have saved the colortool project, and run qmake to generate a Makefile: Click File|Save to ensure that all our work is saved to disk. Open a console (e.g. an xterm or DOS window), change directory to where you have saved the colortool project, and run tqmake to generate a Makefile: Now make the project (run nmake on Windows, make on other platforms). Providing you commented out the "findForm" and "loadSettings" lines in the init() function, the program should build. (If it doesn't build see the Troubleshooting section.) Once the make has finished, run the program. You still can't change views since we haven't written the code for that yet, but it does create a default set of colors. You can terminate the application by clicking the close (X) button or by clicking File|Exit. When you've opened or created a project you can set up its database connections using the Edit Database Connections dialog (invoked by the Project|Database Connections menu option). The connections you make are stored in a .db file. When you reload a project you can reconnect by going to the Edit Database Connections dialog, clicking a connection in the list and clicking the Connect button. In most non-trivial database applications you will want to access the database from more than one form. This is why the .db file is part of a project, not just part of a single form. TQt Designer needs to store information on projects, for example, the list of forms, the image collection and information about available databases and how to access them. The majority of TQt users already use a project file format to create multiplatform makefiles: tmake (and with TQt 3.0 qmake) project .pro files. These files already contain the list of forms, .ui files, used in the project for tquic. We've extended the sections in the .pro file to include the extra information that TQt Designer needs to manage projects. For example, when you add a form to your project in TQt Designer, it is automatically added to the FORMS section of the project file, and thus qmake will generate the required build rules without any further work. Similarly, the images are added to the IMAGES section and thus gets automatically compiled into your executable. We don't force you to use qmake; if you prefer another build system, for example automake/autoconf or jam, you can still continue to use it. Look upon the .pro file as a file that describes the GUI part of your application. All you need to do -- as previously -- is add the .ui files and the images collection to your own Makefiles. TQt Designer needs to store information on projects, for example, the list of forms, the image collection and information about available databases and how to access them. The majority of TQt users already use a project file format to create multiplatform makefiles: tmake (and with TQt 3.0 tqmake) project .pro files. These files already contain the list of forms, .ui files, used in the project for tquic. We've extended the sections in the .pro file to include the extra information that TQt Designer needs to manage projects. For example, when you add a form to your project in TQt Designer, it is automatically added to the FORMS section of the project file, and thus tqmake will generate the required build rules without any further work. Similarly, the images are added to the IMAGES section and thus gets automatically compiled into your executable. We don't force you to use tqmake; if you prefer another build system, for example automake/autoconf or jam, you can still continue to use it. Look upon the .pro file as a file that describes the GUI part of your application. All you need to do -- as previously -- is add the .ui files and the images collection to your own Makefiles. First let us look at a small figure that shows the relationship between .ui files, generated code and application code:
diff --git a/doc/html/designer-manual-6.html b/doc/html/designer-manual-6.html
index 503dcd9d..38d68867 100644
--- a/doc/html/designer-manual-6.html
+++ b/doc/html/designer-manual-6.html
@@ -34,14 +34,14 @@ body { background: #ffffff; color: black; }
We'll start with a general description of how to subclass a form and follow with a short example. Note that subclassing has some disadvantages compared with putting your code into a form directly; see Extending the functionality of a form in The Designer Approach chapter for details. TQt Designer reads and writes qmake .pro (project) files which are used to record the files used to build the application and from which Makefiles are generated. TQt Designer also reads and writes .ui (user interface) files. These are XML files that record the widgets, layouts, source code and settings you've used for a form. Every .ui file is converted by the tquic (user interface compiler) into a C++ .h file and a C++ .cpp file. These C++ files are then read by tqmoc (meta object compiler), and finally compiled by your compiler into a working application. TQt Designer reads and writes tqmake .pro (project) files which are used to record the files used to build the application and from which Makefiles are generated. TQt Designer also reads and writes .ui (user interface) files. These are XML files that record the widgets, layouts, source code and settings you've used for a form. Every .ui file is converted by the tquic (user interface compiler) into a C++ .h file and a C++ .cpp file. These C++ files are then read by tqmoc (meta object compiler), and finally compiled by your compiler into a working application. If you create applications wholly within TQt Designer you only need to create a main.cpp. If you create the main.cpp file within TQt Designer, it will automatically be added to your project file by TQt Designer. If you create the main.cpp file outside of TQt Designer you must add it to the project file manually by adding the following line at the end of your project's .pro file: You can then use qmake to generate the Makefile. (For example qmake -o Makefile myproject.pro.) Running make (Linux or Unix compilers), or nmake (Visual C++), will then call tquic, tqmoc and your compiler as necessary to build your application. If you use TQt Designer to create your main window and dialogs, but also add other C++ files, or if you subclass any of your forms you will need to add these files to the .pro file so that they are compiled with the rest of your application's source files. Each .h file that you create separately from TQt Designer should be added to the HEADERS line, and each .cpp file should be added to the SOURCES line, just as we've done for main.cpp. If you get undefined reference errors it is worth checking that you've added the names of all your header and implementation files to the .pro file. You can then use tqmake to generate the Makefile. (For example tqmake -o Makefile myproject.pro.) Running make (Linux or Unix compilers), or nmake (Visual C++), will then call tquic, tqmoc and your compiler as necessary to build your application. If you use TQt Designer to create your main window and dialogs, but also add other C++ files, or if you subclass any of your forms you will need to add these files to the .pro file so that they are compiled with the rest of your application's source files. Each .h file that you create separately from TQt Designer should be added to the HEADERS line, and each .cpp file should be added to the SOURCES line, just as we've done for main.cpp. If you get undefined reference errors it is worth checking that you've added the names of all your header and implementation files to the .pro file. When subclassing a form it is helpful to use a naming convention to help us identify which files are generated from TQt Designer's .ui files and which are hand coded. Suppose, for example, that we are developing a dialog and writing the code directly in TQt Designer. We might call our dialog 'OptionsForm' and the .ui file, optionsform.ui. The automatically generated files will be optionsform.h and optionsform.cpp. Note that we're including creditformbase.h and instantiating a CreditFormBase object; once we've written our subclass we'll replace the header with our subclass, creditform.h, and instantiate a CreditForm. We can now generate the application with qmake, e.g. qmake -o Makefile credit.pro, make it and run it. The form should run fine, but doesn't yet have the behaviour we require. We can now generate the application with tqmake, e.g. tqmake -o Makefile credit.pro, make it and run it. The form should run fine, but doesn't yet have the behaviour we require. We need to create a header and an implementation file for our subclass. The code for our subclass is minimal. The header file is qt/tools/designer/examples/credit/creditform.h: We call setAmount() in the constructor to ensure that the correct amount is shown when the form starts based on whichever radio button we checked in TQt Designer. In setAmount() we set the amount if the standard or none radio button is checked. If the user has checked the special radio button they are free to change the amount themselves. To be able to test our subclass we change main.cpp to include creditform.h rather than creditformbase.h and change the instantiation of the creditForm object: To be able to test our subclass we change main.cpp to include creditform.h rather than creditformbase.h and change the instantiation of the creditForm object: To test the form rerun qmake to regenerate the Makefile, then make and run. To test the form rerun tqmake to regenerate the Makefile, then make and run. The subclassing example we've used is simple, but this reflects subclassing forms in TQt: it is easy to do. TQt programs are capable of loading TQt Designer .ui files and instantiating the forms represented by the .ui files. Since the .ui file is not compiled it cannot include any C++ code, (e.g. slot implementations). In this section we will explain how to load a dynamic dialog and how to create a class that can be used to implement the dynamic dialog's custom slots. We can create the makefile using qmake: qmake -o Makefile filechooser.pro, then we can make and run the harness to test our new widget. Once we're satisfied that the custom widget is robust and has the behaviour we require we can embed it into a plugin. We can create the makefile using tqmake: tqmake -o Makefile filechooser.pro, then we can make and run the harness to test our new widget. Once we're satisfied that the custom widget is robust and has the behaviour we require we can embed it into a plugin. TQt Plugins can be used to provide self-contained software components for TQt applications. TQt currently supports the creation of five kinds of plugins: codecs, image formats, database drivers, styles and custom widgets. In this section we will explain how to convert our filechooser custom widget into a TQt Designer custom widget plugin. A TQt Designer custom widget plugin is always derived from TQWidgetPlugin. The amout of code that needs to be written is minimal. qt/tools/designer/examples/filechooser/plugin/plugin.pro Change the HEADERS line to list your plugin's header file plus a header file for each of your widgets. Make the equivalent change for the SOURCES line. If you create a Makefile with qmake and make the project the plugin will be created and placed in a directory where TQt Designer can find it. The next time you run TQt Designer it will detect your new plugin and load it automatically, displaying its icon in the toolbar you specified. Change the HEADERS line to list your plugin's header file plus a header file for each of your widgets. Make the equivalent change for the SOURCES line. If you create a Makefile with tqmake and make the project the plugin will be created and placed in a directory where TQt Designer can find it. The next time you run TQt Designer it will detect your new plugin and load it automatically, displaying its icon in the toolbar you specified. Once the plugin has been compiled it will automatically be found and loaded by TQt Designer the next time TQt Designer is run. Use your custom widget just like any other. If you want to use the plugin in another of your projects you can link against it by adding an appropriate line to the project, e.g. by adding a line like this to the project's .pro file: Edit Database Connections Dialog Choose Project|Database Connections from the menu bar. The Edit Database Connections dialog will appear. Click New Connection. For applications that use a single database it will probably be most convenient to use the default connection name of '(default)'. If you use more than one database then each one must be given a unique name. A driver must be chosen from the Driver combo box. The database name may be available in the Database Name combo box or may have to be typed in. The database name, username, password, hostname and port should be provided by your database system administrator. When the Connection information has been completed click Connect. If the connection is made the connection name will appear in the list box on the left hand side of the dialog. You can now close the dialog; the connection settings will remain in effect until you change or delete them or exit from TQt Designer. Warning: If you are using an existing SQLite database, ensure that the name you specify in the "Database Name" field is not the same as the existing database file. TQt Designer will create a configuration file using the name given for the database and will overwrite any existing files with the same name. TQt Designer can remember database connection settings in qmake project files. Create a new project, e.g. click File|New, then click the 'C++ Project' icon to invoke the Project Settings dialog. Click the ellipsis button to invoke the Save As dialog; navigate to the project's directory (creating it if necessary). Make sure you're in the project's directory, then enter a project name of 'book.pro'. Click the Save button to return to the Project Settings dialog, then click OK. Next time you start TQt Designer instead of opening individual .ui files open the .pro project file instead and TQt Designer will automatically reload the project's connection settings. To activate the connection click Project|Database Connections. The connections previously saved with the project will be listed in the left hand list box. Click the connection you wish to use and then click Connect. This connection will be used from now on, e.g. for previewing TQDataTables. Opening a project file also causes TQt Designer to load in the list of forms associated with the project into the Project Overview window. In most of the explanation that follows we will assume that you use project files and have clicked Connect so that there is always a connection available when you work in TQt Designer. TQt Designer can remember database connection settings in tqmake project files. Create a new project, e.g. click File|New, then click the 'C++ Project' icon to invoke the Project Settings dialog. Click the ellipsis button to invoke the Save As dialog; navigate to the project's directory (creating it if necessary). Make sure you're in the project's directory, then enter a project name of 'book.pro'. Click the Save button to return to the Project Settings dialog, then click OK. Next time you start TQt Designer instead of opening individual .ui files open the .pro project file instead and TQt Designer will automatically reload the project's connection settings. To activate the connection click Project|Database Connections. The connections previously saved with the project will be listed in the left hand list box. Click the connection you wish to use and then click Connect. This connection will be used from now on, e.g. for previewing TQDataTables. Opening a project file also causes TQt Designer to load in the list of forms associated with the project into the Project Overview window. In most of the explanation that follows we will assume that you use project files and have clicked Connect so that there is always a connection available when you work in TQt Designer. The applications you create must make their own connections to the SQL database. We provide an example function, createConnections(), that you can use as a basis for your own code. Click on the form and change its name to 'BookForm' and its caption to 'Book'. Click on the TQDataTable and change its name to 'AuthorDataTable'. Click File|Save All. Open the project file, e.g. book.pro, in a plain text editor and add the line: SOURCES += main.cpp at the end of the file. Run qmake to generate the make file, e.g. qmake -o Makefile book.pro, then make and run the book program. Run tqmake to generate the make file, e.g. tqmake -o Makefile book.pro, then make and run the book program. This example shows how easy it is to use TQDataTable to show the contents of a database table or view. You can use the application we've just built to update and delete author records. In the examples that follow we will cover insertions, setting up master-detail relationships, drilldown and foreign key lookups. A Note on Foreign Keys New TQt Project -- A small application wizard New TQt Dialog -- Add an empty TQt Dialog to the active project, or add an existing dialog TQt GUI Designer -- Run TQt Designer Open TQt Project -- Runs qmake with a .pro file Open TQt Project -- Runs tqmake with a .pro file Write TQt Project -- Saves the current VS project as a .pro file Use TQt -- Add the TQt libraries to the active project Add TQMoc -- Add tqmoc precompiler to the active file Double clicking a .ui file in the workspace overview will now launch TQt Designer. If you create a .cpp file which contains the TQ_OBJECT macro you will need an additional file which is generated by tqmoc to be included in your project. For example, if you have 'file.cpp', then the last line would be #include "file.moc" and the additional file would be called 'file.moc'. To ensure that Visual Studio executes the tqmoc and generates this file you must create a custom dependency. Double click the .cpp file (in your project workspace) that contains the TQ_OBJECT macro. Click the Add TQMoc toolbar button; this will create an empty .moc file in your project workspace. Right click the newly created .moc file, then click Settings from the pop-up menu to invoke the Project Settings dialog. Click the Custom Build tab. Click the Dependencies button to pop up the User Defined Dependencies dialog. Type in $(InputDir)\$(InputPath), then press Return. Click OK to leave the Dependencies dialog, then click OK to leave the Project Settings dialog. If you wish to delete the add-in remove it from the toolbar then delete the qmsdev.dll file from the add-ins directory. The qmake tool provided with TQt can create Makefiles appropriate to your platform based on .pro project files. This section describes the dependencies involved in building a TQt application and gives a couple of simple example Makefiles. This section assumes that you have a good understanding of Makefiles. The tqmake tool provided with TQt can create Makefiles appropriate to your platform based on .pro project files. This section describes the dependencies involved in building a TQt application and gives a couple of simple example Makefiles. This section assumes that you have a good understanding of Makefiles. TQt Designer produces .ui files which are used to generate .h and .cpp files for the compiler to compile. The .ui files are processed by tquic. Classes which inherit from TQObject, e.g. those which use slots and signals, require an additional .cpp file to be generated. These files are generated by tqmoc and are named 'tqmoc_file.cpp' where the original .cpp file is called 'file.cpp'. If your .cpp file contains the TQ_OBJECT macro an additional file 'file.moc' should be generated which must be #included in the .cpp, normally at the end. This requires an extra dependency being created. Processing .ui files with tquic is done twice: To see more sophisticated Makefiles simply generate them using qmake on any of your TQt projects or any of the examples supplied with TQt. To see more sophisticated Makefiles simply generate them using tqmake on any of your TQt projects or any of the examples supplied with TQt. To import a file in a supported foreign file format click File|Open, then click the File Type combobox to choose the file type you wish to load. Click the required file and TQt Designer will convert and load the file. The filters that TQt Designer uses to read foreign file formats are 'works in progress'. You may have different filters available in your version of TQt Designer than those described here. The easiest way to see which filters are available is to invoke the file open dialog; all your filters are listed in the File Type combobox. The main function is a standard implementation opening
the application main window.
To build the example go to the helpsystem directory
-(TQTDIR/examples/helpsystem) run qmake to generate the makefile,
+(TQTDIR/examples/helpsystem) run tqmake to generate the makefile,
and use the make tool to build the library.
When you run lupdate or lrelease, you must give the name of the
project file as a command-line argument.
In this example, four exotic languages are supported: Danish, Finnish,
-Norwegian and Swedish. If you use qmake, you usually don't need an extra project
-file for lupdate; your qmake project file will work fine once
+Norwegian and Swedish. If you use tqmake, you usually don't need an extra project
+file for lupdate; your tqmake project file will work fine once
you add the TRANSLATIONS entry.
In your application, you must TQTranslator::load() the translation
files appropriate for the user's language, and install them using TQApplication::installTranslator().
diff --git a/doc/html/index.html b/doc/html/index.html
index 20c22b9c..79d0b8b7 100644
--- a/doc/html/index.html
+++ b/doc/html/index.html
@@ -157,7 +157,7 @@ Licenses & Credits
The 'Open TQt Project' button allows you to convert an existing qmake project file into a .dsp file which you can insert into
+ The 'Open TQt Project' button allows you to convert an existing tqmake project file into a .dsp file which you can insert into
your existing workspace. When you click the 'Open TQt Project'
-button, just select an existing qmake project file (a .pro
+button, just select an existing tqmake project file (a .pro
file) and then click OK. You will get a message box at the end
which asks you to insert the newly created .dsp file into your
existing workspace.
The 'Write TQt Project' button creates a qmake project (.pro)
+ The 'Write TQt Project' button creates a tqmake project (.pro)
file for your current project so that you can easily copy the files
-onto another platform and be able to use qmake to create a Makefile
+onto another platform and be able to use tqmake to create a Makefile
on that other platform. All you need to do is make the project you
want to create a .pro file for, and click on the button. Just
-name your qmake project file and click Save.
+name your tqmake project file and click Save.
The 'Use TQt In Current Project' button simply adds in the necessary
diff --git a/doc/html/keyfeatures30.html b/doc/html/keyfeatures30.html
index eaf55792..4645a782 100644
--- a/doc/html/keyfeatures30.html
+++ b/doc/html/keyfeatures30.html
@@ -339,11 +339,11 @@ Designer and TQt Linguist. It offers index searching, a contents
overview, bookmarks history and incremental search. TQt Assistant is
used by both TQt Designer and TQt Linguist for browsing their help
documentation.
- To ease portability we now provide the qmake utility to replace tmake. TQMake is a C++ version of
+ To ease portability we now provide the tqmake utility to replace tmake. TQMake is a C++ version of
tmake which offers additional functionallity that is difficult to
-reproduce in tmake. Trolltech uses qmake in its build system for TQt
+reproduce in tmake. Trolltech uses tqmake in its build system for TQt
and related products and we have released it as free software.
diff --git a/doc/html/linguist-manual-2.html b/doc/html/linguist-manual-2.html
index ae9d3342..529f9f77 100644
--- a/doc/html/linguist-manual-2.html
+++ b/doc/html/linguist-manual-2.html
@@ -30,10 +30,10 @@ body { background: #ffffff; color: black; }
[Prev: Introduction] [Home] [Next: Translators] Two tools are provided for the release manager, lupdate and lrelease. These tools depend on qmake project files. You don't have to use qmake, though. Two tools are provided for the release manager, lupdate and lrelease. These tools depend on tqmake project files. You don't have to use tqmake, though. A third tool, tqm2ts, can be used for converting TQt 2.x message files to .ts files. lupdate and lrelease depend on information in the application's .pro TQt project file. There must be an entry in the TRANSLATIONS section of the project file for each language that is additional to the native language. A typical entry looks like this: lupdate and lrelease depend on information in the application's .pro TQt project file. There must be an entry in the TRANSLATIONS section of the project file for each language that is additional to the native language. A typical entry looks like this: Run lupdate to incorporate any new text added to the application. lupdate synchronizes the user-visible text from the application with the translations; it does not destroy any data. Steps 2 and 3 are repeated as often as necessary. When a release of the application is needed lrelease is run to read the .ts files and produce the .qm files used by the application at runtime. For lupdate to work successfully, it must know which translation files to produce. The files are simply listed in the application's .pro TQt project file, for example: For lupdate to work successfully, it must know which translation files to produce. The files are simply listed in the application's .pro TQt project file, for example:
RC_FILE = myapp.rc
@@ -78,7 +78,7 @@ RC_FILE = myapp.rc
-This will ensure that qmake puts your
+This will ensure that tqmake puts your
icons in the proper place and creates an Info.plist entry for the
icon.
- Setting the Application Icon on Mac OS X
@@ -97,7 +97,7 @@ Developer/Application folder). Icon Composer allows you to import sever
different sized icons (for use in different contexts) as well as the masks
that go with them. Save the set of icons to a file in your project
directory.
-
Customizing TQt Assistant
Modifying the Default Documentation Set
-
1: > assistant -addContentFile file.dcf
diff --git a/doc/html/commonproblems.html b/doc/html/commonproblems.html
index d2b396f8..dc964def 100644
--- a/doc/html/commonproblems.html
+++ b/doc/html/commonproblems.html
@@ -72,7 +72,7 @@ the relevant release of TQt.
-The Search Dialogs
Find Text Dialog
diff --git a/doc/html/designer-manual-2.html b/doc/html/designer-manual-2.html
index b925f7ad..189e7dc5 100644
--- a/doc/html/designer-manual-2.html
+++ b/doc/html/designer-manual-2.html
@@ -277,7 +277,7 @@ body { background: #ffffff; color: black; }
Wrapping Up
diff --git a/doc/html/designer-manual-3.html b/doc/html/designer-manual-3.html
index 46dc87d3..aadcad5a 100644
--- a/doc/html/designer-manual-3.html
+++ b/doc/html/designer-manual-3.html
@@ -55,7 +55,7 @@ body { background: #ffffff; color: black; }
Building and Running
- qmake -o Makefile colortool.pro
+ tqmake -o Makefile colortool.pro
.pro files
-Extending the functionality of a form
Subclassing
Generating Source Code from TQt Designer .ui Files
-
SOURCES += main.cpp
-Subclassing a Form
Creating the Subclass
#include "creditformbase.h"
@@ -134,7 +134,7 @@ int main( int argc, char *argv[] )
}
#include <tqapplication.h>
#include "creditform.h"
@@ -154,7 +154,7 @@ int main( int argc, char *argv[] )
HEADERS += creditform.h
SOURCES += creditform.cpp
-Creating Dynamic Dialogs from .ui Files
Creating a Plugin
-Using the Widget Plugin
Setting Up Connections for Applications
@@ -136,7 +136,7 @@ bool createConnections()
Creating Makefiles without qmake
-Creating Makefiles without tqmake
+
@@ -169,7 +169,7 @@ myform.cpp: myform.h myform.ui
myform.h: myform.ui
tquic myform.ui -o myform.h
-Importing Foreign File Formats
diff --git a/doc/html/i18n.html b/doc/html/i18n.html
index bd7ba3bc..518b55ce 100644
--- a/doc/html/i18n.html
+++ b/doc/html/i18n.html
@@ -341,8 +341,8 @@ an example project file (.pro file):
diff --git a/doc/html/integration.html b/doc/html/integration.html
index e395653a..d36ebe4d 100644
--- a/doc/html/integration.html
+++ b/doc/html/integration.html
@@ -128,20 +128,20 @@ existing projects. It can also be started up by using the Ctrl+Shift+D key
combination in Visual Studio.
Using the 'Open TQt Project' button
- Using the 'Write TQt Project' button
- Using the 'Use TQt In Current Project' button
qmake
+
tqmake
-Release Manager
-TQt Project Files
- TRANSLATIONS = tt2_fr.ts \
tt2_nl.ts
diff --git a/doc/html/linguist-manual-4.html b/doc/html/linguist-manual-4.html
index fe06608a..5918e5d6 100644
--- a/doc/html/linguist-manual-4.html
+++ b/doc/html/linguist-manual-4.html
@@ -43,7 +43,7 @@ body { background: #ffffff; color: black; }
TRANSLATIONS = tt2_fr.ts \
tt2_nl.ts
@@ -233,7 +233,7 @@ int main( int argc, char **argv )
Tutorial 1 Screenshot, English version
The first step is to create a project file, tt1.pro, that lists all the source files for the project. The project file can be a qmake project file, or even an ordinary makefile. Any file that contains
+The first step is to create a project file, tt1.pro, that lists all the source files for the project. The project file can be a tqmake project file, or even an ordinary makefile. Any file that contains
SOURCES = main.cpp TRANSLATIONS = tt1_la.ts@@ -283,7 +283,7 @@ int main( int argc, char **argv )
-Tutorial 2 Screenshot, English version
TEMPLATE = app +TEMPLATE = app CONFIG += qt warn_on HEADERS = arrowpad.h \ mainwindow.h @@ -419,7 +419,7 @@ TRANSLATIONS = tt3_pt.ts
mainwindow.h contains the definition of MainWindow;
mainwindow.cpp contains the implementation of MainWindow;
main.cpp contains main();
-tt3.pro is the qmake project file.
+tt3.pro is the tqmake project file.
tt3_pt.ts is the Portuguese message file.
The PrintPanel is defined in printpanel.h.
diff --git a/doc/html/mac-differences.html b/doc/html/mac-differences.html index 62aa0a56..691a7c26 100644 --- a/doc/html/mac-differences.html +++ b/doc/html/mac-differences.html @@ -122,7 +122,7 @@ application bundle (the application directory), then you place these into a directory called Frameworks, a subdirectory of the application bundle.The application finds these dynamic libraries if the libraries have an install name of "@executable_path/../Frameworks/libname.dylib. -
If you use qmake and Makefiles, use the QMAKE_LFFLAGS_SONAME setting: +
If you use tqmake and Makefiles, use the QMAKE_LFFLAGS_SONAME setting:
QMAKE_LFLAGS_SONAME = -Wl,-install_name,@executable_path/../Frameworks/@@ -158,7 +158,7 @@ have not been called yet).
Note that it is not possible to build TQt plugins using Project Builder -or Xcode. Use qmake to configure and +or Xcode. Use tqmake to configure and build plugins.
If you use tmake with TQt 2.x, and now use qmake with TQt 3.x, then the +
If you use tmake with TQt 2.x, and now use tqmake with TQt 3.x, then the cause of the problem is with the project file. In the project file, there is usually line that looks like:
CONFIG = ...
this should be changed to
CONFIG += ... -
so that qmake can look at the configuration that TQt was built with and +
so that tqmake can look at the configuration that TQt was built with and set any relevant preprocessor defines in the makefile.
- qmake -spec macx-pbuilder project.pro + tqmake -spec macx-pbuilder project.pro-
will generate an Xcode project file from project.pro. With qmake +
will generate an Xcode project file from project.pro. With tqmake you do not have to worry about rules for TQt's preprocessors (tqmoc -and tquic) since qmake automatically handles them and ensures that +and tquic) since tqmake automatically handles them and ensures that everything necessary is linked into your application.
TQt does not entirely interact with the development environment (for example plugins to set a file to 'mocable' from within the Xcode diff --git a/doc/html/signalsandslots.html b/doc/html/signalsandslots.html index 8653dd36..9c6c16bf 100644 --- a/doc/html/signalsandslots.html +++ b/doc/html/signalsandslots.html @@ -173,7 +173,7 @@ connection between them initially.
Run the tqmoc on class definitions that contain signals or slots. This produces a C++ source file which should be compiled and linked with the other object files for the application. If you use -qmake, the makefile rules to +tqmake, the makefile rules to automatically invoke the tqmoc will be added to your makefile for you.
You need the MySQL header files and as well as the shared library libmysqlclient.so. Depending on your Linux distribution you need to install a package which is usually called "mysql-devel". -
Tell qmake where to find the MySQL +
Tell tqmake where to find the MySQL header files and shared libraries (here it is assumed that MySQL is installed in /usr/local) and run make:
cd $TQTDIR/plugins/src/sqldrivers/mysql -qmake -o Makefile "INCLUDEPATH+=/usr/local/include" "LIBS+=-L/usr/local/lib -lmysqlclient" mysql.pro +tqmake -o Makefile "INCLUDEPATH+=/usr/local/include" "LIBS+=-L/usr/local/lib -lmysqlclient" mysql.pro make@@ -147,7 +147,7 @@ Build the plugin as follows (here it is assumed that MySQL is installed in C:\MYSQL):
cd %TQTDIR%\plugins\src\sqldrivers\mysql -qmake -o Makefile "INCLUDEPATH+=C:\MYSQL\INCLUDE" "LIBS+=C:\MYSQL\LIB\OPT\LIBMYSQL.LIB" mysql.pro +tqmake -o Makefile "INCLUDEPATH+=C:\MYSQL\INCLUDE" "LIBS+=C:\MYSQL\LIB\OPT\LIBMYSQL.LIB" mysql.pro nmake@@ -189,27 +189,27 @@ Client install.
Tell qmake where to find the Oracle header files and shared +
Tell tqmake where to find the Oracle header files and shared libraries (it is assumed that the variable $ORACLE_HOME points to the directory where Oracle is installed) and run make:
If you are using Oracle 8:
cd $TQTDIR/plugins/src/sqldrivers/oci -qmake -o Makefile "INCLUDEPATH+=$ORACLE_HOME/rdbms/public $ORACLE_HOME/rdbms/demo" "LIBS+=-L$ORACLE_HOME/lib -lclntsh -lwtc8" oci.pro +tqmake -o Makefile "INCLUDEPATH+=$ORACLE_HOME/rdbms/public $ORACLE_HOME/rdbms/demo" "LIBS+=-L$ORACLE_HOME/lib -lclntsh -lwtc8" oci.pro make
For Oracle version 9:
cd $TQTDIR/plugins/src/sqldrivers/oci -qmake -o Makefile "INCLUDEPATH+=$ORACLE_HOME/rdbms/public $ORACLE_HOME/rdbms/demo" "LIBS+=-L$ORACLE_HOME/lib -lclntsh -lwtc9" oci.pro +tqmake -o Makefile "INCLUDEPATH+=$ORACLE_HOME/rdbms/public $ORACLE_HOME/rdbms/demo" "LIBS+=-L$ORACLE_HOME/lib -lclntsh -lwtc9" oci.pro make
For Oracle version 10:
cd $TQTDIR/plugins/src/sqldrivers/oci -qmake -o Makefile "INCLUDEPATH+=$ORACLE_HOME/rdbms/public $ORACLE_HOME/rdbms/demo" "LIBS+=-L$ORACLE_HOME/lib -lclntsh" oci.pro +tqmake -o Makefile "INCLUDEPATH+=$ORACLE_HOME/rdbms/public $ORACLE_HOME/rdbms/demo" "LIBS+=-L$ORACLE_HOME/lib -lclntsh" oci.pro make@@ -230,7 +230,7 @@ installed in C:\oracle): set INCLUDE=%INCLUDE%;c:\oracle\oci\include set LIB=%LIB%;c:\oracle\oci\lib\msvc cd %TQTDIR%\plugins\src\sqldrivers\oci -qmake -o Makefile oci.pro +tqmake -o Makefile oci.pro nmake @@ -283,12 +283,12 @@ will convert all Unicode strings to local 8 bit.
It is recommended that you use unixODBC. You can find the latest version and ODBC drivers at http://www.unixodbc.org. You need the unixODBC header files and shared libraries. -
Tell qmake where to find the unixODBC header files and shared +
Tell tqmake where to find the unixODBC header files and shared libraries (here it is assumed that unixODBC is installed in /usr/local/unixODBC) and run make:
cd $TQTDIR/plugins/src/sqldrivers/odbc -qmake "INCLUDEPATH+=/usr/local/unixODBC/include" "LIBS+=-L/usr/local/unixODBC/lib -lodbc" +tqmake "INCLUDEPATH+=/usr/local/unixODBC/include" "LIBS+=-L/usr/local/unixODBC/lib -lodbc" make@@ -298,7 +298,7 @@ make right directories. You just have to build the plugin as follows:
cd %TQTDIR%\plugins\src\sqldrivers\odbc -qmake -o Makefile odbc.pro +tqmake -o Makefile odbc.pro nmake@@ -347,12 +347,12 @@ distribution and run the configure script. If you've already installed a binary distribution you don't need to build it. The source distribution is needed because the TQPSQL7 plugin relies on a couple of header files that are usually not a part of the binary distribution. -
To make qmake find the PostgreSQL header files and shared -libraries, run qmake the following way (assuming that the +
To make tqmake find the PostgreSQL header files and shared +libraries, run tqmake the following way (assuming that the PostgreSQL sources can be found in /usr/src/psql):
cd $TQTDIR/plugins/src/sqldrivers/psql -qmake -o Makefile "INCLUDEPATH+=/usr/src/psql/src/include /usr/src/psql/src/interfaces/libpq" "LIBS+=-L/usr/lib -lpq" psql.pro +tqmake -o Makefile "INCLUDEPATH+=/usr/src/psql/src/include /usr/src/psql/src/interfaces/libpq" "LIBS+=-L/usr/lib -lpq" psql.pro make@@ -363,7 +363,7 @@ the PostgreSQL documentation. Assuming the PostgreSQL sources resides in C:\psql, build the plugin as follows:
cd %TQTDIR%\plugins\src\sqldrivers\psql -qmake -o Makefile "INCLUDEPATH+=C:\psql\src\include C:\psql\src\interfaces\libpq" psql.pro +tqmake -o Makefile "INCLUDEPATH+=C:\psql\src\include C:\psql\src\interfaces\libpq" psql.pro nmake@@ -388,10 +388,10 @@ Note for Linux users: Get the Open Client RPM from
Regardless of which library you use, the shared object file libsybdb.so is needed. Set the SYBASE environment variable to point to the directory where you installed the client library and -execute qmake: +execute tqmake:
cd $TQTDIR/plugins/src/sqldrivers/tds -qmake -o Makefile "INCLUDEPATH=$SYBASE/include" "LIBS=-L$SYBASE/lib -lsybdb" +tqmake -o Makefile "INCLUDEPATH=$SYBASE/include" "LIBS=-L$SYBASE/lib -lsybdb" make@@ -401,7 +401,7 @@ make Open Client (http://www.sybase.com). You must include NTWDBLIB.LIB to build the plugin:
cd %TQTDIR%\plugins\src\sqldrivers\tds -qmake -o Makefile "LIBS+=NTWDBLIB.LIB" tds.pro +tqmake -o Makefile "LIBS+=NTWDBLIB.LIB" tds.pro nmake@@ -426,7 +426,7 @@ in DB2 (see TQSqlQuery::setForwardOnly<
cd $TQTDIR/plugins/src/sqldrivers/db2 -qmake -o Makefile "INCLUDEPATH+=$DB2DIR/include" "LIBS+=-L$DB2DIR/lib -ldb2" +tqmake -o Makefile "INCLUDEPATH+=$DB2DIR/include" "LIBS+=-L$DB2DIR/lib -ldb2" make@@ -436,7 +436,7 @@ make right directories. You just have to build the plugin as follows:
cd %TQTDIR%\plugins\src\sqldrivers\db2 -qmake -o Makefile "INCLUDEPATH+=<DB2 home>/sqllib/include" "LIBS+=<DB2 home>/sqllib/lib/db2cli.lib" +tqmake -o Makefile "INCLUDEPATH+=<DB2 home>/sqllib/include" "LIBS+=<DB2 home>/sqllib/lib/db2cli.lib" nmake@@ -468,7 +468,7 @@ build it manually (replace $SQLITE by the directory where SQLite resides):
cd $TQTDIR/plugins/src/sqldrivers/sqlite -qmake -o Makefile "INCLUDEPATH+=$SQLITE/include" "LIBS+=-L$SQLITE/lib -lsqlite" +tqmake -o Makefile "INCLUDEPATH+=$SQLITE/include" "LIBS+=-L$SQLITE/lib -lsqlite" make@@ -501,7 +501,7 @@ or the free edition of Interbase. /opt/interbase:
cd $TQTDIR/plugins/src/sqldrivers/ibase -qmake -o Makefile "INCLUDEPATH+=/opt/interbase/include" "LIBS+=-L/opt/interbase/lib" ibase.pro +tqmake -o Makefile "INCLUDEPATH+=/opt/interbase/include" "LIBS+=-L/opt/interbase/lib" ibase.pro make@@ -511,7 +511,7 @@ make C:\interbase:
cd %TQTDIR%\plugins\src\sqldrivers\ibase -qmake -o Makefile "INCLUDEPATH+=C:\interbase\include" ibase.pro +tqmake -o Makefile "INCLUDEPATH+=C:\interbase\include" ibase.pro nmakediff --git a/doc/html/tools-list.html b/doc/html/tools-list.html index 90dcaac8..305f46c0 100644 --- a/doc/html/tools-list.html +++ b/doc/html/tools-list.html @@ -42,7 +42,7 @@ design forms applications to reach international markets
To build the example go to the toplevel directory (TQTDIR/examples/toplevel) (3) -and run qmake to generate the makefile, then use the make tool to +and run tqmake to generate the makefile, then use the make tool to build the library.
This class is not included in the TQt library itself. To use it you must link against libtqassistantclient.a (Unix) or tqassistantclient.lib (Windows), which is built into INSTALL/lib if you built the TQt tools (INSTALL is the directory where TQt is -installed). If you use qmake, then you can simply add the following +installed). If you use tqmake, then you can simply add the following line to your pro file:
LIBS += -ltqassistantclient diff --git a/doc/html/qmake-manual-1.html b/doc/html/tqmake-manual-1.html similarity index 59% rename from doc/html/qmake-manual-1.html rename to doc/html/tqmake-manual-1.html index 32b92148..6c48a7a6 100644 --- a/doc/html/qmake-manual-1.html +++ b/doc/html/tqmake-manual-1.html @@ -2,7 +2,7 @@ -Introduction to qmake +Introduction to tqmake