Rename moc to tqmoc

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
pull/194/head
Michele Calgaro 2 months ago
parent 4161606c30
commit 587657561b
Signed by: MicheleC
GPG Key ID: 2A75B7CA8ADED5CF

@ -26,7 +26,7 @@ the directories where you choose to install Qt.
file if it is not there already.
TQTDIR - the directory in which you're building Qt
PATH - to locate the moc program and other TQt tools
PATH - to locate the tqmoc program and other TQt tools
MANPATH - to access the TQt man pages
LD_LIBRARY_PATH - for the shared TQt library

@ -1,5 +1,5 @@
README Getting started with Qt
INSTALL How to install Qt
README Getting started with TQt
INSTALL How to install TQt
PLATFORMS How to install TQt - platform notes
changes-<ver> List of changes from the last version
LICENSE License statement
@ -7,15 +7,15 @@ MANIFEST This file
Directories:
------------
bin Place for TQt executables (moc, uic, etc.)
config.tests Qt configuration system
doc Qt documentation in HTML and manpage format
examples Qt example programs
include Qt include files
bin Place for TQt executables (tqmoc, tquic, etc.)
config.tests TQt configuration system
doc TQt documentation in HTML and manpage format
examples TQt example programs
include TQt include files
lib Place for the TQt libraries
mkspecs Platform/compiler configuration files
plugins Qt plugins
qmake Qt build system
src Qt library source code
tools Qt tools source code
tutorial Qt tutorial source code
plugins TQt plugins
qmake TQt build system
src TQt library source code
tools TQt tools source code
tutorial TQt tutorial source code

@ -11,7 +11,7 @@ uninstall: FORCE
install: FORCE
@$(MAKE) qt.install
all: symlinks src-qmake src-moc sub-src sub-tools sub-tutorial sub-examples
all: symlinks src-qmake src-tqmoc sub-src sub-tools sub-tutorial sub-examples
@echo
@echo "The TQt library is now built in ./lib"
@echo "The TQt examples are built in the directories in ./examples"
@ -20,23 +20,23 @@ all: symlinks src-qmake src-moc sub-src sub-tools sub-tutorial sub-examples
@echo "Enjoy! - the Trolltech team"
@echo
qt.install: qmake-install moc-install src-install tools-install plugins-install
qt.uninstall: qmake-uninstall moc-uninstall src-uninstall tools-uninstall plugins-uninstall
qt.install: qmake-install tqmoc-install src-install tools-install plugins-install
qt.uninstall: qmake-uninstall tqmoc-uninstall src-uninstall tools-uninstall plugins-uninstall
#moc
moc-uninstall: .qmake.cache
cd src/moc && $(MAKE) uninstall
moc-install: src-moc
cd src/moc && $(MAKE) install
src-moc: src-qmake FORCE
cd src/moc && $(MAKE)
#tqmoc
tqmoc-uninstall: .qmake.cache
cd src/tqmoc && $(MAKE) uninstall
tqmoc-install: src-tqmoc
cd src/tqmoc && $(MAKE) install
src-tqmoc: src-qmake FORCE
cd src/tqmoc && $(MAKE)
#Qt
src-uninstall: .qmake.cache
cd src && $(MAKE) uninstall
src-install: sub-src
cd src && $(MAKE) install
sub-src: src-moc .qmake.cache FORCE
sub-src: src-tqmoc .qmake.cache FORCE
cd src && $(MAKE)
#qmake
@ -80,7 +80,7 @@ symlinks: .qmake.cache
distclean clean uiclean mocclean:
cd tools && $(MAKE) $@
cd src/moc && $(MAKE) $@
cd src/tqmoc && $(MAKE) $@
cd src && $(MAKE) $@
cd tutorial && $(MAKE) $@
cd plugins/src && $(MAKE) $@
@ -93,7 +93,7 @@ distclean clean uiclean mocclean:
[ ! -f config.tests/x11/notype/Makefile ] || cd config.tests/x11/notype && $(MAKE) $@
cd qmake && $(MAKE) $@
#confclean is actually the same as distclean, except qmake and moc
#confclean is actually the same as distclean, except qmake and tqmoc
#are not cleaned.
confclean:
cd tools && $(MAKE) distclean

2
configure vendored

@ -1074,7 +1074,7 @@ QMAKE_VARS="$QMAKE_VARS \"QMAKE_MOC=$outpath/bin/tqmoc\""
QMAKE_VARS="$QMAKE_VARS \"QMAKE_UIC=$outpath/bin/tquic -L \$\$QT_BUILD_TREE/plugins\""
QMAKE_VARS="$QMAKE_VARS \"QMAKE_QMAKE=$outpath/bin/tqmake\""
# hacky src line
QMAKE_VARS="$QMAKE_VARS \"QMAKE_MOC_SRC=$outpath/src/moc\""
QMAKE_VARS="$QMAKE_VARS \"QMAKE_MOC_SRC=$outpath/src/tqmoc\""
# find out which awk we want to use, prefer gawk, then nawk, then regular awk
AWK=

@ -180,7 +180,7 @@ Example:
There is one bug that is so common that it deserves mention here: If
you include the TQ_OBJECT macro in a class declaration and run the
\link moc.html moc\endlink, but forget to link the moc-generated
\link tqmoc.html tqmoc\endlink, but forget to link the tqmoc-generated
object code into your executable, you will get very confusing error
messages. Any link error complaining about a lack of \c{vtbl},
\c{_vtbl}, \c{__vtbl} or similar is likely to be a result of this

@ -54,8 +54,8 @@ machine</a>
<h2> Link error, complaining about a lack of <tt>vtbl</tt>, <tt>_vtbl</tt>, <tt>__vtbl</tt> or similar
</h2>
<a name="1"></a><p> This indicates that you've included the <a href="metaobjects.html#TQ_OBJECT">TQ_OBJECT</a> macro in a class
declaration and probably also run the <a href="moc.html#moc">moc</a>, but forgot to link the
moc-generated object code into your executable. See <a href="moc.html">Using the Meta Object Compiler</a> for details on how to use moc.
declaration and probably also run the <a href="tqmoc.html#tqmoc">tqmoc</a>, but forgot to link the
tqmoc-generated object code into your executable. See <a href="tqmoc.html">Using the TQt Meta Object Compiler</a> for details on how to use tqmoc.
<p> <a name="diffver"></a>
<h2> Using different versions of TQt on the same machine
</h2>
@ -70,12 +70,12 @@ TQt. Those with a command-line compiler will typically use options such as
the relevant release of TQt.
<p> <dt>Meta Object Compiler and other tools - Compile time
<p> <dd>Programmers need to run <em>moc</em> and other tools such as <em>uic</em>. These
<p> <dd>Programmers need to run <em>tqmoc</em> and other tools such as <em>tquic</em>. These
tools are usually located in the <tt>bin</tt> subdirectory of TQt distributions.
Either run <tt>"$TQTDIR"/bin/moc</tt> and <tt>"$TQTDIR"/bin/uic</tt> or add <tt>"$TQTDIR"/bin</tt>
to your <tt>PATH</tt> and run <a href="moc.html#moc">moc</a> and <tt>uic</tt>. If you use <tt>qmake</tt> the
Either run <tt>"$TQTDIR"/bin/tqmoc</tt> and <tt>"$TQTDIR"/bin/tquic</tt> or add <tt>"$TQTDIR"/bin</tt>
to your <tt>PATH</tt> and run <a href="tqmoc.html#tqmoc">tqmoc</a> and <tt>uic</tt>. If you use <tt>qmake</tt> the
appropriate lines will be added to your Makefiles so that <em>uic</em> and
<em>moc</em> will be executed as required.
<em>tqmoc</em> will be executed as required.
<p> <dt>Static or shared libraries - Link time
<p> <dd>Programmers need to link with the TQt static or shared libraries. The TQt
libraries are usually located in the <tt>lib</tt> subdirectory of TQt distributions.
@ -101,7 +101,7 @@ source package that contain all these files once they have been built.
usually consist of two parts:
<p> <ul>
<li> shared libraries in the run time package, usually called <tt>qt3</tt>.
<p> <li> header files, static libraries, the moc and other tools in the developers'
<p> <li> header files, static libraries, tqmoc and other tools in the developers'
kit, usually called <tt>qt3-dev</tt>.
<p> </ul>
<p> Depending on how you are using TQt, you need to make specific parts of
@ -118,7 +118,7 @@ package with a name like <tt>qt</tt> and a developer package with a name
like <tt>qt-dev</tt>. You will need the appropriate packages:
<p> <ul>
<p> <li> To build programs you will need the header files, the libraries,
the moc and other tools from TQt 3.x. They are included in the developer
tqmoc and other tools from TQt 3.x. They are included in the developer
package of TQt 3.x (<tt>qt3-dev</tt> or similar).
<p> <li> To run programs you will need the shared libraries of TQt 3.x and
TQt 2.x. They are included in the regular packages of TQt 3.x (<tt>qt3</tt>
@ -131,7 +131,7 @@ need to set the environment variable <tt>TQTDIR</tt> to point to TQt 3.x.
</h3>
<a name="2-2"></a><p> You build and run programs for TQt 2.x and TQt 3.x. You will need:
<p> <ul>
<p> <li> the header files, the libraries, the moc and other tools from TQt 3.x
<p> <li> the header files, the libraries, tqmoc and other tools from TQt 3.x
and TQt 2.x to build programs,
<p> <li> the shared libraries of TQt 3.x and TQt 2.x to run programs.
<p> </ul>
@ -186,7 +186,7 @@ setenv PATH ${TQTDIR}/bin:${PATH}
documentation appropriate to the version of TQt you're using. Also
your Makfiles may refer to <tt>"$TQTDIR"/include</tt> and <tt>"$TQTDIR"/lib</tt> to
include the proper header files and link with the proper libraries.
Setting the <tt>PATH</tt> ensures that the proper version of moc and other
Setting the <tt>PATH</tt> ensures that the proper version of tqmoc and other
tools is being used.
<p> <a name="nowinman"></a>
<h2> Using TQt on X11 without a window manager

@ -155,7 +155,7 @@ define TQT_NO_CHECK.
</h2>
<a name="4"></a><p> There is one bug that is so common that it deserves mention here: If
you include the <a href="metaobjects.html#TQ_OBJECT">TQ_OBJECT</a> macro in a class declaration and run the
<a href="moc.html">moc</a>, but forget to link the <a href="moc.html#moc">moc</a>-generated
<a href="tqmoc.html">tqmoc</a>, but forget to link the <a href="tqmoc.html#tqmoc">tqmoc</a>-generated
object code into your executable, you will get very confusing error
messages. Any link error complaining about a lack of <tt>vtbl</tt>,
<tt>_vtbl</tt>, <tt>__vtbl</tt> or similar is likely to be a result of this

@ -35,13 +35,13 @@ body { background: #ffffff; color: black; }
<h3><a name="1"></a>Subclassing</h3>
<p>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 <a href="designer-manual-5.html#3">Extending the functionality of a form</a> in <a href="designer-manual-5.html#the-designer-approach">The Designer Approach</a> chapter for details.</p>
<h4><a name="1-1"></a>Generating Source Code from <em>TQt Designer</em> .ui Files</h4>
<p><em>TQt Designer</em> reads and writes <tt>qmake</tt><!-- index .pro --> <tt>.pro</tt> (project) files which are used to record the files used to build the application and from which Makefiles are generated. <em>TQt Designer</em> also reads and writes<!-- index .ui --> <tt>.ui</tt> (user interface) files. These are XML files that record the widgets, layouts, source code and settings you've used for a form. Every<!-- index .ui --> <tt>.ui</tt> file is converted by the <tt>uic</tt> (user interface compiler) into a C++<!-- index .h --> <tt>.h</tt> file and a C++<!-- index .cpp --> <tt>.cpp</tt> file. These C++ files are then read by <tt>moc</tt> (meta object compiler), and finally compiled by your compiler into a working application.</p>
<p><em>TQt Designer</em> reads and writes <tt>qmake</tt><!-- index .pro --> <tt>.pro</tt> (project) files which are used to record the files used to build the application and from which Makefiles are generated. <em>TQt Designer</em> also reads and writes<!-- index .ui --> <tt>.ui</tt> (user interface) files. These are XML files that record the widgets, layouts, source code and settings you've used for a form. Every<!-- index .ui --> <tt>.ui</tt> file is converted by the <tt>uic</tt> (user interface compiler) into a C++<!-- index .h --> <tt>.h</tt> file and a C++<!-- index .cpp --> <tt>.cpp</tt> file. These C++ files are then read by <tt>tqmoc</tt> (meta object compiler), and finally compiled by your compiler into a working application.</p>
<!-- index Makefiles --><!-- index Projects!Adding Files --><!-- index Adding!Files to Projects --><p>If you create applications wholly within <em>TQt Designer</em> you only need to create a<!-- index main.cpp --> <tt>main.cpp</tt>.</p>
<p>If you create the <tt>main.cpp</tt> file within <em>TQt Designer</em>, it will automatically be added to your project file by <em>TQt Designer</em>. If you create the <tt>main.cpp</tt> file outside of <em>TQt Designer</em> you must add it to the project file manually by adding the following line at the end of your project's<!-- index .pro --> <tt>.pro</tt> file:</p>
<pre>
SOURCES += main.cpp
</pre>
<p>You can then use <tt>qmake</tt> to generate the Makefile. (For example <tt>qmake -o Makefile myproject.pro</tt>.) Running <tt>make</tt> (Linux, Unix or Borland compilers), or <tt>nmake</tt> (Visual C++), will then call <tt>uic</tt>, <tt>moc</tt> and your compiler as necessary to build your application.</p>
<p>You can then use <tt>qmake</tt> to generate the Makefile. (For example <tt>qmake -o Makefile myproject.pro</tt>.) Running <tt>make</tt> (Linux, Unix or Borland compilers), or <tt>nmake</tt> (Visual C++), will then call <tt>tquic</tt>, <tt>tqmoc</tt> and your compiler as necessary to build your application.</p>
<!-- index Errors!Undefined reference --><!-- index Undefined references, Error --><!-- index qmake!HEADERS --><!-- index qmake!SOURCES --><p>If you use <em>TQt Designer</em> 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<!-- index .pro --> <tt>.pro</tt> file so that they are compiled with the rest of your application's source files. Each<!-- index .h --> <tt>.h</tt> file that you create separately from <em>TQt Designer</em> should be added to the <tt>HEADERS</tt> line, and each<!-- index .cpp --> <tt>.cpp</tt> file should be added to the <tt>SOURCES</tt> line, just as we've done for<!-- index main.cpp --> <tt>main.cpp</tt>. 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<!-- index .pro --> <tt>.pro</tt> file.</p>
<h4><a name="1-2"></a>Subclassing a Form</h4>
<!-- index Subclassing --><p>When subclassing a form it is helpful to use a naming convention to help us identify which files are generated from <em>TQt Designer</em>'s<!-- index .ui --> <tt>.ui</tt> files and which are hand coded.</p>

@ -105,13 +105,13 @@ body { background: #ffffff; color: black; }
<li><p>Open TQt Project -- Runs <tt>qmake</tt> with a<!-- index .pro --> <tt>.pro</tt> file</p>
<li><p>Write TQt Project -- Saves the current VS project as a<!-- index .pro --> <tt>.pro</tt> file</p>
<li><p>Use TQt -- Add the TQt libraries to the active project</p>
<li><p>Add MOC -- Add the <tt>moc</tt> precompiler to the active file</p>
<li><p>Add TQMoc -- Add <tt>tqmoc</tt> precompiler to the active file</p>
</ul><p>Double clicking a<!-- index .ui --> <tt>.ui</tt> file in the workspace overview will now launch <em>TQt Designer</em>.</p>
<!-- index Macros!TQ_OBJECT --><!-- index TQ_OBJECT --><p>If you create a<!-- index .cpp --> <tt>.cpp</tt> file which contains the <tt>TQ_OBJECT</tt> macro you will need an additional file which is generated by the <tt>moc</tt> to be included in your project. For example, if you have 'file.cpp', then the last line would be <tt>#include "file.moc"</tt> and the additional file would be called 'file.moc'. To ensure that Visual Studio executes the <tt>moc</tt> and generates this file you must create a custom dependency. Double click the<!-- index .cpp --> <tt>.cpp</tt> file (in your project workspace) that contains the <tt>TQ_OBJECT</tt> macro. Click the <b>Add MOC</b> toolbar button; this will create an empty<!-- index .moc --> <tt>.moc</tt> file in your project workspace. Right click the newly created<!-- index .moc --> <tt>.moc</tt> file, then click <b>Settings</b> from the pop-up menu to invoke the Project Settings dialog. Click the Custom Build tab. Click the <b>Dependencies</b> button to pop up the User Defined Dependencies dialog. Type in <tt>$(InputDir)\$(InputPath)</tt>, then press <b>Return</b>. Click <b>OK</b> to leave the Dependencies dialog, then click <b>OK</b> to leave the Project Settings dialog.</p>
<!-- index Macros!TQ_OBJECT --><!-- index TQ_OBJECT --><p>If you create a<!-- index .cpp --> <tt>.cpp</tt> file which contains the <tt>TQ_OBJECT</tt> macro you will need an additional file which is generated by <tt>tqmoc</tt> to be included in your project. For example, if you have 'file.cpp', then the last line would be <tt>#include "file.moc"</tt> and the additional file would be called 'file.moc'. To ensure that Visual Studio executes the <tt>tqmoc</tt> and generates this file you must create a custom dependency. Double click the<!-- index .cpp --> <tt>.cpp</tt> file (in your project workspace) that contains the <tt>TQ_OBJECT</tt> macro. Click the <b>Add TQMoc</b> toolbar button; this will create an empty<!-- index .moc --> <tt>.moc</tt> file in your project workspace. Right click the newly created<!-- index .moc --> <tt>.moc</tt> file, then click <b>Settings</b> from the pop-up menu to invoke the Project Settings dialog. Click the Custom Build tab. Click the <b>Dependencies</b> button to pop up the User Defined Dependencies dialog. Type in <tt>$(InputDir)\$(InputPath)</tt>, then press <b>Return</b>. Click <b>OK</b> to leave the Dependencies dialog, then click <b>OK</b> to leave the Project Settings dialog.</p>
<p>If you wish to delete the add-in remove it from the toolbar then delete the<!-- index qmsdev.dll --> <tt>qmsdev.dll</tt> file from the add-ins directory.</p>
<h4><a name="3-1"></a>Creating Makefiles without qmake</h4>
<!-- index Makefiles --><p>The <tt>qmake</tt> tool provided with TQt can create Makefiles appropriate to your platform based on<!-- index .pro --> <tt>.pro</tt> 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.</p>
<!-- index Macros!TQ_OBJECT --><!-- index TQ_OBJECT --><p><em>TQt Designer</em> produces<!-- index .ui --> <tt>.ui</tt> files which are used to generate<!-- index .h --> <tt>.h</tt> and<!-- index .cpp --> <tt>.cpp</tt> files for the compiler to compile. The<!-- index .ui --> <tt>.ui</tt> files are processed by <tt>uic</tt>. Classes which inherit from <a href="tqobject.html">TQObject</a>, e.g. those which use slots and signals, require an additional<!-- index .cpp --> <tt>.cpp</tt> file to be generated. These files are generated by the <tt>moc</tt> and are named '<em>moc_</em>file.cpp' where the original<!-- index .cpp --> <tt>.cpp</tt> file is called 'file.cpp'. If your<!-- index .cpp --> <tt>.cpp</tt> file contains the <tt>TQ_OBJECT</tt> macro an additional file 'file.moc' should be generated which must be <tt>#include</tt>d in the<!-- index .cpp --> <tt>.cpp</tt>, normally at the end. This requires an extra dependency being created.</p>
<!-- index Macros!TQ_OBJECT --><!-- index TQ_OBJECT --><p><em>TQt Designer</em> produces<!-- index .ui --> <tt>.ui</tt> files which are used to generate<!-- index .h --> <tt>.h</tt> and<!-- index .cpp --> <tt>.cpp</tt> files for the compiler to compile. The<!-- index .ui --> <tt>.ui</tt> files are processed by <tt>uic</tt>. Classes which inherit from <a href="tqobject.html">TQObject</a>, e.g. those which use slots and signals, require an additional<!-- index .cpp --> <tt>.cpp</tt> file to be generated. These files are generated by <tt>tqmoc</tt> and are named '<em>tqmoc_</em>file.cpp' where the original<!-- index .cpp --> <tt>.cpp</tt> file is called 'file.cpp'. If your<!-- index .cpp --> <tt>.cpp</tt> file contains the <tt>TQ_OBJECT</tt> macro an additional file 'file.moc' should be generated which must be <tt>#include</tt>d in the<!-- index .cpp --> <tt>.cpp</tt>, normally at the end. This requires an extra dependency being created.</p>
<p>Processing<!-- index .ui --> <tt>.ui</tt> files with <tt>uic</tt> is done <em>twice</em>:</p>
<pre>
uic myform.ui -o myform.h
@ -125,23 +125,23 @@ uic -subdecl Form formbase.h formbase.ui -o form.h
uic -subimpl Form form.h formbase.ui -o form.cpp
</pre>
<p>First we generate the header and implementation file for our base class. Then we generate the header and implementation skeletons for our subclass. Note that the use of <tt>uic</tt> to generate skeletons is not something that would be done in a Makefile, we mention it here because it can be useful for command line users. Note also that the command line for <tt>-subdecl</tt> and for <tt>-subimpl</tt> are subtly different.</p>
<p>For implementation files that contain classes which inherit from <a href="tqobject.html">TQObject</a> we must create moc files:</p>
<p>For implementation files that contain classes which inherit from <a href="tqobject.html">TQObject</a> we must create tqmoc files:</p>
<pre>
moc myform.h -o moc_myform.cpp
tqmoc myform.h -o tqmoc_myform.cpp
</pre>
<p>We'll look at a simple Makefile to see the dependencies in practice.</p>
<pre>
myapp: moc_myform.o myform.o main.o
g++ -lqt -o myapp moc_myform.o myform.o main.o
myapp: tqmoc_myform.o myform.o main.o
g++ -lqt -o myapp tqmoc_myform.o myform.o main.o
main.o: main.cpp
g++ -o main.o main.cpp
moc_myform.o: moc_myform.cpp
g++ -o moc_myform.o moc_myform.cpp
tqmoc_myform.o: tqmoc_myform.cpp
g++ -o tqmoc_myform.o tqmoc_myform.cpp
moc_myform.cpp: myform.h
moc myform.h -o moc_myform.cpp
tqmoc_myform.cpp: myform.h
tqmoc myform.h -o tqmoc_myform.cpp
myform.o: myform.cpp
g++ -o myform.o myform.cpp
@ -152,17 +152,17 @@ myform.cpp: myform.h myform.ui
myform.h: myform.ui
uic myform.ui -o myform.h
</pre>
<p>Note that you may need to include the full path to the commands in your Makefile, and under Windows the filenames are<!-- index moc.exe --> <tt>moc.exe</tt> and<!-- index uic.exe --> <tt>uic.exe</tt>.</p>
<p>Note that you may need to include the full path to the commands in your Makefile, and under Windows the filenames are<!-- index tqmoc.exe --> <tt>tqmoc.exe</tt> and<!-- index uic.exe --> <tt>uic.exe</tt>.</p>
<p>In Unix/Linux environments the <tt>make</tt> command may be able to do more for us, so we should be able to use a simpler Makefile like this:</p>
<pre>
myapp: moc_myform.o myform.o main.o
myapp: tqmoc_myform.o myform.o main.o
g++ -lq -o $@ $^
%.o: %.cpp
g++ -o $^ $@
moc_%.cpp: %.h
moc $^ -o $@
tqmoc_%.cpp: %.h
tqmoc $^ -o $@
myform.cpp: myform.h myform.ui
uic myform.ui -i myform.h -o myform.cpp

@ -476,7 +476,7 @@ and use the make tool to build the library.
<hr>
<ol> <li><a name="footnote1"></a>
Note that <a href="moc.html#moc">moc</a> requires that <a href="tqobject.html">TQObject</a>
Note that <a href="tqmoc.html#tqmoc">tqmoc</a> requires that <a href="tqobject.html">TQObject</a>
is the first base class. <a href="#footnote-call1">Back...</a> <li><a name="footnote2"></a>
Note that we have to explicitly scope the orientation

@ -7808,7 +7808,7 @@
"Tutorial #2" tutorial2.html
"User Interface Compiler (uic)" uic.html
"Using menus" menu-example.html
"Using the Meta Object Compiler" moc.html
"Using the Meta Object Compiler" tqmoc.html
"Walkthrough: A Simple Application" simple-application.html
"Walkthrough: How to use the TQt SAX2 classes" xml-sax-walkthrough.html
"Walkthrough: Using SAX2 features with the TQt XML classes" xml-sax-features-walkthrough.html

@ -54,7 +54,7 @@ depending on your shell) in your home directory. Create the
file if it is not there already.
<p> <ul>
<li> TQTDIR -- the directory in which you're building TQt
<li> PATH -- to locate the <a href="moc.html#moc">moc</a> program and other TQt tools
<li> PATH -- to locate the <a href="tqmoc.html#tqmoc">tqmoc</a> program and other TQt tools
<li> MANPATH -- to access the TQt man pages
<li> LD_LIBRARY_PATH -- for the shared TQt library
</ul>

@ -55,7 +55,7 @@ depending on your shell) in your home directory. Create the
file if it is not there already.
<p> <ul>
<li> TQTDIR -- the directory in which you're building TQt
<li> PATH -- to locate the <a href="moc.html#moc">moc</a> program and other TQt tools
<li> PATH -- to locate the <a href="tqmoc.html#tqmoc">tqmoc</a> program and other TQt tools
<li> MANPATH -- to access the TQt man pages
<li> LD_LIBRARY_PATH -- for the shared TQt library
</ul>

@ -57,7 +57,7 @@ TQt application.
</a>
<li><a href="#3-6"> Using the 'Use TQt In Current Project' button
</a>
<li><a href="#3-7"> Using the 'Add MOC' button
<li><a href="#3-7"> Using the 'Add TQMoc' button
</a>
</ul>
</ul>
@ -96,7 +96,7 @@ following steps.
<li> Open TQt Project
<li> Write TQt Project
<li> Use TQt In Current Project
<li> Add MOC
<li> Add TQMoc
</ul>
<p> <h3> Using the 'New TQt Project' button
</h3>
@ -148,10 +148,10 @@ name your <tt>qmake</tt> project file and click Save.
<a name="3-6"></a><p> The 'Use TQt In Current Project' button simply adds in the necessary
information for the current project so that it links against TQt and
sets any other settings needed to use TQt in that project.
<p> <h3> Using the 'Add MOC' button
<p> <h3> Using the 'Add TQMoc' button
</h3>
<a name="3-7"></a><p> The 'Add MOC' button will add in the custom build step for the selected file
so that it creates any needed MOC files and it will add these generated
<a name="3-7"></a><p> The 'Add TQMoc' button will add in the custom build step for the selected file
so that it creates any needed moc files and it will add these generated
files to the project. All you need to do to use it is click on a file that
has <a href="metaobjects.html#TQ_OBJECT">TQ_OBJECT</a> and click the button.
<p> You only need to use this button if you added a file that has <a href="metaobjects.html#TQ_OBJECT">TQ_OBJECT</a> in it by hand, you don't need to use this if you used any

@ -42,9 +42,9 @@ property system.
<li> the <a href="tqobject.html">TQObject</a> class;
<li> the TQ_OBJECT macro inside the private section of the class
declaration;
<li> the <a href="moc.html">Meta Object Compiler (moc)</a>.
<li> the <a href="tqmoc.html">TQt Meta Object Compiler (tqmoc)</a>.
</ol>
<p> The <em><a href="moc.html#moc">moc</a></em> reads a C++ source file. If it finds one or more class
<p> The <em><a href="tqmoc.html#tqmoc">tqmoc</a></em> reads a C++ source file. If it finds one or more class
declarations that contain the TQ_OBJECT macro, it produces another C++
source file which contains the meta object code for the classes that
contain the TQ_OBJECT macro. This generated source file is either

@ -61,7 +61,7 @@ pointers which become "dangling pointers" when their objects are destroyed.
techniques, based on inheritance from <a href="tqobject.html">TQObject</a>. Others, like the
object communication mechanism and the dynamic property system,
require the <a href="metaobjects.html">Meta Object System</a> provided
by TQt's own <a href="moc.html">Meta Object Compiler (moc)</a>.
by TQt's own <a href="tqmoc.html">Meta Object Compiler (tqmoc)</a>.
<p> The Meta Object System is a C++ extension that makes the language
better suited to true component GUI programming. Although templates can
be used to extend C++, the Meta Object System provides benefits using

@ -45,7 +45,7 @@ body { background: #ffffff; color: black; }
<li> <a href="signalsandslots.html">Signals and Slots</a>
<li> <a href="metaobjects.html">Meta Object System</a>
<li> <a href="properties.html">Properties</a>
<li> <a href="moc.html">Using the Meta Object Compiler</a>
<li> <a href="tqmoc.html">Using the Meta Object Compiler</a>
<li> <a href="templates.html">Why doesn't TQt use templates for signals and slots?</a>
</ul>
<p> <td valign="top">

@ -34,7 +34,7 @@ body { background: #ffffff; color: black; }
<h3><a name="1"></a>Introduction to qmake</h3>
<p><em>qmake</em> is a tool created by Trolltech to write makefiles for different compilers and platforms.</p>
<p>Writing makefiles by hand can be difficult and error prone, especially if several makefiles are required for different compiler and platform combinations. With <em>qmake</em>, developers create a simple single 'project' file and run <em>qmake</em> to generate the appropriate makefiles. <em>qmake</em> takes care of all the compiler and platform dependencies, freeing developers to focus on their code. Trolltech uses <em>qmake</em> as the primary build tool for the TQt library, and for the tools supplied with TQt.</p>
<p><em>qmake</em> also takes care of TQt's special requirements, automatically including build rules for <a href="moc.html">moc</a> and <em>uic</em>.</p>
<p><em>qmake</em> also takes care of TQt's special requirements, automatically including build rules for <a href="tqmoc.html">tqmoc</a> and <em>tquic</em>.</p>
<!-- eof -->
<p align="right">[<a href="qmake-manual.html">Home</a>] [<a href="qmake-manual-2.html">Next: Installing qmake</a>]</p>
<p><address><hr><div align=center>

@ -64,7 +64,7 @@ body { background: #ffffff; color: black; }
<pre>
TARGET = helloworld
</pre>
<p>The final step is to set the <em>CONFIG</em> variable. Since this is a TQt application, we need to put 'qt' on the CONFIG line so that <em>qmake</em> will add the relevant libraries to be linked against and ensure that build lines for <em>moc</em> and <em>uic</em> are included in the makefile.</p>
<p>The final step is to set the <em>CONFIG</em> variable. Since this is a TQt application, we need to put 'qt' on the CONFIG line so that <em>qmake</em> will add the relevant libraries to be linked against and ensure that build lines for <em>tqmoc</em> and <em>tquic</em> are included in the makefile.</p>
<p>The finished project file should look like this:</p>
<pre>
CONFIG += qt

@ -141,7 +141,7 @@ DEFINES += USE_MY_STUFF QT_DLL
<p>Specifies where to copy the <a href="qmake-manual-8.html#TARGET">target</a> dll.</p>
<a name="HEADERS"></a><h5><a name="4-1-6"></a>HEADERS</h5>
<p>Defines the header files for the project.</p>
<p><em>qmake</em> will generate dependency information (unless -nodepend is specified on the <a href="qmake-manual-8.html#Commands">command line</a>) for the specified headers. <em>qmake</em> will also automatically detect if <em>moc</em> is required by the classes in these headers, and add the appropriate dependencies and files to the project for generating and linking the moc files.</p>
<p><em>qmake</em> will generate dependency information (unless -nodepend is specified on the <a href="qmake-manual-8.html#Commands">command line</a>) for the specified headers. <em>qmake</em> will also automatically detect if <em>tqmoc</em> is required by the classes in these headers, and add the appropriate dependencies and files to the project for generating and linking the tqmoc files.</p>
<p>For example:</p>
<pre>
HEADERS = myclass.h \
@ -178,7 +178,7 @@ unix:LIBS += -lmath -L/usr/local/lib
win32:LIBS += c:\mylibs\math.lib
</pre>
<a name="MOC_DIR"></a><h5><a name="4-1-11"></a>MOC_DIR</h5>
<p>This variable specifies the directory where all intermediate moc files should be placed.</p>
<p>This variable specifies the directory where all intermediate tqmoc files should be placed.</p>
<p>For example:</p>
<pre>
unix:MOC_DIR = ../myproject/tmp
@ -271,7 +271,7 @@ DISTFILES += ../program.txt
<p>This variable contains a list of yacc source files to be included in the project. All dependencies, headers and source files will automatically be included in the project.</p>
<p>For example:</p>
<pre>
YACCSOURCES = moc.y
YACCSOURCES = tqmoc.y
</pre>
<a name="RarelyUsedSystemVariables"></a><h4><a name="4-2"></a>Rarely Used System Variables</h4>
<p>The following variables are also recognized by <em>qmake</em> but are either internal or very rarely used.</p>
@ -299,11 +299,11 @@ message($$join(urlPieces, $$LITERAL_HASH))
<a name="OBJECTS"></a><h5><a name="4-2-8"></a>OBJECTS</h5>
<p>This variable is generated from the <a href="qmake-manual-8.html#SOURCES">SOURCES</a> variable. The extension of each source file will have been replaced by .o (Unix) or .obj (Win32). The value of this variable is typically handled by <em>qmake</em> or <a href="qmake-manual-8.html#QMAKESPEC">qmake.conf</a> and rarely needs to be modified.</p>
<a name="OBJMOC"></a><h5><a name="4-2-9"></a>OBJMOC</h5>
<p>This variable is set by <em>qmake</em> if files can be found that contain the TQ_OBJECT macro. <tt>OBJMOC</tt> contains the name of all intermediate moc object files. The value of this variable is typically handled by <em>qmake</em> or <a href="qmake-manual-8.html#QMAKESPEC">qmake.conf</a> and rarely needs to be modified.</p>
<p>This variable is set by <em>qmake</em> if files can be found that contain the TQ_OBJECT macro. <tt>OBJMOC</tt> contains the name of all intermediate tqmoc object files. The value of this variable is typically handled by <em>qmake</em> or <a href="qmake-manual-8.html#QMAKESPEC">qmake.conf</a> and rarely needs to be modified.</p>
<a name="PRECOMPILED_HEADER"></a><h5><a name="4-2-10"></a>PRECOMPILED_HEADER</h5>
<p>This variable indicates the header file for creating a precompiled header file, to increase the compilation speed of a project. Precompiled headers are currently only supported on some platforms (Windows - all MSVC project types, Mac OS X - Xcode, Makefile, UNIX - gcc 3.3 and up).</p>
<p>On other platforms, this variable has different meaning, as noted below.</p>
<p>This variable contains a list of header files that require some sort of pre-compilation step (such as with moc). The value of this variable is typically handled by <em>qmake</em> or <a href="qmake-manual-8.html#QMAKESPEC">qmake.conf</a> and rarely needs to be modified.</p>
<p>This variable contains a list of header files that require some sort of pre-compilation step (such as with tqmoc). The value of this variable is typically handled by <em>qmake</em> or <a href="qmake-manual-8.html#QMAKESPEC">qmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE"></a><h5><a name="4-2-11"></a>QMAKE</h5>
<p>This variable contains the name of the <em>qmake</em> program itself and is placed in generated makefiles. The value of this variable is typically handled by <em>qmake</em> or <a href="qmake-manual-8.html#QMAKESPEC">qmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKESPEC_systemvariable"></a><h5><a name="4-2-12"></a>QMAKESPEC</h5>
@ -344,7 +344,7 @@ app {
<a name="QMAKE_CFLAGS_WARN_ON"></a><h5><a name="4-2-25"></a>QMAKE_CFLAGS_WARN_ON</h5>
<p>This variable is not empty if the warn_on <a href="qmake-manual-8.html#TEMPLATE">TEMPLATE</a> option is specified. The value of this variable is typically handled by <em>qmake</em> or <a href="qmake-manual-8.html#QMAKESPEC">qmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_CLEAN"></a><h5><a name="4-2-26"></a>QMAKE_CLEAN</h5>
<p>This variable contains any files which are not generated files (such as moc and uic generated files) and object files that should be removed when using "make clean".</p>
<p>This variable contains any files which are not generated files (such as tqmoc and tquic generated files) and object files that should be removed when using "make clean".</p>
<a name="QMAKE_CXXFLAGS_DEBUG"></a><h5><a name="4-2-27"></a>QMAKE_CXXFLAGS_DEBUG</h5>
<p>This variable contains the C++ compiler flags for creating a debuggable application. The value of this variable is typically handled by <em>qmake</em> or <a href="qmake-manual-8.html#QMAKESPEC">qmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_CXXFLAGS_MT"></a><h5><a name="4-2-28"></a>QMAKE_CXXFLAGS_MT</h5>
@ -484,7 +484,7 @@ app {
<h5><a name="4-2-85"></a>QMAKE_MAKEFILE</h5>
<p>This variable contains the name of the makefile to create. The value of this variable is typically handled by <em>qmake</em> or <a href="qmake-manual-8.html#QMAKESPEC">qmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-86"></a>QMAKE_MOC_SRC</h5>
<p>This variable contains the names of all moc source files to generate and include in the project. The value of this variable is typically handled by <em>qmake</em> or <a href="qmake-manual-8.html#QMAKESPEC">qmake.conf</a> and rarely needs to be modified.</p>
<p>This variable contains the names of all tqmoc source files to generate and include in the project. The value of this variable is typically handled by <em>qmake</em> or <a href="qmake-manual-8.html#QMAKESPEC">qmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-87"></a>QMAKE_QMAKE</h5>
<p>This variable contains the location of qmake if it is not in the path. The value of this variable is typically handled by <em>qmake</em> or <a href="qmake-manual-8.html#QMAKESPEC">qmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-88"></a>QMAKE_QT_DLL</h5>
@ -510,7 +510,7 @@ app {
<h5><a name="4-2-96"></a>RES_FILE</h5>
<p>This variable contains the name of the resource file for the application. The value of this variable is typically handled by <em>qmake</em> or <a href="qmake-manual-8.html#QMAKESPEC">qmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-97"></a>SRCMOC</h5>
<p>This variable is set by <em>qmake</em> if files can be found that contain the TQ_OBJECT macro. <tt>SRCMOC</tt> contains the name of all the generated moc files. The value of this variable is typically handled by <em>qmake</em> or <a href="qmake-manual-8.html#QMAKESPEC">qmake.conf</a> and rarely needs to be modified.</p>
<p>This variable is set by <em>qmake</em> if files can be found that contain the TQ_OBJECT macro. <tt>SRCMOC</tt> contains the name of all the generated tqmoc files. The value of this variable is typically handled by <em>qmake</em> or <a href="qmake-manual-8.html#QMAKESPEC">qmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-98"></a>TARGET_EXT</h5>
<p>This variable specifies the target's extension. The value of this variable is typically handled by <em>qmake</em> or <a href="qmake-manual-8.html#QMAKESPEC">qmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-99"></a>TARGET_x</h5>
@ -528,7 +528,7 @@ app {
<h5><a name="4-2-105"></a>VER_PAT</h5>
<p>This variable contains the patch version number of the library, if the 'lib' <a href="qmake-manual-8.html#TEMPLATE">template</a> is specified.</p>
<h5><a name="4-2-106"></a>QMAKE_EXT_MOC</h5>
<p>This variable changes the extention used on included moc files.</p>
<p>This variable changes the extention used on included tqmoc files.</p>
<p>See also <a href="qmake-manual-8.html#Extensions">File Extensions</a>.</p>
<h5><a name="4-2-107"></a>QMAKE_EXT_UI</h5>
<p>This variable changes the extention used on /e Designer UI files.</p>
@ -714,8 +714,8 @@ QMAKE_EXTRA_UNIX_TARGETS += mytarget mytarget2
<p>This is all you need to do to actually build custom targets in qmake, of course you may want to tie one of these targets to actually building the <a href="qmake-manual-8.html#TARGET">qmake build target</a>. To do this, you simply need to include your Makefile target in the list of <a href="qmake-manual-8.html#PRE_TARGETDEPS">PRE_TARGETDEPS</a>.</p>
<p>For convenience there is also a method of customizing (UNIX) projects for generic new compilers (or even preprocessors).</p>
<pre>
new_moc.output = moc_${QMAKE_FILE_BASE}.cpp
new_moc.commands = moc ${QMAKE_FILE_NAME} -o ${QMAKE_FILE_OUT}
new_moc.output = tqmoc_${QMAKE_FILE_BASE}.cpp
new_moc.commands = tqmoc ${QMAKE_FILE_NAME} -o ${QMAKE_FILE_OUT}
new_moc.depends = g++ -E -M ${QMAKE_FILE_NAME} | sed "s,^.*: ,,"
new_moc.input = NEW_HEADERS
QMAKE_EXTRA_UNIX_COMPILERS += new_moc

@ -9802,8 +9802,8 @@
<section ref="menu-example.html" title="Using menus">
<keyword ref="menu-example.html">Using menus</keyword>
</section>
<section ref="moc.html" title="Using the Meta Object Compiler">
<keyword ref="moc.html">Using the Meta Object Compiler</keyword>
<section ref="tqmoc.html" title="Using the Meta Object Compiler">
<keyword ref="tqmoc.html">Using the Meta Object Compiler</keyword>
</section>
<section ref="simple-application.html" title="Walkthrough: A Simple Application">
<keyword ref="simple-application.html">Walkthrough: A Simple Application</keyword>

@ -118,8 +118,8 @@ the qmake tool. For example:
</pre>
<p> will generate an Xcode project file from project.pro. With qmake
you do not have to worry about rules for TQt's preprocessors (moc
and uic) since qmake automatically handles them and ensures that
you do not have to worry about rules for TQt's preprocessors (tqmoc
and tquic) since qmake automatically handles them and ensures that
everything necessary is linked into your application.
<p> TQt does not entirely interact with the development environment (for
example plugins to set a file to 'mocable' from within the Xcode

@ -171,11 +171,11 @@ about each other, as long as there is someone around to set up a
connection between them initially.
<p> The preprocessor changes or removes the <tt>signals</tt>, <tt>slots</tt> and
<tt>emit</tt> keywords so that the compiler is presented with standard C++.
<p> Run the <a href="moc.html">moc</a> on class definitions that contain
<p> Run the <a href="tqmoc.html">tqmoc</a> 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
<a href="qmake-manual.html">qmake</a>, the makefile rules to
automatically invoke the <a href="moc.html">moc</a> will be added to
automatically invoke the <a href="tqmoc.html">tqmoc</a> will be added to
your makefile for you.
<p> <h2> Signals
</h2>
@ -197,7 +197,7 @@ mechanism is totally independent of any GUI event loop. The
<p> If several slots are connected to one signal, the slots will be
executed one after the other, in an arbitrary order, when the signal
is emitted.
<p> Signals are automatically generated by the <a href="moc.html">moc</a>
<p> Signals are automatically generated by the <a href="tqmoc.html">tqmoc</a>
and must not be implemented in the <tt>.cpp</tt> file. They can never have
return types (i.e. use <tt>void</tt>).
<p> A note about arguments. Our experience shows that signals and slots
@ -254,7 +254,7 @@ the signals and slots mechanism is well worth the overhead, which your
users won't even notice.
<p> <h2> Meta Object Information
</h2>
<a name="4"></a><p> The <a href="metaobjects.html#meta-object">meta object</a> compiler (<a href="moc.html"><a href="moc.html#moc">moc</a></a>) parses the class
<a name="4"></a><p> The <a href="metaobjects.html#meta-object">meta object</a> compiler (<a href="tqmoc.html"><a href="tqmoc.html#tqmoc">tqmoc</a></a>) parses the class
declaration in a C++ file and generates C++ code that initializes the
meta object. The meta object contains the names of all the signal and
slot members, as well as pointers to these functions. (For more
@ -287,21 +287,21 @@ declarations.
</pre>
<p> TQ_OBJECT is expanded by the preprocessor to declare several member
functions that are implemented by the moc; if you get compiler errors
functions that are implemented by tqmoc; if you get compiler errors
along the lines of "virtual function TQButton::className not defined"
you have probably forgotten to <a href="moc.html">run the moc</a> or to
include the moc output in the link command.
you have probably forgotten to <a href="tqmoc.html">run tqmoc</a> or to
include tqmoc output in the link command.
<p> <pre>
public:
<a href="tqlcdnumber.html">TQLCDNumber</a>( <a href="tqwidget.html">TQWidget</a> *parent=0, const char *name=0 );
TQLCDNumber( uint numDigits, TQWidget *parent=0, const char *name=0 );
</pre>
<p> It's not obviously relevant to the moc, but if you inherit TQWidget you
<p> It's not obviously relevant to tqmoc, but if you inherit TQWidget you
almost certainly want to have the <em>parent</em> and <em>name</em>
arguments in your constructors, and pass them to the parent
constructor.
<p> Some destructors and member functions are omitted here; the moc
<p> Some destructors and member functions are omitted here; tqmoc
ignores member functions.
<p> <pre>
signals:

@ -59,15 +59,15 @@ the signals are protected in the sense of protected C++ member
functions. This helps programmers get their design right from the very
beginning, without even having to think about design patterns.
<p> <h3>2. Precompilers are good</h3>
<p> TQt's <tt><a href="moc.html#moc">moc</a></tt> (Meta Object Compiler) provides a clean way to go
<p> TQt's <tt><a href="tqmoc.html#tqmoc">tqmoc</a></tt> (Meta Object Compiler) provides a clean way to go
beyond the compiled language's facilities. It does so by generating
additional C++ code which can be compiled by any standard C++ compiler.
The <tt>moc</tt> reads C++ source files. If it finds one or more class
<tt>TQMoc</tt> reads C++ source files. If it finds one or more class
declarations that contain the "TQ_OBJECT" macro, it produces another C++
source file which contains the meta object code for those classes. The
C++ source file generated by the <tt>moc</tt> must be compiled and
C++ source file generated by <tt>tqmoc</tt> must be compiled and
linked with the implementation of the class (or it can be
<tt>#included</tt> into the class's source file). Typically <tt>moc</tt>
<tt>#included</tt> into the class's source file). Typically <tt>tqmoc</tt>
is not called manually, but automatically by the build system, so it
requires no additional effort by the programmer.
<p> There are other precompilers, for example, <tt>rpc</tt> and
@ -94,7 +94,7 @@ object model is a clear disadvantage over the dynamic messaging approach
of Objective C when it comes to component-based graphical user interface
programming. What's good for a high end database server or an operating
system isn't necessarily the right design choice for a GUI frontend.
With <tt>moc</tt>, we have turned this disadvantage into an advantage,
With <tt>tqmoc</tt>, we have turned this disadvantage into an advantage,
and added the flexibility required to meet the challenge of safe and
efficient graphical user interface programming.
<p> Our approach goes far beyond anything you can do with templates. For
@ -146,7 +146,7 @@ to use a signal to indicate that the requested data arrived. But if you
need to send out every single byte one by one to a consumer, use a
listener interface rather than signals and slots.
<p> <h3>5. No limits</h3>
<p> Because we had the <tt>moc</tt> for signals and slots, we could add
<p> Because we had <tt>tqmoc</tt> for signals and slots, we could add
other useful things to it that could not not be done with templates.
Among these are scoped translations via a generated <tt>tr()</tt>
function, and an advanced property system with introspection and
@ -154,7 +154,7 @@ extended runtime type information. The property system alone is a great
advantage: a powerful and generic user interface design tool like TQt
Designer would be a lot harder to write - if not impossible - without a
powerful and introspective property system.
<p> C++ with the <tt>moc</tt> preprocessor essentially gives us the
<p> C++ with <tt>tqmoc</tt> preprocessor essentially gives us the
flexibility of Objective-C or of a Java Runtime Environment, while
maintaining C++'s unique performance and scalability advantages. It is
what makes TQt the flexible and comfortable tool we have today.

@ -1003,7 +1003,7 @@ Transformed Graphics Demo | xform-example.html
Tutorial #2 | tutorial2.html
User Interface Compiler (uic) | uic.html
Using menus | menu-example.html
Using the Meta Object Compiler | moc.html
Using the Meta Object Compiler | tqmoc.html
Walkthrough: A Simple Application | simple-application.html
Walkthrough: How to use the TQt SAX2 classes | xml-sax-walkthrough.html
Walkthrough: Using SAX2 features with the TQt XML classes | xml-sax-features-walkthrough.html

@ -46,7 +46,7 @@ help you need
<li> <a href="qmake-manual.html">qmake</a> - create Makefiles from
simple platform-independent project files
<li> <a href="qembed.html">qembed</a> - convert data, e.g. images, into C++ code
<li> <a href="moc.html">moc</a> - the Meta Object Compiler
<li> <a href="tqmoc.html">tqmoc</a> - the Meta Object Compiler
<li> <a href="uic.html">uic</a> - the User Interface Compiler
<li> <tt>qtconfig</tt> - a Unix-based TQt configuration tool with online help
<p> </ul>

@ -78,7 +78,7 @@ class's properties.
<p> Classes may have a list of name-value pairs of class information.
The number of pairs is returned by <a href="#numClassInfo">numClassInfo</a>(), and values are
returned by <a href="#classInfo">classInfo</a>().
<p> <p>See also <a href="moc.html">moc (Meta Object Compiler)</a> and <a href="objectmodel.html">Object Model</a>.
<p> <p>See also <a href="tqmoc.html">tqmoc (Meta Object Compiler)</a> and <a href="objectmodel.html">Object Model</a>.
<p>
<hr><h2>Member Function Documentation</h2>

@ -1,5 +1,4 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<!-- /home/espenr/tmp/qt-3.3.8-espenr-2499/qt-x11-free-3.3.8/doc/moc.doc:39 -->
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
@ -33,26 +32,26 @@ body { background: #ffffff; color: black; }
<p> <!-- index moc --><a name="moc"></a>
<p> The Meta Object Compiler, moc among friends, is the program which
<p> <!-- index tqmoc --><a name="tqmoc"></a>
<p> The TQt Meta Object Compiler, tqmoc among friends, is the program which
handles TQt's <a href="metaobjects.html">C++ extensions.</a>
<p> The moc reads a C++ source file. If it finds one or more class
<p> TQMoc reads a C++ source file. If it finds one or more class
declarations that contain the <a href="metaobjects.html#TQ_OBJECT">TQ_OBJECT</a> macro, it produces another
C++ source file which contains the <a href="metaobjects.html#meta-object">meta object</a> code for the classes
that use the TQ_OBJECT macro. Among other things, meta object code is
required for the signal/slot mechanism, runtime type information and
the dynamic property system.
<p> The C++ source file generated by the moc must be compiled and linked
<p> The C++ source file generated by tqmoc must be compiled and linked
with the implementation of the class (or it can be #included into the
class's source file).
<p> If you use <a href="qmake-manual.html">qmake</a> to create your
Makefiles, build rules will be included that call the moc when
required, so you will not need to use the moc directly. For more
background information on moc, see <a href="templates.html">Why doesn't TQt
Makefiles, build rules will be included that call tqmoc when
required, so you will not need to use tqmoc directly. For more
background information on tqmoc, see <a href="templates.html">Why doesn't TQt
use templates for signals and slots?</a>.
<p> <h2> Usage
</h2>
<a name="1"></a><p> The moc is typically used with an input file containing class declarations
<a name="1"></a><p> TQMoc is typically used with an input file containing class declarations
like this:
<p> <pre>
class MyClass : public <a href="tqobject.html">TQObject</a>
@ -71,7 +70,7 @@ like this:
};
</pre>
<p> In addition to the signals and slots shown above, the moc also
<p> In addition to the signals and slots shown above, tqmoc also
implements object properties as in the next example. The TQ_PROPERTY
macro declares an object property, while TQ_ENUMS declares a list of
enumeration types within the class to be usable inside the
@ -113,7 +112,7 @@ attach additional name/value-pairs to the class' meta object:
<p> The three concepts, signals and slots, properties and class
meta-data, can be combined.
<p> The output produced by the moc must be compiled and linked, just like
<p> The output produced by tqmoc must be compiled and linked, just like
the other C++ code in your program; otherwise the build will fail in
the final link phase. By convention, this is done in one of the
following two ways:
@ -121,16 +120,16 @@ following two ways:
<p> <dt><b>Method A: The class declaration is found in a header
(<em>.h</em>) file</b>
<p> <dd>If the class declaration above is found in the file
<em>myclass.h</em>, the moc output should be put in a file called
<em>moc_myclass.cpp</em>. This file should then be compiled as
usual, resulting in an object file <em>moc_myclass.o</em> (on Unix)
or <em>moc_myclass.obj</em> (on Windows). This object should then be
<em>myclass.h</em>, tqmoc output should be put in a file called
<em>tqmoc_myclass.cpp</em>. This file should then be compiled as
usual, resulting in an object file <em>tqmoc_myclass.o</em> (on Unix)
or <em>tqmoc_myclass.obj</em> (on Windows). This object should then be
included in the list of object files that are linked together in the
final building phase of the program.
<p> <dt><b>Method B: The class declaration is found in an implementation
(<em>.cpp</em>) file</b>
<p> <dd>If the class declaration above is found in the file
<em>myclass.cpp</em>, the moc output should be put in a file called
<em>myclass.cpp</em>, tqmoc output should be put in a file called
<em>myclass.moc</em>. This file should be #included in the
implementation file, i.e. <em>myclass.cpp</em> should contain the
line
@ -138,7 +137,7 @@ line
#include "myclass.moc"
</pre>
at the end. This will cause the moc-generated code to be compiled and
at the end. This will cause the tqmoc-generated code to be compiled and
linked together with the normal class definition in <em>myclass.cpp</em>, so
it is not necessary to compile and link it separately, as in Method A.
<p> </dl>
@ -146,35 +145,35 @@ it is not necessary to compile and link it separately, as in Method A.
want the implementation file to be self-contained, or in cases where
the TQ_OBJECT class is implementation-internal and thus should not be
visible in the header file.
<p> <h2> Automating moc Usage with Makefiles
<p> <h2> Automating tqmoc Usage with Makefiles
</h2>
<a name="2"></a><p> For anything but the simplest test programs, it is recommended that
you automate running the moc. By adding some rules to your program's
Makefile, <em>make</em> can take care of running moc when necessary and
handling the moc output.
you automate running tqmoc. By adding some rules to your program's
Makefile, <em>make</em> can take care of running tqmoc when necessary and
handling tqmoc output.
<p> We recommend using Trolltech's free makefile generation tool, <a href="qmake-manual.html">qmake</a>, for building your Makefiles. This tool
recognizes both Method A and B style source files, and generates a
Makefile that does all the necessary moc handling.
Makefile that does all the necessary tqmoc handling.
<p> If you want to create your Makefiles yourself, here are some tips on
how to include moc handling.
how to include tqmoc handling.
<p> For TQ_OBJECT class declarations in header files, here is a useful
makefile rule if you only use GNU make:
<p> <pre>
moc_%.cpp: %.h
moc $&lt; -o $@
tqmoc_%.cpp: %.h
tqmoc $&lt; -o $@
</pre>
<p> If you want to write portably, you can use individual rules with the
following form:
<p> <pre>
moc_NAME.cpp: NAME.h
moc $&lt; -o $@
tqmoc_NAME.cpp: NAME.h
tqmoc $&lt; -o $@
</pre>
<p> You must also remember to add <em>moc_NAME.cpp</em> to your SOURCES
(substitute your favorite name) variable and <em>moc_NAME.o</em> or
<em>moc_NAME.obj</em> to your OBJECTS variable.
<p> (While we prefer to name our C++ source files .cpp, the moc doesn't
<p> You must also remember to add <em>tqmoc_NAME.cpp</em> to your SOURCES
(substitute your favorite name) variable and <em>tqmoc_NAME.o</em> or
<em>tqmoc_NAME.obj</em> to your OBJECTS variable.
<p> (While we prefer to name our C++ source files .cpp, tqmoc doesn't
care, so you can use .C, .cc, .CC, .cxx or even .c++ if you
prefer.)
<p> For TQ_OBJECT class declarations in implementation (.cpp) files, we
@ -183,10 +182,10 @@ suggest a makefile rule like this:
NAME.o: NAME.moc
NAME.moc: NAME.cpp
moc -i $&lt; -o $@
tqmoc -i $&lt; -o $@
</pre>
<p> This guarantees that make will run the moc before it compiles
<p> This guarantees that make will run tqmoc before it compiles
<em>NAME.cpp</em>. You can then put
<p> <pre>
#include "NAME.moc"
@ -194,9 +193,9 @@ suggest a makefile rule like this:
<p> at the end of <em>NAME.cpp</em>, where all the classes declared in
that file are fully known.
<p> <h2> Invoking moc
<p> <h2> Invoking tqmoc
</h2>
<a name="3"></a><p> Here are the command-line options supported by the moc:
<a name="3"></a><p> Here are the command-line options supported by tqmoc:
<p> <center><table cellpadding="4" cellspacing="2" border="0">
<tr bgcolor="#a2c511"> <th valign="top">Option <th valign="top">Meaning
<tr bgcolor="#f0f0f0">
@ -211,7 +210,7 @@ standard naming conventions.
<tr bgcolor="#f0f0f0">
<td valign="top">-i
<td valign="top">Do not generate an #include statement in the output.
This may be used to run the moc on on a C++ file containing one or
This may be used to run tqmoc on on a C++ file containing one or
more class declarations. You should then #include the meta object
code in the .cpp
file. If both -i and -f are present, the last one wins.
@ -223,35 +222,35 @@ file. If both -i and -f are present, the last one wins.
<td valign="top">Write a flood of lex debug information to stdout.
<tr bgcolor="#d0d0d0">
<td valign="top">-p <em>path</em>
<td valign="top">Makes the moc prepend <em>path</em>/ to
<td valign="top">Makes tqmoc prepend <em>path</em>/ to
the file name in the generated #include statement (if one is
generated).
<tr bgcolor="#f0f0f0">
<td valign="top">-q <em>path</em>
<td valign="top">Makes the moc prepend <em>path</em>/ to
<td valign="top">Makes tqmoc prepend <em>path</em>/ to
the file name of qt #include files in the generated code.
</table></center>
<p> You can explicitly tell the moc not to parse parts of a header
<p> You can explicitly tell tqmoc not to parse parts of a header
file. It recognizes any C++ comment (//) that contains the substrings
MOC_SKIP_BEGIN or MOC_SKIP_END. They work as you would expect and you
can have several levels of them. The net result as seen by the moc is
can have several levels of them. The net result as seen by tqmoc is
as if you had removed all lines between a MOC_SKIP_BEGIN and a
MOC_SKIP_END.
<p> <h2> Diagnostics
</h2>
<a name="4"></a><p> The moc will warn you about a number of dangerous or illegal
<a name="4"></a><p> TQMoc will warn you about a number of dangerous or illegal
constructs in the TQ_OBJECT class declarations.
<p> If you get linkage errors in the final building phase of your
program, saying that YourClass::className() is undefined or that
YourClass lacks a vtbl, something has been done wrong. Most often,
you have forgotten to compile or #include the moc-generated C++ code, or
you have forgotten to compile or #include the tqmoc-generated C++ code, or
(in the former case) include that object file in the link command.
<p> <h2> Limitations
</h2>
<a name="5"></a><p> The moc does not expand #include or #define, it simply skips any
<a name="5"></a><p> TQMoc does not expand #include or #define, it simply skips any
preprocessor directives it encounters. This is regrettable, but is
not usually a problem in practice.
<p> The moc does not handle all of C++. The main problem is that class
<p> TQMoc does not handle all of C++. The main problem is that class
templates cannot have signals or slots. Here is an example:
<p> <pre>
class SomeTemplate&lt;int&gt; : public <a href="tqframe.html">TQFrame</a> {
@ -267,7 +266,7 @@ have alternatives which we think are usually better, so removing these
limitations is not a high priority for us.
<p> <h3> Multiple inheritance requires <a href="tqobject.html">TQObject</a> to be first
</h3>
<a name="5-1"></a><p> If you are using multiple inheritance, moc assumes that the <em>first</em>
<a name="5-1"></a><p> If you are using multiple inheritance, tqmoc assumes that the <em>first</em>
inherited class is a subclass of TQObject. Also, be sure that <em>only</em>
the first inherited class is a TQObject.
<p> <pre>
@ -276,7 +275,7 @@ the first inherited class is a TQObject.
};
</pre>
<p> (This limitation is almost impossible to remove; since the moc does not expand
<p> (This limitation is almost impossible to remove; since tqmoc does not expand
#include or #define, it cannot find out which one of the base classes
is a TQObject.)
<p> <h3> Function pointers cannot be arguments to signals or slots
@ -347,7 +346,7 @@ function which is overloaded?
<p>
<p> <h3> Type macros cannot be used for signal and slot parameters
</h3>
<a name="5-5"></a><p> Since the moc does not expand #define, type macros that take an argument
<a name="5-5"></a><p> Since tqmoc does not expand #define, type macros that take an argument
will not work in signals and slots. Here is an illegal example:
<p> <pre>
#ifdef ultrix
@ -408,7 +407,7 @@ contains the respective get and set functions
</h3>
<a name="5-8"></a><p> Declaring the first property within or after the public section that
contains the type definition and the respective get and set functions
does not work as expected. The moc will complain that it can neither
does not work as expected. TQMoc will complain that it can neither
find the functions nor resolve the type. Here is an example of the
illegal syntax:
<p> <pre>

@ -149,7 +149,7 @@ to catch child events.
TQt; see <a href="tqtimer.html">TQTimer</a> for high-level support for timers.
<p> Notice that the <a href="metaobjects.html#TQ_OBJECT">TQ_OBJECT</a> macro is mandatory for any object that
implements signals, slots or properties. You also need to run the
<a href="moc.html">moc program (Meta Object Compiler)</a> on the
<a href="tqmoc.html">tqmoc program (Meta Object Compiler)</a> on the
source file. We strongly recommend the use of this macro in <em>all</em>
subclasses of TQObject regardless of whether or not they actually
use signals, slots and properties, since failure to do so may lead

@ -544,7 +544,7 @@ int main( int argc, char **argv )
return a.<a href="ntqapplication.html#exec">exec</a>();
}
#include "xform.moc" // include metadata generated by the <a href="moc.html#moc">moc</a>
#include "xform.moc" // include metadata generated by the <a href="tqmoc.html#tqmoc">tqmoc</a>
</pre>
<p>See also <a href="examples.html">Examples</a>.

@ -1,6 +1,6 @@
/****************************************************************************
**
** Explanation of moc and the meta object system
** Explanation of tqmoc and the meta object system
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**

@ -83,7 +83,7 @@ where you choose to install Qt.
\list
\i TQTDIR -- the directory in which you're building Qt
\i PATH -- to locate the moc program and other TQt tools
\i PATH -- to locate the tqmoc program and other TQt tools
\i MANPATH -- to access the TQt man pages
\i LD_LIBRARY_PATH -- for the shared TQt library
\endlist
@ -210,7 +210,7 @@ the directories where you choose to install Qt.
\list
\i TQTDIR -- the directory in which you're building Qt
\i PATH -- to locate the moc program and other TQt tools
\i PATH -- to locate the tqmoc program and other TQt tools
\i MANPATH -- to access the TQt man pages
\i LD_LIBRARY_PATH -- for the shared TQt library
\endlist

@ -86,7 +86,7 @@
\i Open TQt Project
\i Write TQt Project
\i Use TQt In Current Project
\i Add MOC
\i Add TQMoc
\endlist
\section2 Using the 'New TQt Project' button
@ -149,10 +149,10 @@
information for the current project so that it links against TQt and
sets any other settings needed to use TQt in that project.
\section2 Using the 'Add MOC' button
\section2 Using the 'Add TQMoc' button
The 'Add MOC' button will add in the custom build step for the selected file
so that it creates any needed MOC files and it will add these generated
The 'Add TQMoc' button will add in the custom build step for the selected file
so that it creates any needed moc files and it will add these generated
files to the project. All you need to do to use it is click on a file that
has \c TQ_OBJECT and click the button.

@ -1,6 +1,6 @@
.TH tqmoc 1 "24 June 2001" "Trolltech AS" \" -*- nroff -*-
.\"
.\" $Id: qt/moc.1 3.3.8 edited Jan 11 14:38 $
.\" $Id: qt/tqmoc.1 3.3.8 edited Jan 11 14:38 $
.\"
.\" Copyright (C) 1992-2007 Trolltech ASA. All rights reserved.
.\"

@ -80,7 +80,7 @@ property() and propertyNames() to obtain information about a class's properties.
.PP
Classes may have a list of name-value pairs of class information. The number of pairs is returned by numClassInfo(), and values are returned by classInfo().
.PP
See also moc (Meta Object Compiler) and Object Model.
See also tqmoc (Meta Object Compiler) and Object Model.
.PP
.SH MEMBER FUNCTION DOCUMENTATION
.SH "const QClassInfo * TQMetaObject::classInfo ( int index, bool super = FALSE ) const"

@ -209,7 +209,7 @@ TQObjects can receive events through event() and filter the events of other obje
.PP
Last but not least, TQObject provides the basic timer support in Qt; see TQTimer for high-level support for timers.
.PP
Notice that the TQ_OBJECT macro is mandatory for any object that implements signals, slots or properties. You also need to run the moc program (Meta Object Compiler) on the source file. We strongly recommend the use of this macro in \fIall\fR subclasses of TQObject regardless of whether or not they actually use signals, slots and properties, since failure to do so may lead certain functions to exhibit undefined behaviour.
Notice that the TQ_OBJECT macro is mandatory for any object that implements signals, slots or properties. You also need to run the tqmoc program (Meta Object Compiler) on the source file. We strongly recommend the use of this macro in \fIall\fR subclasses of TQObject regardless of whether or not they actually use signals, slots and properties, since failure to do so may lead certain functions to exhibit undefined behaviour.
.PP
All TQt widgets inherit TQObject. The convenience function isWidgetType() returns whether an object is actually a widget. It is much faster than inherits( "TQWidget" ).
.PP

@ -1,6 +1,6 @@
/****************************************************************************
**
** Explanation of moc and the meta object system
** Explanation of tqmoc and the meta object system
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
@ -53,10 +53,10 @@ The Meta Object System is based on three things:
\i the \l TQObject class;
\i the TQ_OBJECT macro inside the private section of the class
declaration;
\i the \link moc.html Meta Object Compiler (moc)\endlink.
\i the \link tqmoc.html Meta Object Compiler (tqmoc)\endlink.
\endlist
The \e moc reads a C++ source file. If it finds one or more class
\e TQMoc reads a C++ source file. If it finds one or more class
declarations that contain the TQ_OBJECT macro, it produces another C++
source file which contains the meta object code for the classes that
contain the TQ_OBJECT macro. This generated source file is either

@ -66,9 +66,9 @@ machine\endlink
\section1 Link error, complaining about a lack of \c vtbl, \c _vtbl, \c __vtbl or similar
This indicates that you've included the TQ_OBJECT macro in a class
declaration and probably also run the moc, but forgot to link the
moc-generated object code into your executable. See \link moc.html
Using the Meta Object Compiler\endlink for details on how to use moc.
declaration and probably also run tqmoc, but forgot to link the
moc-generated object code into your executable. See \link tqmoc.html
Using the Meta Object Compiler\endlink for details on how to use tqmoc.
\target diffver
\section1 Using different versions of TQt on the same machine
@ -88,12 +88,12 @@ the relevant release of Qt.
<dt>Meta Object Compiler and other tools - Compile time
<dd>Programmers need to run \e moc and other tools such as \e uic. These
<dd>Programmers need to run \e tqmoc and other tools such as \e uic. These
tools are usually located in the \c bin subdirectory of TQt distributions.
Either run \c "$TQTDIR"/bin/moc and \c "$TQTDIR"/bin/uic or add \c "$TQTDIR"/bin
to your \c PATH and run \c moc and \c uic. If you use \c qmake the
Either run \c "$TQTDIR"/bin/tqmoc and \c "$TQTDIR"/bin/tquic or add \c "$TQTDIR"/bin
to your \c PATH and run \c tqmoc and \c tquic. If you use \c qmake the
appropriate lines will be added to your Makefiles so that \e uic and
\e moc will be executed as required.
\e tqmoc will be executed as required.
<dt>Static or shared libraries - Link time
@ -128,7 +128,7 @@ usually consist of two parts:
\list
\i shared libraries in the run time package, usually called \c qt3.
\i header files, static libraries, the moc and other tools in the developers'
\i header files, static libraries, tqmoc and other tools in the developers'
kit, usually called \c qt3-dev.
\endlist
@ -150,7 +150,7 @@ like \c qt-dev. You will need the appropriate packages:
\list
\i To build programs you will need the header files, the libraries,
the moc and other tools from TQt 3.x. They are included in the developer
tqmoc and other tools from TQt 3.x. They are included in the developer
package of TQt 3.x (\c qt3-dev or similar).
\i To run programs you will need the shared libraries of TQt 3.x and
@ -169,7 +169,7 @@ You build and run programs for TQt 2.x and TQt 3.x. You will need:
\list
\i the header files, the libraries, the moc and other tools from TQt 3.x
\i the header files, the libraries, tqmoc and other tools from TQt 3.x
and TQt 2.x to build programs,
\i the shared libraries of TQt 3.x and TQt 2.x to run programs.
@ -234,7 +234,7 @@ Setting \c TQTDIR ensures that the proper resources are used, such as the
documentation appropriate to the version of TQt you're using. Also
your Makfiles may refer to \c "$TQTDIR"/include and \c "$TQTDIR"/lib to
include the proper header files and link with the proper libraries.
Setting the \c PATH ensures that the proper version of moc and other
Setting the \c PATH ensures that the proper version of tqmoc and other
tools is being used.
\target nowinman

@ -72,7 +72,7 @@ Many of these TQt features are implemented with standard C++
techniques, based on inheritance from \l TQObject. Others, like the
object communication mechanism and the dynamic property system,
require the \link metaobjects.html Meta Object System \endlink provided
by Qt's own \link moc.html Meta Object Compiler (moc) \endlink.
by TQt's own \link tqmoc.html Meta Object Compiler (tqmoc) \endlink.
The Meta Object System is a C++ extension that makes the language
better suited to true component GUI programming. Although templates can
@ -646,15 +646,15 @@ beginning, without even having to think about design patterns.
<h3>2. Precompilers are good</h3>
Qt's <tt>moc</tt> (Meta Object Compiler) provides a clean way to go
TQt's <tt>tqmoc</tt> (Meta Object Compiler) provides a clean way to go
beyond the compiled language's facilities. It does so by generating
additional C++ code which can be compiled by any standard C++ compiler.
The <tt>moc</tt> reads C++ source files. If it finds one or more class
<tt>TQMoc</tt> reads C++ source files. If it finds one or more class
declarations that contain the "TQ_OBJECT" macro, it produces another C++
source file which contains the meta object code for those classes. The
C++ source file generated by the <tt>moc</tt> must be compiled and
C++ source file generated by <tt>tqmoc</tt> must be compiled and
linked with the implementation of the class (or it can be
<tt>#included</tt> into the class's source file). Typically <tt>moc</tt>
<tt>#included</tt> into the class's source file). Typically <tt>tqmoc</tt>
is not called manually, but automatically by the build system, so it
requires no additional effort by the programmer.
@ -686,7 +686,7 @@ object model is a clear disadvantage over the dynamic messaging approach
of Objective C when it comes to component-based graphical user interface
programming. What's good for a high end database server or an operating
system isn't necessarily the right design choice for a GUI frontend.
With <tt>moc</tt>, we have turned this disadvantage into an advantage,
With <tt>tqmoc</tt>, we have turned this disadvantage into an advantage,
and added the flexibility required to meet the challenge of safe and
efficient graphical user interface programming.
@ -746,7 +746,7 @@ listener interface rather than signals and slots.
<h3>5. No limits</h3>
Because we had the <tt>moc</tt> for signals and slots, we could add
Because we had <tt>tqmoc</tt> for signals and slots, we could add
other useful things to it that could not not be done with templates.
Among these are scoped translations via a generated <tt>tr()</tt>
function, and an advanced property system with introspection and
@ -755,7 +755,7 @@ advantage: a powerful and generic user interface design tool like Qt
Designer would be a lot harder to write - if not impossible - without a
powerful and introspective property system.
C++ with the <tt>moc</tt> preprocessor essentially gives us the
C++ with <tt>tqmoc</tt> preprocessor essentially gives us the
flexibility of Objective-C or of a Java Runtime Environment, while
maintaining C++'s unique performance and scalability advantages. It is
what makes TQt the flexible and comfortable tool we have today.

@ -55,7 +55,7 @@
\i \link signalsandslots.html Signals and Slots \endlink
\i \link metaobjects.html Meta Object System \endlink
\i \link properties.html Properties \endlink
\i \link moc.html Using the Meta Object Compiler \endlink
\i \link tqmoc.html Using the Meta Object Compiler \endlink
\i \link templates.html Why doesn't TQt use templates for signals and slots? \endlink
\endlist

@ -148,8 +148,8 @@ it can interact with specific components of the Mac OS X experience:
\endcode
will generate an Xcode project file from project.pro. With qmake
you do not have to worry about rules for Qt's preprocessors (moc
and uic) since qmake automatically handles them and ensures that
you do not have to worry about rules for TQt's preprocessors (tqmoc
and tquic) since qmake automatically handles them and ensures that
everything necessary is linked into your application.
TQt does not entirely interact with the development environment (for

@ -1,6 +1,6 @@
/****************************************************************************
**
** Explanation of moc and the meta object system
** Explanation of tqmoc and the meta object system
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
@ -202,11 +202,11 @@ connection between them initially.
The preprocessor changes or removes the \c{signals}, \c{slots} and
\c{emit} keywords so that the compiler is presented with standard C++.
Run the \link moc.html moc\endlink on class definitions that contain
Run the \link tqmoc.html tqmoc\endlink 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
\link qmake-manual.book qmake\endlink, the makefile rules to
automatically invoke the \link moc.html moc\endlink will be added to
automatically invoke the \link tqmoc.html tqmoc\endlink will be added to
your makefile for you.
\section1 Signals
@ -233,7 +233,7 @@ If several slots are connected to one signal, the slots will be
executed one after the other, in an arbitrary order, when the signal
is emitted.
Signals are automatically generated by the \link moc.html moc\endlink
Signals are automatically generated by the \link tqmoc.html tqmoc\endlink
and must not be implemented in the \c .cpp file. They can never have
return types (i.e. use \c void).
@ -301,7 +301,7 @@ users won't even notice.
\section1 Meta Object Information
The meta object compiler (\link moc.html moc\endlink) parses the class
The meta object compiler (\link tqmoc.html tqmoc\endlink) parses the class
declaration in a C++ file and generates C++ code that initializes the
meta object. The meta object contains the names of all the signal and
slot members, as well as pointers to these functions. (For more
@ -339,10 +339,10 @@ declarations.
\endcode
TQ_OBJECT is expanded by the preprocessor to declare several member
functions that are implemented by the moc; if you get compiler errors
functions that are implemented by tqmoc; if you get compiler errors
along the lines of "virtual function TQButton::className not defined"
you have probably forgotten to \link moc.html run the moc\endlink or to
include the moc output in the link command.
you have probably forgotten to \link tqmoc.html run tqmoc\endlink or to
include tqmoc output in the link command.
\code
public:
@ -350,12 +350,12 @@ include the moc output in the link command.
TQLCDNumber( uint numDigits, TQWidget *parent=0, const char *name=0 );
\endcode
It's not obviously relevant to the moc, but if you inherit TQWidget you
It's not obviously relevant to tqmoc, but if you inherit TQWidget you
almost certainly want to have the \e{parent} and \e{name}
arguments in your constructors, and pass them to the parent
constructor.
Some destructors and member functions are omitted here; the moc
Some destructors and member functions are omitted here; tqmoc
ignores member functions.
\code

@ -16,8 +16,8 @@
\i \link qmake-manual.book qmake \endlink - create Makefiles from
simple platform-independent project files
\i \link qembed.html qembed\endlink - convert data, e.g. images, into C++ code
\i \link moc.html moc\endlink - the Meta Object Compiler
\i \link uic.html uic\endlink - the User Interface Compiler
\i \link tqmoc.html tqmoc\endlink - the Meta Object Compiler
\i \link tquic.html tquic\endlink - the User Interface Compiler
\i \c qtconfig - a Unix-based TQt configuration tool with online help
\endlist

@ -1,6 +1,6 @@
/****************************************************************************
**
** Moc usage, expanded from the manual page
** TQMoc usage, expanded from the manual page
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
@ -36,39 +36,39 @@
**
**********************************************************************/
// Note: Text in this file must also be copied to the moc man page:
// src/moc/moc.1
// Note: Text in this file must also be copied to the tqmoc man page:
// src/tqmoc/tqmoc.1
/*!
\page moc.html
\page tqmoc.html
\title Using the Meta Object Compiler
\keyword moc
\keyword tqmoc
The Meta Object Compiler, moc among friends, is the program which
handles Qt's \link metaobjects.html C++ extensions.\endlink
The Meta Object Compiler, tqmoc among friends, is the program which
handles TQt's \link metaobjects.html C++ extensions.\endlink
The moc reads a C++ source file. If it finds one or more class
TQMoc reads a C++ source file. If it finds one or more class
declarations that contain the TQ_OBJECT macro, it produces another
C++ source file which contains the meta object code for the classes
that use the TQ_OBJECT macro. Among other things, meta object code is
required for the signal/slot mechanism, runtime type information and
the dynamic property system.
The C++ source file generated by the moc must be compiled and linked
The C++ source file generated by tqmoc must be compiled and linked
with the implementation of the class (or it can be #included into the
class's source file).
If you use \link qmake-manual.book qmake\endlink to create your
Makefiles, build rules will be included that call the moc when
required, so you will not need to use the moc directly. For more
background information on moc, see \link templates.html Why doesn't Qt
Makefiles, build rules will be included that call tqmoc when
required, so you will not need to use tqmoc directly. For more
background information on tqmoc, see \link templates.html Why doesn't Qt
use templates for signals and slots?\endlink.
\section1 Usage
The moc is typically used with an input file containing class declarations
TQMoc is typically used with an input file containing class declarations
like this:
\code
@ -88,7 +88,7 @@ like this:
};
\endcode
In addition to the signals and slots shown above, the moc also
In addition to the signals and slots shown above, tqmoc also
implements object properties as in the next example. The TQ_PROPERTY
macro declares an object property, while TQ_ENUMS declares a list of
enumeration types within the class to be usable inside the
@ -133,7 +133,7 @@ attach additional name/value-pairs to the class' meta object:
The three concepts, signals and slots, properties and class
meta-data, can be combined.
The output produced by the moc must be compiled and linked, just like
The output produced by tqmoc must be compiled and linked, just like
the other C++ code in your program; otherwise the build will fail in
the final link phase. By convention, this is done in one of the
following two ways:
@ -144,10 +144,10 @@ following two ways:
(\e .h) file</b>
<dd>If the class declaration above is found in the file
\e myclass.h, the moc output should be put in a file called
\e moc_myclass.cpp. This file should then be compiled as
usual, resulting in an object file \e moc_myclass.o (on Unix)
or \e moc_myclass.obj (on Windows). This object should then be
\e myclass.h, tqmoc output should be put in a file called
\e tqmoc_myclass.cpp. This file should then be compiled as
usual, resulting in an object file \e tqmoc_myclass.o (on Unix)
or \e tqmoc_myclass.obj (on Windows). This object should then be
included in the list of object files that are linked together in the
final building phase of the program.
@ -156,14 +156,14 @@ final building phase of the program.
(\e .cpp) file</b>
<dd>If the class declaration above is found in the file
\e myclass.cpp, the moc output should be put in a file called
\e myclass.cpp, tqmoc output should be put in a file called
\e myclass.moc. This file should be #included in the
implementation file, i.e. \e myclass.cpp should contain the
line
\code
#include "myclass.moc"
\endcode
at the end. This will cause the moc-generated code to be compiled and
at the end. This will cause the tqmoc-generated code to be compiled and
linked together with the normal class definition in \e myclass.cpp, so
it is not necessary to compile and link it separately, as in Method A.
@ -175,42 +175,42 @@ the TQ_OBJECT class is implementation-internal and thus should not be
visible in the header file.
\section1 Automating moc Usage with Makefiles
\section1 Automating tqmoc Usage with Makefiles
For anything but the simplest test programs, it is recommended that
you automate running the moc. By adding some rules to your program's
Makefile, \e make can take care of running moc when necessary and
handling the moc output.
you automate running the tqmoc. By adding some rules to your program's
Makefile, \e make can take care of running tqmoc when necessary and
handling tqmoc output.
We recommend using Trolltech's free makefile generation tool, \link
qmake-manual.book qmake\endlink, for building your Makefiles. This tool
recognizes both Method A and B style source files, and generates a
Makefile that does all the necessary moc handling.
Makefile that does all the necessary tqmoc handling.
If you want to create your Makefiles yourself, here are some tips on
how to include moc handling.
how to include tqmoc handling.
For TQ_OBJECT class declarations in header files, here is a useful
makefile rule if you only use GNU make:
\code
moc_%.cpp: %.h
moc $< -o $@
tqmoc_%.cpp: %.h
tqmoc $< -o $@
\endcode
If you want to write portably, you can use individual rules with the
following form:
\code
moc_NAME.cpp: NAME.h
moc $< -o $@
tqmoc_NAME.cpp: NAME.h
tqmoc $< -o $@
\endcode
You must also remember to add \e moc_NAME.cpp to your SOURCES
(substitute your favorite name) variable and \e moc_NAME.o or
\e moc_NAME.obj to your OBJECTS variable.
You must also remember to add \e tqmoc_NAME.cpp to your SOURCES
(substitute your favorite name) variable and \e tqmoc_NAME.o or
\e tqmoc_NAME.obj to your OBJECTS variable.
(While we prefer to name our C++ source files .cpp, the moc doesn't
(While we prefer to name our C++ source files .cpp, tqmoc doesn't
care, so you can use .C, .cc, .CC, .cxx or even .c++ if you
prefer.)
@ -221,10 +221,10 @@ suggest a makefile rule like this:
NAME.o: NAME.moc
NAME.moc: NAME.cpp
moc -i $< -o $@
tqmoc -i $< -o $@
\endcode
This guarantees that make will run the moc before it compiles
This guarantees that make will run tqmoc before it compiles
\e NAME.cpp. You can then put
\code
@ -235,9 +235,9 @@ at the end of \e NAME.cpp, where all the classes declared in
that file are fully known.
\section1 Invoking moc
\section1 Invoking tqmoc
Here are the command-line options supported by the moc:
Here are the command-line options supported by tqmoc:
\table
\header \i Option \i Meaning
@ -254,7 +254,7 @@ standard naming conventions.
\row
\i -i
\i Do not generate an #include statement in the output.
This may be used to run the moc on on a C++ file containing one or
This may be used to run tqmoc on on a C++ file containing one or
more class declarations. You should then #include the meta object
code in the .cpp
file. If both -i and -f are present, the last one wins.
@ -266,42 +266,42 @@ file. If both -i and -f are present, the last one wins.
\i Write a flood of lex debug information to stdout.
\row
\i -p \e path
\i Makes the moc prepend \e {path}/ to
\i Makes tqmoc prepend \e {path}/ to
the file name in the generated #include statement (if one is
generated).
\row
\i -q \e path
\i Makes the moc prepend \e {path}/ to
\i Makes tqmoc prepend \e {path}/ to
the file name of qt #include files in the generated code.
\endtable
You can explicitly tell the moc not to parse parts of a header
You can explicitly tell tqmoc not to parse parts of a header
file. It recognizes any C++ comment (//) that contains the substrings
MOC_SKIP_BEGIN or MOC_SKIP_END. They work as you would expect and you
can have several levels of them. The net result as seen by the moc is
can have several levels of them. The net result as seen by tqmoc is
as if you had removed all lines between a MOC_SKIP_BEGIN and a
MOC_SKIP_END.
\section1 Diagnostics
The moc will warn you about a number of dangerous or illegal
TQMoc will warn you about a number of dangerous or illegal
constructs in the TQ_OBJECT class declarations.
If you get linkage errors in the final building phase of your
program, saying that YourClass::className() is undefined or that
YourClass lacks a vtbl, something has been done wrong. Most often,
you have forgotten to compile or #include the moc-generated C++ code, or
you have forgotten to compile or #include the tqmoc-generated C++ code, or
(in the former case) include that object file in the link command.
\section1 Limitations
The moc does not expand #include or #define, it simply skips any
TQMoc does not expand #include or #define, it simply skips any
preprocessor directives it encounters. This is regrettable, but is
not usually a problem in practice.
The moc does not handle all of C++. The main problem is that class
TQMoc does not handle all of C++. The main problem is that class
templates cannot have signals or slots. Here is an example:
\code
@ -319,7 +319,7 @@ limitations is not a high priority for us.
\section2 Multiple inheritance requires TQObject to be first
If you are using multiple inheritance, moc assumes that the \e first
If you are using multiple inheritance, tqmoc assumes that the \e first
inherited class is a subclass of TQObject. Also, be sure that \e only
the first inherited class is a TQObject.
@ -329,7 +329,7 @@ the first inherited class is a TQObject.
};
\endcode
(This limitation is almost impossible to remove; since the moc does not expand
(This limitation is almost impossible to remove; since tqmoc does not expand
#include or #define, it cannot find out which one of the base classes
is a TQObject.)
@ -410,7 +410,7 @@ C++ ARM, section r.11.3
\section2 Type macros cannot be used for signal and slot parameters
Since the moc does not expand #define, type macros that take an argument
Since tqmoc does not expand #define, type macros that take an argument
will not work in signals and slots. Here is an illegal example:
\code
@ -475,7 +475,7 @@ contains the respective get and set functions
Declaring the first property within or after the public section that
contains the type definition and the respective get and set functions
does not work as expected. The moc will complain that it can neither
does not work as expected. TQMoc will complain that it can neither
find the functions nor resolve the type. Here is an example of the
illegal syntax:

@ -78,7 +78,7 @@
The WhatsThis class is a subclass of both TQObject and
TQWhatsThis and serves as a base class for the HeaderWhatsThis
and TableWhatsThis classes. \footnote Note that moc requires that TQObject
and TableWhatsThis classes. \footnote Note that tqmoc requires that TQObject
is the first base class. \endfootnote WhatsThis
reimplements clicked() which will be called when the user clicks
inside the "What's this?" window. It also declares a signal

@ -88,7 +88,7 @@ QMAKE_LIBS_QT_ENTRY = qtmain.lib
QMAKE_LIBS_OPENGL =
QMAKE_LFLAGS_OPENGL = /dopengl32.dll
QMAKE_MOC = $(TQTDIR)\bin\moc.exe
QMAKE_MOC = $(TQTDIR)\bin\tqmoc.exe
QMAKE_UIC = $(TQTDIR)\bin\uic.exe
QMAKE_IDC = $(TQTDIR)\bin\idc.exe

@ -77,7 +77,7 @@ QMAKE_LIBS_QT_ENTRY = -lqtmain
QMAKE_LIBS_OPENGL = -lopengl32 -lglu32
QMAKE_MOC = $(TQTDIR)\bin\moc.exe
QMAKE_MOC = $(TQTDIR)\bin\tqmoc.exe
QMAKE_UIC = $(TQTDIR)\bin\uic.exe
QMAKE_IDC = $(TQTDIR)\bin\idc.exe

@ -85,7 +85,7 @@ QMAKE_LIBS_QT_ENTRY = qtmain.lib
QMAKE_LIBS_OPENGL = opengl32.lib glu32.lib delayimp.lib
QMAKE_LFLAGS_OPENGL = /DELAYLOAD:opengl32.dll
QMAKE_MOC = $(TQTDIR)\bin\moc.exe
QMAKE_MOC = $(TQTDIR)\bin\tqmoc.exe
QMAKE_UIC = $(TQTDIR)\bin\uic.exe
QMAKE_IDC = $(TQTDIR)\bin\idc.exe

@ -85,7 +85,7 @@ QMAKE_LIBS_QT_ENTRY = qtmain.lib
QMAKE_LIBS_OPENGL = opengl32.lib glu32.lib
QMAKE_LFLAGS_OPENGL = /DELAYLOAD:opengl32.dll
QMAKE_MOC = $(TQTDIR)\bin\moc.exe
QMAKE_MOC = $(TQTDIR)\bin\tqmoc.exe
QMAKE_UIC = $(TQTDIR)\bin\uic.exe
QMAKE_IDC = $(TQTDIR)\bin\idc.exe

@ -85,7 +85,7 @@ QMAKE_LIBS_QT_ENTRY = qtmain.lib
QMAKE_LIBS_OPENGL = opengl32.lib glu32.lib delayimp.lib
QMAKE_LFLAGS_OPENGL = /DELAYLOAD:opengl32.dll
QMAKE_MOC = $(TQTDIR)\bin\moc.exe
QMAKE_MOC = $(TQTDIR)\bin\tqmoc.exe
QMAKE_UIC = $(TQTDIR)\bin\uic.exe
QMAKE_IDC = $(TQTDIR)\bin\idc.exe

@ -87,7 +87,7 @@ QMAKE_LIBS_QT_ENTRY = qtmain.lib
QMAKE_LIBS_OPENGL = opengl32.lib glu32.lib
QMAKE_LFLAGS_OPENGL = /DELAYLOAD:opengl32.dll
QMAKE_MOC = $(TQTDIR)\bin\moc.exe
QMAKE_MOC = $(TQTDIR)\bin\tqmoc.exe
QMAKE_UIC = $(TQTDIR)\bin\uic.exe
QMAKE_IDC = $(TQTDIR)\bin\idc.exe

@ -303,7 +303,7 @@ Defines the header files for the project.
\e qmake will generate dependency information (unless -nodepend
is specified on the \link #Commands command line \endlink) for the
specified headers. \e qmake will also automatically detect if
\e moc is required by the classes in these headers, and add the
\e tqmoc is required by the classes in these headers, and add the
appropriate dependencies and files to the project for generating and
linking the moc files.
@ -579,7 +579,7 @@ automatically be included in the project.
For example:
\code
YACCSOURCES = moc.y
YACCSOURCES = tqmoc.y
\endcode
@ -694,7 +694,7 @@ On other platforms, this variable has different meaning, as noted
below.
This variable contains a list of header files that require some
sort of pre-compilation step (such as with moc). The value of this
sort of pre-compilation step (such as with tqmoc). The value of this
variable is typically handled by \e qmake or \link #QMAKESPEC qmake.conf \endlink and rarely needs to be
modified.
@ -880,7 +880,7 @@ to be modified.
\target QMAKE_CLEAN
\section3 QMAKE_CLEAN
This variable contains any files which are not generated files (such as moc and uic
This variable contains any files which are not generated files (such as tqmoc and tquic
generated files) and object files that should be removed when using "make clean".
@ -2138,8 +2138,8 @@ For convenience there is also a method of customizing (UNIX) projects
for generic new compilers (or even preprocessors).
\code
new_moc.output = moc_${QMAKE_FILE_BASE}.cpp
new_moc.commands = moc ${QMAKE_FILE_NAME} -o ${QMAKE_FILE_OUT}
new_moc.output = tqmoc_${QMAKE_FILE_BASE}.cpp
new_moc.commands = tqmoc ${QMAKE_FILE_NAME} -o ${QMAKE_FILE_OUT}
new_moc.depends = g++ -E -M ${QMAKE_FILE_NAME} | sed "s,^.*: ,,"
new_moc.input = NEW_HEADERS
QMAKE_EXTRA_UNIX_COMPILERS += new_moc

@ -15,4 +15,4 @@ uses \e qmake as the primary build tool for the TQt library, and for
the tools supplied with Qt.
\e qmake also takes care of Qt's special requirements, automatically
including build rules for \link moc.html moc\endlink and \e uic.
including build rules for \link tqmoc.html tqmoc\endlink and \e uic.

@ -72,7 +72,7 @@ you can set it in the project file:
The final step is to set the \e CONFIG variable. Since this is a Qt
application, we need to put 'qt' on the CONFIG line so that \e qmake
will add the relevant libraries to be linked against and ensure that
build lines for \e moc and \e uic are included in the makefile.
build lines for \e tqmoc and \e tquic are included in the makefile.
The finished project file should look like this:
\code

@ -453,7 +453,7 @@ MetrowerksMakefileGenerator::writeMakeParts(TQTextStream &t)
t << endl;
file.close();
if(mocAware()) {
if(tqmocAware()) {
TQString mocs = project->first("MOCS");
TQFile mocfile(mocs);
if(!mocfile.open(IO_WriteOnly)) {
@ -558,7 +558,7 @@ MetrowerksMakefileGenerator::init()
if(project->first("TEMPLATE") == "lib")
mocfile += project->isActiveConfig("staticlib") ? "_static" : "_shared";
project->variables()["MOCS"].append(mocfile + ".mocs");
setMocAware(TRUE);
setTQMocAware(TRUE);
}
if(!project->isEmpty("FORMS")) {
TQString uicfile = project->first("TARGET");

@ -94,7 +94,7 @@ static bool createDir(const TQString& fullPath)
MakefileGenerator::MakefileGenerator(TQMakeProject *p) : init_opath_already(FALSE),
init_already(FALSE), moc_aware(FALSE),
init_already(FALSE), tqmoc_aware(FALSE),
no_io(FALSE), project(p)
{
}
@ -545,7 +545,7 @@ MakefileGenerator::generateDependencies(TQPtrList<MakefileDependDir> &dirs, cons
}
}
}
if( mocAware() && //is it a moc file?
if( tqmocAware() && //is it a moc file?
( inc.endsWith(Option::cpp_ext.first()) || inc.endsWith(Option::cpp_moc_ext) )
|| ( (Option::cpp_ext.first() != Option::h_moc_ext) && inc.endsWith(Option::h_moc_ext) )) {
TQString mocs[] = { TQString("_HDRMOC"), TQString("_SRCMOC"), TQString::null };
@ -944,8 +944,8 @@ MakefileGenerator::init()
if(!found_cache_moc || !found_cache_dep)
write_cache = TRUE;
}
/* Do moc before dependency checking since some includes can come from
moc_*.cpp files */
/* Do tqmoc before dependency checking since some includes can come from
tqmoc_*.cpp files */
if(found_cache_moc) {
TQString fixed_file(fileFixify((*val_it), TQDir::currentDirPath(), Option::output_dir));
TQString moc = findMocDestination(fixed_file);
@ -960,7 +960,7 @@ MakefileGenerator::init()
}
}
}
} else if(mocAware() && (sources[x] == "SOURCES" || sources[x] == "HEADERS") &&
} else if(tqmocAware() && (sources[x] == "SOURCES" || sources[x] == "HEADERS") &&
(Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT ||
Option::mkfile::do_mocs)) {
generateMocList((*val_it));
@ -1199,7 +1199,7 @@ MakefileGenerator::init()
Option::output_dir));
//moc files
if ( mocAware() ) {
if ( tqmocAware() ) {
if(!project->isEmpty("MOC_DIR"))
project->variables()["INCLUDEPATH"].append(project->first("MOC_DIR"));
if ( Option::h_moc_ext == Option::cpp_ext.first() )

@ -51,7 +51,7 @@
class MakefileGenerator
{
TQString spec;
bool init_opath_already, init_already, moc_aware, no_io;
bool init_opath_already, init_already, tqmoc_aware, no_io;
TQStringList createObjectList(const TQString &var);
TQString build_args();
TQString dependencyKey(const TQString &file) const;
@ -95,8 +95,8 @@ protected:
void setNoIO(bool o);
bool noIO() const;
void setMocAware(bool o);
bool mocAware() const;
void setTQMocAware(bool o);
bool tqmocAware() const;
void logicWarn(const TQString &, const TQString &);
virtual bool doDepends() const { return Option::mkfile::do_deps; }
@ -164,11 +164,11 @@ inline TQString MakefileGenerator::findMocDestination(const TQString &src_file)
return TQString("");
}
inline void MakefileGenerator::setMocAware(bool o)
{ moc_aware = o; }
inline void MakefileGenerator::setTQMocAware(bool o)
{ tqmoc_aware = o; }
inline bool MakefileGenerator::mocAware() const
{ return moc_aware; }
inline bool MakefileGenerator::tqmocAware() const
{ return tqmoc_aware; }
inline void MakefileGenerator::setNoIO(bool o)
{ no_io = o; }

@ -244,7 +244,7 @@ UnixMakefileGenerator::init()
project->variables()["QMAKE_LFLAGS"] += project->variables()["QMAKE_LFLAGS_THREAD"];
}
if ( project->isActiveConfig("moc") )
setMocAware(TRUE);
setTQMocAware(TRUE);
TQString compile_flag = var("QMAKE_COMPILE_FLAG");
if(compile_flag.isEmpty())
compile_flag = "-c";

@ -687,7 +687,7 @@ UnixMakefileGenerator::writeMakeParts(TQTextStream &t)
//moc itself shouldn't have this dependency - this is a little kludgy but it is
//better than the alternative for now.
TQString moc = project->first("QMAKE_MOC"), target = project->first("TARGET"),
moc_dir = "$(TQTDIR)/src/moc";
moc_dir = "$(TQTDIR)/src/tqmoc";
if(!project->isEmpty("QMAKE_MOC_SRC"))
moc_dir = project->first("QMAKE_MOC_SRC");
fixEnvVariables(target);
@ -777,7 +777,7 @@ UnixMakefileGenerator::writeMakeParts(TQTextStream &t)
TQString clean_targets;
t << "mocclean:" << "\n";
if(mocAware()) {
if(tqmocAware()) {
if(!objMoc.isEmpty() || !srcMoc.isEmpty() || moc_incremental) {
if(!objMoc.isEmpty())
t << "\t-$(DEL_FILE) $(OBJMOC)" << '\n';

@ -557,7 +557,7 @@ BorlandMakefileGenerator::init()
project->variables()["QMAKE_LIBS"] += project->variables()["QMAKE_LIBS_RT"];
}
if ( project->isActiveConfig("moc") ) {
setMocAware(TRUE);
setTQMocAware(TRUE);
}
project->variables()["QMAKE_LIBS"] += project->variables()["LIBS"];
// Update -lname to name.lib, and -Ldir to

@ -574,7 +574,7 @@ MingwMakefileGenerator::init()
}
if ( project->isActiveConfig("moc") )
setMocAware(TRUE);
setTQMocAware(TRUE);
// add -L libs to libdir
TQStringList &libs = project->variables()["QMAKE_LIBS"];

@ -227,7 +227,7 @@ DspMakefileGenerator::writeDspParts(TQTextStream &t)
mocpath = mocpath.replace( TQRegExp( "\\..*$" ), "" ) + " ";
buildCmds += "\t" + mocpath + (*it) + " -o " + findMocDestination((*it)) + " \\\n";
createMOC = "\"" + findMocDestination((*it)) + "\" : $(SOURCE) \"$(INTDIR)\" \"$(OUTDIR)\"\n $(BuildCmds)\n\n";
customDependencies += "\"$(TQTDIR)\\bin\\moc.exe\"";
customDependencies += "\"$(TQTDIR)\\bin\\tqmoc.exe\"";
}
if (!createMOC.isEmpty() || !compilePCH.isEmpty()) {
bool doMOC = !createMOC.isEmpty();
@ -462,7 +462,7 @@ DspMakefileGenerator::writeDspParts(TQTextStream &t)
uiHeadersDir = fpath;
}
t << "USERDEP_" << base << "=\"$(TQTDIR)\\bin\\moc.exe\" \"$(TQTDIR)\\bin\\uic.exe\"" << endl << endl;
t << "USERDEP_" << base << "=\"$(TQTDIR)\\bin\\tqmoc.exe\" \"$(TQTDIR)\\bin\\tquic.exe\"" << endl << endl;
TQString build = "\n\n# Begin Custom Build - Uic'ing " + base + "...\n"
"InputPath=.\\" + base + "\n\n" "BuildCmds= \\\n\t" + uicpath + base +
@ -818,7 +818,7 @@ DspMakefileGenerator::init()
TQString targetfilename = project->variables()["TARGET"].first();
project->variables()["TARGET"].first() += project->first("TARGET_EXT");
if ( project->isActiveConfig("moc") )
setMocAware(TRUE);
setTQMocAware(TRUE);
project->variables()["QMAKE_LIBS"] += project->variables()["LIBS"];
project->variables()["QMAKE_FILETAGS"] += TQStringList::split(' ',

@ -653,7 +653,7 @@ NmakeMakefileGenerator::init()
if ( project->isActiveConfig("moc") )
setMocAware(TRUE);
setTQMocAware(TRUE);
project->variables()["QMAKE_LIBS"] += project->variables()["LIBS"];
TQStringList &libList = project->variables()["QMAKE_LIBS"];

@ -1214,7 +1214,7 @@ void VcprojGenerator::initOld()
// MOC -----------------------------------------------------------
if ( project->isActiveConfig("moc") )
setMocAware(TRUE);
setTQMocAware(TRUE);
// /VERSION:x.yz -------------------------------------------------
if ( !project->variables()["VERSION"].isEmpty() ) {

@ -109,7 +109,7 @@
The number of pairs is returned by numClassInfo(), and values are
returned by classInfo().
\sa \link moc.html moc (Meta Object Compiler)\endlink
\sa \link tqmoc.html tqmoc (Meta Object Compiler)\endlink
*/
@ -118,7 +118,7 @@
The private object.
*****************************************************************************/
// extra flags from moc.y
// extra flags from tqmoc.y
enum Flags {
Invalid = 0x00000000,
Readable = 0x00000001,
@ -660,7 +660,7 @@ const TQMetaProperty* TQMetaObject::resolveProperty( const TQMetaProperty* p ) c
\overload
The version of resolveProperty that is used by moc generated code
The version of resolveProperty that is used by tqmoc generated code
*/
int TQMetaObject::resolveProperty( int index ) const
@ -1197,7 +1197,7 @@ bool TQMetaProperty::reset( TQObject* o ) const
#endif // TQT_NO_PROPERTIES
/*
* TQMetaObjectCleanUp is used as static global object in the moc-generated cpp
* TQMetaObjectCleanUp is used as static global object in the tqmoc-generated cpp
* files and deletes the TQMetaObject provided with setMetaObject. It sets the
* TQObject reference to the metaObj to NULL when it is destroyed.
*/

@ -388,7 +388,7 @@ TQMetaCallEvent::~TQMetaCallEvent()
Notice that the TQ_OBJECT macro is mandatory for any object that
implements signals, slots or properties. You also need to run the
\link moc.html moc program (Meta Object Compiler) \endlink on the
\link tqmoc.html tqmoc program (Meta Object Compiler) \endlink on the
source file. We strongly recommend the use of this macro in \e all
subclasses of TQObject regardless of whether or not they actually
use signals, slots and properties, since failure to do so may lead
@ -3219,7 +3219,7 @@ TQVariant TQObject::property( const char *name ) const
className(), name );
return v;
}
TQObject* that = (TQObject*) this; // moc ensures constness for the tqt_property call
TQObject* that = (TQObject*) this; // tqmoc ensures constness for the tqt_property call
that->tqt_property( id, 1, &v );
return v;
}

@ -71,7 +71,7 @@
#endif
// The following macros are our "extensions" to C++
// They are used, strictly speaking, only by the moc.
// They are used, strictly speaking, only by tqmoc.
struct TQUObject;
#ifdef QT_MOC_CPP

@ -1345,7 +1345,7 @@ void TQProcess::flushStdin()
}
/*
This private slot is only used under Windows (but moc does not know about #if
This private slot is only used under Windows (but tqmoc does not know about #if
defined()).
*/
void TQProcess::timeout()

@ -26,7 +26,4 @@ Boston, MA 02110-1301, USA.
#define Qt TQt
#define tqmoc moc
#define TQMOC MOC
#endif /* TQT_H */

@ -984,10 +984,10 @@ void TQVariant::clear()
/* Attention!
For dependency reasons, this table is duplicated in moc.y. If you
For dependency reasons, this table is duplicated in tqmoc.y. If you
change one, change both.
(Search for the word 'Attention' in moc.y.)
(Search for the word 'Attention' in tqmoc.y.)
*/
static const int ntypes = 35;
static const char* const type_map[ntypes] =

@ -1 +1 @@
This is a temporary directory for moc output
This is a temporary directory for tqmoc output

@ -1,10 +1,10 @@
This directory contains the source code for the TQt Meta Object
Compiler (moc).
Compiler (tqmoc).
The files moc_yacc.cpp, moc_yacc.h and moc_lex.cpp are generated by
lex and yacc from moc.l and moc.y.
The files tqmoc_yacc.cpp, tqmoc_yacc.h and tqmoc_lex.cpp are generated by
lex and yacc from tqmoc.l and tqmoc.y.
To compile the moc program from scratch, you need lex and yacc. These
To compile the tqmoc program from scratch, you need lex and yacc. These
tools are preinstalled on most Unix systems, often as symbolic links
to flex and byacc or bison.

@ -39,9 +39,9 @@
*****************************************************************************/
%{
#ifdef MOC_YACC_CODE
#ifdef TQMOC_YACC_CODE
#ifdef MOC_MWERKS_PLUGIN
#ifdef TQMOC_MWERKS_PLUGIN
#ifdef Q_OS_MAC9
# define isascii(c) ((int)( (unsigned int) (c) <= (unsigned char)0x7F ))
#endif
@ -102,7 +102,7 @@ class TQString;
extern void addExpressionChar( const char );
extern void addExpressionString( const char * );
extern void moc_warn( const char *msg );
extern void tqmoc_warn( const char *msg );
%}
%start OUTSIDE QT_DEF IN_CLASS IN_NAMESPACE IN_ENUM IN_EXPR IN_DEF_ARG IN_FCT IN_TEMPL_ARGS GIMME_SEMICOLON SKIP IN_PROPERTY IN_CLASSINFO
@ -148,7 +148,7 @@ STRING {ALMOSTSTRING}\"
if ( classPLevel == 1 )
return TQ_OBJECT;
else if ( classPLevel > 1 )
moc_warn( "Cannot use TQ_OBJECT in nested class." );
tqmoc_warn( "Cannot use TQ_OBJECT in nested class." );
}
<IN_CLASS>"TQ_PROPERTY" { X;if( classPLevel == 1 ) return TQ_PROPERTY; }
<IN_CLASS>"TQ_OVERRIDE" { X;if( classPLevel == 1 ) return TQ_OVERRIDE; }
@ -443,7 +443,7 @@ STRING {ALMOSTSTRING}\"
} else
if ( s.contains( "MOC_SKIP_END" ) ) {
if ( skipLevel == 0 ) {
moc_warn(" MOC_SKIP_END without MOC_SKIP_BEGIN");
tqmoc_warn(" MOC_SKIP_END without MOC_SKIP_BEGIN");
} else {
skipLevel--;
if ( skipLevel == 0 ) {
@ -495,4 +495,4 @@ STRING {ALMOSTSTRING}\"
%%
#endif // MOC_YACC_CODE
#endif // TQMOC_YACC_CODE

@ -39,10 +39,10 @@ SOURCES = ../tools/tqbuffer.cpp \
../codecs/tqutfcodec.cpp
isEmpty(QT_PRODUCT)|contains(QT_PRODUCT, qt-internal) {
LEXSOURCES = moc.l
YACCSOURCES = moc.y
LEXSOURCES = tqmoc.l
YACCSOURCES = tqmoc.y
} else {
SOURCES += moc_yacc.cpp
SOURCES += tqmoc_yacc.cpp
}
unix:SOURCES += ../tools/tqfile_unix.cpp ../tools/tqdir_unix.cpp ../tools/tqfileinfo_unix.cpp
@ -57,7 +57,7 @@ INSTALLS += target
TARGET = McMoc
CONFIG -= static
CONFIG += shared plugin
DEFINES += MOC_MWERKS_PLUGIN
DEFINES += TQMOC_MWERKS_PLUGIN
MWERKSDIR = $QT_SOURCE_TREE/util/mwerks_plugin
INCLUDEPATH += $$MWERKSDIR/Headers
LIBS += $$MWERKSDIR/Libraries/PluginLib4.shlb

@ -55,7 +55,7 @@
*****************************************************************************/
%{
#define MOC_YACC_CODE
#define TQMOC_YACC_CODE
void yyerror( const char *msg );
#include "qplatformdefs.h"
@ -67,7 +67,7 @@ void yyerror( const char *msg );
#include "tqptrlist.h"
#include "tqregexp.h"
#include "tqstrlist.h"
#ifdef MOC_MWERKS_PLUGIN
#ifdef TQMOC_MWERKS_PLUGIN
# ifdef Q_OS_MACX
# undef OLD_DEBUG
# ifdef DEBUG
@ -108,9 +108,9 @@ static void selectOutsideClassState();
static void registerClassInNamespace();
static bool suppress_func_warn = FALSE;
static void func_warn( const char *msg );
static void moc_warn( const char *msg );
static void moc_err( const char *s );
static void moc_err( const char *s1, const char *s2 );
static void tqmoc_warn( const char *msg );
static void tqmoc_err( const char *s );
static void tqmoc_err( const char *s1, const char *s2 );
static void operatorError();
static void checkPropertyName( const char* ident );
@ -681,8 +681,8 @@ extern "C" int hack_isatty( int )
# endif
# define YYDEBUG 1
# include "moc_yacc.h"
# include "moc_lex.cpp"
# include "tqmoc_yacc.h"
# include "tqmoc_lex.cpp"
#endif //YYBISON
%}
@ -1236,7 +1236,7 @@ obj_member_list: obj_member_list obj_member_area
qt_access_specifier: access_specifier { tmpAccess = $1; }
| SLOTS { moc_err( "Missing access specifier"
| SLOTS { tqmoc_err( "Missing access specifier"
" before \"slots:\"." ); }
;
@ -1246,7 +1246,7 @@ obj_member_area: qt_access_specifier { BEGIN QT_DEF; }
':' opt_signal_declarations
| TQ_OBJECT {
if ( tmpAccess )
moc_warn("TQ_OBJECT is not in the private"
tqmoc_warn("TQ_OBJECT is not in the private"
" section of the class.\n"
"TQ_OBJECT is a macro that resets"
" access permission to \"private\".");
@ -1287,7 +1287,7 @@ obj_member_area: qt_access_specifier { BEGIN QT_DEF; }
opt_property_candidates
;
slot_area: SIGNALS ':' { moc_err( "Signals cannot "
slot_area: SIGNALS ':' { tqmoc_err( "Signals cannot "
"have access specifiers" ); }
| SLOTS ':' opt_slot_declarations
| ':' { if ( tmpAccess == Public && TQ_PROPERTYdetected )
@ -1302,7 +1302,7 @@ slot_area: SIGNALS ':' { moc_err( "Signals cannot "
}
| IDENTIFIER { BEGIN IN_CLASS;
if ( classPLevel != 1 )
moc_warn( "unexpected access"
tqmoc_warn( "unexpected access"
"specifier" );
}
;
@ -1488,7 +1488,7 @@ signal_or_slot: type_and_name fct_decl opt_semicolons
{ func_warn("Unexpected using declaration."); }
| NAMESPACE IDENTIFIER '{'
{ classPLevel++;
moc_err("Unexpected namespace declaration."); }
tqmoc_err("Unexpected namespace declaration."); }
| nested_class_head ';' opt_semicolons
{ func_warn("Unexpected class declaration.");}
| nested_class_head
@ -1570,14 +1570,14 @@ property: IDENTIFIER IDENTIFIER
prop_statements
{
if ( g->propRead.isEmpty() && !g->propOverride )
moc_err( "A property must at least feature a read method." );
tqmoc_err( "A property must at least feature a read method." );
checkPropertyName( $2 );
TQ_PROPERTYdetected = TRUE;
// Avoid duplicates
for( TQPtrListIterator<Property> lit( g->props ); lit.current(); ++lit ) {
if ( lit.current()->name == $2 ) {
if ( displayWarnings )
moc_err( "Property '%s' defined twice.",
tqmoc_err( "Property '%s' defined twice.",
(const char*)lit.current()->name );
}
}
@ -1619,7 +1619,7 @@ extern "C" int hack_isatty( int )
# else
# include <unistd.h>
# endif
# include "moc_lex.cpp"
# include "tqmoc_lex.cpp"
#endif //YYBISON
void cleanup();
@ -1673,7 +1673,7 @@ void setDefaultIncludeFile()
#define ErrorFormatString "%s:%d:"
#endif
#ifndef MOC_MWERKS_PLUGIN
#ifndef TQMOC_MWERKS_PLUGIN
int main( int argc, char **argv )
{
init();
@ -1771,21 +1771,21 @@ int main( int argc, char **argv )
} else if ( argc < 2 || error ) { // incomplete/wrong args
fprintf( stderr, "TQt meta object compiler\n" );
if ( error )
fprintf( stderr, "moc: %s\n", error );
fprintf( stderr, "Usage: moc [options] <header-file>\n"
fprintf( stderr, "tqmoc: %s\n", error );
fprintf( stderr, "Usage: tqmoc [options] <header-file>\n"
"\t-o file Write output to file rather than stdout\n"
"\t-f[file] Force #include, optional file name\n"
"\t-p path Path prefix for included file\n"
"\t-i Do not generate an #include statement\n"
"\t-k Do not stop on errors\n"
"\t-nw Do not display warnings\n"
"\t-v Display version of moc\n" );
"\t-v Display version of tqmoc\n" );
cleanup();
return 1;
} else {
yyin = fopen( (const char *)g->fileName, "r" );
if ( !yyin ) {
fprintf( stderr, "moc: %s: No such file\n", (const char*)g->fileName);
fprintf( stderr, "tqmoc: %s: No such file\n", (const char*)g->fileName);
cleanup();
return 1;
}
@ -1793,7 +1793,7 @@ int main( int argc, char **argv )
if ( !g->outputFile.isEmpty() ) { // output file specified
out = fopen( (const char *)g->outputFile, "w" ); // create output file
if ( !out ) {
fprintf( stderr, "moc: Cannot create %s\n",
fprintf( stderr, "tqmoc: Cannot create %s\n",
(const char*)g->outputFile );
cleanup();
return 1;
@ -1835,7 +1835,7 @@ const unsigned char *p_str(const char *, int =-1);
CWPluginContext g_ctx;
moc_status do_moc( CWPluginContext ctx, const TQCString &fin, const TQCString &fout, CWFileSpec *dspec, bool i)
tqmoc_status do_moc( CWPluginContext ctx, const TQCString &fin, const TQCString &fout, CWFileSpec *dspec, bool i)
{
init();
@ -1853,7 +1853,7 @@ moc_status do_moc( CWPluginContext ctx, const TQCString &fin, const TQCString &f
fi.isdependentoffile = kCurrentCompiledFile;
if(CWFindAndLoadFile( ctx, fin.data(), &fi) != cwNoErr) {
cleanup();
return moc_no_source;
return tqmoc_no_source;
}
if(dspec) {
@ -1872,7 +1872,7 @@ moc_status do_moc( CWPluginContext ctx, const TQCString &fin, const TQCString &f
char tmp[sizeof(Str63)+2];
if(NewAlias( NULL, &fi.filespec, &alias) != noErr) {
cleanup();
return moc_general_error;
return tqmoc_general_error;
}
for(;;) {
GetAliasInfo(alias, x++, str);
@ -1889,18 +1889,18 @@ moc_status do_moc( CWPluginContext ctx, const TQCString &fin, const TQCString &f
struct stat istat, ostat;
if(stat(inpath, &istat) == -1) {
cleanup();
return moc_no_source;
return tqmoc_no_source;
}
if(stat(outpath, &ostat) == 0 && istat.st_mtime < ostat.st_mtime) {
cleanup();
return moc_not_time;
return tqmoc_not_time;
}
unlink(outpath.data());
out = fopen(outpath.data(), "w+");
if(!out) {
cleanup();
return moc_general_error;
return tqmoc_general_error;
}
yyparse();
@ -1909,13 +1909,13 @@ moc_status do_moc( CWPluginContext ctx, const TQCString &fin, const TQCString &f
if(g->mocError || !g->generatedCode) {
unlink(outpath.data());
moc_status ret = !g->generatedCode ? moc_no_qobject : moc_parse_error;
tqmoc_status ret = !g->generatedCode ? tqmoc_no_qobject : tqmoc_parse_error;
cleanup();
return ret;
}
cleanup();
return moc_success;
return tqmoc_success;
}
#endif
void replace( char *s, char c1, char c2 )
@ -1996,7 +1996,7 @@ void init() // initialize
tmpFunc = new Function;
tmpEnum = new Enum;
#ifdef MOC_MWERKS_PLUGIN
#ifdef TQMOC_MWERKS_PLUGIN
buf_buffer = NULL;
buf_index = 0;
buf_size_total = 0;
@ -2008,7 +2008,7 @@ void cleanup()
delete g;
g = NULL;
#ifdef MOC_MWERKS_PLUGIN
#ifdef TQMOC_MWERKS_PLUGIN
if(buf_buffer && g_ctx)
CWReleaseFileText(g_ctx, buf_buffer);
#endif
@ -2191,7 +2191,7 @@ void addExpressionChar( const char c )
void yyerror( const char *msg ) // print yacc error message
{
g->mocError = TRUE;
#ifndef MOC_MWERKS_PLUGIN
#ifndef TQMOC_MWERKS_PLUGIN
fprintf( stderr, ErrorFormatString" Error: %s\n", g->fileName.data(), lineNo, msg );
#else
char msg2[200];
@ -2205,25 +2205,25 @@ void yyerror( const char *msg ) // print yacc error message
}
}
void moc_err( const char *s )
void tqmoc_err( const char *s )
{
yyerror( s );
}
void moc_err( const char *s1, const char *s2 )
void tqmoc_err( const char *s1, const char *s2 )
{
static char tmp[1024];
sprintf( tmp, s1, s2 );
yyerror( tmp );
}
void moc_warn( const char *msg )
void tqmoc_warn( const char *msg )
{
if ( displayWarnings )
fprintf( stderr, ErrorFormatString" Warning: %s\n", g->fileName.data(), lineNo, msg);
}
void moc_warn( char *s1, char *s2 )
void tqmoc_warn( char *s1, char *s2 )
{
static char tmp[1024];
sprintf( tmp, s1, s2 );
@ -2234,14 +2234,14 @@ void moc_warn( char *s1, char *s2 )
void func_warn( const char *msg )
{
if ( !suppress_func_warn )
moc_warn( msg );
tqmoc_warn( msg );
skipFunc = TRUE;
}
void operatorError()
{
if ( !suppress_func_warn )
moc_warn("Operator functions cannot be signals or slots.");
tqmoc_warn("Operator functions cannot be signals or slots.");
skipFunc = TRUE;
}
@ -2732,7 +2732,7 @@ int generateProps()
//
if ( g->props.count() ) {
if ( displayWarnings && !TQ_OBJECTdetected )
moc_err("The declaration of the class \"%s\" contains properties"
tqmoc_err("The declaration of the class \"%s\" contains properties"
" but no TQ_OBJECT macro.", g->className.data());
fprintf( out, "#ifndef TQT_NO_PROPERTIES\n" );
@ -2814,7 +2814,7 @@ int generateClassInfos()
return 0;
if ( displayWarnings && !TQ_OBJECTdetected )
moc_err("The declaration of the class \"%s\" contains class infos"
tqmoc_err("The declaration of the class \"%s\" contains class infos"
" but no TQ_OBJECT macro.", g->className.data());
fprintf( out, " static const TQClassInfo classinfo_tbl[] = {\n" );
@ -2845,17 +2845,17 @@ void generateClass() // generate C++ source code for a class
if ( g->signals.count() == 0 && g->slots.count() == 0 && g->props.count() == 0 && g->infos.count() == 0 )
return;
if ( displayWarnings && (g->signals.count() + g->slots.count()) != 0 )
moc_err("The declaration of the class \"%s\" contains signals "
tqmoc_err("The declaration of the class \"%s\" contains signals "
"or slots\n\t but no TQ_OBJECT macro.", g->className.data());
} else {
if ( g->superClassName.isEmpty() )
moc_err("The declaration of the class \"%s\" contains the\n"
tqmoc_err("The declaration of the class \"%s\" contains the\n"
"\tTQ_OBJECT macro but does not inherit from any class!\n"
"\tInherit from TQObject or one of its descendants"
" or remove TQ_OBJECT.", g->className.data() );
}
if ( templateClass ) { // don't generate for class
moc_err( "Sorry, TQt does not support templates that contain\n"
tqmoc_err( "Sorry, TQt does not support templates that contain\n"
"\tsignals, slots or TQ_OBJECT." );
return;
}
@ -2908,9 +2908,9 @@ void generateClass() // generate C++ source code for a class
fprintf( out, "#include <%sntqapplication.h>\n\n", (const char*)g->qtPath );
fprintf( out, "#include <%sprivate/tqucomextra_p.h>\n", (const char*)g->qtPath );
fprintf( out, "#if !defined(Q_MOC_OUTPUT_REVISION) || (Q_MOC_OUTPUT_REVISION != %d)\n", formatRevision );
fprintf( out, "#error \"This file was generated using the moc from %s."
fprintf( out, "#error \"This file was generated using the tqmoc from %s."
" It\"\n#error \"cannot be used with the include files from"
" this version of TQt.\"\n#error \"(The moc has changed too"
" this version of TQt.\"\n#error \"(TQMoc has changed too"
" much.)\"\n", TQT_VERSION_STR );
fprintf( out, "#endif\n\n" );
} else {
@ -3540,7 +3540,7 @@ void addEnum()
if ( lit.current()->name == tmpEnum->name )
{
if ( displayWarnings )
moc_err( "Enum %s defined twice.", (const char*)tmpEnum->name );
tqmoc_err( "Enum %s defined twice.", (const char*)tmpEnum->name );
}
}
@ -3601,7 +3601,7 @@ void addMember( Member m )
void checkPropertyName( const char* ident )
{
if ( ident[0] == '_' ) {
moc_err( "Invalid property name '%s'.", ident );
tqmoc_err( "Invalid property name '%s'.", ident );
return;
}
}

@ -984,9 +984,9 @@ char *yytext;
**
*****************************************************************************/
#line 42 "moc.l"
#ifdef MOC_YACC_CODE
#ifdef TQMOC_YACC_CODE
#ifdef MOC_MWERKS_PLUGIN
#ifdef TQMOC_MWERKS_PLUGIN
#ifdef Q_OS_MAC9
# define isascii(c) ((int)( (unsigned int) (c) <= (unsigned char)0x7F ))
#endif
@ -1047,7 +1047,7 @@ class TQString;
extern void addExpressionChar( const char );
extern void addExpressionString( const char * );
extern void moc_warn( const char *msg );
extern void tqmoc_warn( const char *msg );
#line 1053 "lex.yy.c"
@ -1465,7 +1465,7 @@ YY_RULE_SETUP
if ( classPLevel == 1 )
return TQ_OBJECT;
else if ( classPLevel > 1 )
moc_warn( "Cannot use TQ_OBJECT in nested class." );
tqmoc_warn( "Cannot use TQ_OBJECT in nested class." );
}
YY_BREAK
case 24:
@ -2180,7 +2180,7 @@ YY_RULE_SETUP
} else
if ( s.contains( "MOC_SKIP_END" ) ) {
if ( skipLevel == 0 ) {
moc_warn(" MOC_SKIP_END without MOC_SKIP_BEGIN");
tqmoc_warn(" MOC_SKIP_END without MOC_SKIP_BEGIN");
} else {
skipLevel--;
if ( skipLevel == 0 ) {
@ -3311,5 +3311,5 @@ void yyfree (void * ptr )
#endif // MOC_YACC_CODE
#endif // TQMOC_YACC_CODE

File diff suppressed because it is too large Load Diff

@ -157,7 +157,7 @@ typedef union YYSTYPE
{
/* Line 2068 of yacc.c */
#line 692 "moc.y"
#line 692 "tqmoc.y"
char char_val;
int int_val;
@ -171,7 +171,7 @@ typedef union YYSTYPE
/* Line 2068 of yacc.c */
#line 175 "moc_yacc.h"
#line 175 "tqmoc_yacc.h"
} YYSTYPE;
# define YYSTYPE_IS_TRIVIAL 1
# define yystype YYSTYPE /* obsolescent; will be withdrawn */

@ -51,7 +51,7 @@
#ifndef TQT_NO_TEXTEDIT
// uncomment below to enable optimization mode - also uncomment the
// optimDoAutoScroll() private slot since moc ignores #ifdefs..
// optimDoAutoScroll() private slot since tqmoc ignores #ifdefs..
#define QT_TEXTEDIT_OPTIMIZATION
class TQPainter;

Loading…
Cancel
Save