rename qmake to tqmake

Signed-off-by: Michele Calgaro <michele.calgaro@yahoo.it>
feat/tqmake
Michele Calgaro 3 weeks ago
parent c489c62c17
commit be01f8c8e3
Signed by: MicheleC
GPG Key ID: 2A75B7CA8ADED5CF

16
.gitignore vendored

@ -86,7 +86,7 @@ Makefile
/examples/network/ftpclient/ftpclient
/examples/network/ftpclient/ftpmainwindow.cpp
/examples/network/ftpclient/ftpmainwindow.h
/examples/network/ftpclient/qmake_image_collection.cpp
/examples/network/ftpclient/tqmake_image_collection.cpp
/examples/network/httpd/httpd
/examples/network/infoprotocol/infoclient/clientbase.cpp
/examples/network/infoprotocol/infoclient/clientbase.h
@ -165,7 +165,7 @@ Makefile
/examples/tablet/tabletstatsbase.cpp
/examples/tablet/tabletstatsbase.h
/examples/tetrix/tetrix
/examples/textedit/qmake_image_collection.cpp
/examples/textedit/tqmake_image_collection.cpp
/examples/textedit/textedit
/examples/themes/themes
/examples/thread/prodcons/prodcons
@ -190,7 +190,7 @@ Makefile
/plugins/inputmethods/
/plugins/sqldrivers/
/plugins/styles/
/qmake/tqmake
/tqmake/tqmake
/src/tools/tqconfig.cpp
/tools/assistant/finddialog.cpp
/tools/assistant/finddialog.h
@ -198,7 +198,7 @@ Makefile
/tools/assistant/helpdialog.h
/tools/assistant/mainwindow.cpp
/tools/assistant/mainwindow.h
/tools/assistant/qmake_image_collection.cpp
/tools/assistant/tqmake_image_collection.cpp
/tools/assistant/settingsdialog.cpp
/tools/assistant/settingsdialog.h
/tools/assistant/tabbedbrowser.cpp
@ -258,7 +258,7 @@ Makefile
/tools/designer/designer/previewwidget.h
/tools/designer/designer/projectsettings.cpp
/tools/designer/designer/projectsettings.h
/tools/designer/designer/qmake_image_collection.cpp
/tools/designer/designer/tqmake_image_collection.cpp
/tools/designer/designer/replacedialog.cpp
/tools/designer/designer/replacedialog.h
/tools/designer/designer/richtextfontdialog.cpp
@ -280,13 +280,13 @@ Makefile
/tools/designer/plugins/cppeditor/projectsettings.h
/tools/designer/plugins/wizards/mainwindowwizard.cpp
/tools/designer/plugins/wizards/mainwindowwizard.h
/tools/designer/plugins/wizards/qmake_image_collection.cpp
/tools/designer/plugins/wizards/tqmake_image_collection.cpp
/tools/designer/plugins/wizards/sqlformwizard.cpp
/tools/designer/plugins/wizards/sqlformwizard.h
/tools/designer/tools/tqtcreatecw/tqtcreatecw
/tools/linguist/linguist/about.cpp
/tools/linguist/linguist/about.h
/tools/linguist/linguist/qmake_image_collection.cpp
/tools/linguist/linguist/tqmake_image_collection.cpp
/tools/linguist/linguist/statistics.cpp
/tools/linguist/linguist/statistics.h
/tools/linguist/linguist/tqlinguist.png
@ -302,6 +302,6 @@ Makefile
/tools/qtconfig/paletteeditoradvancedbase.h
/tools/qtconfig/previewwidgetbase.cpp
/tools/qtconfig/previewwidgetbase.h
/tools/qtconfig/qmake_image_collection.cpp
/tools/qtconfig/tqmake_image_collection.cpp
/tools/qtconfig/tqtconfig.png
/tools/tqtmergetr/tqtmergetr

@ -15,7 +15,7 @@ include TQt include files
lib Place for the TQt libraries
mkspecs Platform/compiler configuration files
plugins TQt plugins
qmake TQt build system
tqmake 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-tqmoc sub-src sub-tools sub-tutorial sub-examples
all: symlinks src-tqmake 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,35 +20,35 @@ all: symlinks src-qmake src-tqmoc sub-src sub-tools sub-tutorial sub-examples
@echo "Enjoy! - the Trolltech team"
@echo
qt.install: qmake-install tqmoc-install src-install tools-install plugins-install
qt.uninstall: qmake-uninstall tqmoc-uninstall src-uninstall tools-uninstall plugins-uninstall
qt.install: tqmake-install tqmoc-install src-install tools-install plugins-install
qt.uninstall: tqmake-uninstall tqmoc-uninstall src-uninstall tools-uninstall plugins-uninstall
#tqmoc
tqmoc-uninstall: .qmake.cache
tqmoc-uninstall: .tqmake.cache
cd src/tqmoc && $(MAKE) uninstall
tqmoc-install: src-tqmoc
cd src/tqmoc && $(MAKE) install
src-tqmoc: src-qmake FORCE
src-tqmoc: src-tqmake FORCE
cd src/tqmoc && $(MAKE)
#Qt
src-uninstall: .qmake.cache
src-uninstall: .tqmake.cache
cd src && $(MAKE) uninstall
src-install: sub-src
cd src && $(MAKE) install
sub-src: src-tqmoc .qmake.cache FORCE
sub-src: src-tqmoc .tqmake.cache FORCE
cd src && $(MAKE)
#qmake
qmake-uninstall: .qmake.cache
cd qmake && $(MAKE) uninstall
qmake-install: src-qmake
cd qmake && $(MAKE) install
src-qmake: symlinks FORCE
cd qmake && $(MAKE)
#tqmake
tqmake-uninstall: .tqmake.cache
cd tqmake && $(MAKE) uninstall
tqmake-install: src-tqmake
cd tqmake && $(MAKE) install
src-tqmake: symlinks FORCE
cd tqmake && $(MAKE)
#tools
tools-uninstall: .qmake.cache
tools-uninstall: .tqmake.cache
cd tools && $(MAKE) uninstall
tools-install: sub-tools
cd tools && $(MAKE) install
@ -56,11 +56,11 @@ sub-tools: sub-plugins FORCE
cd tools && $(MAKE)
#plugins
plugins-uninstall: .qmake.cache
plugins-uninstall: .tqmake.cache
cd plugins/src && $(MAKE) uninstall
plugins-install: sub-plugins
cd plugins/src && $(MAKE) install
sub-plugins: sub-src .qmake.cache FORCE
sub-plugins: sub-src .tqmake.cache FORCE
cd plugins/src && $(MAKE)
#tutorials
@ -75,7 +75,7 @@ sub-examples: sub-tools FORCE
doc: FORCE
qdoc util/qdoc/qdoc.conf
symlinks: .qmake.cache
symlinks: .tqmake.cache
# @cd include && rm -f q*.h; ln -s ../src/*/q*.h .; ln -s ../extensions/*/src/q*.h .; rm -f q*_p.h
distclean clean uiclean mocclean:
@ -91,9 +91,9 @@ distclean clean uiclean mocclean:
cd config.tests/unix/largefile && $(MAKE) distclean
cd config.tests/unix/ptrsize && $(MAKE) distclean
[ ! -f config.tests/x11/notype/Makefile ] || cd config.tests/x11/notype && $(MAKE) $@
cd qmake && $(MAKE) $@
cd tqmake && $(MAKE) $@
#confclean is actually the same as distclean, except qmake and tqmoc
#confclean is actually the same as distclean, except tqmake and tqmoc
#are not cleaned.
confclean:
cd tools && $(MAKE) distclean
@ -108,7 +108,7 @@ confclean:
cd config.tests/unix/ptrsize && $(MAKE) distclean
[ ! -f config.tests/x11/notype/Makefile ] || cd config.tests/x11/notype && $(MAKE) distclean
.qmake.cache:
.tqmake.cache:
@echo
@echo ' TQt must first be configured using the "configure" script.'
@echo

@ -2,7 +2,7 @@
CUPS=yes
XPLATFORM=`basename $1`
XCONFIG=$1/qmake.conf
XCONFIG=$1/tqmake.conf
VERBOSE=$2
shift 2
IN_INCDIRS=""

@ -2,7 +2,7 @@
NIS=yes
XPLATFORM=`basename $1`
XCONFIG=$1/qmake.conf
XCONFIG=$1/tqmake.conf
VERBOSE=$2
shift 2
IN_INCDIRS=""

@ -2,7 +2,7 @@
PRECOMP_SUPPORT=no
XPLATFORM=`basename $1`
XCONFIG=$1/qmake.conf
XCONFIG=$1/tqmake.conf
VERBOSE=$2
>precomp_header.h

@ -1,7 +1,7 @@
#!/bin/sh
OPENGL=yes
XCONFIG=$1/qmake.conf
XCONFIG=$1/tqmake.conf
THREAD=$2
VERBOSE=$3
shift 3

@ -1,7 +1,7 @@
#!/bin/sh
SM=yes
XCONFIG=$1/qmake.conf
XCONFIG=$1/tqmake.conf
VERBOSE=$2
shift 2
IN_INCDIRS=""

@ -1,7 +1,7 @@
#!/bin/sh
XCURSOR=yes
XCONFIG=$1/qmake.conf
XCONFIG=$1/tqmake.conf
VERBOSE=$2
shift 2
IN_LIBDIRS=""

@ -3,7 +3,7 @@
XFT=yes
XFT2=no
XFT2_HEADER=no
XCONFIG=$1/qmake.conf
XCONFIG=$1/tqmake.conf
VERBOSE=$2
SRCDIR=$3
OUTDIR=$4

@ -1,7 +1,7 @@
#!/bin/sh
XINERAMA=yes
XCONFIG=$1/qmake.conf
XCONFIG=$1/tqmake.conf
VERBOSE=$2
shift 2
IN_LIBDIRS=""

@ -1,7 +1,7 @@
#!/bin/sh
XINPUT=yes
XCONFIG=$1/qmake.conf
XCONFIG=$1/tqmake.conf
VERBOSE=$2
shift 2
IN_LIBDIRS=""

@ -2,7 +2,7 @@
XKB=yes
XPLATFORM=`basename $1`
XCONFIG=$1/qmake.conf
XCONFIG=$1/tqmake.conf
VERBOSE=$2
shift 2
IN_INCDIRS=""

@ -1,7 +1,7 @@
#!/bin/sh
XRANDR=yes
XCONFIG=$1/qmake.conf
XCONFIG=$1/tqmake.conf
VERBOSE=$2
shift 2
IN_LIBDIRS=""

@ -1,7 +1,7 @@
#!/bin/sh
XRENDER=yes
XCONFIG=$1/qmake.conf
XCONFIG=$1/tqmake.conf
VERBOSE=$2
shift 2
IN_LIBDIRS=""

@ -1,7 +1,7 @@
#!/bin/sh
XSHAPE=yes
XCONFIG=$1/qmake.conf
XCONFIG=$1/tqmake.conf
VERBOSE=$2
shift 2
IN_LIBDIRS=

114
configure vendored

@ -784,7 +784,7 @@ while [ "$#" -gt 0 ]; do
;;
v|verbose)
if [ "$VAL" = "yes" ]; then
if [ "$OPT_VERBOSE" = "$VAL" ]; then # takes two verboses to turn on qmake debugs
if [ "$OPT_VERBOSE" = "$VAL" ]; then # takes two verboses to turn on tqmake debugs
QMAKE_SWITCHES="$QMAKE_SWITCHES -d"
else
OPT_VERBOSE=yes
@ -928,19 +928,19 @@ WHICH=$unixtests/which.test
### skip this if the user just needs help...
if [ "$OPT_HELP" != "yes" ]; then
# create the include and include/qmake directory (for tqconfig.h and tqmodules.h)
[ -d $outpath/include/qmake ] || mkdir -p $outpath/include/qmake
# create the include and include/tqmake directory (for tqconfig.h and tqmodules.h)
[ -d $outpath/include/tqmake ] || mkdir -p $outpath/include/tqmake
# create temporary tqconfig.h for compiling qmake
# when building qmake, we use #defines for the install paths,
# create temporary tqconfig.h for compiling tqmake
# when building tqmake, we use #defines for the install paths,
# however they are real functions in the library
cat >>$outpath/include/qmake/tqconfig.h <<EOF
/* All features enabled while building qmake */
cat >>$outpath/include/tqmake/tqconfig.h <<EOF
/* All features enabled while building tqmake */
EOF
# create temporary tqmodules.h for compiling qmake
cat >>$outpath/include/qmake/tqmodules.h <<EOF
/* All modules enabled while building qmake */
# create temporary tqmodules.h for compiling tqmake
cat >>$outpath/include/tqmake/tqmodules.h <<EOF
/* All modules enabled while building tqmake */
EOF
# is this a shadow build?
@ -1005,8 +1005,8 @@ if [ "$OPT_SHADOW" = "yes" ]; then
exit 1
fi
# symlink the qmake directory
for a in `find $relpath/qmake`; do
# symlink the tqmake directory
for a in `find $relpath/tqmake`; do
my_a=`echo $a | sed "s,^${relpath}/,${outpath}/,"`
if [ '!' -f $my_a ]; then
if [ -d $a ]; then
@ -1017,7 +1017,7 @@ if [ "$OPT_SHADOW" = "yes" ]; then
[ -d $a_dir ] || mkdir -p $a_dir
# ... and files are symlinked
case `basename $a` in
*.o|*.d|GNUmakefile*|qmake)
*.o|*.d|GNUmakefile*|tqmake)
;;
*)
rm -f $my_a
@ -1309,15 +1309,15 @@ if [ '!' -f "${XQMAKESPEC}/qplatformdefs.h" ]; then
fi
# now look at the configs and figure out what platform we are config'd for
[ '!' -z "`grep QMAKE_LIBS_X11 $XQMAKESPEC/qmake.conf | awk '{print $3;}'`" ] && PLATFORM_X11=yes
[ '!' -z "`grep QMAKE_LIBS_X11 $XQMAKESPEC/tqmake.conf | awk '{print $3;}'`" ] && PLATFORM_X11=yes
# find default thread option for target
if grep >/dev/null '^QMAKE_LIBS_THREAD' $XQMAKESPEC/qmake.conf; then
if grep >/dev/null '^QMAKE_LIBS_THREAD' $XQMAKESPEC/tqmake.conf; then
AUTOTHREAD=yes
else
AUTOTHREAD=never
fi
# common qmake.conf file but dependency on OS version
# common tqmake.conf file but dependency on OS version
if [ "$UNAME_SYSTEM" = "HP-UX" ]; then
if echo $UNAME_RELEASE | grep -E "^B\.(09|10)" >/dev/null 2>&1; then
AUTOTHREAD=never
@ -1326,15 +1326,15 @@ fi
if [ "$UNAME_SYSTEM" = "SunOS" ]; then
# Solaris 2.5 and 2.6 have libposix4, which was renamed to librt for Solaris >=7
if echo $UNAME_RELEASE | grep "^5\.[5|6]" >/dev/null 2>&1; then
sed -e "s,-lrt,-lposix4," $XQMAKESPEC/qmake.conf > $XQMAKESPEC/qmake.conf.new
mv $XQMAKESPEC/qmake.conf.new $XQMAKESPEC/qmake.conf
sed -e "s,-lrt,-lposix4," $XQMAKESPEC/tqmake.conf > $XQMAKESPEC/tqmake.conf.new
mv $XQMAKESPEC/tqmake.conf.new $XQMAKESPEC/tqmake.conf
fi
fi
if [ $AUTOTHREAD = never ]; then
if [ "$CFG_THREAD" = "yes" ]; then
echo
echo "ERROR: TQt is not configured to support threading on this platform"
echo " See the THREAD settings in $XQMAKESPEC/qmake.conf"
echo " See the THREAD settings in $XQMAKESPEC/tqmake.conf"
echo
exit 2
fi
@ -1344,7 +1344,7 @@ fi
#-------------------------------------------------------------------------------
# tests that don't need qmake (must be run before displaying help)
# tests that don't need tqmake (must be run before displaying help)
#-------------------------------------------------------------------------------
# auto-detect precompiled header support
@ -1766,7 +1766,7 @@ Configure options:
-fast .............. Configure TQt quickly by generating Makefiles only for
library and subdirectory targets. All other Makefiles
are created as wrappers, which will in turn run qmake.
are created as wrappers, which will in turn run tqmake.
* -no-fast ........... Configure TQt normally by generating Makefiles for all
project files.
@ -2058,7 +2058,7 @@ irix-cc*)
esac
# -----------------------------------------------------------------------------
# build qmake
# build tqmake
# -----------------------------------------------------------------------------
# symlink includes
@ -2073,9 +2073,9 @@ if [ "$OPT_SHADOW" = "yes" ]; then
QMAKE_VARS="$QMAKE_VARS \"INCLUDEPATH+=${outpath}/include\""
fi
# build qmake
# build tqmake
if true; then ###[ '!' -f "$outpath/bin/tqmake" ];
echo "Creating qmake. Please wait..."
echo "Creating tqmake. Please wait..."
rm -f mkspecs/default
ln -s `echo $QMAKESPEC | sed "s,^${relpath}/mkspecs/,,"` mkspecs/default
# fix makefiles
@ -2084,13 +2084,13 @@ if true; then ###[ '!' -f "$outpath/bin/tqmake" ];
EXTRA_CFLAGS=
in_mkfile="${mkfile}.in"
if [ "$mkfile" = "Makefile" ]; then
# if which qmake >/dev/null 2>&1 && [ -f qmake/qmake.pro ]; then
# (cd qmake && qmake) >/dev/null 2>&1 && continue
# if which tqmake >/dev/null 2>&1 && [ -f tqmake/tqmake.pro ]; then
# (cd tqmake && tqmake) >/dev/null 2>&1 && continue
# fi
in_mkfile="${mkfile}.unix"
fi
in_mkfile="$relpath/qmake/$in_mkfile"
mkfile="$outpath/qmake/$mkfile"
in_mkfile="$relpath/tqmake/$in_mkfile"
mkfile="$outpath/tqmake/$mkfile"
if [ -f "$mkfile" ]; then
[ "$Edition" = "troll" ] && $WHICH chflags >/dev/null 2>&1 && chflags nouchg $mkfile
rm -f $mkfile
@ -2103,19 +2103,19 @@ if true; then ###[ '!' -f "$outpath/bin/tqmake" ];
EXTRA_CFLAGS="\$(QMAKE_CFLAGS)"
EXTRA_CXXFLAGS="\$(QMAKE_CXXFLAGS)"
EXTRA_LFLAGS="\$(QMAKE_LFLAGS)"
grep "^QMAKE_CC[^_A-Z0-9]" $QMAKESPEC/qmake.conf | sed "s,QMAKE_CC,CC," >>$mkfile
grep "^QMAKE_CXX[^_A-Z0-9]" $QMAKESPEC/qmake.conf | sed "s,QMAKE_CXX,CXX," >>$mkfile
grep "^QMAKE_CFLAGS[^_A-Z0-9]" $QMAKESPEC/qmake.conf >>$mkfile
grep "^QMAKE_CXXFLAGS[^_A-Z0-9]" $QMAKESPEC/qmake.conf | sed "s,\$\$QMAKE_CFLAGS,\$(QMAKE_CFLAGS)," >>$mkfile
grep "^QMAKE_LFLAGS[^_A-Z0-9]" $QMAKESPEC/qmake.conf >>$mkfile
grep "^QMAKE_CC[^_A-Z0-9]" $QMAKESPEC/tqmake.conf | sed "s,QMAKE_CC,CC," >>$mkfile
grep "^QMAKE_CXX[^_A-Z0-9]" $QMAKESPEC/tqmake.conf | sed "s,QMAKE_CXX,CXX," >>$mkfile
grep "^QMAKE_CFLAGS[^_A-Z0-9]" $QMAKESPEC/tqmake.conf >>$mkfile
grep "^QMAKE_CXXFLAGS[^_A-Z0-9]" $QMAKESPEC/tqmake.conf | sed "s,\$\$QMAKE_CFLAGS,\$(QMAKE_CFLAGS)," >>$mkfile
grep "^QMAKE_LFLAGS[^_A-Z0-9]" $QMAKESPEC/tqmake.conf >>$mkfile
if [ "$CFG_DEBUG" = "yes" ]; then
grep "QMAKE_CFLAGS_DEBUG[^_A-Z0-9]" $QMAKESPEC/qmake.conf >>$mkfile
grep "^QMAKE_CXXFLAGS_DEBUG[^_A-Z0-9]" $QMAKESPEC/qmake.conf | sed "s,\$\$QMAKE_CFLAGS_DEBUG,\$(QMAKE_CFLAGS_DEBUG)," >>$mkfile
grep "QMAKE_CFLAGS_DEBUG[^_A-Z0-9]" $QMAKESPEC/tqmake.conf >>$mkfile
grep "^QMAKE_CXXFLAGS_DEBUG[^_A-Z0-9]" $QMAKESPEC/tqmake.conf | sed "s,\$\$QMAKE_CFLAGS_DEBUG,\$(QMAKE_CFLAGS_DEBUG)," >>$mkfile
EXTRA_CFLAGS="$EXTRA_CFLAGS \$(QMAKE_CFLAGS_DEBUG)"
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(QMAKE_CXXFLAGS_DEBUG)"
else
grep "QMAKE_CFLAGS_RELEASE[^_A-Z0-9]" $QMAKESPEC/qmake.conf >>$mkfile
grep "^QMAKE_CXXFLAGS_RELEASE[^_A-Z0-9]" $QMAKESPEC/qmake.conf | sed "s,\$\$QMAKE_CFLAGS_RELEASE,\$(QMAKE_CFLAGS_RELEASE)," >>$mkfile
grep "QMAKE_CFLAGS_RELEASE[^_A-Z0-9]" $QMAKESPEC/tqmake.conf >>$mkfile
grep "^QMAKE_CXXFLAGS_RELEASE[^_A-Z0-9]" $QMAKESPEC/tqmake.conf | sed "s,\$\$QMAKE_CFLAGS_RELEASE,\$(QMAKE_CFLAGS_RELEASE)," >>$mkfile
EXTRA_CFLAGS="$EXTRA_CFLAGS \$(QMAKE_CFLAGS_RELEASE)"
EXTRA_CXXFLAGS="$EXTRA_CXXFLAGS \$(QMAKE_CXXFLAGS_RELEASE)"
fi
@ -2157,21 +2157,21 @@ if true; then ###[ '!' -f "$outpath/bin/tqmake" ];
if [ "$Edition" = "troll" ] &&
$WHICH makedepend >/dev/null 2>&1 && grep 'depend:' "$mkfile" >/dev/null 2>&1; then
(cd $outpath/qmake && $MAKE -f $mkfile depend) >/dev/null 2>&1
(cd $outpath/tqmake && $MAKE -f $mkfile depend) >/dev/null 2>&1
fi
done
(cd $outpath/qmake; $MAKE || (echo "qmake failed to build. Aborting." && exit 2)) || exit 2
(cd $outpath/tqmake; $MAKE || (echo "tqmake failed to build. Aborting." && exit 2)) || exit 2
fi
# clean up temporary tqconfig.h and tqmodules.h
rm -f $outpath/include/qmake/tqconfig.h
rm -f $outpath/include/qmake/tqmodules.h
rmdir $outpath/include/qmake
rm -f $outpath/include/tqmake/tqconfig.h
rm -f $outpath/include/tqmake/tqmodules.h
rmdir $outpath/include/tqmake
#-------------------------------------------------------------------------------
# tests that need qmake
# tests that need tqmake
#-------------------------------------------------------------------------------
# work around broken X11 headers when using GCC 2.95 or later
@ -2186,7 +2186,7 @@ if [ $PLATFORM = "hpux-acc" -a "$CFG_STL" != "no" ]; then
echo
echo "As of aCC A.3.0.30 you may enable STL support in TQt by adding -AA"
echo "to the QMAKE_CXXFLAGS and QMAKE_LFLAGS variables in"
echo "$XQMAKESPEC/qmake.conf"
echo "$XQMAKESPEC/tqmake.conf"
echo "and re-running configure. Make sure to use the -AA compiler switch"
echo "in all your software projects using TQt as it turns on the new C++"
echo "Standard Library which is not binary compatible with the old one."
@ -2473,7 +2473,7 @@ fi
[ '!' -z "$l_FLAGS" ] && QMAKE_VARS="$QMAKE_VARS \"LIBS+=$l_FLAGS\""
if [ '!' -z "$R_FLAGS" ]; then
if grep QMAKE_RPATH $XQMAKESPEC/qmake.conf >/dev/null; then
if grep QMAKE_RPATH $XQMAKESPEC/tqmake.conf >/dev/null; then
echo # Using -R/-rpath, so no need to warn
else
echo
@ -2557,7 +2557,7 @@ fi
case "$COMPILER" in
g++*)
# GNU C++
QMAKE_CONF_COMPILER=`grep "QMAKE_CXX[^_A-Z0-9a-z]" $QMAKESPEC/qmake.conf | sed "s,.* *= *\(.*\)$,\1,"`
QMAKE_CONF_COMPILER=`grep "QMAKE_CXX[^_A-Z0-9a-z]" $QMAKESPEC/tqmake.conf | sed "s,.* *= *\(.*\)$,\1,"`
COMPILER_VERSION=`${QMAKE_CONF_COMPILER} -dumpversion 2>/dev/null | sed 's,^[^0-9]*,,g'`
case "$COMPILER_VERSION" in
2.95.*)
@ -2576,7 +2576,7 @@ g++*)
;;
clang)
# Clang
QMAKE_CONF_COMPILER=`grep "QMAKE_CXX[^_A-Z0-9a-z]" $QMAKESPEC/qmake.conf | sed "s,.* *= *\(.*\)$,\1,"`
QMAKE_CONF_COMPILER=`grep "QMAKE_CXX[^_A-Z0-9a-z]" $QMAKESPEC/tqmake.conf | sed "s,.* *= *\(.*\)$,\1,"`
COMPILER_VERSION=`${QMAKE_CONF_COMPILER} -dumpversion 2>/dev/null | sed 's,^[^0-9]*,,g'`
case "$COMPILER_VERSION" in
*)
@ -2818,10 +2818,10 @@ fi
#-------------------------------------------------------------------------------
# save configuration into .qmake.cache
# save configuration into .tqmake.cache
#-------------------------------------------------------------------------------
CACHEFILE=$outpath/.qmake.cache
CACHEFILE=$outpath/.tqmake.cache
[ -f $CACHEFILE.tmp ] && rm -f $CACHEFILE.tmp
cat >>$CACHEFILE.tmp <<EOF
CONFIG += $QMAKE_CONFIG dylib create_prl link_prl
@ -2862,10 +2862,10 @@ if [ "$CFG_INCREMENTAL" = "yes" ]; then
INCREMENTAL="$INCREMENTAL `basename $f | sed 's,.cpp,.o,'`"
done
[ '!' -z "$INCREMENTAL" ] && echo "QMAKE_INCREMENTAL += $INCREMENTAL" >>$CACHEFILE.tmp
[ -r "$outpath/.qmake.incremental" ] && echo "include($outpath/.qmake.incremental)" >>$CACHEFILE.tmp
[ -r "$outpath/.tqmake.incremental" ] && echo "include($outpath/.tqmake.incremental)" >>$CACHEFILE.tmp
fi
# replace .qmake.cache if it differs from the newly created temp file
# replace .tqmake.cache if it differs from the newly created temp file
if cmp -s $CACHEFILE.tmp $CACHEFILE; then
rm -f $CACHEFILE.tmp
else
@ -2933,8 +2933,8 @@ else
fi
if [ "$OPT_VERBOSE" = "yes" ]; then
echo "qmake vars ...... $QMAKE_VARS"
echo "qmake switches .. $QMAKE_SWITCHES"
echo "tqmake vars ...... $QMAKE_VARS"
echo "tqmake switches .. $QMAKE_SWITCHES"
fi
[ "$OPT_CONCURRENT" != "0" ] && echo "Concurrent .......... $OPT_CONCURRENT"
@ -3172,7 +3172,7 @@ for file in .projects .projects.3; do
for a in `cat $file`; do
case $a in
*-kde.pro|*qtmain.pro) continue ;;
*/qmake/qmake.pro) continue ;;
*/tqmake/tqmake.pro) continue ;;
*projects.pro) continue ;;
*-pro.pro)
[ "x$Edition" != "xpro" ] && continue
@ -3185,8 +3185,8 @@ for file in .projects .projects.3; do
OUTDIR=$outpath/$dir
if [ -f "${OUTDIR}/Makefile" ] && [ "$OPT_FAST" = "yes" ]; then
# fast configure - the makefile exists, skip it
# since the makefile exists, it was generated by qmake, which means we
# can skip it, since qmake has a rule to regenerate the makefile if the .pro
# since the makefile exists, it was generated by tqmake, which means we
# can skip it, since tqmake has a rule to regenerate the makefile if the .pro
# file changes...
[ "$OPT_VERBOSE" = "yes" ] && echo " skipping $a"
continue;
@ -3211,7 +3211,7 @@ for file in .projects .projects.3; do
# WARNING: This makefile will be replaced with a real makefile.
# All changes made to this file will be lost.
all clean install qmake Makefile: FORCE
all clean install tqmake Makefile: FORCE
$outpath/bin/tqmake $QMAKE_SWITCHES $QMAKE_SPEC_ARGS -o $OUTDIR $a
cd $OUTDIR
\$(MAKE) \$@

@ -43,7 +43,7 @@ called e.g. "myapp.rc" in which you put a single line of text:
IDI_ICON1 ICON DISCARDABLE "myappico.ico"
\endcode
Finally, assuming you are using \link qmake-manual.book qmake\endlink
Finally, assuming you are using \link tqmake-manual.book tqmake\endlink
to generate your makefiles, add this line to your "myapp.pro" file:
\code
@ -53,7 +53,7 @@ RC_FILE = myapp.rc
Regenerate your makefile and your application. The .exe file will now be
represented with your icon e.g. in Explorer.
If you do not use \link qmake-manual.book qmake\endlink, the necessary
If you do not use \link tqmake-manual.book tqmake\endlink, the necessary
steps are: first, run the "rc" program on the .rc file, then link your
application with the resulting .res file.
@ -76,7 +76,7 @@ different sized icons (for use in different contexts) as well as the masks
that go with them. Save the set of icons to a file in your project
directory.
If you are using \link qmake-manual.book qmake\endlink to generate
If you are using \link tqmake-manual.book tqmake\endlink to generate
your make files, you only need to add a single line to your \c .pro
project file. For example, if the name of your icon file is
\c{myapp.icns}, and your project file is \c{myapp.pro}, add this line
@ -84,11 +84,11 @@ to \c{myapp.pro}:
\code
RC_FILE = myapp.icns
\endcode
This will ensure that \link qmake-manual.book qmake\endlink puts your
This will ensure that \link tqmake-manual.book tqmake\endlink puts your
icons in the proper place and creates an \c{Info.plist} entry for the
icon.
If you do not use \link qmake-manual.book qmake\endlink, you must do
If you do not use \link tqmake-manual.book tqmake\endlink, you must do
the following manually:
\list 1
\i Create an Info.plist file for your application (using the

@ -442,12 +442,12 @@ used by both TQt Designer and TQt Linguist for browsing their help
documentation.
\section1 qmake
\section1 tqmake
To ease portability we now provide the \link qmake-manual.book
qmake\endlink utility to replace tmake. QMake is a C++ version of
To ease portability we now provide the \link tqmake-manual.book
tqmake\endlink utility to replace tmake. TQMake is a C++ version of
tmake which offers additional functionallity that is difficult to
reproduce in tmake. Trolltech uses qmake in its build system for Qt
reproduce in tmake. Trolltech uses tqmake in its build system for Qt
and related products and we have released it as free software.
*/

@ -70,7 +70,7 @@ called e.g. "myapp.rc" in which you put a single line of text:
IDI_ICON1 ICON DISCARDABLE "myappico.ico"
</pre>
<p> Finally, assuming you are using <a href="qmake-manual.html">qmake</a>
<p> Finally, assuming you are using <a href="tqmake-manual.html">tqmake</a>
to generate your makefiles, add this line to your "myapp.pro" file:
<p> <pre>
RC_FILE = myapp.rc
@ -78,7 +78,7 @@ RC_FILE = myapp.rc
<p> Regenerate your makefile and your application. The .exe file will now be
represented with your icon e.g. in Explorer.
<p> If you do not use <a href="qmake-manual.html">qmake</a>, the necessary
<p> If you do not use <a href="tqmake-manual.html">tqmake</a>, the necessary
steps are: first, run the "rc" program on the .rc file, then link your
application with the resulting .res file.
<p> <h2> Setting the Application Icon on Mac OS X
@ -97,7 +97,7 @@ Developer/Application folder). <em>Icon Composer</em> allows you to import sever
different sized icons (for use in different contexts) as well as the masks
that go with them. Save the set of icons to a file in your project
directory.
<p> If you are using <a href="qmake-manual.html">qmake</a> to generate
<p> If you are using <a href="tqmake-manual.html">tqmake</a> to generate
your make files, you only need to add a single line to your <tt>.pro</tt>
project file. For example, if the name of your icon file is
<tt>myapp.icns</tt>, and your project file is <tt>myapp.pro</tt>, add this line
@ -106,10 +106,10 @@ to <tt>myapp.pro</tt>:
RC_FILE = myapp.icns
</pre>
This will ensure that <a href="qmake-manual.html">qmake</a> puts your
This will ensure that <a href="tqmake-manual.html">tqmake</a> puts your
icons in the proper place and creates an <tt>Info.plist</tt> entry for the
icon.
<p> If you do not use <a href="qmake-manual.html">qmake</a>, you must do
<p> If you do not use <a href="tqmake-manual.html">tqmake</a>, you must do
the following manually:
<ol type=1>
<li> Create an Info.plist file for your application (using the

@ -32,7 +32,7 @@ body { background: #ffffff; color: black; }
<h2 align="center">Customizing TQt Assistant</h2>
<p><em>TQt Assistant</em> can be customized by adding and removing documentation from its documentation set. In addition, <em>TQt Assistant</em> introduces the profiles option, which enables its properties to change, for example, the default startup page, and application icon.</p>
<h3><a name="1"></a>Modifying the Default Documentation Set</h3>
<p>When it is started without any options, <em>TQt Assistant</em> displays a default set of documentation. When TQt is installed, the default documentation set in <em>TQt Assistant</em> contains the TQt reference documentation as well as the tools that come with TQt, such as <em>TQt Designer</em> and qmake.</p>
<p>When it is started without any options, <em>TQt Assistant</em> displays a default set of documentation. When TQt is installed, the default documentation set in <em>TQt Assistant</em> contains the TQt reference documentation as well as the tools that come with TQt, such as <em>TQt Designer</em> and tqmake.</p>
<p>Documentation can be added or removed from <em>TQt Assistant</em> by adding and removing the content files. The format of the content files are specified below. To add a content file, type the following command line option: <tt>-addContentFile docfile</tt>. To remove a content file from the default set, type the following command line option: <tt>-removeContentFile docfile</tt>. For example:</p>
<pre>
1: &gt; assistant -addContentFile file.dcf

@ -72,7 +72,7 @@ the relevant release of TQt.
<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/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>tquic</tt>. If you use <tt>qmake</tt> the
to your <tt>PATH</tt> and run <a href="tqmoc.html#tqmoc">tqmoc</a> and <tt>tquic</tt>. If you use <tt>tqmake</tt> the
appropriate lines will be added to your Makefiles so that <em>tquic</em> and
<em>tqmoc</em> will be executed as required.
<p> <dt>Static or shared libraries - Link time

@ -35,10 +35,10 @@ body { background: #ffffff; color: black; }
<p><em>TQt Designer</em> helps you build user interfaces with layout tools that move and scale your widgets (<em>controls</em> in Windows terminology) automatically at runtime. The resulting interfaces are both functional and attractive, comfortably suiting your users' operating environments and preferences. <em>TQt Designer</em> supports TQt's signals and slots mechanism for type-safe communication between widgets. <em>TQt Designer</em> includes a code editor which you can use to embed your own custom slots inside the generated code. Those who prefer to separate generated code from hand crafted code can continue to use the subclassing approach pioneered in the first version of <em>TQt Designer</em>.<!-- index Controls!Widgets --></p>
<p>The manual introduces you to <em>TQt Designer</em> by leading you through the development of example applications. The first seven chapters are tutorials, each designed to be as self-contained as possible. Every chapter, except the first three, assumes that you are familiar with the material in chapters two and three which cover the basics of building a TQt application with <em>TQt Designer</em>. Here's a brief overview of the chapters:</p>
<ul><li><p>Chapter one, <a href="designer-manual-2.html">Quick Start</a>, is a fast hands-on tutorial that takes you through the creation of a short, simple dialog application. The aim of this chapter is to give you a feel for how <em>TQt Designer</em> works, with explanations and details deferred to later chapters.</p>
<li><p>Chapter two, <a href="designer-manual-3.html">Creating a Main Window Application</a>, introduces <em>TQt Designer</em> and takes you step by step through the creation of a small but fully functional application. Along the way you will learn how to create a main window with menus, toolbars and a status bar. Most of the application's implementation will be covered, but the custom dialogs are deferred until chapter three. In the course of this chapter you will use the form and property editors to customize the application. You'll also learn how to use TQt's signals and slots mechanism and <em>TQt Designer</em>'s built-in code editor to make the application functional. We will also explain how to use <tt>qmake</tt> to generate a Makefile so that you can compile and run the application.</p>
<li><p>Chapter two, <a href="designer-manual-3.html">Creating a Main Window Application</a>, introduces <em>TQt Designer</em> and takes you step by step through the creation of a small but fully functional application. Along the way you will learn how to create a main window with menus, toolbars and a status bar. Most of the application's implementation will be covered, but the custom dialogs are deferred until chapter three. In the course of this chapter you will use the form and property editors to customize the application. You'll also learn how to use TQt's signals and slots mechanism and <em>TQt Designer</em>'s built-in code editor to make the application functional. We will also explain how to use <tt>tqmake</tt> to generate a Makefile so that you can compile and run the application.</p>
<li><p>In chapter three, <a href="designer-manual-4.html">Creating Dialogs</a>, we will create the custom dialogs required by the main window application created in chapter two. In addition to demonstrating various ways of creating dialogs, you will also learn how to lay out forms using the layout tools.</p>
<li><p>Chapter four, <a href="designer-manual-5.html#the-designer-approach">The Designer Approach</a>, provides information on the <em>TQt Designer</em> approach to developing applications, and explains some of the rationale behind <em>TQt Designer</em>.</p>
<li><p>Chapter five, <a href="designer-manual-6.html">Subclassing and Dynamic Dialogs</a>, will show you how to subclass a form; this allows you to clearly separate the user interface from the underlying code that implements its functionality. Additional information on <tt>qmake</tt> and <tt>tquic</tt> is included in this chapter. This chapter will also explain how you can dynamically load dialogs from<!-- index .ui --> <tt>.ui</tt> files into your application using <a href="tqwidgetfactory.html">TQWidgetFactory</a> and how to access the widgets and sub-widgets of these dialogs.</p>
<li><p>Chapter five, <a href="designer-manual-6.html">Subclassing and Dynamic Dialogs</a>, will show you how to subclass a form; this allows you to clearly separate the user interface from the underlying code that implements its functionality. Additional information on <tt>tqmake</tt> and <tt>tquic</tt> is included in this chapter. This chapter will also explain how you can dynamically load dialogs from<!-- index .ui --> <tt>.ui</tt> files into your application using <a href="tqwidgetfactory.html">TQWidgetFactory</a> and how to access the widgets and sub-widgets of these dialogs.</p>
<li><p>Chapter six, <a href="designer-manual-7.html">Creating Custom Widgets</a>, explains how you can create your own custom widgets. Both the simple method, that was introduced with the first version of <em>TQt Designer</em>, and the new more powerful method using plugins, are explained.</p>
<li><p>Chapter seven, <a href="designer-manual-8.html">Creating Database Applications</a> introduces TQt's SQL classes and takes you through an example that demonstrates how to execute SQL queries and how to set up master-detail relationships, perform drilldown and handle foreign keys.</p>
<li><p>Chapter eight, <a href="designer-manual-9.html">Customizing and Integrating TQt Designer</a>, focuses on <em>TQt Designer</em> itself, showing you how to customize Designer, how to integrate Designer with Visual Studio and how to create Makefiles.</p>

@ -204,7 +204,7 @@ body { background: #ffffff; color: black; }
<p align="center"><img align="middle" src="rd-projset2.png" width="383" height="273">
</p>
<blockquote><p align="center"><em>Project Settings- C++ Tab</em></p></blockquote>
<p>Click the C++ Tab to change the <tt>qmake</tt> options. See the <a href="qmake-manual.html">qmake documentation</a> for details on what these options mean. Click the 'Template' combobox and choose application or library to create makefiles for building applications or libraries. Click the 'Config' combobox to select the project configuration and compiler options for all platforms, or specific platforms. Type the Config value in the line edit. Note: Unix defaults to a shared library. If you want a shared library in Windows, type 'dll' at the end of the default config command and make sure you select lib from the Template combobox. Click the 'Libs' combobox to select a platform. Type the libraries in the line edit. Click the 'Defines' combobox and select a platform. 'Defines' values are added as compiler pre-processor macros. Type the 'Defines' values in the line edit. Click the 'Includepath' combobox to select a platform. Includepath specifies the directories that should be searched for include files when compiling the project. Type the 'Includepath' values in the line edit.</p>
<p>Click the C++ Tab to change the <tt>tqmake</tt> options. See the <a href="tqmake-manual.html">tqmake documentation</a> for details on what these options mean. Click the 'Template' combobox and choose application or library to create makefiles for building applications or libraries. Click the 'Config' combobox to select the project configuration and compiler options for all platforms, or specific platforms. Type the Config value in the line edit. Note: Unix defaults to a shared library. If you want a shared library in Windows, type 'dll' at the end of the default config command and make sure you select lib from the Template combobox. Click the 'Libs' combobox to select a platform. Type the libraries in the line edit. Click the 'Defines' combobox and select a platform. 'Defines' values are added as compiler pre-processor macros. Type the 'Defines' values in the line edit. Click the 'Includepath' combobox to select a platform. Includepath specifies the directories that should be searched for include files when compiling the project. Type the 'Includepath' values in the line edit.</p>
<p>Cick <b>OK</b> to accept changes to the project settings. Click <b>Cancel</b> to exit the dialog without making any changes to the project settings.</p>
<h3><a name="6"></a>The Search Dialogs</h3>
<a name="dialog-find-text"></a><h4><a name="6-1"></a>Find Text Dialog</h4>

@ -277,7 +277,7 @@ body { background: #ffffff; color: black; }
<li><p>Click <b>Save</b> to save the project.</p>
</ul><p>Compiling and Running the Application</p>
<ul><li><p>Start or switch to a console, and navigate to the directory where the project is saved.</p>
<li><p>Run <em>qmake</em> on the project file (<tt>metric.pro</tt>) by typing <tt>qmake -o Makefile metric.pro</tt>.</p>
<li><p>Run <em>tqmake</em> on the project file (<tt>metric.pro</tt>) by typing <tt>tqmake -o Makefile metric.pro</tt>.</p>
<li><p>Run <em>make</em> (or <em>nmake</em> depending on your system).</p>
<li><p>After the project has compiled, run the application.</p>
</ul><h3><a name="5"></a>Wrapping Up</h3>

@ -55,7 +55,7 @@ body { background: #ffffff; color: black; }
<blockquote>
<p align="center"><b> Creating a Project</b></p>
<!-- index Projects --><!-- index Projects!Creating New --><!-- index Creating Projects!Projects --><!-- index Pixmaps!In Projects --><!-- index Pixmaps!Adding to Forms --><p>Whenever you create a new application we recommend that you create a project file and open the project rather than individual<!-- index .ui --> <tt>.ui</tt> files. Using a project has the advantage that all the forms you create for the project are available via a single mouse click rather than having to be loaded individually through file open dialogs. An additional benefit of using project files is that they allow you to store all your images in a single file rather than duplicate them in each form in which they appear. See <a href="designer-manual-5.html#the-designer-approach">The Designer Approach</a> chapter's <a href="designer-manual-5.html#2">Project management</a> section for detailed information on the benefits of using project files.</p>
<p>Project files use the <tt>.pro</tt> suffix and are used by the <tt>qmake</tt> tool to create makefiles for the relevant target platforms.</p>
<p>Project files use the <tt>.pro</tt> suffix and are used by the <tt>tqmake</tt> tool to create makefiles for the relevant target platforms.</p>
</blockquote>
<p>Create a new project as follows:</p>
<ol type=1><li><p>Click <b>File|New</b> to invoke the <em>New File</em> dialog.</p>
@ -492,9 +492,9 @@ body { background: #ffffff; color: black; }
<p>This ensures that our application will cleanly terminate. Later we'll revise this function to give the user the opportunity to save any unsaved data.</p>
<h4><a name="6-13"></a>Building and Running</h4>
<p>We now have some code in the application and a <tt>main.cpp</tt> containing the <tt>main()</tt> function, so we should be able to compile, link and run the application.</p>
<p>Click <b>File|Save</b> to ensure that all our work is saved to disk. Open a console (e.g. an xterm or DOS window), change directory to where you have saved the <tt>colortool</tt> project, and run <tt>qmake</tt> to generate a Makefile:</p>
<p>Click <b>File|Save</b> to ensure that all our work is saved to disk. Open a console (e.g. an xterm or DOS window), change directory to where you have saved the <tt>colortool</tt> project, and run <tt>tqmake</tt> to generate a Makefile:</p>
<pre>
qmake -o Makefile colortool.pro
tqmake -o Makefile colortool.pro
</pre>
<p>Now make the project (run <tt>nmake</tt> on Windows, <tt>make</tt> on other platforms). Providing you commented out the "findForm" and "loadSettings" lines in the <tt>init()</tt> function, the program should build. (If it doesn't build see the <a href="designer-manual-4.html#6">Troubleshooting</a> section.)</p>
<p>Once the make has finished, run the program. You still can't change views since we haven't written the code for that yet, but it does create a default set of colors. You can terminate the application by clicking the close (X) button or by clicking <b>File|Exit</b>.</p>

@ -57,9 +57,9 @@ body { background: #ffffff; color: black; }
<p>When you've opened or created a project you can set up its database connections using the <em>Edit Database Connections</em> dialog (invoked by the <b>Project|Database Connections</b> menu option). The connections you make are stored in a <tt>.db</tt> file. When you reload a project you can reconnect by going to the <em>Edit Database Connections</em> dialog, clicking a connection in the list and clicking the <b>Connect</b> button.</p>
<p>In most non-trivial database applications you will want to access the database from more than one form. This is why the <tt>.db</tt> file is part of a project, not just part of a single form.</p>
<h4><a name="2-4"></a>.pro files</h4>
<p><em>TQt Designer</em> needs to store information on projects, for example, the list of forms, the image collection and information about available databases and how to access them. The majority of TQt users already use a project file format to create multiplatform makefiles: <tt>tmake</tt> (and with TQt 3.0 <tt>qmake</tt>) project <tt>.pro</tt> files. These files already contain the list of forms, <tt>.ui</tt> files, used in the project for <tt>tquic</tt>.</p>
<p>We've extended the sections in the <tt>.pro</tt> file to include the extra information that <em>TQt Designer</em> needs to manage projects. For example, when you add a form to your project in <em>TQt Designer</em>, it is automatically added to the FORMS section of the project file, and thus <tt>qmake</tt> will generate the required build rules without any further work. Similarly, the images are added to the IMAGES section and thus gets automatically compiled into your executable.</p>
<p>We don't force you to use <tt>qmake</tt>; if you prefer another build system, for example automake/autoconf or jam, you can still continue to use it. Look upon the <tt>.pro</tt> file as a file that describes the GUI part of your application. All you need to do -- as previously -- is add the <tt>.ui</tt> files and the images collection to your own Makefiles.</p>
<p><em>TQt Designer</em> needs to store information on projects, for example, the list of forms, the image collection and information about available databases and how to access them. The majority of TQt users already use a project file format to create multiplatform makefiles: <tt>tmake</tt> (and with TQt 3.0 <tt>tqmake</tt>) project <tt>.pro</tt> files. These files already contain the list of forms, <tt>.ui</tt> files, used in the project for <tt>tquic</tt>.</p>
<p>We've extended the sections in the <tt>.pro</tt> file to include the extra information that <em>TQt Designer</em> needs to manage projects. For example, when you add a form to your project in <em>TQt Designer</em>, it is automatically added to the FORMS section of the project file, and thus <tt>tqmake</tt> will generate the required build rules without any further work. Similarly, the images are added to the IMAGES section and thus gets automatically compiled into your executable.</p>
<p>We don't force you to use <tt>tqmake</tt>; if you prefer another build system, for example automake/autoconf or jam, you can still continue to use it. Look upon the <tt>.pro</tt> file as a file that describes the GUI part of your application. All you need to do -- as previously -- is add the <tt>.ui</tt> files and the images collection to your own Makefiles.</p>
<h3><a name="3"></a>Extending the functionality of a form</h3>
<p>First let us look at a small figure that shows the relationship between <tt>.ui</tt> files, generated code and application code:</p>
<p align="center"><img align="middle" src="designer1.jpg">

@ -34,14 +34,14 @@ 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>tquic</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>
<p><em>TQt Designer</em> reads and writes <tt>tqmake</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>tquic</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 or Unix 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>
<p>You can then use <tt>tqmake</tt> to generate the Makefile. (For example <tt>tqmake -o Makefile myproject.pro</tt>.) Running <tt>make</tt> (Linux or Unix 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 tqmake!HEADERS --><!-- index tqmake!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>
<p>Suppose, for example, that we are developing a dialog and writing the code directly in <em>TQt Designer</em>. We might call our dialog 'OptionsForm' and the<!-- index .ui --> <tt>.ui</tt> file, <tt>optionsform.ui</tt>. The automatically generated files will be <tt>optionsform.h</tt> and <tt>optionsform.cpp</tt>.</p>
@ -94,7 +94,7 @@ int main( int argc, char *argv[] )
}
</pre>
<p>Note that we're including <tt>creditformbase.h</tt> and instantiating a CreditFormBase object; once we've written our subclass we'll replace the header with our subclass, <tt>creditform.h</tt>, and instantiate a CreditForm.</p>
<p>We can now generate the application with <tt>qmake</tt>, e.g. <tt>qmake -o Makefile credit.pro</tt>, make it and run it. The form should run fine, but doesn't yet have the behaviour we require.</p>
<p>We can now generate the application with <tt>tqmake</tt>, e.g. <tt>tqmake -o Makefile credit.pro</tt>, make it and run it. The form should run fine, but doesn't yet have the behaviour we require.</p>
<h5><a name="1-3-3"></a>Creating the Subclass</h5>
<p>We need to create a header and an implementation file for our subclass. The code for our subclass is minimal. The header file is <tt>qt/tools/designer/examples/credit/creditform.h</tt>:</p>
<pre> #include "creditformbase.h"
@ -134,7 +134,7 @@ int main( int argc, char *argv[] )
}
</pre>
<p>We call <tt>setAmount()</tt> in the constructor to ensure that the correct amount is shown when the form starts based on whichever radio button we checked in <em>TQt Designer</em>. In <tt>setAmount()</tt> we set the amount if the standard or none radio button is checked. If the user has checked the special radio button they are free to change the amount themselves.</p>
<!-- index Makefiles --><!-- index qmake!HEADERS --><!-- index qmake!SOURCES --><p>To be able to test our subclass we change<!-- index main.cpp --> <tt>main.cpp</tt> to include <tt>creditform.h</tt> rather than <tt>creditformbase.h</tt> and change the instantiation of the creditForm object:</p>
<!-- index Makefiles --><!-- index tqmake!HEADERS --><!-- index tqmake!SOURCES --><p>To be able to test our subclass we change<!-- index main.cpp --> <tt>main.cpp</tt> to include <tt>creditform.h</tt> rather than <tt>creditformbase.h</tt> and change the instantiation of the creditForm object:</p>
<pre> #include &lt;<a href="tqapplication-h.html">tqapplication.h</a>&gt;
#include "creditform.h"
@ -154,7 +154,7 @@ int main( int argc, char *argv[] )
HEADERS += creditform.h
SOURCES += creditform.cpp
</pre>
<p>To test the form rerun <tt>qmake</tt> to regenerate the Makefile, then make and run.</p>
<p>To test the form rerun <tt>tqmake</tt> to regenerate the Makefile, then make and run.</p>
<p>The subclassing example we've used is simple, but this reflects subclassing forms in TQt: it is easy to do.</p>
<a name="dynamicdialogs"></a><h3><a name="2"></a>Creating Dynamic Dialogs from .ui Files</h3>
<!-- index Dynamic Dialogs --><!-- index Dialogs!Dynamic --><!-- index Code Editing!Not in Dynamic Dialogs --><p>TQt programs are capable of loading <em>TQt Designer</em><!-- index .ui --> <tt>.ui</tt> files and instantiating the forms represented by the<!-- index .ui --> <tt>.ui</tt> files. Since the<!-- index .ui --> <tt>.ui</tt> file is not compiled it cannot include any C++ code, (e.g. slot implementations). In this section we will explain how to load a dynamic dialog and how to create a class that can be used to implement the dynamic dialog's custom slots.</p>

@ -244,7 +244,7 @@ CONFIG += qt warn_on release
DBFILE = filechooser.db
DEFINES += FILECHOOSER_IS_WIDGET
</pre>
<p>We can create the makefile using <tt>qmake</tt>: <tt>qmake -o Makefile filechooser.pro</tt>, then we can make and run the harness to test our new widget. Once we're satisfied that the custom widget is robust and has the behaviour we require we can embed it into a plugin.</p>
<p>We can create the makefile using <tt>tqmake</tt>: <tt>tqmake -o Makefile filechooser.pro</tt>, then we can make and run the harness to test our new widget. Once we're satisfied that the custom widget is robust and has the behaviour we require we can embed it into a plugin.</p>
<h4><a name="2-2"></a>Creating a Plugin</h4>
<!-- index Creating Plugins --><!-- index Plugins!Creating a Plugin --><!-- index Component!Plugins --><p>TQt Plugins can be used to provide self-contained software components for TQt applications. TQt currently supports the creation of five kinds of plugins: codecs, image formats, database drivers, styles and custom widgets. In this section we will explain how to convert our filechooser custom widget into a <em>TQt Designer</em> custom widget plugin.</p>
<p>A <em>TQt Designer</em> custom widget plugin is always derived from <a href="tqwidgetplugin.html">TQWidgetPlugin</a>. The amout of code that needs to be written is minimal.</p>
@ -372,7 +372,7 @@ INCLUDEPATH += $$QT_SOURCE_TREE/tools/designer/interfaces
DBFILE = plugin.db
</pre>
<blockquote><p align="center"><em><tt>qt/tools/designer/examples/filechooser/plugin/plugin.pro</tt></em></p></blockquote>
<p>Change the <tt>HEADERS</tt> line to list your plugin's header file plus a header file for each of your widgets. Make the equivalent change for the <tt>SOURCES</tt> line. If you create a Makefile with <tt>qmake</tt> and make the project the plugin will be created and placed in a directory where <em>TQt Designer</em> can find it. The next time you run <em>TQt Designer</em> it will detect your new plugin and load it automatically, displaying its icon in the toolbar you specified.</p>
<p>Change the <tt>HEADERS</tt> line to list your plugin's header file plus a header file for each of your widgets. Make the equivalent change for the <tt>SOURCES</tt> line. If you create a Makefile with <tt>tqmake</tt> and make the project the plugin will be created and placed in a directory where <em>TQt Designer</em> can find it. The next time you run <em>TQt Designer</em> it will detect your new plugin and load it automatically, displaying its icon in the toolbar you specified.</p>
<h5><a name="2-2-4"></a>Using the Widget Plugin</h5>
<p>Once the plugin has been compiled it will automatically be found and loaded by <em>TQt Designer</em> the next time <em>TQt Designer</em> is run. Use your custom widget just like any other.</p>
<p>If you want to use the plugin in another of your projects you can link against it by adding an appropriate line to the project, e.g. by adding a line like this to the project's <tt>.pro</tt> file:</p>

@ -67,7 +67,7 @@ body { background: #ffffff; color: black; }
<blockquote><p align="center"><em>Edit Database Connections Dialog</em></p></blockquote>
<p>Choose <b>Project|Database Connections</b> from the menu bar. The <em>Edit Database Connections</em> dialog will appear. Click <b>New Connection</b>. For applications that use a single database it will probably be most convenient to use the default connection name of '(default)'. If you use more than one database then each one must be given a unique name. A driver must be chosen from the Driver combo box. The database name may be available in the Database Name combo box or may have to be typed in. The database name, username, password, hostname and port should be provided by your database system administrator. When the Connection information has been completed click <b>Connect</b>. If the connection is made the connection name will appear in the list box on the left hand side of the dialog. You can now close the dialog; the connection settings will remain in effect until you change or delete them or exit from <em>TQt Designer</em>.</p>
<p><b>Warning:</b> If you are using an existing SQLite database, ensure that the name you specify in the "Database Name" field is not the same as the existing database file. <em>TQt Designer</em> will create a configuration file using the name given for the database and will overwrite any existing files with the same name.</p>
<!-- index Projects!Database Connections --><p><em>TQt Designer</em> can remember database connection settings in <tt>qmake</tt> project files. Create a new project, e.g. click <b>File|New</b>, then click the 'C++ Project' icon to invoke the <em>Project Settings</em> dialog. Click the ellipsis button to invoke the <em>Save As</em> dialog; navigate to the project's directory (creating it if necessary). Make sure you're in the project's directory, then enter a project name of 'book.pro'. Click the <b>Save</b> button to return to the <em>Project Settings</em> dialog, then click <b>OK</b>. Next time you start <em>TQt Designer</em> instead of opening individual <tt>.ui</tt> files open the <tt>.pro</tt> project file instead and <em>TQt Designer</em> will automatically reload the project's connection settings. To activate the connection click <b>Project|Database Connections</b>. The connections previously saved with the project will be listed in the left hand list box. Click the connection you wish to use and then click <b>Connect</b>. This connection will be used from now on, e.g. for previewing <a href="tqdatatable.html">TQDataTable</a>s. Opening a project file also causes <em>TQt Designer</em> to load in the list of forms associated with the project into the Project Overview window. In most of the explanation that follows we will assume that you use project files and have clicked <b>Connect</b> so that there is always a connection available when you work in <em>TQt Designer</em>.</p>
<!-- index Projects!Database Connections --><p><em>TQt Designer</em> can remember database connection settings in <tt>tqmake</tt> project files. Create a new project, e.g. click <b>File|New</b>, then click the 'C++ Project' icon to invoke the <em>Project Settings</em> dialog. Click the ellipsis button to invoke the <em>Save As</em> dialog; navigate to the project's directory (creating it if necessary). Make sure you're in the project's directory, then enter a project name of 'book.pro'. Click the <b>Save</b> button to return to the <em>Project Settings</em> dialog, then click <b>OK</b>. Next time you start <em>TQt Designer</em> instead of opening individual <tt>.ui</tt> files open the <tt>.pro</tt> project file instead and <em>TQt Designer</em> will automatically reload the project's connection settings. To activate the connection click <b>Project|Database Connections</b>. The connections previously saved with the project will be listed in the left hand list box. Click the connection you wish to use and then click <b>Connect</b>. This connection will be used from now on, e.g. for previewing <a href="tqdatatable.html">TQDataTable</a>s. Opening a project file also causes <em>TQt Designer</em> to load in the list of forms associated with the project into the Project Overview window. In most of the explanation that follows we will assume that you use project files and have clicked <b>Connect</b> so that there is always a connection available when you work in <em>TQt Designer</em>.</p>
<h4><a name="1-2"></a>Setting Up Connections for Applications</h4>
<p>The applications you create must make their own connections to the SQL database. We provide an example function, <tt>createConnections()</tt>, that you can use as a basis for your own code.<!-- index createConnections() --></p>
<pre>
@ -136,7 +136,7 @@ bool createConnections()
<ol type=1><li><p>Click on the form and change its name to 'BookForm' and its caption to 'Book'. Click on the <a href="tqdatatable.html">TQDataTable</a> and change its name to 'AuthorDataTable'.</p>
<li><p>Click <b>File|Save All</b>.</p>
<li><p>Open the project file, e.g.<!-- index book.pro --> <tt>book.pro</tt>, in a plain text editor and add the line: <tt>SOURCES += main.cpp</tt> at the end of the file.</p>
<li><p>Run <tt>qmake</tt> to generate the make file, e.g. <tt>qmake -o Makefile book.pro</tt>, then make and run the <tt>book</tt> program.</p>
<li><p>Run <tt>tqmake</tt> to generate the make file, e.g. <tt>tqmake -o Makefile book.pro</tt>, then make and run the <tt>book</tt> program.</p>
</ol><p>This example shows how easy it is to use <a href="tqdatatable.html">TQDataTable</a> to show the contents of a database table or view. You can use the application we've just built to update and delete author records. In the examples that follow we will cover insertions, setting up master-detail relationships, drilldown and foreign key lookups.</p>
<blockquote>
<p align="center"><b> A Note on Foreign Keys</b></p>

@ -101,15 +101,15 @@ body { background: #ffffff; color: black; }
<ul><li><p>New TQt Project -- A small application wizard</p>
<li><p>New TQt Dialog -- Add an empty TQt Dialog to the active project, or add an existing dialog</p>
<li><p>TQt GUI Designer -- Run <em>TQt Designer</em></p>
<li><p>Open TQt Project -- Runs <tt>qmake</tt> with a<!-- index .pro --> <tt>.pro</tt> file</p>
<li><p>Open TQt Project -- Runs <tt>tqmake</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 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 <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>
<h4><a name="3-1"></a>Creating Makefiles without tqmake</h4>
<!-- index Makefiles --><p>The <tt>tqmake</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>tquic</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>tquic</tt> is done <em>twice</em>:</p>
<pre>
@ -169,7 +169,7 @@ myform.cpp: myform.h myform.ui
myform.h: myform.ui
tquic myform.ui -o myform.h
</pre>
<p>To see more sophisticated Makefiles simply generate them using <tt>qmake</tt> on any of your TQt projects or any of the examples supplied with TQt.</p>
<p>To see more sophisticated Makefiles simply generate them using <tt>tqmake</tt> on any of your TQt projects or any of the examples supplied with TQt.</p>
<h3><a name="4"></a>Importing Foreign File Formats</h3>
<!-- index Foreign File Formats --><p>To import a file in a supported foreign file format click <b>File|Open</b>, then click the File Type combobox to choose the file type you wish to load. Click the required file and <em>TQt Designer</em> will convert and load the file.</p>
<p>The filters that <em>TQt Designer</em> uses to read foreign file formats are 'works in progress'. You may have different filters available in your version of <em>TQt Designer</em> than those described here. The easiest way to see which filters are available is to invoke the file open dialog; all your filters are listed in the File Type combobox.</p>

@ -470,7 +470,7 @@ in TQt Assistant.
<p> The main function is a standard implementation opening
the application main window.
<p> To build the example go to the helpsystem directory
(TQTDIR/examples/helpsystem) run qmake to generate the makefile,
(TQTDIR/examples/helpsystem) run tqmake to generate the makefile,
and use the make tool to build the library.
<hr>

@ -341,8 +341,8 @@ an example project file (<tt>.pro</tt> file):
<p> When you run <em>lupdate</em> or <em>lrelease</em>, you must give the name of the
project file as a command-line argument.
<p> In this example, four exotic languages are supported: Danish, Finnish,
Norwegian and Swedish. If you use <a href="qmake-manual.html">qmake</a>, you usually don't need an extra project
file for <em>lupdate</em>; your <tt>qmake</tt> project file will work fine once
Norwegian and Swedish. If you use <a href="tqmake-manual.html">tqmake</a>, you usually don't need an extra project
file for <em>lupdate</em>; your <tt>tqmake</tt> project file will work fine once
you add the <tt>TRANSLATIONS</tt> entry.
<p> In your application, you must <a href="tqtranslator.html#load">TQTranslator::load</a>() the translation
files appropriate for the user's language, and install them using <a href="tqapplication.html#installTranslator">TQApplication::installTranslator</a>().

@ -157,7 +157,7 @@ Licenses &amp; Credits
<li> <a href="designer-manual.html">TQt Designer</a>
<li> <a href="linguist-manual.html">TQt Linguist</a>
<li> <a href="assistant.html">TQt Assistant</a>
<li> <a href="qmake-manual.html">qmake</a>
<li> <a href="tqmake-manual.html">tqmake</a>
</ul>
</td>
<td valign="top">

@ -128,20 +128,20 @@ existing projects. It can also be started up by using the Ctrl+Shift+D key
combination in Visual Studio.
<p> <h3> Using the 'Open TQt Project' button
</h3>
<a name="3-4"></a><p> The 'Open TQt Project' button allows you to convert an existing <tt>qmake</tt> project file into a <tt>.dsp</tt> file which you can insert into
<a name="3-4"></a><p> The 'Open TQt Project' button allows you to convert an existing <tt>tqmake</tt> project file into a <tt>.dsp</tt> file which you can insert into
your existing workspace. When you click the 'Open TQt Project'
button, just select an existing <tt>qmake</tt> project file (a <tt>.pro</tt>
button, just select an existing <tt>tqmake</tt> project file (a <tt>.pro</tt>
file) and then click OK. You will get a message box at the end
which asks you to insert the newly created <tt>.dsp</tt> file into your
existing workspace.
<p> <h3> Using the 'Write TQt Project' button
</h3>
<a name="3-5"></a><p> The 'Write TQt Project' button creates a <tt>qmake</tt> project (<tt>.pro</tt>)
<a name="3-5"></a><p> The 'Write TQt Project' button creates a <tt>tqmake</tt> project (<tt>.pro</tt>)
file for your current project so that you can easily copy the files
onto another platform and be able to use <tt>qmake</tt> to create a Makefile
onto another platform and be able to use <tt>tqmake</tt> to create a Makefile
on that other platform. All you need to do is make the project you
want to create a <tt>.pro</tt> file for, and click on the button. Just
name your <tt>qmake</tt> project file and click Save.
name your <tt>tqmake</tt> project file and click Save.
<p> <h3> Using the 'Use TQt In Current Project' button
</h3>
<a name="3-6"></a><p> The 'Use TQt In Current Project' button simply adds in the necessary

@ -339,11 +339,11 @@ Designer and TQt Linguist. It offers index searching, a contents
overview, bookmarks history and incremental search. TQt Assistant is
used by both TQt Designer and TQt Linguist for browsing their help
documentation.
<p> <h2> qmake
<p> <h2> tqmake
</h2>
<a name="5"></a><p> To ease portability we now provide the <a href="qmake-manual.html">qmake</a> utility to replace tmake. TQMake is a C++ version of
<a name="5"></a><p> To ease portability we now provide the <a href="tqmake-manual.html">tqmake</a> utility to replace tmake. TQMake is a C++ version of
tmake which offers additional functionallity that is difficult to
reproduce in tmake. Trolltech uses qmake in its build system for TQt
reproduce in tmake. Trolltech uses tqmake in its build system for TQt
and related products and we have released it as free software.
<p>
<!-- eof -->

@ -30,10 +30,10 @@ body { background: #ffffff; color: black; }
</td>
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><p align="right">[<a href="linguist-manual-1.html">Prev: Introduction</a>] [<a href="linguist-manual.html">Home</a>] [<a href="linguist-manual-3.html">Next: Translators</a>]</p>
<h2 align="center">Release Manager</h2>
<!-- index Release Manager --><p>Two tools are provided for the release manager, <a href="linguist-manual-2.html#2">lupdate</a> and <a href="linguist-manual-2.html#3">lrelease</a>. These tools depend on <em>qmake</em> project files. You don't have to use <em>qmake</em>, though.</p>
<!-- index Release Manager --><p>Two tools are provided for the release manager, <a href="linguist-manual-2.html#2">lupdate</a> and <a href="linguist-manual-2.html#3">lrelease</a>. These tools depend on <em>tqmake</em> project files. You don't have to use <em>tqmake</em>, though.</p>
<p>A third tool, <tt>tqm2ts</tt>, can be used for converting TQt 2.x message files to <tt>.ts</tt> files.</p>
<h3><a name="1"></a>TQt Project Files</h3>
<!-- index .pro Files --><!-- index Project Files --><!-- index qmake!Project Files --><p><a href="linguist-manual-2.html#2">lupdate</a> and <a href="linguist-manual-2.html#3">lrelease</a> depend on information in the application's <tt>.pro</tt> TQt project file. There must be an entry in the <tt>TRANSLATIONS</tt> section of the project file for each language that is additional to the native language. A typical entry looks like this:</p>
<!-- index .pro Files --><!-- index Project Files --><!-- index tqmake!Project Files --><p><a href="linguist-manual-2.html#2">lupdate</a> and <a href="linguist-manual-2.html#3">lrelease</a> depend on information in the application's <tt>.pro</tt> TQt project file. There must be an entry in the <tt>TRANSLATIONS</tt> section of the project file for each language that is additional to the native language. A typical entry looks like this:</p>
<!-- index TRANSLATIONS!in Project Files --><pre> TRANSLATIONS = tt2_fr.ts \
tt2_nl.ts
</pre>

@ -43,7 +43,7 @@ body { background: #ffffff; color: black; }
<li><p>Run <a href="linguist-manual-2.html#2">lupdate</a> to incorporate any new text added to the application. <a href="linguist-manual-2.html#2">lupdate</a> synchronizes the user-visible text from the application with the translations; it does not destroy any data.</p>
<li><p>Steps 2 and 3 are repeated as often as necessary.</p>
<li><p>When a release of the application is needed <a href="linguist-manual-2.html#3">lrelease</a> is run to read the <tt>.ts</tt> files and produce the <tt>.qm</tt> files used by the application at runtime.</p>
</ol><!-- index .pro Files --><!-- index Project Files --><!-- index qmake!Project Files --><p>For <a href="linguist-manual-2.html#2">lupdate</a> to work successfully, it must know which translation files to produce. The files are simply listed in the application's <tt>.pro</tt> TQt project file, for example:</p>
</ol><!-- index .pro Files --><!-- index Project Files --><!-- index tqmake!Project Files --><p>For <a href="linguist-manual-2.html#2">lupdate</a> to work successfully, it must know which translation files to produce. The files are simply listed in the application's <tt>.pro</tt> TQt project file, for example:</p>
<pre> TRANSLATIONS = tt2_fr.ts \
tt2_nl.ts
</pre>
@ -233,7 +233,7 @@ int main( int argc, char **argv )
</p>
<blockquote><p align="center"><em>Tutorial 1 Screenshot, English version</em></p></blockquote>
<h5><a name="2-1-3"></a>Creating a Latin Message File</h5>
<!-- index tt1.pro --><!-- index Latin --><p>The first step is to create a project file, <tt>tt1.pro</tt>, that lists all the source files for the project. The project file can be a qmake project file, or even an ordinary makefile. Any file that contains</p>
<!-- index tt1.pro --><!-- index Latin --><p>The first step is to create a project file, <tt>tt1.pro</tt>, that lists all the source files for the project. The project file can be a tqmake project file, or even an ordinary makefile. Any file that contains</p>
<!-- index SOURCES!in Project Files --><!-- index TRANSLATIONS!in Project Files --><pre> SOURCES = main.cpp
TRANSLATIONS = tt1_la.ts
</pre>
@ -283,7 +283,7 @@ int main( int argc, char **argv )
<p align="center"><img align="middle" src="tt2_en.png" width="170" height="157">
</p>
<blockquote><p align="center"><em>Tutorial 2 Screenshot, English version</em></p></blockquote>
<!-- index .pro Files --><!-- index Project Files --><!-- index qmake!Project Files --><pre>TEMPLATE = app
<!-- index .pro Files --><!-- index Project Files --><!-- index tqmake!Project Files --><pre>TEMPLATE = app
CONFIG += qt warn_on
HEADERS = arrowpad.h \
mainwindow.h
@ -419,7 +419,7 @@ TRANSLATIONS = tt3_pt.ts
<li><p><tt>mainwindow.h</tt> contains the definition of <tt>MainWindow</tt>;</p>
<li><p><tt>mainwindow.cpp</tt> contains the implementation of <tt>MainWindow</tt>;</p>
<li><p><tt>main.cpp</tt> contains main();</p>
<li><p><tt>tt3.pro</tt> is the <em>qmake</em> project file.</p>
<li><p><tt>tt3.pro</tt> is the <em>tqmake</em> project file.</p>
<li><p><tt>tt3_pt.ts</tt> is the Portuguese message file.</p>
</ul><h5><a name="2-3-1"></a>Line by Line Walk-through</h5>
<p>The PrintPanel is defined in <tt>printpanel.h</tt>.</p>

@ -122,7 +122,7 @@ application bundle (the application directory), then you place these into a
directory called Frameworks, a subdirectory of the application bundle.
<p> The application finds these dynamic libraries if the libraries have an
install name of "@executable_path/../Frameworks/libname.dylib.
<p> If you use qmake and Makefiles, use the QMAKE_LFFLAGS_SONAME setting:
<p> If you use tqmake and Makefiles, use the QMAKE_LFFLAGS_SONAME setting:
<p> <pre>
QMAKE_LFLAGS_SONAME = -Wl,-install_name,@executable_path/../Frameworks/
</pre>
@ -158,7 +158,7 @@ have not been called yet).
<p> <h3> Plugin Support
</h3>
<a name="4-4"></a><p> Note that it is not possible to build TQt plugins using Project Builder
or Xcode. Use <a href="qmake-manual.html">qmake</a> to configure and
or Xcode. Use <a href="tqmake-manual.html">tqmake</a> to configure and
build plugins.
<p> <h2> Compiler Settings
</h2>

@ -149,13 +149,13 @@ library is static. If you just use the default configuration you
don't need to set certain preprocessor defines. In TQt 3.0, the
default configuration of the TQt library is to build it as a shared
library, therefore the preprocessor define <tt>QT_DLL</tt> is needed.
<p> If you use tmake with TQt 2.x, and now use qmake with TQt 3.x, then the
<p> If you use tmake with TQt 2.x, and now use tqmake with TQt 3.x, then the
cause of the problem is with the project file. In the project file,
there is usually line that looks like:
<p> <tt>CONFIG</tt> = ...
<p> this should be changed to
<p> <tt>CONFIG</tt> += ...
<p> so that qmake can look at the configuration that TQt was built with and
<p> so that tqmake can look at the configuration that TQt was built with and
set any relevant preprocessor defines in the makefile.
<p> <a name="Headers"></a>
<h2> Header file inclusion changes

@ -1,11 +0,0 @@
<!DOCTYPE DCF>
<DCF ref="qmake-manual.html" imagedir="../../gif" title="qmake User Guide">
<section ref="qmake-manual-1.html" title="Introduction to qmake"/>
<section ref="qmake-manual-2.html" title="Installing qmake"/>
<section ref="qmake-manual-3.html" title="The 10 minute guide to using qmake"/>
<section ref="qmake-manual-4.html" title="qmake Tutorial"/>
<section ref="qmake-manual-5.html" title="qmake Concepts"/>
<section ref="qmake-manual-6.html" title="qmake's Advanced Concepts"/>
<section ref="qmake-manual-7.html" title="Using Precompiled Headers"/>
<section ref="qmake-manual-8.html" title=" qmake Command Reference"/>
</DCF>

@ -111,14 +111,14 @@ accessiblity, and hopefully a host of assistive devices.
between their development toolkit and the platform's developer
tools (for example MSVC, gmake, etc). TQt/Mac supports both Unix
style Makefiles, and ProjectBuilder/Xcode project files by using
the qmake tool. For example:
the tqmake tool. For example:
<p> <pre>
qmake -spec macx-pbuilder project.pro
tqmake -spec macx-pbuilder project.pro
</pre>
<p> will generate an Xcode project file from project.pro. With qmake
<p> will generate an Xcode project file from project.pro. With tqmake
you do not have to worry about rules for TQt's preprocessors (tqmoc
and tquic) since qmake automatically handles them and ensures that
and tquic) since tqmake automatically handles them and ensures that
everything necessary is linked into your application.
<p> TQt does not entirely interact with the development environment (for
example plugins to set a file to 'mocable' from within the Xcode

@ -173,7 +173,7 @@ connection between them initially.
<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
<a href="tqmake-manual.html">tqmake</a>, the makefile rules to
automatically invoke the <a href="tqmoc.html">tqmoc</a> will be added to
your makefile for you.
<p> <h2> Signals

@ -130,12 +130,12 @@ transactions are enabled by default.
<a name="3-1-2"></a><p> You need the MySQL header files and as well as the shared library
<tt>libmysqlclient.so</tt>. Depending on your Linux distribution you need to
install a package which is usually called "mysql-devel".
<p> Tell <a href="qmake-manual.html">qmake</a> where to find the MySQL
<p> Tell <a href="tqmake-manual.html">tqmake</a> where to find the MySQL
header files and shared libraries (here it is assumed that MySQL is
installed in <tt>/usr/local</tt>) and run <tt>make</tt>:
<p> <pre>
cd $TQTDIR/plugins/src/sqldrivers/mysql
qmake -o Makefile "INCLUDEPATH+=/usr/local/include" "LIBS+=-L/usr/local/lib -lmysqlclient" mysql.pro
tqmake -o Makefile "INCLUDEPATH+=/usr/local/include" "LIBS+=-L/usr/local/lib -lmysqlclient" mysql.pro
make
</pre>
@ -147,7 +147,7 @@ Build the plugin as follows (here it is assumed that MySQL is
installed in <tt>C:&#92;MYSQL</tt>):
<p> <pre>
cd %TQTDIR%\plugins\src\sqldrivers\mysql
qmake -o Makefile "INCLUDEPATH+=C:\MYSQL\INCLUDE" "LIBS+=C:\MYSQL\LIB\OPT\LIBMYSQL.LIB" mysql.pro
tqmake -o Makefile "INCLUDEPATH+=C:\MYSQL\INCLUDE" "LIBS+=C:\MYSQL\LIB\OPT\LIBMYSQL.LIB" mysql.pro
nmake
</pre>
@ -189,27 +189,27 @@ Client install.
<li> <tt>libclntsh.so</tt> (all versions)
<li> <tt>libwtc8.so</tt> (only Oracle 8) or <tt>libwtc9.so</tt> (only Oracle 9)
</ul>
<p> Tell <tt>qmake</tt> where to find the Oracle header files and shared
<p> Tell <tt>tqmake</tt> where to find the Oracle header files and shared
libraries (it is assumed that the variable <tt>$ORACLE_HOME</tt> points to
the directory where Oracle is installed) and run make:
<p> If you are using Oracle 8:
<pre>
cd $TQTDIR/plugins/src/sqldrivers/oci
qmake -o Makefile "INCLUDEPATH+=$ORACLE_HOME/rdbms/public $ORACLE_HOME/rdbms/demo" "LIBS+=-L$ORACLE_HOME/lib -lclntsh -lwtc8" oci.pro
tqmake -o Makefile "INCLUDEPATH+=$ORACLE_HOME/rdbms/public $ORACLE_HOME/rdbms/demo" "LIBS+=-L$ORACLE_HOME/lib -lclntsh -lwtc8" oci.pro
make
</pre>
<p> For Oracle version 9:
<pre>
cd $TQTDIR/plugins/src/sqldrivers/oci
qmake -o Makefile "INCLUDEPATH+=$ORACLE_HOME/rdbms/public $ORACLE_HOME/rdbms/demo" "LIBS+=-L$ORACLE_HOME/lib -lclntsh -lwtc9" oci.pro
tqmake -o Makefile "INCLUDEPATH+=$ORACLE_HOME/rdbms/public $ORACLE_HOME/rdbms/demo" "LIBS+=-L$ORACLE_HOME/lib -lclntsh -lwtc9" oci.pro
make
</pre>
<p> For Oracle version 10:
<pre>
cd $TQTDIR/plugins/src/sqldrivers/oci
qmake -o Makefile "INCLUDEPATH+=$ORACLE_HOME/rdbms/public $ORACLE_HOME/rdbms/demo" "LIBS+=-L$ORACLE_HOME/lib -lclntsh" oci.pro
tqmake -o Makefile "INCLUDEPATH+=$ORACLE_HOME/rdbms/public $ORACLE_HOME/rdbms/demo" "LIBS+=-L$ORACLE_HOME/lib -lclntsh" oci.pro
make
</pre>
@ -230,7 +230,7 @@ installed in <tt>C:&#92;oracle</tt>):
set INCLUDE=%INCLUDE%;c:\oracle\oci\include
set LIB=%LIB%;c:\oracle\oci\lib\msvc
cd %TQTDIR%\plugins\src\sqldrivers\oci
qmake -o Makefile oci.pro
tqmake -o Makefile oci.pro
nmake
</pre>
@ -283,12 +283,12 @@ will convert all Unicode strings to local 8 bit.
<a name="3-3-3"></a><p> It is recommended that you use unixODBC. You can find the latest
version and ODBC drivers at <a href="http://www.unixodbc.org">http://www.unixodbc.org</a>.
You need the unixODBC header files and shared libraries.
<p> Tell <tt>qmake</tt> where to find the unixODBC header files and shared
<p> Tell <tt>tqmake</tt> where to find the unixODBC header files and shared
libraries (here it is assumed that unixODBC is installed in
<tt>/usr/local/unixODBC</tt>) and run <tt>make</tt>:
<p> <pre>
cd $TQTDIR/plugins/src/sqldrivers/odbc
qmake "INCLUDEPATH+=/usr/local/unixODBC/include" "LIBS+=-L/usr/local/unixODBC/lib -lodbc"
tqmake "INCLUDEPATH+=/usr/local/unixODBC/include" "LIBS+=-L/usr/local/unixODBC/lib -lodbc"
make
</pre>
@ -298,7 +298,7 @@ make
right directories. You just have to build the plugin as follows:
<p> <pre>
cd %TQTDIR%\plugins\src\sqldrivers\odbc
qmake -o Makefile odbc.pro
tqmake -o Makefile odbc.pro
nmake
</pre>
@ -347,12 +347,12 @@ distribution and run the configure script. If you've already installed
a binary distribution you don't need to build it. The source
distribution is needed because the TQPSQL7 plugin relies on a couple of
header files that are usually not a part of the binary distribution.
<p> To make <tt>qmake</tt> find the PostgreSQL header files and shared
libraries, run <tt>qmake</tt> the following way (assuming that the
<p> To make <tt>tqmake</tt> find the PostgreSQL header files and shared
libraries, run <tt>tqmake</tt> the following way (assuming that the
PostgreSQL sources can be found in <tt>/usr/src/psql</tt>):
<p> <pre>
cd $TQTDIR/plugins/src/sqldrivers/psql
qmake -o Makefile "INCLUDEPATH+=/usr/src/psql/src/include /usr/src/psql/src/interfaces/libpq" "LIBS+=-L/usr/lib -lpq" psql.pro
tqmake -o Makefile "INCLUDEPATH+=/usr/src/psql/src/include /usr/src/psql/src/interfaces/libpq" "LIBS+=-L/usr/lib -lpq" psql.pro
make
</pre>
@ -363,7 +363,7 @@ the PostgreSQL documentation. Assuming the PostgreSQL sources resides
in <tt>C:&#92;psql</tt>, build the plugin as follows:
<p> <pre>
cd %TQTDIR%\plugins\src\sqldrivers\psql
qmake -o Makefile "INCLUDEPATH+=C:\psql\src\include C:\psql\src\interfaces\libpq" psql.pro
tqmake -o Makefile "INCLUDEPATH+=C:\psql\src\include C:\psql\src\interfaces\libpq" psql.pro
nmake
</pre>
@ -388,10 +388,10 @@ Note for Linux users: Get the Open Client RPM from
<p> Regardless of which library you use, the shared object file
<tt>libsybdb.so</tt> is needed. Set the SYBASE environment variable to
point to the directory where you installed the client library and
execute <tt>qmake</tt>:
execute <tt>tqmake</tt>:
<p> <pre>
cd $TQTDIR/plugins/src/sqldrivers/tds
qmake -o Makefile "INCLUDEPATH=$SYBASE/include" "LIBS=-L$SYBASE/lib -lsybdb"
tqmake -o Makefile "INCLUDEPATH=$SYBASE/include" "LIBS=-L$SYBASE/lib -lsybdb"
make
</pre>
@ -401,7 +401,7 @@ make
Open Client (<a href="http://www.sybase.com">http://www.sybase.com</a>). You must include <tt>NTWDBLIB.LIB</tt> to build the plugin:
<p> <pre>
cd %TQTDIR%\plugins\src\sqldrivers\tds
qmake -o Makefile "LIBS+=NTWDBLIB.LIB" tds.pro
tqmake -o Makefile "LIBS+=NTWDBLIB.LIB" tds.pro
nmake
</pre>
@ -426,7 +426,7 @@ in DB2 (see <a href="tqsqlquery.html#setForwardOnly">TQSqlQuery::setForwardOnly<
</h4>
<a name="3-6-2"></a><p> <pre>
cd $TQTDIR/plugins/src/sqldrivers/db2
qmake -o Makefile "INCLUDEPATH+=$DB2DIR/include" "LIBS+=-L$DB2DIR/lib -ldb2"
tqmake -o Makefile "INCLUDEPATH+=$DB2DIR/include" "LIBS+=-L$DB2DIR/lib -ldb2"
make
</pre>
@ -436,7 +436,7 @@ make
right directories. You just have to build the plugin as follows:
<p> <pre>
cd %TQTDIR%\plugins\src\sqldrivers\db2
qmake -o Makefile "INCLUDEPATH+=&lt;DB2 home&gt;/sqllib/include" "LIBS+=&lt;DB2 home&gt;/sqllib/lib/db2cli.lib"
tqmake -o Makefile "INCLUDEPATH+=&lt;DB2 home&gt;/sqllib/include" "LIBS+=&lt;DB2 home&gt;/sqllib/lib/db2cli.lib"
nmake
</pre>
@ -468,7 +468,7 @@ build it manually (replace <tt>$SQLITE</tt> by the directory where SQLite
resides):
<p> <pre>
cd $TQTDIR/plugins/src/sqldrivers/sqlite
qmake -o Makefile "INCLUDEPATH+=$SQLITE/include" "LIBS+=-L$SQLITE/lib -lsqlite"
tqmake -o Makefile "INCLUDEPATH+=$SQLITE/include" "LIBS+=-L$SQLITE/lib -lsqlite"
make
</pre>
@ -501,7 +501,7 @@ or the free edition of Interbase.
<tt>/opt/interbase</tt>:
<p> <pre>
cd $TQTDIR/plugins/src/sqldrivers/ibase
qmake -o Makefile "INCLUDEPATH+=/opt/interbase/include" "LIBS+=-L/opt/interbase/lib" ibase.pro
tqmake -o Makefile "INCLUDEPATH+=/opt/interbase/include" "LIBS+=-L/opt/interbase/lib" ibase.pro
make
</pre>
@ -511,7 +511,7 @@ make
<tt>C:&#92;interbase</tt>:
<p> <pre>
cd %TQTDIR%\plugins\src\sqldrivers\ibase
qmake -o Makefile "INCLUDEPATH+=C:\interbase\include" ibase.pro
tqmake -o Makefile "INCLUDEPATH+=C:\interbase\include" ibase.pro
nmake
</pre>

@ -42,7 +42,7 @@ design forms
applications to reach international markets
<li> <a href="assistant.html">TQt Assistant</a> - quickly find the
help you need
<li> <a href="qmake-manual.html">qmake</a> - create Makefiles from
<li> <a href="tqmake-manual.html">tqmake</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="tqmoc.html">tqmoc</a> - the Meta Object Compiler

@ -213,7 +213,7 @@ this attribute for toplevel window.
<p> To build the example go to the toplevel directory
(<tt>TQTDIR/examples/toplevel</tt>)
<a href="#footnote3"><sup>(3)</sup></a><a name="footnote-call3"></a>
and run <tt>qmake</tt> to generate the makefile, then use the make tool to
and run <tt>tqmake</tt> to generate the makefile, then use the make tool to
build the library.
<hr>

@ -82,7 +82,7 @@ emitted. Similarly when closeAssistant() is called,
<p> This class is not included in the TQt library itself. To use it you
must link against <tt>libtqassistantclient.a</tt> (Unix) or <tt>tqassistantclient.lib</tt> (Windows), which is built into <tt>INSTALL/lib</tt>
if you built the TQt tools (<tt>INSTALL</tt> is the directory where TQt is
installed). If you use qmake, then you can simply add the following
installed). If you use tqmake, then you can simply add the following
line to your pro file:
<p> <pre>
LIBS += -ltqassistantclient

@ -2,7 +2,7 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Introduction to qmake</title>
<title>Introduction to tqmake</title>
<style type="text/css"><!--
fn { margin-left: 1cm; text-indent: -1cm; }
a:link { color: #004faf; text-decoration: none }
@ -28,14 +28,14 @@ body { background: #ffffff; color: black; }
| <a href="functions.html">
<font color="#004faf">Functions</font></a>
</td>
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><p align="right">[<a href="qmake-manual.html">Home</a>] [<a href="qmake-manual-2.html">Next: Installing qmake</a>]</p>
<h2 align="center">Introduction to qmake</h2>
<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="tqmoc.html">tqmoc</a> and <em>tquic</em>.</p>
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><p align="right">[<a href="tqmake-manual.html">Home</a>] [<a href="tqmake-manual-2.html">Next: Installing tqmake</a>]</p>
<h2 align="center">Introduction to tqmake</h2>
<h3><a name="1"></a>Introduction to tqmake</h3>
<p><em>tqmake</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>tqmake</em>, developers create a simple single 'project' file and run <em>tqmake</em> to generate the appropriate makefiles. <em>tqmake</em> takes care of all the compiler and platform dependencies, freeing developers to focus on their code. Trolltech uses <em>tqmake</em> as the primary build tool for the TQt library, and for the tools supplied with TQt.</p>
<p><em>tqmake</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 align="right">[<a href="tqmake-manual.html">Home</a>] [<a href="tqmake-manual-2.html">Next: Installing tqmake</a>]</p>
<p><address><hr><div align=center>
<table width=100% cellspacing=0 border=0><tr>
<td>Copyright &copy; 2007

@ -2,7 +2,7 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>Installing qmake</title>
<title>Installing tqmake</title>
<style type="text/css"><!--
fn { margin-left: 1cm; text-indent: -1cm; }
a:link { color: #004faf; text-decoration: none }
@ -28,21 +28,21 @@ body { background: #ffffff; color: black; }
| <a href="functions.html">
<font color="#004faf">Functions</font></a>
</td>
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><p align="right">[<a href="qmake-manual-1.html">Prev: Introduction to qmake</a>] [<a href="qmake-manual.html">Home</a>] [<a href="qmake-manual-3.html">Next: The 10 minute guide to using qmake</a>]</p>
<h2 align="center">Installing qmake</h2>
<h3><a name="1"></a>Installing qmake</h3>
<p><em>qmake</em> is built by default when TQt is built.</p>
<p>This section explains how to build <em>qmake</em> manually. Skip ahead to <a href="qmake-manual-3.html">The 10 minute guide to using qmake</a>, if you already have <em>qmake</em>.</p>
<h4><a name="1-1"></a>Installing qmake manually</h4>
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><p align="right">[<a href="tqmake-manual-1.html">Prev: Introduction to tqmake</a>] [<a href="tqmake-manual.html">Home</a>] [<a href="tqmake-manual-3.html">Next: The 10 minute guide to using tqmake</a>]</p>
<h2 align="center">Installing tqmake</h2>
<h3><a name="1"></a>Installing tqmake</h3>
<p><em>tqmake</em> is built by default when TQt is built.</p>
<p>This section explains how to build <em>tqmake</em> manually. Skip ahead to <a href="tqmake-manual-3.html">The 10 minute guide to using tqmake</a>, if you already have <em>tqmake</em>.</p>
<h4><a name="1-1"></a>Installing tqmake manually</h4>
<p>Before building TQt manually the following environment variables must be set:</p>
<ul><li><p>QMAKESPEC <br> This must be set to the platform and compiler combination that you are using on your system. <br> For example, if you are using Windows and Microsoft Visual Studio, you would set this environment variable to <em>win32-msvc</em>. If you are using Solaris and g++, you would set this environment variable to <em>solaris-g++</em>.</p>
<p>The following is a list of environment variables available to choose from when setting QMAKESPEC:</p>
<p>aix-64 hpux-cc irix-032 netbsd-g++ solaris-cc unixware7-g++ aix-g++ hpux-g++ linux-cxx openbsd-g++ solaris-g++ aix-xlc hpux-n64 linux-g++ openunix-cc sunos-g++ win32-g++ bsdi-g++ hpux-o64 linux-icc qnx-g++ tru64-cxx win32-msvc dgux-g++ hurd-g++ linux-kcc reliant-64 tru64-g++ win32-watc freebsd-g++ irix-64 macx-pbuilder reliant-cds ultrix-g++ win32-visa hpux-acc irix-g++ macx-g++ sco-g++ unixware-g hpux-acc irix-n32 solaris-64 unixware7-cc</p>
<li><p>TQTDIR <br> This must be set to where TQt is (or will be) installed. For example, <em>c:\qt</em> and <em>\local\qt</em></p>
</ul><p>Once the environment variables are set go into the qmake directory, <em>$TQTDIR/qmake</em>, e.g. <em>C:\qt\qmake</em>. Now run <em>make</em> or <em>nmake</em> depending on your compiler.</p>
<p>When the make has completed, <em>qmake</em> is ready for use.</p>
</ul><p>Once the environment variables are set go into the tqmake directory, <em>$TQTDIR/tqmake</em>, e.g. <em>C:\qt\tqmake</em>. Now run <em>make</em> or <em>nmake</em> depending on your compiler.</p>
<p>When the make has completed, <em>tqmake</em> is ready for use.</p>
<!-- eof -->
<p align="right">[<a href="qmake-manual-1.html">Prev: Introduction to qmake</a>] [<a href="qmake-manual.html">Home</a>] [<a href="qmake-manual-3.html">Next: The 10 minute guide to using qmake</a>]</p>
<p align="right">[<a href="tqmake-manual-1.html">Prev: Introduction to tqmake</a>] [<a href="tqmake-manual.html">Home</a>] [<a href="tqmake-manual-3.html">Next: The 10 minute guide to using tqmake</a>]</p>
<p><address><hr><div align=center>
<table width=100% cellspacing=0 border=0><tr>
<td>Copyright &copy; 2007

@ -2,7 +2,7 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>The 10 minute guide to using qmake</title>
<title>The 10 minute guide to using tqmake</title>
<style type="text/css"><!--
fn { margin-left: 1cm; text-indent: -1cm; }
a:link { color: #004faf; text-decoration: none }
@ -28,10 +28,10 @@ body { background: #ffffff; color: black; }
| <a href="functions.html">
<font color="#004faf">Functions</font></a>
</td>
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><p align="right">[<a href="qmake-manual-2.html">Prev: Installing qmake</a>] [<a href="qmake-manual.html">Home</a>] [<a href="qmake-manual-4.html">Next: qmake Tutorial</a>]</p>
<h2 align="center">The 10 minute guide to using qmake</h2>
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><p align="right">[<a href="tqmake-manual-2.html">Prev: Installing tqmake</a>] [<a href="tqmake-manual.html">Home</a>] [<a href="tqmake-manual-4.html">Next: tqmake Tutorial</a>]</p>
<h2 align="center">The 10 minute guide to using tqmake</h2>
<h3><a name="1"></a>Creating a project file</h3>
<p><em>qmake</em> uses information stored in project (.pro) files to determine what should go in the makefiles it generates.</p>
<p><em>tqmake</em> uses information stored in project (.pro) files to determine what should go in the makefiles it generates.</p>
<p>A basic project file contains information about the application, for example, which files are needed to compile the application, and which configuration settings to use.</p>
<p>Here's a simple example project file:</p>
<pre>
@ -63,27 +63,27 @@ body { background: #ffffff; color: black; }
HEADERS += hello.h
</pre>
<p>Any of the approaches used to list source files may be used for header files.</p>
<p>The CONFIG line is used to give <em>qmake</em> information about the application's configuration.</p>
<p>The CONFIG line is used to give <em>tqmake</em> information about the application's configuration.</p>
<pre>
CONFIG += qt warn_on release
</pre>
<p>The "+=" is used here, because we add our configuration options to any that are already present. This is safer than using "=" which replaces all options with just those specified.</p>
<p>The <em>qt</em> part of the CONFIG line tells <em>qmake</em> that the application is built using TQt. This means that <em>qmake</em> will link against the TQt libraries when linking and add in the neccesary include paths for compiling.</p>
<p>The <em>warn_on</em> part of the CONFIG line tells <em>qmake</em> that it should set the compiler flags so that warnings are output.</p>
<p>The <em>release</em> part of the CONFIG line tells <em>qmake</em> that the application must be built as a release application. During development, programmers may prefer to replace <em>release</em> with <em>debug</em>, which is discussed later.</p>
<p>The <em>qt</em> part of the CONFIG line tells <em>tqmake</em> that the application is built using TQt. This means that <em>tqmake</em> will link against the TQt libraries when linking and add in the neccesary include paths for compiling.</p>
<p>The <em>warn_on</em> part of the CONFIG line tells <em>tqmake</em> that it should set the compiler flags so that warnings are output.</p>
<p>The <em>release</em> part of the CONFIG line tells <em>tqmake</em> that the application must be built as a release application. During development, programmers may prefer to replace <em>release</em> with <em>debug</em>, which is discussed later.</p>
<p>Project files are plain text (i.e. use an editor like notepad, vim or xemacs) and must be saved with a '.pro' extension. The name of the application's executable will be the same as the project file's name, but with an extension appropriate to the platform. For example, a project file called 'hello.pro' will produce 'hello.exe' on Windows and 'hello' on Unix.</p>
<h3><a name="2"></a>Generating a makefile</h3>
<p>When you have created your project file it is very easy to generate a makefile, all you need to do is go to where you have created your project file and type:</p>
<p>Makefiles are generated from the '.pro' files like this:</p>
<pre>
qmake -o Makefile hello.pro
tqmake -o Makefile hello.pro
</pre>
<p>For Visual Studio users, <em>qmake</em> can also generate '.dsp' files, for example:</p>
<p>For Visual Studio users, <em>tqmake</em> can also generate '.dsp' files, for example:</p>
<pre>
qmake -t vcapp -o hello.dsp hello.pro
tqmake -t vcapp -o hello.dsp hello.pro
</pre>
<!-- eof -->
<p align="right">[<a href="qmake-manual-2.html">Prev: Installing qmake</a>] [<a href="qmake-manual.html">Home</a>] [<a href="qmake-manual-4.html">Next: qmake Tutorial</a>]</p>
<p align="right">[<a href="tqmake-manual-2.html">Prev: Installing tqmake</a>] [<a href="tqmake-manual.html">Home</a>] [<a href="tqmake-manual-4.html">Next: tqmake Tutorial</a>]</p>
<p><address><hr><div align=center>
<table width=100% cellspacing=0 border=0><tr>
<td>Copyright &copy; 2007

@ -2,7 +2,7 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>qmake Tutorial</title>
<title>tqmake Tutorial</title>
<style type="text/css"><!--
fn { margin-left: 1cm; text-indent: -1cm; }
a:link { color: #004faf; text-decoration: none }
@ -28,16 +28,16 @@ body { background: #ffffff; color: black; }
| <a href="functions.html">
<font color="#004faf">Functions</font></a>
</td>
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><p align="right">[<a href="qmake-manual-3.html">Prev: The 10 minute guide to using qmake</a>] [<a href="qmake-manual.html">Home</a>] [<a href="qmake-manual-5.html">Next: qmake Concepts</a>]</p>
<h2 align="center">qmake Tutorial</h2>
<h3><a name="1"></a>Introduction to the qmake tutorial</h3>
<p>This tutorial teaches you how to use <em>qmake</em>. We recommend that you read the <em>qmake</em> user guide after completing this tutorial.</p>
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><p align="right">[<a href="tqmake-manual-3.html">Prev: The 10 minute guide to using tqmake</a>] [<a href="tqmake-manual.html">Home</a>] [<a href="tqmake-manual-5.html">Next: tqmake Concepts</a>]</p>
<h2 align="center">tqmake Tutorial</h2>
<h3><a name="1"></a>Introduction to the tqmake tutorial</h3>
<p>This tutorial teaches you how to use <em>tqmake</em>. We recommend that you read the <em>tqmake</em> user guide after completing this tutorial.</p>
<h3><a name="2"></a>Starting off simple</h3>
<p>Let's assume that you have just finished a basic implementation of your application, and you have created the following files:</p>
<ul><li><p>hello.cpp</p>
<li><p>hello.h</p>
<li><p>main.cpp</p>
</ul><p>You will find these files in <em>qt/qmake/examples/tutorial</em>. The only other thing you know about the setup of the application is that it's written in TQt. First, using your favorite plain text editor, create a file called <em>hello.pro</em> in <em>qt/qmake/tutorial</em>. The first thing you need to do is add the lines that tell <em>qmake</em> about the source and header files that are part of your development project.</p>
</ul><p>You will find these files in <em>qt/tqmake/examples/tutorial</em>. The only other thing you know about the setup of the application is that it's written in TQt. First, using your favorite plain text editor, create a file called <em>hello.pro</em> in <em>qt/tqmake/tutorial</em>. The first thing you need to do is add the lines that tell <em>tqmake</em> about the source and header files that are part of your development project.</p>
<p>We'll add the source files to the project file first. To do this you need to use the SOURCES variable. Just start a new line with <em>SOURCES +=</em> and put hello.cpp after it. You should have something like:</p>
<pre>
SOURCES += hello.cpp
@ -63,7 +63,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>tqmoc</em> and <em>tquic</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>tqmake</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
@ -71,9 +71,9 @@ body { background: #ffffff; color: black; }
SOURCES += hello.cpp
SOURCES += main.cpp
</pre>
<p>You can now use <em>qmake</em> to generate a makefile for your application. On the command line, in your application directory, type:</p>
<p>You can now use <em>tqmake</em> to generate a makefile for your application. On the command line, in your application directory, type:</p>
<pre>
qmake -o Makefile hello.pro
tqmake -o Makefile hello.pro
</pre>
<p>Then type <em>make</em> or <em>nmake</em> depending on the compiler you use.</p>
<h3><a name="3"></a>Making an application debuggable</h3>
@ -85,16 +85,16 @@ body { background: #ffffff; color: black; }
SOURCES += hello.cpp
SOURCES += main.cpp
</pre>
<p>Use <em>qmake</em> as before to generate a makefile and you will be able to debug your application.</p>
<p>Use <em>tqmake</em> as before to generate a makefile and you will be able to debug your application.</p>
<h3><a name="4"></a>Adding platform specific source files</h3>
<p>After a few hours of coding, you might have made a start on the platform specific part of your application, and decided to keep the platform dependent code separate. So you now have two new files to include into your project file - <em>hellowin.cpp</em> and <em>hellounix.cpp</em>. We can't just add these to the <em>SOURCES</em> variable since this will put both files in the makefile. So what we need to do here is to use a scope which will be processed depending on which platform <em>qmake</em> is run on.</p>
<p>After a few hours of coding, you might have made a start on the platform specific part of your application, and decided to keep the platform dependent code separate. So you now have two new files to include into your project file - <em>hellowin.cpp</em> and <em>hellounix.cpp</em>. We can't just add these to the <em>SOURCES</em> variable since this will put both files in the makefile. So what we need to do here is to use a scope which will be processed depending on which platform <em>tqmake</em> is run on.</p>
<p>A simple scope which will add in the platform dependent file for Windows looks like this:</p>
<pre>
win32 {
SOURCES += hellowin.cpp
}
</pre>
<p>So if <em>qmake</em> is run on Windows, it will add <em>hellowin.cpp</em> to the list of source files. If <em>qmake</em> is run on any other platform, it will simply ignore it. Now all that is left to be done is to create a scope for the unix dependent file.</p>
<p>So if <em>tqmake</em> is run on Windows, it will add <em>hellowin.cpp</em> to the list of source files. If <em>tqmake</em> is run on any other platform, it will simply ignore it. Now all that is left to be done is to create a scope for the unix dependent file.</p>
<p>When you have done that, your project file should now look something like this:</p>
<pre>
CONFIG += qt debug
@ -108,9 +108,9 @@ body { background: #ffffff; color: black; }
SOURCES += hellounix.cpp
}
</pre>
<p>Use <em>qmake</em> as before to generate a makefile.</p>
<h3><a name="5"></a>Stopping qmake if a file doesn't exist</h3>
<p>You may not want to create a makefile if a certain file doesn't exist. We can check if a file exists by using the exists() function. We can stop <em>qmake</em> from processing by using the error() function. This works in the same way as scopes. Simply replace the scope condition with the function. A check for a main.cpp file looks like this:</p>
<p>Use <em>tqmake</em> as before to generate a makefile.</p>
<h3><a name="5"></a>Stopping tqmake if a file doesn't exist</h3>
<p>You may not want to create a makefile if a certain file doesn't exist. We can check if a file exists by using the exists() function. We can stop <em>tqmake</em> from processing by using the error() function. This works in the same way as scopes. Simply replace the scope condition with the function. A check for a main.cpp file looks like this:</p>
<pre>
!exists( main.cpp ) {
error( "No main.cpp file found" )
@ -132,7 +132,7 @@ body { background: #ffffff; color: black; }
error( "No main.cpp file found" )
}
</pre>
<p>Use <em>qmake</em> as before to generate a makefile. If you rename <em>main.cpp</em> temporarily, you will see the message and <em>qmake</em> will stop processing.</p>
<p>Use <em>tqmake</em> as before to generate a makefile. If you rename <em>main.cpp</em> temporarily, you will see the message and <em>tqmake</em> will stop processing.</p>
<h3><a name="6"></a>Checking for more than one condition</h3>
<p>Suppose you use Windows and you want to be able to see the tqDebug() statements when you run your application on the command line. Unless you build your application with the console setting, you won't see the output. We can easily put <em>console</em> on the CONFIG line so that on Windows the makefile will have this setting. But let's say that we only want to add the CONFIG line if we are running on Windows <em>and</em> when <em>debug</em> is already on the CONFIG line. This requires using two nested scopes; just create one scope, then create the other inside that one. Put the settings to be processed inside the last scope, like this:</p>
<pre>
@ -161,9 +161,9 @@ body { background: #ffffff; color: black; }
CONFIG += console
}
</pre>
<p>That's it! You have now completed the tutorial for <em>qmake</em>, and are ready to write project files for your development projects.</p>
<p>That's it! You have now completed the tutorial for <em>tqmake</em>, and are ready to write project files for your development projects.</p>
<!-- eof -->
<p align="right">[<a href="qmake-manual-3.html">Prev: The 10 minute guide to using qmake</a>] [<a href="qmake-manual.html">Home</a>] [<a href="qmake-manual-5.html">Next: qmake Concepts</a>]</p>
<p align="right">[<a href="tqmake-manual-3.html">Prev: The 10 minute guide to using tqmake</a>] [<a href="tqmake-manual.html">Home</a>] [<a href="tqmake-manual-5.html">Next: tqmake Concepts</a>]</p>
<p><address><hr><div align=center>
<table width=100% cellspacing=0 border=0><tr>
<td>Copyright &copy; 2007

@ -2,7 +2,7 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>qmake Concepts</title>
<title>tqmake Concepts</title>
<style type="text/css"><!--
fn { margin-left: 1cm; text-indent: -1cm; }
a:link { color: #004faf; text-decoration: none }
@ -28,29 +28,29 @@ body { background: #ffffff; color: black; }
| <a href="functions.html">
<font color="#004faf">Functions</font></a>
</td>
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><p align="right">[<a href="qmake-manual-4.html">Prev: qmake Tutorial</a>] [<a href="qmake-manual.html">Home</a>] [<a href="qmake-manual-6.html">Next: qmake's Advanced Concepts</a>]</p>
<h2 align="center">qmake Concepts</h2>
<h3><a name="1"></a>Introducing qmake</h3>
<p><em>qmake</em> is an easy-to-use tool from Trolltech that creates makefiles for development projects across different platforms. <em>qmake</em> simplifies the generation of makefiles so that only a few lines of information are needed to create a makefile. <em>qmake</em> can be used for any software project whether it is written in TQt or not, although it also contains additional features to support TQt development.</p>
<p><em>qmake</em> generates a makefile based on the information in a project file. Project files are created by the developer. Project files are usually simple, but can be quite sophisticated if required. <em>qmake</em> can also generate projects for Microsoft Visual studio without having to change the project file.</p>
<h3><a name="2"></a>qmake's Concepts</h3>
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><p align="right">[<a href="tqmake-manual-4.html">Prev: tqmake Tutorial</a>] [<a href="tqmake-manual.html">Home</a>] [<a href="tqmake-manual-6.html">Next: tqmake's Advanced Concepts</a>]</p>
<h2 align="center">tqmake Concepts</h2>
<h3><a name="1"></a>Introducing tqmake</h3>
<p><em>tqmake</em> is an easy-to-use tool from Trolltech that creates makefiles for development projects across different platforms. <em>tqmake</em> simplifies the generation of makefiles so that only a few lines of information are needed to create a makefile. <em>tqmake</em> can be used for any software project whether it is written in TQt or not, although it also contains additional features to support TQt development.</p>
<p><em>tqmake</em> generates a makefile based on the information in a project file. Project files are created by the developer. Project files are usually simple, but can be quite sophisticated if required. <em>tqmake</em> can also generate projects for Microsoft Visual studio without having to change the project file.</p>
<h3><a name="2"></a>tqmake's Concepts</h3>
<h4><a name="2-1"></a>The QMAKESPEC environment variable</h4>
<p>Before <em>qmake</em> can be used to build makefiles, the QMAKESPEC environment variable must be set to the platform-compiler combination that is being used on the system. The QMAKESPEC environment variable tells qmake where to look to find platform and compiler specific information. This ensures that the right libraries are used, and that the generated makefile uses the correct syntax. A list of the currently supported platform-compiler combinations can be found in qt/mkspecs. Just set your environment variable to one of the directories listed.</p>
<p>Before <em>tqmake</em> can be used to build makefiles, the QMAKESPEC environment variable must be set to the platform-compiler combination that is being used on the system. The QMAKESPEC environment variable tells tqmake where to look to find platform and compiler specific information. This ensures that the right libraries are used, and that the generated makefile uses the correct syntax. A list of the currently supported platform-compiler combinations can be found in qt/mkspecs. Just set your environment variable to one of the directories listed.</p>
<p>For example, if you are using Microsoft Visual Studio on Windows, then you would set the QMAKESPEC environment variable to <em>win32-msvc</em>. If you are using gcc on Solaris then you would set your QMAKESPEC environment variable to <em>solaris-g++</em>.</p>
<p>Inside each of the directories in qt/mkspecs, there is a <em>qmake.conf</em> file which contains the platform and compiler specific information. These settings are applied to any project that is built using <em>qmake</em> and should not be modified unless you're an expert. For example, if all your applications had to link against a particular library, you might add this information to the relevant <em>qmake.conf</em> file.</p>
<p>Inside each of the directories in qt/mkspecs, there is a <em>tqmake.conf</em> file which contains the platform and compiler specific information. These settings are applied to any project that is built using <em>tqmake</em> and should not be modified unless you're an expert. For example, if all your applications had to link against a particular library, you might add this information to the relevant <em>tqmake.conf</em> file.</p>
<h4><a name="2-2"></a>Project (.pro) files</h4>
<p>A project file is used to tell <em>qmake</em> the details it needs to know about creating a makefile for the application. For instance, a list of source files and header files that should be put into the project file; any application specific configuration, such as an extra library that should be linked against, or an extra include path.</p>
<p>A project file is used to tell <em>tqmake</em> the details it needs to know about creating a makefile for the application. For instance, a list of source files and header files that should be put into the project file; any application specific configuration, such as an extra library that should be linked against, or an extra include path.</p>
<h5><a name="2-2-1"></a>'#' comments</h5>
<p>You can add comments to project files. Comments begin with the '#' symbol and run to the end of the line.</p>
<h4><a name="2-3"></a>Templates</h4>
<p>The template variable tells <em>qmake</em> what sort of makefile should be generated for the application. The following choices are available:</p>
<p>The template variable tells <em>tqmake</em> what sort of makefile should be generated for the application. The following choices are available:</p>
<ul><li><p>app - Creates a makefile that builds an application. This is the default, so if a template is not specified, this is used.</p>
<li><p>lib - Creates a makefile that builds a library.</p>
<li><p>vcapp - Creates a Visual Studio Project file which builds an application.</p>
<li><p>vclib - Creates a Visual Studio Project file which builds a library.</p>
<li><p>subdirs - This is a special template which creates a makefile which will go into the specified directories and create a makefile for the project file and call make on it.</p>
</ul><h5><a name="2-3-1"></a>The 'app' template</h5>
<p>The 'app' template tells <em>qmake</em> to generate a makefile that will build an application. When using this template the following <em>qmake</em> system variables are recognized. You should use these in your .pro file to specify information about your application.</p>
<p>The 'app' template tells <em>tqmake</em> to generate a makefile that will build an application. When using this template the following <em>tqmake</em> system variables are recognized. You should use these in your .pro file to specify information about your application.</p>
<ul><li><p>HEADERS - A list of all the header files for the application.</p>
<li><p>SOURCES - A list of all the source files for the application.</p>
<li><p>FORMS - A list of all the .ui files (created using <em>TQt Designer</em>) for the application.</p>
@ -65,7 +65,7 @@ body { background: #ffffff; color: black; }
<li><p>DEF_FILE - Windows only: A .def file to be linked against for the application.</p>
<li><p>RC_FILE - Windows only: A resource file for the application.</p>
<li><p>RES_FILE - Windows only: A resource file to be linked against for the application.</p>
</ul><p>You only need to use the system variables that you have values for, for instance, if you don't have any extra INCLUDEPATHs then you don't need to specify any, <em>qmake</em> will add in the default ones needed. For instance, an example project file might look like this:</p>
</ul><p>You only need to use the system variables that you have values for, for instance, if you don't have any extra INCLUDEPATHs then you don't need to specify any, <em>tqmake</em> will add in the default ones needed. For instance, an example project file might look like this:</p>
<pre>
TEMPLATE = app
DESTDIR = c:\helloapp
@ -77,13 +77,13 @@ CONFIG += qt warn_on release
</pre>
<p>For items that are single valued, e.g. the template or the destination directory, we use "="; but for multi-valued items we use "+=" to <em>add</em> to the existing items of that type. Using "=" replaces the item's value with the new value, for example if we wrote <tt>DEFINES=QT_DLL</tt>, all other definitions would be deleted.</p>
<h5><a name="2-3-2"></a>The 'lib' template</h5>
<p>The 'lib' template tells <em>qmake</em> to generate a makefile that will build a library. When using this template, in addition to the system variables mentioned above for the 'app' template the <em>VERSION</em> variable is supported. You should use these in your .pro file to specify information about the library.</p>
<p>The 'lib' template tells <em>tqmake</em> to generate a makefile that will build a library. When using this template, in addition to the system variables mentioned above for the 'app' template the <em>VERSION</em> variable is supported. You should use these in your .pro file to specify information about the library.</p>
<ul><li><p>VERSION - The version number of the target library, for example, 2.3.1.</p>
</ul><h5><a name="2-3-3"></a>The 'subdirs' template</h5>
<p>The 'subdirs' template tells qmake to generate a makefile that will go into the specified subdirectories and generate a makefile for the project file in the directory and call make on it.</p>
<p>The only system variable that is recognised for this template is the <em>SUBDIRS</em> variable. This variable contains a list of all the subdirectories that contain project files to be processed. It is essential that the project file in the sub directory has the same name as the subdirectory, so that <em>qmake</em> can find it. For example, if the subdirectory is called 'myapp' then the project file in that directory should be called <em>myapp.pro</em> in that directory.</p>
<p>The 'subdirs' template tells tqmake to generate a makefile that will go into the specified subdirectories and generate a makefile for the project file in the directory and call make on it.</p>
<p>The only system variable that is recognised for this template is the <em>SUBDIRS</em> variable. This variable contains a list of all the subdirectories that contain project files to be processed. It is essential that the project file in the sub directory has the same name as the subdirectory, so that <em>tqmake</em> can find it. For example, if the subdirectory is called 'myapp' then the project file in that directory should be called <em>myapp.pro</em> in that directory.</p>
<h4><a name="2-4"></a>The CONFIG variable</h4>
<p>The config variable specifies the options that the compiler should use and the libraries that should be linked against. Anything can be added to the config variable, but the options covered below are recognised by qmake internally.</p>
<p>The config variable specifies the options that the compiler should use and the libraries that should be linked against. Anything can be added to the config variable, but the options covered below are recognised by tqmake internally.</p>
<p>The following options control what compiler flags are used:</p>
<ul><li><p>release - The application is to be built in release mode. This is ignored if 'debug' is specified.</p>
<li><p>debug - The application is to be built in debug mode.</p>
@ -102,9 +102,9 @@ CONFIG += qt warn_on release
<pre>
CONFIG += qt thread debug
</pre>
<p>Note, that you must use "+=", not "=", or <em>qmake</em> will not be able to use the settings used to build TQt as a guide as what type of TQt library was built.</p>
<p>Note, that you must use "+=", not "=", or <em>tqmake</em> will not be able to use the settings used to build TQt as a guide as what type of TQt library was built.</p>
<!-- eof -->
<p align="right">[<a href="qmake-manual-4.html">Prev: qmake Tutorial</a>] [<a href="qmake-manual.html">Home</a>] [<a href="qmake-manual-6.html">Next: qmake's Advanced Concepts</a>]</p>
<p align="right">[<a href="tqmake-manual-4.html">Prev: tqmake Tutorial</a>] [<a href="tqmake-manual.html">Home</a>] [<a href="tqmake-manual-6.html">Next: tqmake's Advanced Concepts</a>]</p>
<p><address><hr><div align=center>
<table width=100% cellspacing=0 border=0><tr>
<td>Copyright &copy; 2007

@ -2,7 +2,7 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>qmake's Advanced Concepts</title>
<title>tqmake's Advanced Concepts</title>
<style type="text/css"><!--
fn { margin-left: 1cm; text-indent: -1cm; }
a:link { color: #004faf; text-decoration: none }
@ -28,10 +28,10 @@ body { background: #ffffff; color: black; }
| <a href="functions.html">
<font color="#004faf">Functions</font></a>
</td>
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><p align="right">[<a href="qmake-manual-5.html">Prev: qmake Concepts</a>] [<a href="qmake-manual.html">Home</a>] [<a href="qmake-manual-7.html">Next: Using Precompiled Headers</a>]</p>
<h2 align="center">qmake's Advanced Concepts</h2>
<h3><a name="1"></a>qmake's Advanced Concepts</h3>
<p>The <em>qmake</em> project files we've seen up to now have been very simple, just a list of <em>name = value</em> and <em>name += value</em> lines. <em>qmake</em> provides a lot more power, for example you can use a single project file to produce makefiles for multiple platforms.</p>
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><p align="right">[<a href="tqmake-manual-5.html">Prev: tqmake Concepts</a>] [<a href="tqmake-manual.html">Home</a>] [<a href="tqmake-manual-7.html">Next: Using Precompiled Headers</a>]</p>
<h2 align="center">tqmake's Advanced Concepts</h2>
<h3><a name="1"></a>tqmake's Advanced Concepts</h3>
<p>The <em>tqmake</em> project files we've seen up to now have been very simple, just a list of <em>name = value</em> and <em>name += value</em> lines. <em>tqmake</em> provides a lot more power, for example you can use a single project file to produce makefiles for multiple platforms.</p>
<h3><a name="2"></a>Operators</h3>
<p>So far, you have seen the <em>=</em> operator and <em>+=</em> operator being used in a project file. There are more operators available for use; but some of these should be used carefully as they may change more than you expect them to.</p>
<h4><a name="2-1"></a>The '=' operator</h4>
@ -71,7 +71,7 @@ body { background: #ffffff; color: black; }
DEFINES += QT_DLL
}
</pre>
<p>The above code will add the QT_DLL define to the makefile if <em>qmake</em> is used on a Windows platform. If <em>qmake</em> is used on a different platform than Windows, the define will be ignored. You may also perform single line conditionals/assignments with qmake like this:</p>
<p>The above code will add the QT_DLL define to the makefile if <em>tqmake</em> is used on a Windows platform. If <em>tqmake</em> is used on a different platform than Windows, the define will be ignored. You may also perform single line conditionals/assignments with tqmake like this:</p>
<pre>
win32:DEFINES += QT_DLL
</pre>
@ -125,7 +125,7 @@ body { background: #ffffff; color: black; }
<pre>
MY_VARIABLE = value
</pre>
<p>There are no restricitions on what you do to your own variables, as <em>qmake</em> will just ignore them unless it needs to look at them for a scope.</p>
<p>There are no restricitions on what you do to your own variables, as <em>tqmake</em> will just ignore them unless it needs to look at them for a scope.</p>
<p>You can also assign the value of a current variable to another variable by prefixing $$ to the variable name. For example:</p>
<pre>
MY_DEFINES = $$DEFINES
@ -134,7 +134,7 @@ body { background: #ffffff; color: black; }
<pre>
MY_DEFINES = $${DEFINES}
</pre>
<p>The second notation allows you to adjoin the variable expansion to another value without separating by space. <em>qmake</em> will allow a variable to contain anything (including $(VALUE), which will be placed directly into the Makefile, and allow it to expand as appropriate, usually an environment variable). However, if you require an environment variable to be replaced immediately then you may use the $$() notation. For example:</p>
<p>The second notation allows you to adjoin the variable expansion to another value without separating by space. <em>tqmake</em> will allow a variable to contain anything (including $(VALUE), which will be placed directly into the Makefile, and allow it to expand as appropriate, usually an environment variable). However, if you require an environment variable to be replaced immediately then you may use the $$() notation. For example:</p>
<pre>
MY_DEFINES = $$(ENV_DEFINES)
</pre>
@ -160,7 +160,7 @@ body { background: #ffffff; color: black; }
contains( UNAME, [lL]inux ):message( This looks like Linux ($$UNAME) to me )
</pre>
<h3><a name="5"></a>Test Functions</h3>
<p><em>qmake</em> provides built-in functions that perform simple, yet powerful tests. These tests may be used in place of scopes (as described above), in some cases it is more usefull to use the test function by itself ignoring its test value.</p>
<p><em>tqmake</em> provides built-in functions that perform simple, yet powerful tests. These tests may be used in place of scopes (as described above), in some cases it is more usefull to use the test function by itself ignoring its test value.</p>
<h4><a name="5-1"></a>contains( variablename, value )</h4>
<p>If <em>value</em> is in the list of values stored in the variable called <em>variablename</em>, then the settings inside the scope will be processed. For example:</p>
<pre>
@ -177,19 +177,19 @@ body { background: #ffffff; color: black; }
}
</pre>
<h4><a name="5-3"></a>error( string )</h4>
<p>This function outputs the string given and then makes <em>qmake</em> exit. For example:</p>
<p>This function outputs the string given and then makes <em>tqmake</em> exit. For example:</p>
<pre>
error( "An error has occured" )
</pre>
<p>The text "An error has occured" will be displayed on the console and <em>qmake</em> will exit.</p>
<p>The text "An error has occured" will be displayed on the console and <em>tqmake</em> will exit.</p>
<h4><a name="5-4"></a>exists( filename )</h4>
<p>If the specified file exists, then the settings inside the scope will be processed. For example:</p>
<pre>
exists( /local/qt/qmake/main.cpp ) {
exists( /local/qt/tqmake/main.cpp ) {
SOURCES += main.cpp
}
</pre>
<p>If <em>/local/qt/qmake/main.cpp</em> exists then main.cpp is added to the list of source files.</p>
<p>If <em>/local/qt/tqmake/main.cpp</em> exists then main.cpp is added to the list of source files.</p>
<p>Note that "/" can be used as a directory separator regardless of the platform.</p>
<h4><a name="5-5"></a>equals( variable, value )</h4>
<p>If the specified variable is equal to the value passed the scope will be processed. For example:</p>
@ -229,9 +229,9 @@ body { background: #ffffff; color: black; }
</pre>
<p>So if the command <em>ls /bin</em> returns 1 then <em>bin/main.cpp</em> is added to the list of sources and <em>bin/main.h</em> is added to the list of headers.</p>
<h4><a name="5-10"></a>infile( filename, var, val )</h4>
<p>This function will succeed if the file <em>filename</em> (when parsed by qmake itself) contains the variable <em>var</em> with a value of <em>val</em>. You may also not pass in a third argument (<em>val</em>) and the function will only test if <em>var</em> has been assigned to in the file.</p>
<p>This function will succeed if the file <em>filename</em> (when parsed by tqmake itself) contains the variable <em>var</em> with a value of <em>val</em>. You may also not pass in a third argument (<em>val</em>) and the function will only test if <em>var</em> has been assigned to in the file.</p>
<!-- eof -->
<p align="right">[<a href="qmake-manual-5.html">Prev: qmake Concepts</a>] [<a href="qmake-manual.html">Home</a>] [<a href="qmake-manual-7.html">Next: Using Precompiled Headers</a>]</p>
<p align="right">[<a href="tqmake-manual-5.html">Prev: tqmake Concepts</a>] [<a href="tqmake-manual.html">Home</a>] [<a href="tqmake-manual-7.html">Next: Using Precompiled Headers</a>]</p>
<p><address><hr><div align=center>
<table width=100% cellspacing=0 border=0><tr>
<td>Copyright &copy; 2007

@ -28,11 +28,11 @@ body { background: #ffffff; color: black; }
| <a href="functions.html">
<font color="#004faf">Functions</font></a>
</td>
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><p align="right">[<a href="qmake-manual-6.html">Prev: qmake's Advanced Concepts</a>] [<a href="qmake-manual.html">Home</a>] [<a href="qmake-manual-8.html">Next: qmake Command Reference</a>]</p>
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><p align="right">[<a href="tqmake-manual-6.html">Prev: tqmake's Advanced Concepts</a>] [<a href="tqmake-manual.html">Home</a>] [<a href="tqmake-manual-8.html">Next: tqmake Command Reference</a>]</p>
<h2 align="center">Using Precompiled Headers</h2>
<a name="About"></a><h3><a name="1"></a>About Precompiled Headers<!-- index About Precompiled Headers --><!-- index Using Precompiled Headers --><!-- index Precompiled Headers --><!-- index PCH --></h3>
<p>Precompiled headers are a performance feature supported by some compilers to compile a stable body of code, and store the compiled state of the code in a binary file. During subsequent compilations, the compiler will load the stored state, and continue compiling the specified file. Each subsequent compilation is faster because the stable code does not need to be recompiled.</p>
<p><em>qmake</em> supports the use of precompiled headers (PCH) on some platforms and build environments, including:</p>
<p><em>tqmake</em> supports the use of precompiled headers (PCH) on some platforms and build environments, including:</p>
<ul><li><p>Windows</p>
<ul><li><p>nmake</p>
<li><p>Dsp projects (VC 6.0)</p>
@ -69,7 +69,7 @@ body { background: #ffffff; color: black; }
<pre>
PRECOMPILED_HEADER = stable.h
</pre>
<p><em>qmake</em> will handle the rest, to ensure the creation and use of the precompiled header file. You do not need to include the precompiled header file in HEADERS, as qmake will do this if the configuration supports PCH.</p>
<p><em>tqmake</em> will handle the rest, to ensure the creation and use of the precompiled header file. You do not need to include the precompiled header file in HEADERS, as tqmake will do this if the configuration supports PCH.</p>
<p>All platforms that support precompiled headers have the configuration option <b>precompile_header</b> set. Using this option, you may trigger conditional blocks in your .pro file, to add settings when using PCH. For example:</p>
<pre>
precompile_header:!isEmpty(PRECOMPILED_HEADER) {
@ -78,7 +78,7 @@ body { background: #ffffff; color: black; }
</pre>
<a name="EXAMPLE_PROJECT"></a><h3><a name="3"></a>Example project</h3>
<p>You can find the following source code in the <em>qt/qmake/examples/precompile</em> directory:</p>
<p>You can find the following source code in the <em>qt/tqmake/examples/precompile</em> directory:</p>
<p><b>mydialog.ui</b></p>
<pre> &lt;!DOCTYPE UI&gt;&lt;UI version="3.3" stdsetdef="1"&gt;
&lt;class&gt;MyDialog&lt;/class&gt;
@ -192,7 +192,7 @@ body { background: #ffffff; color: black; }
FORMS = mydialog.ui
</pre>
<!-- eof -->
<p align="right">[<a href="qmake-manual-6.html">Prev: qmake's Advanced Concepts</a>] [<a href="qmake-manual.html">Home</a>] [<a href="qmake-manual-8.html">Next: qmake Command Reference</a>]</p>
<p align="right">[<a href="tqmake-manual-6.html">Prev: tqmake's Advanced Concepts</a>] [<a href="tqmake-manual.html">Home</a>] [<a href="tqmake-manual-8.html">Next: tqmake Command Reference</a>]</p>
<p><address><hr><div align=center>
<table width=100% cellspacing=0 border=0><tr>
<td>Copyright &copy; 2007

@ -2,7 +2,7 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title> qmake Command Reference</title>
<title> tqmake Command Reference</title>
<style type="text/css"><!--
fn { margin-left: 1cm; text-indent: -1cm; }
a:link { color: #004faf; text-decoration: none }
@ -28,68 +28,68 @@ body { background: #ffffff; color: black; }
| <a href="functions.html">
<font color="#004faf">Functions</font></a>
</td>
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><p align="right">[<a href="qmake-manual-7.html">Prev: Using Precompiled Headers</a>] [<a href="qmake-manual.html">Home</a>]</p>
<h2 align="center"> qmake Command Reference</h2>
<h3><a name="1"></a>qmake Command Reference</h3>
<ul><li><p><a href="qmake-manual-8.html#About">About This Reference</a></p>
<li><p><a href="qmake-manual-8.html#Commands">Command Line Options</a></p>
<li><p><a href="qmake-manual-8.html#SystemVariables">System Variables</a></p>
<li><p><a href="qmake-manual-8.html#Functions">Functions</a></p>
<li><p><a href="qmake-manual-8.html#Properties">Properties</a></p>
<li><p><a href="qmake-manual-8.html#Environment">Environment Variables and Configuration</a></p>
<li><p><a href="qmake-manual-8.html#Extensions">File Extensions</a></p>
<li><p><a href="qmake-manual-8.html#Customizing">Customizing Makefile Output</a></p>
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><p align="right">[<a href="tqmake-manual-7.html">Prev: Using Precompiled Headers</a>] [<a href="tqmake-manual.html">Home</a>]</p>
<h2 align="center"> tqmake Command Reference</h2>
<h3><a name="1"></a>tqmake Command Reference</h3>
<ul><li><p><a href="tqmake-manual-8.html#About">About This Reference</a></p>
<li><p><a href="tqmake-manual-8.html#Commands">Command Line Options</a></p>
<li><p><a href="tqmake-manual-8.html#SystemVariables">System Variables</a></p>
<li><p><a href="tqmake-manual-8.html#Functions">Functions</a></p>
<li><p><a href="tqmake-manual-8.html#Properties">Properties</a></p>
<li><p><a href="tqmake-manual-8.html#Environment">Environment Variables and Configuration</a></p>
<li><p><a href="tqmake-manual-8.html#Extensions">File Extensions</a></p>
<li><p><a href="tqmake-manual-8.html#Customizing">Customizing Makefile Output</a></p>
</ul><a name="About"></a><h3><a name="2"></a>About This Reference</h3>
<p>This reference is a detailed index of all command line options, configurations and internal variables used by the cross-platform makefile generation utility <em>qmake</em>.</p>
<p>In addition to the variables and functions described in the following sections, <em>qmake</em> project files may also include comments. Comments begin with the '#' symbol and run to the end of the line.</p>
<p>This reference is a detailed index of all command line options, configurations and internal variables used by the cross-platform makefile generation utility <em>tqmake</em>.</p>
<p>In addition to the variables and functions described in the following sections, <em>tqmake</em> project files may also include comments. Comments begin with the '#' symbol and run to the end of the line.</p>
<a name="Commands"></a><h3><a name="3"></a>Command Line Options</h3>
<h4><a name="3-1"></a>Syntax</h4>
<pre>
qmake [options] files
tqmake [options] files
</pre>
<h4><a name="3-2"></a>Options</h4>
<p>The following options can be specified on the command line to <em>qmake</em>:</p>
<ul><li><p><tt>-o</tt> file <br> <em>qmake</em> output will be directed to <em>file</em>. if this argument is not specified, then <em>qmake</em> will try to guess a suitable name. If '-' is specified, output is directed to stdout.</p>
<li><p><tt>-unix</tt> <br> <em>qmake</em> will run in unix mode. In this mode, Unix file naming and path conventions will be used, additionally testing for unix (as a scope) will succeed. This is the default mode on all Unices.</p>
<li><p><tt>-macx</tt> <br> <em>qmake</em> will run in Mac OS X mode. In this mode, Unix file naming and path conventions will be used, additionally testing for macx (as a scope) will succeed. This is the default mode on Mac OS X.</p>
<li><p><tt>-win32</tt> <br> <em>qmake</em> will run in win32 mode. In this mode, Windows file naming and path conventions will be used, additionally testing for win32 (as a scope) will succeed. This is the default mode on Windows.</p>
<li><p><tt>-d</tt> <br> <em>qmake</em> will output (hopefully) useful debugging information.</p>
<li><p><tt>-t</tt> tmpl <br> <em>qmake</em> will override any set TEMPLATE variables with tmpl, but only <em>after</em> the .pro file has been processed.</p>
<li><p><tt>-tp</tt> prefix <br> <em>qmake</em> will add the prefix to the TEMPLATE variable.</p>
<li><p><tt>-help</tt> <br> <em>qmake</em> will go over these features and give some useful help.</p>
<p>The following options can be specified on the command line to <em>tqmake</em>:</p>
<ul><li><p><tt>-o</tt> file <br> <em>tqmake</em> output will be directed to <em>file</em>. if this argument is not specified, then <em>tqmake</em> will try to guess a suitable name. If '-' is specified, output is directed to stdout.</p>
<li><p><tt>-unix</tt> <br> <em>tqmake</em> will run in unix mode. In this mode, Unix file naming and path conventions will be used, additionally testing for unix (as a scope) will succeed. This is the default mode on all Unices.</p>
<li><p><tt>-macx</tt> <br> <em>tqmake</em> will run in Mac OS X mode. In this mode, Unix file naming and path conventions will be used, additionally testing for macx (as a scope) will succeed. This is the default mode on Mac OS X.</p>
<li><p><tt>-win32</tt> <br> <em>tqmake</em> will run in win32 mode. In this mode, Windows file naming and path conventions will be used, additionally testing for win32 (as a scope) will succeed. This is the default mode on Windows.</p>
<li><p><tt>-d</tt> <br> <em>tqmake</em> will output (hopefully) useful debugging information.</p>
<li><p><tt>-t</tt> tmpl <br> <em>tqmake</em> will override any set TEMPLATE variables with tmpl, but only <em>after</em> the .pro file has been processed.</p>
<li><p><tt>-tp</tt> prefix <br> <em>tqmake</em> will add the prefix to the TEMPLATE variable.</p>
<li><p><tt>-help</tt> <br> <em>tqmake</em> will go over these features and give some useful help.</p>
</ul><p>There are also warning options that can help to find problems in your project file:</p>
<ul><li><p><tt>-Wall</tt> <br> With this <em>qmake</em> will turn on all known warnings.</p>
<li><p><tt>-Wnone</tt> <br> No warning information will be generated by <em>qmake</em>.</p>
<li><p><tt>-Wparser</tt> <br> <em>qmake</em> will only generate parser warnings, this will alert you to common pitfalls, and potential problems in the parsing of your .pro files.</p>
<li><p><tt>-Wlogic</tt> <br> Again <em>qmake</em> will warn of common pitfalls, and potential problems. This can include (but not limited to) checking if a file is placed into a list of files multiple times, if a file cannot be found, etc.</p>
</ul><p><em>qmake</em> supports two different modes of operation. The first mode, which is the default is makefile generation. In this mode, <em>qmake</em> will take a .pro file and turn it into a makefile. Creating makefiles is covered by this reference guide, there is another mode which generates .pro files.</p>
<p>To toggle between these modes you must specify in the first argument what mode you want to use. If no mode is specified, <em>qmake</em> will assume you want makefile mode. The available modes are:</p>
<ul><li><p><tt>-makefile</tt> <br> <em>qmake</em> output will be a makefile (<a href="qmake-manual-8.html#MakefileMode">Makefile mode</a>).</p>
<li><p><tt>-project</tt> <br> <em>qmake</em> output will be a project file (<a href="qmake-manual-8.html#ProjectfileMode">Project file mode</a>).</p>
<ul><li><p><tt>-Wall</tt> <br> With this <em>tqmake</em> will turn on all known warnings.</p>
<li><p><tt>-Wnone</tt> <br> No warning information will be generated by <em>tqmake</em>.</p>
<li><p><tt>-Wparser</tt> <br> <em>tqmake</em> will only generate parser warnings, this will alert you to common pitfalls, and potential problems in the parsing of your .pro files.</p>
<li><p><tt>-Wlogic</tt> <br> Again <em>tqmake</em> will warn of common pitfalls, and potential problems. This can include (but not limited to) checking if a file is placed into a list of files multiple times, if a file cannot be found, etc.</p>
</ul><p><em>tqmake</em> supports two different modes of operation. The first mode, which is the default is makefile generation. In this mode, <em>tqmake</em> will take a .pro file and turn it into a makefile. Creating makefiles is covered by this reference guide, there is another mode which generates .pro files.</p>
<p>To toggle between these modes you must specify in the first argument what mode you want to use. If no mode is specified, <em>tqmake</em> will assume you want makefile mode. The available modes are:</p>
<ul><li><p><tt>-makefile</tt> <br> <em>tqmake</em> output will be a makefile (<a href="tqmake-manual-8.html#MakefileMode">Makefile mode</a>).</p>
<li><p><tt>-project</tt> <br> <em>tqmake</em> output will be a project file (<a href="tqmake-manual-8.html#ProjectfileMode">Project file mode</a>).</p>
</ul><a name="MakefileMode"></a><h5><a name="3-2-1"></a>Makefile Mode</h5>
<p>In Makefile mode <em>qmake</em> will generate a makefile. Additionally you may supply the following arguments in this mode:</p>
<ul><li><p><tt>-after</tt> <br> <em>qmake</em> will process assignments given on the commandline after the specified files.</p>
<li><p><tt>-nocache</tt> <br> <em>qmake</em> will ignore the .qmake.cache file.</p>
<li><p><tt>-nodepend</tt> <br> <em>qmake</em> will not generate any dependency information.</p>
<li><p><tt>-cache</tt> file <br> <em>qmake</em> will use <em>file</em> as the cache file, ignoring any other .qmake.cache file found</p>
<li><p><tt>-spec</tt> spec <br> <em>qmake</em> will use <em>spec</em> as a path to platform-compiler information and QMAKESPEC will be ignored.</p>
</ul><p>The <tt>files</tt> argument can be a list of one or more project files, separated by spaces. You may also pass qmake assignments on the command line here and they will be processed before all files specified, for example:</p>
<p>qmake -makefile -unix -o Makefile "CONFIG+=test" test.pro</p>
<p>In Makefile mode <em>tqmake</em> will generate a makefile. Additionally you may supply the following arguments in this mode:</p>
<ul><li><p><tt>-after</tt> <br> <em>tqmake</em> will process assignments given on the commandline after the specified files.</p>
<li><p><tt>-nocache</tt> <br> <em>tqmake</em> will ignore the .tqmake.cache file.</p>
<li><p><tt>-nodepend</tt> <br> <em>tqmake</em> will not generate any dependency information.</p>
<li><p><tt>-cache</tt> file <br> <em>tqmake</em> will use <em>file</em> as the cache file, ignoring any other .tqmake.cache file found</p>
<li><p><tt>-spec</tt> spec <br> <em>tqmake</em> will use <em>spec</em> as a path to platform-compiler information and QMAKESPEC will be ignored.</p>
</ul><p>The <tt>files</tt> argument can be a list of one or more project files, separated by spaces. You may also pass tqmake assignments on the command line here and they will be processed before all files specified, for example:</p>
<p>tqmake -makefile -unix -o Makefile "CONFIG+=test" test.pro</p>
<p>If however you are certain you want your variables processed after the the files specified, then you may pass the -after argument. When this is specified all assignments on the commandline after the -after option will be postponed until after the specified files are parsed.</p>
<p>This will generate a Makefile, from test.pro with Unix pathnames. However many of these arguments aren't necessary as they are the default. Therefore the line can be simplified on Unix to:</p>
<p>qmake "CONFIG+=test" test.pro</p>
<p>tqmake "CONFIG+=test" test.pro</p>
<a name="ProjectfileMode"></a><h5><a name="3-2-2"></a>Projectfile Mode</h5>
<p>In Projectfile mode <em>qmake</em> will generate a project file. Additionally, you may supply the following arguments in this mode:</p>
<ul><li><p><tt>-r</tt> <br> <em>qmake</em> will look through supplied directories recursively</p>
<li><p><tt>-nopwd</tt> <br> <em>qmake</em> will not look in your current working directory for source code and only use the specified <tt>files</tt></p>
</ul><p>The <tt>files</tt> argument can be a list of files or directories. If a directory is specified, then it will be included in the <a href="qmake-manual-8.html#DEPENDPATH">DEPENDPATH</a> variable and relevant code from there will be included in the generated project file, if a file is given it will go into the correct variable depending on extension (i.e. .ui files go into FORMS, .cpp files go into SOURCES, etc). Here too you may pass assignments on the commandline, when doing so these assignments will be placed last in the generated .pro file.</p>
<p>In Projectfile mode <em>tqmake</em> will generate a project file. Additionally, you may supply the following arguments in this mode:</p>
<ul><li><p><tt>-r</tt> <br> <em>tqmake</em> will look through supplied directories recursively</p>
<li><p><tt>-nopwd</tt> <br> <em>tqmake</em> will not look in your current working directory for source code and only use the specified <tt>files</tt></p>
</ul><p>The <tt>files</tt> argument can be a list of files or directories. If a directory is specified, then it will be included in the <a href="tqmake-manual-8.html#DEPENDPATH">DEPENDPATH</a> variable and relevant code from there will be included in the generated project file, if a file is given it will go into the correct variable depending on extension (i.e. .ui files go into FORMS, .cpp files go into SOURCES, etc). Here too you may pass assignments on the commandline, when doing so these assignments will be placed last in the generated .pro file.</p>
<a name="SystemVariables"></a><h3><a name="4"></a>System Variables</h3>
<ul><li><p><a href="qmake-manual-8.html#FrequentlyUsedSystemVariables">Frequently Used System Variables</a></p>
<li><p><a href="qmake-manual-8.html#RarelyUsedSystemVariables">Rarely Used System Variables</a></p>
<ul><li><p><a href="tqmake-manual-8.html#FrequentlyUsedSystemVariables">Frequently Used System Variables</a></p>
<li><p><a href="tqmake-manual-8.html#RarelyUsedSystemVariables">Rarely Used System Variables</a></p>
</ul><a name="FrequentlyUsedSystemVariables"></a><h4><a name="4-1"></a>Frequently Used System Variables</h4>
<p>The following variables are recognized by <em>qmake</em> and are used most frequently when creating project files.</p>
<p>The following variables are recognized by <em>tqmake</em> and are used most frequently when creating project files.</p>
<a name="CONFIG"></a><h5><a name="4-1-1"></a>CONFIG</h5>
<p>The <tt>CONFIG</tt> variable specifies project configuration and compiler options. The values will be recognized internally by <em>qmake</em> and have special meaning. They are as follows.</p>
<p>The <tt>CONFIG</tt> variable specifies project configuration and compiler options. The values will be recognized internally by <em>tqmake</em> and have special meaning. They are as follows.</p>
<p>These <tt>CONFIG</tt> values control compilation flags:</p>
<ul><li><p>release - Compile with optimization enabled, ignored if "debug" is specified</p>
<li><p>debug - Compile with debug options enabled</p>
@ -122,7 +122,7 @@ newstuff {
}
</pre>
<a name="DEFINES"></a><h5><a name="4-1-2"></a>DEFINES</h5>
<p><em>qmake</em> adds the values of this variable as compiler C preprocessor macros (-D option).</p>
<p><em>tqmake</em> adds the values of this variable as compiler C preprocessor macros (-D option).</p>
<p>For example:</p>
<pre>
DEFINES += USE_MY_STUFF QT_DLL
@ -131,23 +131,23 @@ DEFINES += USE_MY_STUFF QT_DLL
<p><em>This is only used on Windows when using the 'app' template</em>.</p>
<p>Specifies a .def file to be included in the project.</p>
<a name="DESTDIR"></a><h5><a name="4-1-4"></a>DESTDIR</h5>
<p>Specifies where to put the <a href="qmake-manual-8.html#TARGET">target</a> file.</p>
<p>Specifies where to put the <a href="tqmake-manual-8.html#TARGET">target</a> file.</p>
<p>For example:</p>
<pre>
DESTDIR = ../../lib
</pre>
<a name="DLLDESTDIR"></a><h5><a name="4-1-5"></a>DLLDESTDIR</h5>
<p>Specifies where to copy the <a href="qmake-manual-8.html#TARGET">target</a> dll.</p>
<p>Specifies where to copy the <a href="tqmake-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>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><em>tqmake</em> will generate dependency information (unless -nodepend is specified on the <a href="tqmake-manual-8.html#Commands">command line</a>) for the specified headers. <em>tqmake</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 \
login.h \
mainwindow.h
</pre>
<p>See also <a href="qmake-manual-8.html#SOURCES">SOURCES</a>.</p>
<p>See also <a href="tqmake-manual-8.html#SOURCES">SOURCES</a>.</p>
<a name="INCLUDEPATH"></a><h5><a name="4-1-7"></a>INCLUDEPATH</h5>
<p>This variable specifies the #include directories which should be searched when compiling the project. Use ';' or a space as the directory separator.</p>
<p>For example:</p>
@ -170,7 +170,7 @@ FORMS = mydialog.ui \
LEXSOURCES = lexer.l
</pre>
<a name="LIBS"></a><h5><a name="4-1-10"></a>LIBS</h5>
<p>This variable contains a list of libraries to be linked into the project. If you are more comfortable with the Unix convension of -L/-l flags you are free to use them in a cross-platform manner and qmake will do the correct thing with these libraries on Windows (namely this means passing the full path of the library to the linker). The only limitation to this is the library must exist, for qmake to find which directory a -l lib lives in.</p>
<p>This variable contains a list of libraries to be linked into the project. If you are more comfortable with the Unix convension of -L/-l flags you are free to use them in a cross-platform manner and tqmake will do the correct thing with these libraries on Windows (namely this means passing the full path of the library to the linker). The only limitation to this is the library must exist, for tqmake to find which directory a -l lib lives in.</p>
<p>For example:</p>
<pre>
unix:LIBS += -lmath -L/usr/local/lib
@ -212,7 +212,7 @@ unix:UI_SOURCES_DIR = ../myproject/ui/src
win32:UI_SOURCES_DIR = c:\myproject\ui\src
</pre>
<a name="REQUIRES"></a><h5><a name="4-1-16"></a>REQUIRES</h5>
<p>This is a special variable processed by <em>qmake</em>. If the contents of this variable do not appear in CONFIG by the time this variable is assigned, then a minimal makefile will be generated that states what dependencies (the values assigned to REQUIRES) are missing.</p>
<p>This is a special variable processed by <em>tqmake</em>. If the contents of this variable do not appear in CONFIG by the time this variable is assigned, then a minimal makefile will be generated that states what dependencies (the values assigned to REQUIRES) are missing.</p>
<p>This is mainly used in TQt's build system for building the examples.</p>
<a name="SOURCES"></a><h5><a name="4-1-17"></a>SOURCES</h5>
<p>This variable contains the name of all source files in the project.</p>
@ -223,9 +223,9 @@ SOURCES = myclass.cpp \
mainwindow.cpp
</pre>
<p>See also <a href="qmake-manual-8.html#HEADERS">HEADERS</a></p>
<p>See also <a href="tqmake-manual-8.html#HEADERS">HEADERS</a></p>
<h5><a name="4-1-18"></a>SUBDIRS</h5>
<p>This variable, when used with the 'subdirs' <a href="qmake-manual-8.html#TEMPLATE">TEMPLATE</a> contains the names of all subdirectories to look for a project file.</p>
<p>This variable, when used with the 'subdirs' <a href="tqmake-manual-8.html#TEMPLATE">TEMPLATE</a> contains the names of all subdirectories to look for a project file.</p>
<p>For example:</p>
<pre>
SUBDIRS = kernel \
@ -255,7 +255,7 @@ TARGET = mylib
</pre>
<p>The template can be overridden by specifying a new template type with the <tt>-t</tt> command line option. This overrides the template type <em>after</em> the .pro file has been processed. With .pro files that use the template type to determine how the project is built, it is necessary to declare TEMPLATE on the command line rather than use the <tt>-t</tt> option.</p>
<h5><a name="4-1-21"></a>VERSION</h5>
<p>This variable contains the version number of the library if the 'lib' <a href="qmake-manual-8.html#TEMPLATE">TEMPLATE</a> is specified.</p>
<p>This variable contains the version number of the library if the 'lib' <a href="tqmake-manual-8.html#TEMPLATE">TEMPLATE</a> is specified.</p>
<p>For example:</p>
<pre>
VERSION = 1.2.3
@ -273,285 +273,285 @@ DISTFILES += ../program.txt
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>
<p>The following variables are also recognized by <em>tqmake</em> but are either internal or very rarely used.</p>
<a name="DESTDIR_TARGET"></a><h5><a name="4-2-1"></a>DESTDIR_TARGET</h5>
<p>This variable is set internally by <em>qmake</em>, which is basically the DESTDIR variable with the TARGET variable appened at the end. 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 internally by <em>tqmake</em>, which is basically the DESTDIR variable with the TARGET variable appened at the end. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="DSP_TEMPLATE"></a><h5><a name="4-2-2"></a>DSP_TEMPLATE</h5>
<p>This variable is set internally by <em>qmake</em>, which specifies where the dsp template file for basing generated dsp files is stored. 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 internally by <em>tqmake</em>, which specifies where the dsp template file for basing generated dsp files is stored. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="LEXIMPLS"></a><h5><a name="4-2-3"></a>LEXIMPLS</h5>
<p>This variable contains a list of lex implementation 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 contains a list of lex implementation files. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="LEXOBJECTS"></a><h5><a name="4-2-4"></a>LEXOBJECTS</h5>
<p>This variable contains the names of intermediate lex object files.The value of this variable is typically handled by <em>qmake</em> and rarely needs to be modified.</p>
<p>This variable contains the names of intermediate lex object files.The value of this variable is typically handled by <em>tqmake</em> and rarely needs to be modified.</p>
<a name="LITERAL_HASH"></a><h5><a name="4-2-5"></a>LITERAL_HASH</h5>
<p>This variable is used whenever a literal hash character (<tt>#</tt>) is needed in a variable declaration, perhaps as part of a file name or in a string passed to some external application.</p>
<p>For example:</p>
<pre>
# To include a literal hash character, use the $$LITERAL_HASH variable:
urlPieces = http://doc.trolltech.com/3.3/qmake-manual-8.html LITERAL_HASH
urlPieces = http://doc.trolltech.com/3.3/tqmake-manual-8.html LITERAL_HASH
message($$join(urlPieces, $$LITERAL_HASH))
</pre>
<p>By using <tt>LITERAL_HASH</tt> in this way, the <tt>#</tt> character can be used to construct a URL for the <tt>message()</tt> function to print to the console.</p>
<a name="MAKEFILE"></a><h5><a name="4-2-6"></a>MAKEFILE</h5>
<p>This variable specifies the name of the makefile which <em>qmake</em> should use when outputting the dependency information for building a 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 specifies the name of the makefile which <em>tqmake</em> should use when outputting the dependency information for building a project. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="MAKEFILE_GENERATOR"></a><h5><a name="4-2-7"></a>MAKEFILE_GENERATOR</h5>
<p>This variable contains the name of the makefile generator to use when generating a makefile. The value of this variable is typically handled internally by <em>qmake</em> and rarely needs to be modified.</p>
<p>This variable contains the name of the makefile generator to use when generating a makefile. The value of this variable is typically handled internally by <em>tqmake</em> and rarely needs to be modified.</p>
<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>
<p>This variable is generated from the <a href="tqmake-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>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.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 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>
<p>This variable is set by <em>tqmake</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>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.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 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>
<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>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.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>
<p>This variable contains the name of the <em>tqmake</em> program itself and is placed in generated makefiles. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKESPEC_systemvariable"></a><h5><a name="4-2-12"></a>QMAKESPEC</h5>
<p>This variable contains the name of the <em>qmake</em> configuration to use when generating makefiles. The value of this variable is typically handled by <em>qmake</em> and rarely needs to be modified. Use the <a href="qmake-manual-8.html#QMAKESPEC">QMAKESPEC</a> environment variable instead.</p>
<p>This variable contains the name of the <em>tqmake</em> configuration to use when generating makefiles. The value of this variable is typically handled by <em>tqmake</em> and rarely needs to be modified. Use the <a href="tqmake-manual-8.html#QMAKESPEC">QMAKESPEC</a> environment variable instead.</p>
<a name="QMAKE_APP_FLAG"></a><h5><a name="4-2-13"></a>QMAKE_APP_FLAG</h5>
<p>This variable is empty unless the 'app' <a href="qmake-manual-8.html#TEMPLATE">TEMPLATE</a> 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. Use the following instead:</p>
<p>This variable is empty unless the 'app' <a href="tqmake-manual-8.html#TEMPLATE">TEMPLATE</a> is specified. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified. Use the following instead:</p>
<pre>
app {
#conditional code for 'app' template here
}
</pre>
<a name="QMAKE_APP_OR_DLL"></a><h5><a name="4-2-14"></a>QMAKE_APP_OR_DLL</h5>
<p>This variable is empty unless the 'app' or 'dll' <a href="qmake-manual-8.html#TEMPLATE">TEMPLATE</a> 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>
<p>This variable is empty unless the 'app' or 'dll' <a href="tqmake-manual-8.html#TEMPLATE">TEMPLATE</a> is specified. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_AR_CMD"></a><h5><a name="4-2-15"></a>QMAKE_AR_CMD</h5>
<p><em>This is used on Unix platforms only</em></p>
<p>This variable contains the command for invoking the program which creates, modifies and extracts archives. 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 command for invoking the program which creates, modifies and extracts archives. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_CFLAGS_DEBUG"></a><h5><a name="4-2-16"></a>QMAKE_CFLAGS_DEBUG</h5>
<p>This variable contains the flags for the C compiler in debug mode.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 flags for the C compiler in debug mode.The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_CFLAGS_MT"></a><h5><a name="4-2-17"></a>QMAKE_CFLAGS_MT</h5>
<p>This variable contains the compiler flags for creating a multi-threaded application or when the version of TQt that you link against is a multi-threaded statically linked library. 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 compiler flags for creating a multi-threaded application or when the version of TQt that you link against is a multi-threaded statically linked library. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_CFLAGS_MT_DBG"></a><h5><a name="4-2-18"></a>QMAKE_CFLAGS_MT_DBG</h5>
<p>This variable contains the compiler flags for creating a debuggable multi-threaded application or when the version of TQt that you link against is a debuggable multi-threaded statically linked library. 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 compiler flags for creating a debuggable multi-threaded application or when the version of TQt that you link against is a debuggable multi-threaded statically linked library. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_CFLAGS_MT_DLL"></a><h5><a name="4-2-19"></a>QMAKE_CFLAGS_MT_DLL</h5>
<p><em>This is used on Windows only</em></p>
<p>This variable contains the compiler flags for creating a multi-threaded dll or when the version of TQt that you link against is a multi-threaded dll. 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 compiler flags for creating a multi-threaded dll or when the version of TQt that you link against is a multi-threaded dll. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_CFLAGS_MT_DLLDBG"></a><h5><a name="4-2-20"></a>QMAKE_CFLAGS_MT_DLLDBG</h5>
<p><em>This is used on Windows only</em></p>
<p>This variable contains the compiler flags for creating a debuggable multi-threaded dll or when the version of TQt that you link against is a debuggable multi-threaded statically linked library. 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 compiler flags for creating a debuggable multi-threaded dll or when the version of TQt that you link against is a debuggable multi-threaded statically linked library. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_CFLAGS_RELEASE"></a><h5><a name="4-2-21"></a>QMAKE_CFLAGS_RELEASE</h5>
<p>This variable contains the compiler flags for creating a non-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>
<p>This variable contains the compiler flags for creating a non-debuggable application. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_CFLAGS_SHLIB"></a><h5><a name="4-2-22"></a>QMAKE_CFLAGS_SHLIB</h5>
<p><em>This is used on Unix platforms only</em></p>
<p>This variable contains the compiler flags for creating a shared library. 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 compiler flags for creating a shared library. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_CFLAGS_THREAD"></a><h5><a name="4-2-23"></a>QMAKE_CFLAGS_THREAD</h5>
<p>This variable contains the compiler flags for creating a multi-threaded 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>
<p>This variable contains the compiler flags for creating a multi-threaded application. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_CFLAGS_WARN_OFF"></a><h5><a name="4-2-24"></a>QMAKE_CFLAGS_WARN_OFF</h5>
<p>This variable is not empty if the warn_off <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>
<p>This variable is not empty if the warn_off <a href="tqmake-manual-8.html#TEMPLATE">TEMPLATE</a> option is specified. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<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>
<p>This variable is not empty if the warn_on <a href="tqmake-manual-8.html#TEMPLATE">TEMPLATE</a> option is specified. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.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 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>
<p>This variable contains the C++ compiler flags for creating a debuggable application. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.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>
<p>This variable contains the C++ compiler flags for creating a multi-threaded 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>
<p>This variable contains the C++ compiler flags for creating a multi-threaded application. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_CXXFLAGS_MT_DBG"></a><h5><a name="4-2-29"></a>QMAKE_CXXFLAGS_MT_DBG</h5>
<p>This variable contains the C++ compiler flags for creating a debuggable multi-threaded 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>
<p>This variable contains the C++ compiler flags for creating a debuggable multi-threaded application. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_CXXFLAGS_MT_DLL"></a><h5><a name="4-2-30"></a>QMAKE_CXXFLAGS_MT_DLL</h5>
<p><tt>This is used on Windows only</tt></p>
<p>This variable contains the C++ compiler flags for creating a multi-threaded dll. 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 C++ compiler flags for creating a multi-threaded dll. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_CXXFLAGS_MT_DLLDBG"></a><h5><a name="4-2-31"></a>QMAKE_CXXFLAGS_MT_DLLDBG</h5>
<p><tt>This is used on Windows only</tt></p>
<p>This variable contains the C++ compiler flags for creating a multi-threaded debuggable dll. 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 C++ compiler flags for creating a multi-threaded debuggable dll. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_CXXFLAGS_RELEASE"></a><h5><a name="4-2-32"></a>QMAKE_CXXFLAGS_RELEASE</h5>
<p>This variable contains the C++ compiler flags for creating an 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>
<p>This variable contains the C++ compiler flags for creating an application. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_CXXFLAGS_SHLIB"></a><h5><a name="4-2-33"></a>QMAKE_CXXFLAGS_SHLIB</h5>
<p>This variable contains the C++ compiler flags for creating a shared library. 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 C++ compiler flags for creating a shared library. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_CXXFLAGS_THREAD"></a><h5><a name="4-2-34"></a>QMAKE_CXXFLAGS_THREAD</h5>
<p>This variable contains the C++ compiler flags for creating a multi-threaded 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>
<p>This variable contains the C++ compiler flags for creating a multi-threaded application. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_CXXFLAGS_WARN_OFF"></a><h5><a name="4-2-35"></a>QMAKE_CXXFLAGS_WARN_OFF</h5>
<p>This variable contains the C++ compiler flags for suppressing compiler warnings. 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 C++ compiler flags for suppressing compiler warnings. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_CXXFLAGS_WARN_ON"></a><h5><a name="4-2-36"></a>QMAKE_CXXFLAGS_WARN_ON</h5>
<p>This variable contains C++ compiler flags for generating compiler warnings. 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 C++ compiler flags for generating compiler warnings. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_EXTENSION_SHLIB"></a><h5><a name="4-2-37"></a>QMAKE_EXTENSION_SHLIB</h5>
<p>This variable contains the extention for shared libraries. 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 extention for shared libraries. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_FAILED_REQUIREMENTS"></a><h5><a name="4-2-38"></a>QMAKE_FAILED_REQUIREMENTS</h5>
<p>This variable contains the list of requirements that were failed to be met when <em>qmake</em> was used. For example, the sql module is needed and wasn't compiled into TQt. 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 list of requirements that were failed to be met when <em>tqmake</em> was used. For example, the sql module is needed and wasn't compiled into TQt. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_FILETAGS"></a><h5><a name="4-2-39"></a>QMAKE_FILETAGS</h5>
<p>This variable contains the file tags needed to be entered into the makefile, such as SOURCES and HEADERS. 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 file tags needed to be entered into the makefile, such as SOURCES and HEADERS. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_INCDIR"></a><h5><a name="4-2-40"></a>QMAKE_INCDIR</h5>
<p>This variable contains the location of all known header files to be added to INCLUDEPATH when building an 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>
<p>This variable contains the location of all known header files to be added to INCLUDEPATH when building an application. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="POST_TARGETDEPS"></a><h5><a name="4-2-41"></a>POST_TARGETDEPS</h5>
<p>All libraries that the <a href="qmake-manual-8.html#TARGET">target</a> depends on can be listed in this variable. Some backends do not support this, these include MSVC Dsp, and ProjectBuilder .pbproj files. Generally this is support internally by these build tools, this is usefull for explicitly listing dependant static libraries.</p>
<p>This list will go after all builtin (and <a href="qmake-manual-8.html#PRE_TARGETDEPS">$$PRE_TARGETDEPS</a>) dependencies.</p>
<p>All libraries that the <a href="tqmake-manual-8.html#TARGET">target</a> depends on can be listed in this variable. Some backends do not support this, these include MSVC Dsp, and ProjectBuilder .pbproj files. Generally this is support internally by these build tools, this is usefull for explicitly listing dependant static libraries.</p>
<p>This list will go after all builtin (and <a href="tqmake-manual-8.html#PRE_TARGETDEPS">$$PRE_TARGETDEPS</a>) dependencies.</p>
<a name="PRE_TARGETDEPS"></a><h5><a name="4-2-42"></a>PRE_TARGETDEPS</h5>
<p>All libraries that the <a href="qmake-manual-8.html#TARGET">target</a> depends on can be listed in this variable. Some backends do not support this, these include MSVC Dsp, and ProjectBuilder .pbproj files. Generally this is support internally by these build tools, this is usefull for explicitly listing dependant static libraries.</p>
<p>All libraries that the <a href="tqmake-manual-8.html#TARGET">target</a> depends on can be listed in this variable. Some backends do not support this, these include MSVC Dsp, and ProjectBuilder .pbproj files. Generally this is support internally by these build tools, this is usefull for explicitly listing dependant static libraries.</p>
<p>This list will go before all builtin dependencies.</p>
<a name="QMAKE_INCDIR_OPENGL"></a><h5><a name="4-2-43"></a>QMAKE_INCDIR_OPENGL</h5>
<p>This variable contains the location of OpenGL header files to be added to INCLUDEPATH when building an application with OpenGL support. 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 location of OpenGL header files to be added to INCLUDEPATH when building an application with OpenGL support. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_INCDIR_TQT"></a><h5><a name="4-2-44"></a>QMAKE_INCDIR_TQT</h5>
<p>This variable contains the location of all known header file paths to be added to INCLUDEPATH when building a TQt 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>
<p>This variable contains the location of all known header file paths to be added to INCLUDEPATH when building a TQt application. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_INCDIR_THREAD"></a><h5><a name="4-2-45"></a>QMAKE_INCDIR_THREAD</h5>
<p>This variable contains the location of all known header file paths to be added to INCLUDEPATH when building a multi-threaded 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>
<p>This variable contains the location of all known header file paths to be added to INCLUDEPATH when building a multi-threaded application. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_INCDIR_X11"></a><h5><a name="4-2-46"></a>QMAKE_INCDIR_X11</h5>
<p><em>This is used on Unix platforms only</em></p>
<p>This variable contains the location of X11 header file paths to be added to INCLUDEPATH when building a X11 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>
<p>This variable contains the location of X11 header file paths to be added to INCLUDEPATH when building a X11 application. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="QMAKE_LFLAGS_CONSOLE"></a><h5><a name="4-2-47"></a>QMAKE_LFLAGS_CONSOLE</h5>
<p><em>This is used on Windows only</em></p>
<p>This variable contains link flags when building console programs. 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 link flags when building console programs. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-48"></a>QMAKE_LFLAGS_CONSOLE_DLL</h5>
<p><em>This is used on Windows only</em></p>
<p>This variable contains link flags when building console dlls. 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 link flags when building console dlls. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-49"></a>QMAKE_LFLAGS_DEBUG</h5>
<p>This variable contains link flags when building debuggable applications. 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 link flags when building debuggable applications. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-50"></a>QMAKE_LFLAGS_PLUGIN</h5>
<p>This variable contains link flags when building plugins. 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 link flags when building plugins. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-51"></a>QMAKE_LFLAGS_QT_DLL</h5>
<p>This variable contains link flags when building programs that use the TQt library built as a dll. 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 link flags when building programs that use the TQt library built as a dll. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-52"></a>QMAKE_LFLAGS_RELEASE</h5>
<p>This variable contains link flags when building applications for release. 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 link flags when building applications for release. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-53"></a>QMAKE_LFLAGS_SHAPP</h5>
<p>This variable contains link flags when building applications which are using the 'app' template. 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 link flags when building applications which are using the 'app' template. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-54"></a>QMAKE_LFLAGS_SHLIB</h5>
<p>This variable contains link flags when building shared libraries 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 link flags when building shared libraries The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-55"></a>QMAKE_LFLAGS_SONAME</h5>
<p>This variable specifies the link flags to set the name of shared objects, such as .so or .dll. 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 specifies the link flags to set the name of shared objects, such as .so or .dll. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-56"></a>QMAKE_LFLAGS_THREAD</h5>
<p>This variable contains link flags when building multi-threaded projects. 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 link flags when building multi-threaded projects. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-57"></a>QMAKE_LFLAGS_WINDOWS</h5>
<p><em>This is used on Windows only</em></p>
<p>This variable contains link flags when building windows projects. 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 link flags when building windows projects. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-58"></a>QMAKE_LFLAGS_WINDOWS_DLL</h5>
<p><em>This is used on Windows only</em></p>
<p>This variable contains link flags when building windows dll projects. 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 link flags when building windows dll projects. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-59"></a>QMAKE_LIBDIR</h5>
<p>This variable contains the location of all known library directories.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 location of all known library directories.The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-60"></a>QMAKE_LIBDIR_FLAGS</h5>
<p><em>This is used on Unix platforms only</em></p>
<p>This variable contains the location of all library directory with -L prefixed. 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 location of all library directory with -L prefixed. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-61"></a>VPATH</h5>
<p>This variable tells <em>qmake</em> where to search for files it cannot open. With this you may tell <em>qmake</em> where it may look for things like SOURCES, and if it finds an entry in SOURCES that cannot be opened it will look through the entire VPATH list to see if it can find the file on its own.</p>
<p>See also <a href="qmake-manual-8.html#DEPENDPATH">DEPENDPATH</a>.</p>
<p>This variable tells <em>tqmake</em> where to search for files it cannot open. With this you may tell <em>tqmake</em> where it may look for things like SOURCES, and if it finds an entry in SOURCES that cannot be opened it will look through the entire VPATH list to see if it can find the file on its own.</p>
<p>See also <a href="tqmake-manual-8.html#DEPENDPATH">DEPENDPATH</a>.</p>
<a name="DEPENDPATH"></a><h5><a name="4-2-62"></a>DEPENDPATH</h5>
<p>This variable contains the list of all directories to look in to resolve dependencies. This will be used when crawling through 'included' files.</p>
<h5><a name="4-2-63"></a>QMAKE_LIBDIR_OPENGL</h5>
<p>This variable contains the location of the OpenGL library directory.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 location of the OpenGL library directory.The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-64"></a>QMAKE_LIBDIR_TQT</h5>
<p>This variable contains the location of the TQt library directory.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 location of the TQt library directory.The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-65"></a>QMAKE_LIBDIR_X11</h5>
<p><em>This is used on Unix platforms only</em></p>
<p>This variable contains the location of the X11 library directory.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 location of the X11 library directory.The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-66"></a>QMAKE_LIBS</h5>
<p>This variable contains all project libraries. 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 all project libraries. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-67"></a>QMAKE_LIBS_CONSOLE</h5>
<p><em>This is used on Windows only</em></p>
<p>This variable contains all project libraries that should be linked against when building a console 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>
<p>This variable contains all project libraries that should be linked against when building a console application. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-68"></a>QMAKE_LIBS_OPENGL</h5>
<p>This variable contains all OpenGL libraries. 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 all OpenGL libraries. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-69"></a>QMAKE_LIBS_OPENGL_QT</h5>
<p>This variable contains all OpenGL TQt libraries.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 all OpenGL TQt libraries.The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-70"></a>QMAKE_LIBS_QT</h5>
<p>This variable contains all TQt libraries.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 all TQt libraries.The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-71"></a>QMAKE_LIBS_QT_DLL</h5>
<p><em>This is used on Windows only</em></p>
<p>This variable contains all TQt libraries when TQt is built as a dll. 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 all TQt libraries when TQt is built as a dll. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-72"></a>QMAKE_LIBS_QT_OPENGL</h5>
<p>This variable contains all the libraries needed to link against if OpenGL support is turned on. 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 all the libraries needed to link against if OpenGL support is turned on. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-73"></a>QMAKE_LIBS_QT_THREAD</h5>
<p>This variable contains all the libraries needed to link against if thread support is turned on. 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 all the libraries needed to link against if thread support is turned on. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-75"></a>QMAKE_LIBS_RTMT</h5>
<p><em>This is used with Borland compilers only</em></p>
<p>This variable contains the runtime library needed to link against when building a multi-threaded 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>
<p>This variable contains the runtime library needed to link against when building a multi-threaded application. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-76"></a>QMAKE_LIBS_THREAD</h5>
<p><em>This is used on Unix platforms only</em></p>
<p>This variable contains all libraries that need to be linked against when building a multi-threaded 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>
<p>This variable contains all libraries that need to be linked against when building a multi-threaded application. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-77"></a>QMAKE_LIBS_WINDOWS</h5>
<p><em>This is used on Windows only</em></p>
<p>This variable contains all windows libraries.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 all windows libraries.The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-78"></a>QMAKE_LIBS_X11</h5>
<p><em>This is used on Unix platforms only</em></p>
<p>This variable contains all X11 libraries.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 all X11 libraries.The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-79"></a>QMAKE_LIBS_X11SM</h5>
<p><em>This is used on Unix platforms only</em></p>
<p>This variable contains all X11 session management libraries. 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 all X11 session management libraries. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-80"></a>QMAKE_LIB_FLAG</h5>
<p>This variable is not empty if the 'lib' template 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>
<p>This variable is not empty if the 'lib' template is specified. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-81"></a>QMAKE_LINK_SHLIB_CMD</h5>
<p>This variable contains the command to execute when creating a shared library. 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 command to execute when creating a shared library. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-82"></a>QMAKE_POST_LINK</h5>
<p>This variable contains the command to execute after linking the TARGET together. This variable is normally empty and therefore nothing is executed, additionally some backends will not support this - mostly only Makefile backends.</p>
<h5><a name="4-2-83"></a>QMAKE_PRE_LINK</h5>
<p>This variable contains the command to execute before linking the TARGET together. This variable is normally empty and therefore nothing is executed, additionally some backends will not support this - mostly only Makefile backends.</p>
<h5><a name="4-2-84"></a>QMAKE_LN_SHLIB</h5>
<p>This variable contains the command to execute when creating a link to a shared library. 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 command to execute when creating a link to a shared library. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<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>
<p>This variable contains the name of the makefile to create. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.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 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>
<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>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.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>
<p>This variable contains the location of tqmake if it is not in the path. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-88"></a>QMAKE_QT_DLL</h5>
<p>This variable is not empty if TQt was built as a dll. 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 not empty if TQt was built as a dll. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-89"></a>QMAKE_RUN_CC</h5>
<p>This variable specifies the individual rule needed to build an object. 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 specifies the individual rule needed to build an object. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-90"></a>QMAKE_RUN_CC_IMP</h5>
<p>This variable specifies the individual rule needed to build an object. 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 specifies the individual rule needed to build an object. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-91"></a>QMAKE_RUN_CXX</h5>
<p>This variable specifies the individual rule needed to build an object. 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 specifies the individual rule needed to build an object. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-92"></a>QMAKE_RUN_CXX_IMP</h5>
<p>This variable specifies the individual rule needed to build an object. 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 specifies the individual rule needed to build an object. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-93"></a>QMAKE_TARGET</h5>
<p>This variable contains the name of the project target. 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 name of the project target. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-94"></a>QMAKE_UIC</h5>
<p>This variable contains the location of tquic 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>
<p>This variable contains the location of tquic if it is not in the path. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<p>It can be used to specify arguments to tquic as well, such as additional plugin paths. For example:</p>
<pre>
QMAKE_UIC = tquic -L /path/to/plugin
</pre>
<h5><a name="4-2-95"></a>RC_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>
<p>This variable contains the name of the resource file for the application. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<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>
<p>This variable contains the name of the resource file for the application. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.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 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>
<p>This variable is set by <em>tqmake</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>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.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>
<p>This variable specifies the target's extension. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-99"></a>TARGET_x</h5>
<p>This variable specifies the target's extension with a major version number. 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 specifies the target's extension with a major version number. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-100"></a>TARGET_x.y.z</h5>
<p>This variable specifies the target's extension with version number. 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 specifies the target's extension with version number. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-101"></a>UICIMPLS</h5>
<p>This variable contains a list of the generated implementation files by TQUIC. 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 the generated implementation files by TQUIC. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-102"></a>UICOBJECTS</h5>
<p>This variable is generated from the UICIMPLS variable. The extension of each 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>
<p>This variable is generated from the UICIMPLS variable. The extension of each file will have been replaced by .o (Unix) or .obj (Win32). The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-103"></a>VER_MAJ</h5>
<p>This variable contains the major version number of the library, if the 'lib' <a href="qmake-manual-8.html#TEMPLATE">template</a> is specified.</p>
<p>This variable contains the major version number of the library, if the 'lib' <a href="tqmake-manual-8.html#TEMPLATE">template</a> is specified.</p>
<h5><a name="4-2-104"></a>VER_MIN</h5>
<p>This variable contains the minor version number of the library, if the 'lib' <a href="qmake-manual-8.html#TEMPLATE">template</a> is specified.</p>
<p>This variable contains the minor version number of the library, if the 'lib' <a href="tqmake-manual-8.html#TEMPLATE">template</a> is specified.</p>
<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>
<p>This variable contains the patch version number of the library, if the 'lib' <a href="tqmake-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 tqmoc files.</p>
<p>See also <a href="qmake-manual-8.html#Extensions">File Extensions</a>.</p>
<p>See also <a href="tqmake-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>
<p>See also <a href="qmake-manual-8.html#Extensions">File Extensions</a>.</p>
<p>See also <a href="tqmake-manual-8.html#Extensions">File Extensions</a>.</p>
<h5><a name="4-2-108"></a>QMAKE_EXT_PRL</h5>
<p>This variable changes the extention used on created PRL files.</p>
<p>See also <a href="qmake-manual-8.html#Extensions">File Extensions</a>, <a href="qmake-manual-8.html#LibDepend">Library Dependencies</a>.</p>
<p>See also <a href="tqmake-manual-8.html#Extensions">File Extensions</a>, <a href="tqmake-manual-8.html#LibDepend">Library Dependencies</a>.</p>
<h5><a name="4-2-109"></a>QMAKE_EXT_LEX</h5>
<p>This variable changes the extention used on files given to lex.</p>
<p>See also <a href="qmake-manual-8.html#Extensions">File Extensions</a>, <a href="qmake-manual-8.html#LEXSOURCES">LEXSOURCES</a>.</p>
<p>See also <a href="tqmake-manual-8.html#Extensions">File Extensions</a>, <a href="tqmake-manual-8.html#LEXSOURCES">LEXSOURCES</a>.</p>
<h5><a name="4-2-110"></a>QMAKE_EXT_YACC This variable changes the extention used on files given to yacc.</h5>
<p>See also <a href="qmake-manual-8.html#Extensions">File Extensions</a>, <a href="qmake-manual-8.html#LEXSOURCES">YACCSOURCES</a>.</p>
<p>See also <a href="tqmake-manual-8.html#Extensions">File Extensions</a>, <a href="tqmake-manual-8.html#LEXSOURCES">YACCSOURCES</a>.</p>
<h5><a name="4-2-111"></a>QMAKE_EXT_OBJ</h5>
<p>This variable changes the extention used on generated object files.</p>
<p>See also <a href="qmake-manual-8.html#Extensions">File Extensions</a>.</p>
<p>See also <a href="tqmake-manual-8.html#Extensions">File Extensions</a>.</p>
<h5><a name="4-2-112"></a>QMAKE_EXT_CPP</h5>
<p>This variable changes the interpretation of all suffixes in this list of values as files of type C++ source code.</p>
<p>See also <a href="qmake-manual-8.html#Extensions">File Extensions</a>.</p>
<p>See also <a href="tqmake-manual-8.html#Extensions">File Extensions</a>.</p>
<h5><a name="4-2-113"></a>QMAKE_EXT_H</h5>
<p>This variable changes the interpretation of all suffixes in this list of values as files of type C header files.</p>
<p>See also <a href="qmake-manual-8.html#Extensions">File Extensions</a>.</p>
<p>See also <a href="tqmake-manual-8.html#Extensions">File Extensions</a>.</p>
<h5><a name="4-2-114"></a>YACCIMPLS</h5>
<p>This variable contains a list of yacc source 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 contains a list of yacc source files. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<h5><a name="4-2-115"></a>YACCOBJECTS</h5>
<p>This variable contains a list of yacc 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 contains a list of yacc object files. The value of this variable is typically handled by <em>tqmake</em> or <a href="tqmake-manual-8.html#QMAKESPEC">tqmake.conf</a> and rarely needs to be modified.</p>
<a name="Functions"></a><h3><a name="5"></a>Functions</h3>
<p><em>qmake</em> recognizes the following functions:</p>
<p><em>tqmake</em> recognizes the following functions:</p>
<h4><a name="5-1"></a>include( filename )</h4>
<p>This function will include the contents of <em>filename</em> into the current project at the point where was included. The function succeeds if <em>filename</em> was included, otherwise it fails. You can check the return value of this function using a scope.</p>
<p>For example:</p>
@ -593,7 +593,7 @@ count( MYVAR, 3 ) {
}
</pre>
<h4><a name="5-5"></a>infile( filename, var, val )</h4>
<p>This function will succeed if the file <em>filename</em> (when parsed by qmake itself) contains the variable <em>var</em> with a value of <em>val</em>. You may also not pass in a third argument (<em>val</em>) and the function will only test if <em>var</em> has been assigned to in the file.</p>
<p>This function will succeed if the file <em>filename</em> (when parsed by tqmake itself) contains the variable <em>var</em> with a value of <em>val</em>. You may also not pass in a third argument (<em>val</em>) and the function will only test if <em>var</em> has been assigned to in the file.</p>
<h4><a name="5-6"></a>isEmpty( variablename )</h4>
<p>This function will succeed if the variable <em>variablename</em> is empty (same as <tt>count(variable, 0)</tt>).</p>
<h4><a name="5-7"></a>system( command )</h4>
@ -605,87 +605,87 @@ count( MYVAR, 3 ) {
<h4><a name="5-8"></a>message( string )</h4>
<p>This function will always succeed, and will display the given <em>string</em> to the user.</p>
<h4><a name="5-9"></a>error( string )</h4>
<p>This function will never return a value. It will display the given <em>string</em> to the user, and then exit <em>qmake</em>. This function should only be used for very fatal configurations.</p>
<p>This function will never return a value. It will display the given <em>string</em> to the user, and then exit <em>tqmake</em>. This function should only be used for very fatal configurations.</p>
<p>For example:</p>
<pre>
release:debug:error(You can't have release and debug at the same time!)
</pre>
<a name="Properties"></a><h3><a name="6"></a>Properties</h3>
<p><em>qmake</em> has a system of persistant information, this allows you to 'set' a variable in qmake once, and each time qmake is invoked this value can be queried. Use the following to set a property in qmake:</p>
<p><em>tqmake</em> has a system of persistant information, this allows you to 'set' a variable in tqmake once, and each time tqmake is invoked this value can be queried. Use the following to set a property in tqmake:</p>
<pre>
qmake -set VARIABLE VALUE
tqmake -set VARIABLE VALUE
</pre>
<p>To retrieve this information back from qmake you can do:</p>
<p>To retrieve this information back from tqmake you can do:</p>
<pre>
qmake -query VARIABLE
qmake -query #queries all current VARIABLE/VALUE pairs..
tqmake -query VARIABLE
tqmake -query #queries all current VARIABLE/VALUE pairs..
</pre>
<p>This information will be saved into a TQSettings object (meaning it will be stored in different places for different platforms). As VARIABLE is versioned as well, you can set one value in an older version of qmake, and newer versions will retrieve this value, however if you -set VARIABLE into a newer version of qmake the older version will not use this value. You can however query a specific version of a variable if you prefix that version of qmake to VARIABLE, as in:</p>
<p>This information will be saved into a TQSettings object (meaning it will be stored in different places for different platforms). As VARIABLE is versioned as well, you can set one value in an older version of tqmake, and newer versions will retrieve this value, however if you -set VARIABLE into a newer version of tqmake the older version will not use this value. You can however query a specific version of a variable if you prefix that version of tqmake to VARIABLE, as in:</p>
<pre>
qmake -query "1.06a/VARIABLE"
tqmake -query "1.06a/VARIABLE"
</pre>
<p>qmake also has the notion of 'builtin' properties, for example you can query the installation of TQt for this version of qmake with the QT_INSTALL_PREFIX property:</p>
<p>tqmake also has the notion of 'builtin' properties, for example you can query the installation of TQt for this version of tqmake with the QT_INSTALL_PREFIX property:</p>
<pre>
qmake -query "QT_INSTALL_PREFIX"
tqmake -query "QT_INSTALL_PREFIX"
</pre>
<p>These builtin properties cannot have a version prefixed to them as they are not versioned and each qmake will have its own notion of these values. The list below outlines the builtin properties:</p>
<ul><li><p>QT_INSTALL_PREFIX - Where the version of TQt this qmake is built for resides</p>
<p>These builtin properties cannot have a version prefixed to them as they are not versioned and each tqmake will have its own notion of these values. The list below outlines the builtin properties:</p>
<ul><li><p>QT_INSTALL_PREFIX - Where the version of TQt this tqmake is built for resides</p>
<li><p>QT_INSTALL_DATA - Where data for this version of TQt resides</p>
<li><p>QMAKE_VERSION - The current version of qmake</p>
<li><p>QMAKE_VERSION - The current version of tqmake</p>
</ul><p>Finally, these values can be queried in a project file with a special notation such as:</p>
<pre>
QMAKE_VERS = $$[QMAKE_VERSION]
</pre>
<a name="Environment"></a><h3><a name="7"></a>Environment Variables and Configuration</h3>
<a name="QMAKESPEC"></a><h4><a name="7-1"></a>QMAKESPEC</h4>
<p><em>qmake</em> requires a platform and compiler description file which contains many default values used to generate appropriate makefiles. The standard TQt distribution comes with many of these files, located in the 'mkspecs' subdirectory of the TQt installation.</p>
<p><em>tqmake</em> requires a platform and compiler description file which contains many default values used to generate appropriate makefiles. The standard TQt distribution comes with many of these files, located in the 'mkspecs' subdirectory of the TQt installation.</p>
<p>The QMAKESPEC environment variable can contain any of the following:</p>
<ul><li><p>A complete path to a directory containing a qmake.conf file. In this case <em>qmake</em> will open the qmake.conf file from within that directory. If the file does not exist, <em>qmake</em> will exit with an error.</p>
<li><p>The name of a platform-compiler combination. In this case, <em>qmake</em> will search in the directory specified by the TQTDIR environment variable.</p>
</ul><p>Note: the QMAKESPEC path will automatically be added to the <a href="qmake-manual-8.html#INCLUDEPATH">INCLUDEPATH</a> system variable.</p>
<ul><li><p>A complete path to a directory containing a tqmake.conf file. In this case <em>tqmake</em> will open the tqmake.conf file from within that directory. If the file does not exist, <em>tqmake</em> will exit with an error.</p>
<li><p>The name of a platform-compiler combination. In this case, <em>tqmake</em> will search in the directory specified by the TQTDIR environment variable.</p>
</ul><p>Note: the QMAKESPEC path will automatically be added to the <a href="tqmake-manual-8.html#INCLUDEPATH">INCLUDEPATH</a> system variable.</p>
<a name="INSTALLS"></a><h4><a name="7-2"></a>INSTALLS</h4>
<p>It is common on UNIX to be able to install from the same utility as you build with (e.g make install). For this <em>qmake</em> has introduce the concept of an install set. The notation for this is quite simple, first you fill in an "object" in qmake for example:</p>
<p>It is common on UNIX to be able to install from the same utility as you build with (e.g make install). For this <em>tqmake</em> has introduce the concept of an install set. The notation for this is quite simple, first you fill in an "object" in tqmake for example:</p>
<pre>
documentation.path = /usr/local/program/doc
documentation.files = docs/*
</pre>
<p>In this way you are telling <em>qmake</em> several things about this install, first that you plan to install to /usr/local/program/doc (the path member), second that you plan to copy everything in the docs directory. Once this is done you may insert it in the install list:</p>
<p>In this way you are telling <em>tqmake</em> several things about this install, first that you plan to install to /usr/local/program/doc (the path member), second that you plan to copy everything in the docs directory. Once this is done you may insert it in the install list:</p>
<pre>
INSTALLS += documentation
</pre>
<p>Now <em>qmake</em> will take over making sure the correct things are copied to the specified places. If however you require greater control you may use the 'extra' member of the object:</p>
<p>Now <em>tqmake</em> will take over making sure the correct things are copied to the specified places. If however you require greater control you may use the 'extra' member of the object:</p>
<pre>
unix:documentation.extra = create_docs; mv master.doc toc.doc
</pre>
<p>Then qmake will run the things in extra (this is of course platform specific, so you may need to test for your platform first, this case we test for unix). Then it will do the normal processings of the files member. Finally if you appened a builtin install to INSTALLS <em>qmake</em> (and do not specify a files or extra member) will decide what needs to be copied for you, currently the only supported builtin is target:</p>
<p>Then tqmake will run the things in extra (this is of course platform specific, so you may need to test for your platform first, this case we test for unix). Then it will do the normal processings of the files member. Finally if you appened a builtin install to INSTALLS <em>tqmake</em> (and do not specify a files or extra member) will decide what needs to be copied for you, currently the only supported builtin is target:</p>
<pre>
target.path = /usr/local/myprogram
INSTALLS += target
</pre>
<p>With this <em>qmake</em> will know what you plan need copied, and do this for you.</p>
<p>With this <em>tqmake</em> will know what you plan need copied, and do this for you.</p>
<a name="cache"></a><h4><a name="7-3"></a>Cache File</h4>
<p>The cache file (mentioned above in the options) is a special file <em>qmake</em> will read to find settings not specified in the <tt>qmake.conf</tt> file, the .pro file, or the command line. If <tt>-nocache</tt> is not specified, <em>qmake</em> will try to find a file called <tt>.qmake.cache</tt> in parent directories. If it fails to find this file, it will silently ignore this step of processing.</p>
<p>The cache file (mentioned above in the options) is a special file <em>tqmake</em> will read to find settings not specified in the <tt>tqmake.conf</tt> file, the .pro file, or the command line. If <tt>-nocache</tt> is not specified, <em>tqmake</em> will try to find a file called <tt>.tqmake.cache</tt> in parent directories. If it fails to find this file, it will silently ignore this step of processing.</p>
<a name="LibDepend"></a><h4><a name="7-4"></a>Library Dependencies</h4>
<p>Often when linking against a library <em>qmake</em> relies on the underlying platform to know what other libraries this library links against, and lets the platform pull them in. In many cases, however, this is not sufficent. For example when statically linking a library there are no libraries linked against, and therefore no dependencies to those libraries are created - however an application that later links against this library will need to know where to find the symbols that the linked in library will require. To help with this situation <em>qmake</em> will follow a library's dependencies when it feels appropriate, however this behaviour must be enabled in <em>qmake</em>. To enable requires two steps. First, you must enable it in the library - to do this you must tell <em>qmake</em> to save information about this library:</p>
<p>Often when linking against a library <em>tqmake</em> relies on the underlying platform to know what other libraries this library links against, and lets the platform pull them in. In many cases, however, this is not sufficent. For example when statically linking a library there are no libraries linked against, and therefore no dependencies to those libraries are created - however an application that later links against this library will need to know where to find the symbols that the linked in library will require. To help with this situation <em>tqmake</em> will follow a library's dependencies when it feels appropriate, however this behaviour must be enabled in <em>tqmake</em>. To enable requires two steps. First, you must enable it in the library - to do this you must tell <em>tqmake</em> to save information about this library:</p>
<pre>
CONFIG += create_prl
</pre>
<p>This is only relevant to the lib template, and will be ignored for all others. When this option is enabled <em>qmake</em> will create a file (called a .prl file) which will save some meta information about the library. This metafile is itself just a qmake project file, but with all internal variables. You are free to view this file, and if deleted <em>qmake</em> will know to recreate it when necesary (either when the .pro file is later read, or if a dependent library (described below) has changed). When installing this library (by using target in INSTALLS, above) <em>qmake</em> will automatically copy the .prl file to your install path.</p>
<p>This is only relevant to the lib template, and will be ignored for all others. When this option is enabled <em>tqmake</em> will create a file (called a .prl file) which will save some meta information about the library. This metafile is itself just a tqmake project file, but with all internal variables. You are free to view this file, and if deleted <em>tqmake</em> will know to recreate it when necesary (either when the .pro file is later read, or if a dependent library (described below) has changed). When installing this library (by using target in INSTALLS, above) <em>tqmake</em> will automatically copy the .prl file to your install path.</p>
<p>The second step to enabling this processing is to turn on reading of the meta information created above:</p>
<pre>
CONFIG += link_prl
</pre>
<p>When this is turned on <em>qmake</em> will process all libraries linked to, and find their meta information. With this meta information <em>qmake</em> will figure out what is relevant to linking, specifically it will add to your list of DEFINES as well as LIBS. Once <em>qmake</em> has processed this file, it will then look through the newly introduced LIBS and find their dependent .prl files, and continue until all libraries have been resolved. At this point the makefile is created as usual, and the libraries are linked explicity against your program.</p>
<p>The internals of the .prl file are left closed so they can easily change later. It is not designed to be changed by hand however, and should only be created by <em>qmake</em> - these .prl files should also not be transfered from operating system to operating system as they may be platform dependent (like a makefile).</p>
<p>When this is turned on <em>tqmake</em> will process all libraries linked to, and find their meta information. With this meta information <em>tqmake</em> will figure out what is relevant to linking, specifically it will add to your list of DEFINES as well as LIBS. Once <em>tqmake</em> has processed this file, it will then look through the newly introduced LIBS and find their dependent .prl files, and continue until all libraries have been resolved. At this point the makefile is created as usual, and the libraries are linked explicity against your program.</p>
<p>The internals of the .prl file are left closed so they can easily change later. It is not designed to be changed by hand however, and should only be created by <em>tqmake</em> - these .prl files should also not be transfered from operating system to operating system as they may be platform dependent (like a makefile).</p>
<a name="Extensions"></a><h4><a name="7-5"></a>File Extensions</h4>
<p>Under normal circumstances <em>qmake</em> will try to use appropriate file extensions for your platform. There may be times, however, that you would like to override the behavior of these extensions. To do this, you must modify builtin variables in your .pro file, which will in turn changes <em>qmake</em>'s interpretation of these files. You may do this as:</p>
<p>Under normal circumstances <em>tqmake</em> will try to use appropriate file extensions for your platform. There may be times, however, that you would like to override the behavior of these extensions. To do this, you must modify builtin variables in your .pro file, which will in turn changes <em>tqmake</em>'s interpretation of these files. You may do this as:</p>
<pre>
QMAKE_EXT_MOC = .mymoc
</pre>
<p>The variables are as follows:</p>
<ul><li><p>QMAKE_EXT_MOC - This modifies the extension placed on included moc files.</p>
<li><p>QMAKE_EXT_UI - This modifies the extension used for designer UI files (usually in FORMS).</p>
<li><p>QMAKE_EXT_PRL - This modifies the extension placed on <a href="qmake-manual-8.html#LibDepend">library dependency files</a>.</p>
<li><p>QMAKE_EXT_PRL - This modifies the extension placed on <a href="tqmake-manual-8.html#LibDepend">library dependency files</a>.</p>
<li><p>QMAKE_EXT_LEX - This changes the suffix used in files (usually in LEXSOURCES).</p>
<li><p>QMAKE_EXT_YACC - This changes the suffix used in files (usually in YACCSOURCES).</p>
<li><p>QMAKE_EXT_OBJ - This changes the suffix used on generated object files.</p>
@ -693,8 +693,8 @@ QMAKE_VERS = $$[QMAKE_VERSION]
<ul><li><p>QMAKE_EXT_CPP - Changes interpretation all files with these suffixes to be C++ source files.</p>
<li><p>QMAKE_EXT_H - Changes interpretation all files with these suffixes to be C header files.</p>
</ul><a name="Customizing"></a><h4><a name="7-6"></a>Customizing Makefile Output</h4>
<p>qmake often tries to be all things to all build tools, this is often less than ideal when you really need to run special platform dependent commands. This can be achieved with specific instructions to the different qmake backends (currently this is only supported by the UNIX <a href="qmake-manual-8.html#MAKEFILE_GENERATOR">generator</a>).</p>
<p>The interfaces to customizing the Makefile are done through "objects" as in other places in qmake. The notation for this is quite simple, first you fill in an "object" in qmake for example:</p>
<p>tqmake often tries to be all things to all build tools, this is often less than ideal when you really need to run special platform dependent commands. This can be achieved with specific instructions to the different tqmake backends (currently this is only supported by the UNIX <a href="tqmake-manual-8.html#MAKEFILE_GENERATOR">generator</a>).</p>
<p>The interfaces to customizing the Makefile are done through "objects" as in other places in tqmake. The notation for this is quite simple, first you fill in an "object" in tqmake for example:</p>
<pre>
mytarget.target = .buildfile
mytarget.commands = touch $$mytarget.target
@ -702,12 +702,12 @@ QMAKE_VERS = $$[QMAKE_VERSION]
mytarget2.commands = @echo Building $$mytarget.target
</pre>
<p>The information above defines a qmake target called mytarget which contains a Makefile target called .buildfile, .buildfile is generated by 'touch .buildfile', and finally that this Makefile target depends on the qmake target mytarget2. Additionally we've defined the qmake target mytarget2 which simply echo's something to stdout.</p>
<p>The final step to making use of the above is to instruct qmake that this is actually an object used by the target building parts of qmake by:</p>
<p>The information above defines a tqmake target called mytarget which contains a Makefile target called .buildfile, .buildfile is generated by 'touch .buildfile', and finally that this Makefile target depends on the tqmake target mytarget2. Additionally we've defined the tqmake target mytarget2 which simply echo's something to stdout.</p>
<p>The final step to making use of the above is to instruct tqmake that this is actually an object used by the target building parts of tqmake by:</p>
<pre>
QMAKE_EXTRA_UNIX_TARGETS += mytarget mytarget2
</pre>
<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>This is all you need to do to actually build custom targets in tqmake, of course you may want to tie one of these targets to actually building the <a href="tqmake-manual-8.html#TARGET">tqmake build target</a>. To do this, you simply need to include your Makefile target in the list of <a href="tqmake-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 = tqmoc_${QMAKE_FILE_BASE}.cpp
@ -716,7 +716,7 @@ new_moc.depends = g++ -E -M ${QMAKE_FILE_NAME} | sed "s,^.*: ,,"
new_moc.input = NEW_HEADERS
QMAKE_EXTRA_UNIX_COMPILERS += new_moc
</pre>
<p>With this you can create a new moc for qmake, the commands will be executed over all arguments given to a NEW_HEADERS variable (from the input variable), and write to output (and automatically hand this filename to the compiler to be linked into your target). Additionally qmake will execute depends to generate dependency information and place this in the project as well.</p>
<p>With this you can create a new moc for tqmake, the commands will be executed over all arguments given to a NEW_HEADERS variable (from the input variable), and write to output (and automatically hand this filename to the compiler to be linked into your target). Additionally tqmake will execute depends to generate dependency information and place this in the project as well.</p>
<p>These commands can easily be placed into a cache file, and subsequent .pro files can give several arguments to NEW_HEADERS.</p>
<!-- eof -->
<p><address><hr><div align=center>

@ -3,7 +3,7 @@
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>qmake User Guide</title>
<title>tqmake User Guide</title>
<style type="text/css"><!--
fn { margin-left: 1cm; text-indent: -1cm; }
a:link { color: #004faf; text-decoration: none }
@ -29,16 +29,16 @@ body { background: #ffffff; color: black; }
| <a href="functions.html">
<font color="#004faf">Functions</font></a>
</td>
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><h1 align=center>qmake User Guide</h1>
<td align="right" valign="center"><img src="logo32.png" align="right" width="64" height="32" border="0"></td></tr></table><h1 align=center>tqmake User Guide</h1>
<h2><a href="qmake-manual-1.html">Introduction to qmake</a></h2>
<h2><a href="qmake-manual-2.html">Installing qmake</a></h2>
<h2><a href="qmake-manual-3.html">The 10 minute guide to using qmake</a></h2>
<h2><a href="qmake-manual-4.html">qmake Tutorial</a></h2>
<h2><a href="qmake-manual-5.html">qmake Concepts</a></h2>
<h2><a href="qmake-manual-6.html">qmake's Advanced Concepts</a></h2>
<h2><a href="qmake-manual-7.html">Using Precompiled Headers</a></h2>
<h2><a href="qmake-manual-8.html"> qmake Command Reference</a></h2>
<h2><a href="tqmake-manual-1.html">Introduction to tqmake</a></h2>
<h2><a href="tqmake-manual-2.html">Installing tqmake</a></h2>
<h2><a href="tqmake-manual-3.html">The 10 minute guide to using tqmake</a></h2>
<h2><a href="tqmake-manual-4.html">tqmake Tutorial</a></h2>
<h2><a href="tqmake-manual-5.html">tqmake Concepts</a></h2>
<h2><a href="tqmake-manual-6.html">tqmake's Advanced Concepts</a></h2>
<h2><a href="tqmake-manual-7.html">Using Precompiled Headers</a></h2>
<h2><a href="tqmake-manual-8.html"> tqmake Command Reference</a></h2>
<!-- eof -->
<p><address><hr><div align=center>
<table width=100% cellspacing=0 border=0><tr>

@ -0,0 +1,11 @@
<!DOCTYPE DCF>
<DCF ref="tqmake-manual.html" imagedir="../../gif" title="tqmake User Guide">
<section ref="tqmake-manual-1.html" title="Introduction to tqmake"/>
<section ref="tqmake-manual-2.html" title="Installing tqmake"/>
<section ref="tqmake-manual-3.html" title="The 10 minute guide to using tqmake"/>
<section ref="tqmake-manual-4.html" title="tqmake Tutorial"/>
<section ref="tqmake-manual-5.html" title="tqmake Concepts"/>
<section ref="tqmake-manual-6.html" title="tqmake's Advanced Concepts"/>
<section ref="tqmake-manual-7.html" title="Using Precompiled Headers"/>
<section ref="tqmake-manual-8.html" title=" tqmake Command Reference"/>
</DCF>

@ -44,7 +44,7 @@ the dynamic property system.
<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
<p> If you use <a href="tqmake-manual.html">tqmake</a> to create your
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
@ -151,7 +151,7 @@ visible in the header file.
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
<p> We recommend using Trolltech's free makefile generation tool, <a href="tqmake-manual.html">tqmake</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 tqmoc handling.
<p> If you want to create your Makefiles yourself, here are some tips on

@ -132,14 +132,14 @@ these on to the appropriate widgets.
<h2> Compiling
</h2>
<a name="2"></a><p> To compile a C++ application you need to create a makefile. The
easiest way to create a makefile for TQt is to use the <a href="qmake-manual.html">qmake</a> build tool supplied with TQt. If you've
easiest way to create a makefile for TQt is to use the <a href="tqmake-manual.html">tqmake</a> build tool supplied with TQt. If you've
saved <tt>main.cpp</tt> in its own directory, all you have to do is:
<pre>
qmake -project
qmake
tqmake -project
tqmake
</pre>
<p> The first command tells <a href="qmake-manual.html">qmake</a> to
<p> The first command tells <a href="tqmake-manual.html">tqmake</a> to
create a <tt>.pro</tt> (project) file. The second command tells it to create
a (platform-specific) makefile based on the project file. You should
now be able to type <tt>make</tt> (or <tt>nmake</tt> if you're using Visual

@ -176,11 +176,11 @@ are here creating a "chain" of signals and slots.
creating one for a single-file application. If you've saved all the
files in this example in their own directory, all you have to do is:
<pre>
qmake -project
qmake
tqmake -project
tqmake
</pre>
<p> The first command tells <a href="qmake-manual.html">qmake</a> to
<p> The first command tells <a href="tqmake-manual.html">tqmake</a> to
create a <tt>.pro</tt> (project) file. The second command tells it to create
a (platform-specific) makefile based on the project file. You should
now be able to type <tt>make</tt> (or <tt>nmake</tt> if you're using Visual

@ -58,10 +58,10 @@ body { background: #ffffff; color: black; }
</pre>
<p> By using a project file we can insulate ourselves from having to
create Makefiles for the platforms we wish to target. To generate a
Makefile all we need do is run <a href="qmake-manual.html">qmake</a>,
Makefile all we need do is run <a href="tqmake-manual.html">tqmake</a>,
e.g.
<pre>
qmake -o Makefile chart.pro
tqmake -o Makefile chart.pro
</pre>
<p> <p align="right">

@ -363,9 +363,9 @@ When you run \e lupdate or \e lrelease, you must give the name of the
project file as a command-line argument.
In this example, four exotic languages are supported: Danish, Finnish,
Norwegian and Swedish. If you use \link qmake-manual.book
qmake\endlink, you usually don't need an extra project
file for \e lupdate; your \c qmake project file will work fine once
Norwegian and Swedish. If you use \link tqmake-manual.book
tqmake\endlink, you usually don't need an extra project
file for \e lupdate; your \c tqmake project file will work fine once
you add the \c TRANSLATIONS entry.
In your application, you must \l TQTranslator::load() the translation

@ -160,7 +160,7 @@ Licenses &amp; Credits
\i \link designer-manual.book TQt Designer\endlink
\i \link linguist-manual.book TQt Linguist\endlink
\i \link assistant.book TQt Assistant\endlink
\i \link qmake-manual.book qmake\endlink
\i \link tqmake-manual.book tqmake\endlink
\endlist
</td>
<td valign="top">

@ -127,21 +127,21 @@
\section2 Using the 'Open TQt Project' button
The 'Open TQt Project' button allows you to convert an existing \c
qmake project file into a \c .dsp file which you can insert into
tqmake project file into a \c .dsp file which you can insert into
your existing workspace. When you click the 'Open TQt Project'
button, just select an existing \c qmake project file (a \c .pro
button, just select an existing \c tqmake project file (a \c .pro
file) and then click OK. You will get a message box at the end
which asks you to insert the newly created \c .dsp file into your
existing workspace.
\section2 Using the 'Write TQt Project' button
The 'Write TQt Project' button creates a \c qmake project (\c .pro)
The 'Write TQt Project' button creates a \c tqmake project (\c .pro)
file for your current project so that you can easily copy the files
onto another platform and be able to use \c qmake to create a Makefile
onto another platform and be able to use \c tqmake to create a Makefile
on that other platform. All you need to do is make the project you
want to create a \c .pro file for, and click on the button. Just
name your \c qmake project file and click Save.
name your \c tqmake project file and click Save.
\section2 Using the 'Use TQt In Current Project' button

@ -81,7 +81,7 @@ directory called Frameworks, a subdirectory of the application bundle.
The application finds these dynamic libraries if the libraries have an
install name of "@executable_path/../Frameworks/libname.dylib.
If you use qmake and Makefiles, use the QMAKE_LFFLAGS_SONAME setting:
If you use tqmake and Makefiles, use the QMAKE_LFFLAGS_SONAME setting:
\code
QMAKE_LFLAGS_SONAME = -Wl,-install_name,@executable_path/../Frameworks/
@ -124,7 +124,7 @@ have not been called yet).
\section2 Plugin Support
Note that it is not possible to build TQt plugins using Project Builder
or Xcode. Use \link qmake-manual.book qmake\endlink to configure and
or Xcode. Use \link tqmake-manual.book tqmake\endlink to configure and
build plugins.
\section1 Compiler Settings

@ -17,8 +17,8 @@ Change the commands to suit your needs.
TODO
----
* installation with qmake.
* optional man pages compression with qmake
* installation with tqmake.
* optional man pages compression with tqmake
-------
ORIGINS

@ -69,7 +69,7 @@ One TQAssistantClient instance interacts with one TQt Assistant instance, so eve
.PP
When you call openAssistant() the assistantOpened() signal is emitted. Similarly when closeAssistant() is called, assistantClosed() is emitted. In either case, if an error occurs, error() is emitted.
.PP
This class is not included in the TQt library itself. To use it you must link against \fClibtqassistantclient.a\fR (Unix) or \fCtqassistantclient.lib\fR (Windows), which is built into \fCINSTALL/lib\fR if you built the TQt tools (\fCINSTALL\fR is the directory where TQt is installed). If you use qmake, then you can simply add the following line to your pro file:
This class is not included in the TQt library itself. To use it you must link against \fClibtqassistantclient.a\fR (Unix) or \fCtqassistantclient.lib\fR (Windows), which is built into \fCINSTALL/lib\fR if you built the TQt tools (\fCINSTALL\fR is the directory where TQt is installed). If you use tqmake, then you can simply add the following line to your pro file:
.PP
.nf
.br

@ -91,7 +91,7 @@ the relevant release of Qt.
<dd>Programmers need to run \e tqmoc and other tools such as \e tquic. These
tools are usually located in the \c bin subdirectory of TQt distributions.
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
to your \c PATH and run \c tqmoc and \c tquic. If you use \c tqmake the
appropriate lines will be added to your Makefiles so that \e tquic and
\e tqmoc will be executed as required.

@ -83,7 +83,7 @@ don't need to set certain preprocessor defines. In TQt 3.0, the
default configuration of the TQt library is to build it as a shared
library, therefore the preprocessor define \c QT_DLL is needed.
If you use tmake with TQt 2.x, and now use qmake with TQt 3.x, then the
If you use tmake with TQt 2.x, and now use tqmake with TQt 3.x, then the
cause of the problem is with the project file. In the project file,
there is usually line that looks like:
@ -93,7 +93,7 @@ this should be changed to
\c CONFIG += ...
so that qmake can look at the configuration that TQt was built with and
so that tqmake can look at the configuration that TQt was built with and
set any relevant preprocessor defines in the makefile.
\target Headers

@ -141,15 +141,15 @@ it can interact with specific components of the Mac OS X experience:
between their development toolkit and the platform's developer
tools (for example MSVC, gmake, etc). Qt/Mac supports both Unix
style Makefiles, and ProjectBuilder/Xcode project files by using
the qmake tool. For example:
the tqmake tool. For example:
\code
qmake -spec macx-pbuilder project.pro
tqmake -spec macx-pbuilder project.pro
\endcode
will generate an Xcode project file from project.pro. With qmake
will generate an Xcode project file from project.pro. With tqmake
you do not have to worry about rules for TQt's preprocessors (tqmoc
and tquic) since qmake automatically handles them and ensures that
and tquic) since tqmake automatically handles them and ensures that
everything necessary is linked into your application.
TQt does not entirely interact with the development environment (for

@ -205,7 +205,7 @@ The preprocessor changes or removes the \c{signals}, \c{slots} and
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
\link tqmake-manual.book tqmake\endlink, the makefile rules to
automatically invoke the \link tqmoc.html tqmoc\endlink will be added to
your makefile for you.

@ -154,13 +154,13 @@ You need the MySQL header files and as well as the shared library
\c{libmysqlclient.so}. Depending on your Linux distribution you need to
install a package which is usually called "mysql-devel".
Tell \link qmake-manual.book qmake\endlink where to find the MySQL
Tell \link tqmake-manual.book tqmake\endlink where to find the MySQL
header files and shared libraries (here it is assumed that MySQL is
installed in \c{/usr/local}) and run \c{make}:
\code
cd $TQTDIR/plugins/src/sqldrivers/mysql
qmake -o Makefile "INCLUDEPATH+=/usr/local/include" "LIBS+=-L/usr/local/lib -lmysqlclient" mysql.pro
tqmake -o Makefile "INCLUDEPATH+=/usr/local/include" "LIBS+=-L/usr/local/lib -lmysqlclient" mysql.pro
make
\endcode
@ -173,7 +173,7 @@ installed in \c{C:\MYSQL}):
\code
cd %TQTDIR%\plugins\src\sqldrivers\mysql
qmake -o Makefile "INCLUDEPATH+=C:\MYSQL\INCLUDE" "LIBS+=C:\MYSQL\LIB\OPT\LIBMYSQL.LIB" mysql.pro
tqmake -o Makefile "INCLUDEPATH+=C:\MYSQL\INCLUDE" "LIBS+=C:\MYSQL\LIB\OPT\LIBMYSQL.LIB" mysql.pro
nmake
\endcode
@ -227,28 +227,28 @@ Oracle library files required to build driver:
\i \c libwtc8.so (only Oracle 8) or \c libwtc9.so (only Oracle 9)
\endlist
Tell \c qmake where to find the Oracle header files and shared
Tell \c tqmake where to find the Oracle header files and shared
libraries (it is assumed that the variable \c $ORACLE_HOME points to
the directory where Oracle is installed) and run make:
If you are using Oracle 8:
\code
cd $TQTDIR/plugins/src/sqldrivers/oci
qmake -o Makefile "INCLUDEPATH+=$ORACLE_HOME/rdbms/public $ORACLE_HOME/rdbms/demo" "LIBS+=-L$ORACLE_HOME/lib -lclntsh -lwtc8" oci.pro
tqmake -o Makefile "INCLUDEPATH+=$ORACLE_HOME/rdbms/public $ORACLE_HOME/rdbms/demo" "LIBS+=-L$ORACLE_HOME/lib -lclntsh -lwtc8" oci.pro
make
\endcode
For Oracle version 9:
\code
cd $TQTDIR/plugins/src/sqldrivers/oci
qmake -o Makefile "INCLUDEPATH+=$ORACLE_HOME/rdbms/public $ORACLE_HOME/rdbms/demo" "LIBS+=-L$ORACLE_HOME/lib -lclntsh -lwtc9" oci.pro
tqmake -o Makefile "INCLUDEPATH+=$ORACLE_HOME/rdbms/public $ORACLE_HOME/rdbms/demo" "LIBS+=-L$ORACLE_HOME/lib -lclntsh -lwtc9" oci.pro
make
\endcode
For Oracle version 10:
\code
cd $TQTDIR/plugins/src/sqldrivers/oci
qmake -o Makefile "INCLUDEPATH+=$ORACLE_HOME/rdbms/public $ORACLE_HOME/rdbms/demo" "LIBS+=-L$ORACLE_HOME/lib -lclntsh" oci.pro
tqmake -o Makefile "INCLUDEPATH+=$ORACLE_HOME/rdbms/public $ORACLE_HOME/rdbms/demo" "LIBS+=-L$ORACLE_HOME/lib -lclntsh" oci.pro
make
\endcode
@ -272,7 +272,7 @@ installed in \c{C:\oracle}):
set INCLUDE=%INCLUDE%;c:\oracle\oci\include
set LIB=%LIB%;c:\oracle\oci\lib\msvc
cd %TQTDIR%\plugins\src\sqldrivers\oci
qmake -o Makefile oci.pro
tqmake -o Makefile oci.pro
nmake
\endcode
@ -338,13 +338,13 @@ It is recommended that you use unixODBC. You can find the latest
version and ODBC drivers at \l http://www.unixodbc.org.
You need the unixODBC header files and shared libraries.
Tell \c qmake where to find the unixODBC header files and shared
Tell \c tqmake where to find the unixODBC header files and shared
libraries (here it is assumed that unixODBC is installed in
\c{/usr/local/unixODBC}) and run \c{make}:
\code
cd $TQTDIR/plugins/src/sqldrivers/odbc
qmake "INCLUDEPATH+=/usr/local/unixODBC/include" "LIBS+=-L/usr/local/unixODBC/lib -lodbc"
tqmake "INCLUDEPATH+=/usr/local/unixODBC/include" "LIBS+=-L/usr/local/unixODBC/lib -lodbc"
make
\endcode
@ -355,7 +355,7 @@ right directories. You just have to build the plugin as follows:
\code
cd %TQTDIR%\plugins\src\sqldrivers\odbc
qmake -o Makefile odbc.pro
tqmake -o Makefile odbc.pro
nmake
\endcode
@ -415,13 +415,13 @@ a binary distribution you don't need to build it. The source
distribution is needed because the QPSQL7 plugin relies on a couple of
header files that are usually not a part of the binary distribution.
To make \c qmake find the PostgreSQL header files and shared
libraries, run \c qmake the following way (assuming that the
To make \c tqmake find the PostgreSQL header files and shared
libraries, run \c tqmake the following way (assuming that the
PostgreSQL sources can be found in \c{/usr/src/psql}):
\code
cd $TQTDIR/plugins/src/sqldrivers/psql
qmake -o Makefile "INCLUDEPATH+=/usr/src/psql/src/include /usr/src/psql/src/interfaces/libpq" "LIBS+=-L/usr/lib -lpq" psql.pro
tqmake -o Makefile "INCLUDEPATH+=/usr/src/psql/src/include /usr/src/psql/src/interfaces/libpq" "LIBS+=-L/usr/lib -lpq" psql.pro
make
\endcode
@ -433,7 +433,7 @@ in \c{C:\psql}, build the plugin as follows:
\code
cd %TQTDIR%\plugins\src\sqldrivers\psql
qmake -o Makefile "INCLUDEPATH+=C:\psql\src\include C:\psql\src\interfaces\libpq" psql.pro
tqmake -o Makefile "INCLUDEPATH+=C:\psql\src\include C:\psql\src\interfaces\libpq" psql.pro
nmake
\endcode
@ -463,11 +463,11 @@ Under Unix, two libraries are available which support the TDS protocol:
Regardless of which library you use, the shared object file
\c{libsybdb.so} is needed. Set the SYBASE environment variable to
point to the directory where you installed the client library and
execute \c{qmake}:
execute \c{tqmake}:
\code
cd $TQTDIR/plugins/src/sqldrivers/tds
qmake -o Makefile "INCLUDEPATH=$SYBASE/include" "LIBS=-L$SYBASE/lib -lsybdb"
tqmake -o Makefile "INCLUDEPATH=$SYBASE/include" "LIBS=-L$SYBASE/lib -lsybdb"
make
\endcode
@ -479,7 +479,7 @@ NTWDBLIB.LIB to build the plugin:
\code
cd %TQTDIR%\plugins\src\sqldrivers\tds
qmake -o Makefile "LIBS+=NTWDBLIB.LIB" tds.pro
tqmake -o Makefile "LIBS+=NTWDBLIB.LIB" tds.pro
nmake
\endcode
@ -509,7 +509,7 @@ in DB2 (see TQSqlQuery::setForwardOnly()).
\code
cd $TQTDIR/plugins/src/sqldrivers/db2
qmake -o Makefile "INCLUDEPATH+=$DB2DIR/include" "LIBS+=-L$DB2DIR/lib -ldb2"
tqmake -o Makefile "INCLUDEPATH+=$DB2DIR/include" "LIBS+=-L$DB2DIR/lib -ldb2"
make
\endcode
@ -520,7 +520,7 @@ right directories. You just have to build the plugin as follows:
\code
cd %TQTDIR%\plugins\src\sqldrivers\db2
qmake -o Makefile "INCLUDEPATH+=<DB2 home>/sqllib/include" "LIBS+=<DB2 home>/sqllib/lib/db2cli.lib"
tqmake -o Makefile "INCLUDEPATH+=<DB2 home>/sqllib/include" "LIBS+=<DB2 home>/sqllib/lib/db2cli.lib"
nmake
\endcode
@ -560,7 +560,7 @@ resides):
\code
cd $TQTDIR/plugins/src/sqldrivers/sqlite
qmake -o Makefile "INCLUDEPATH+=$SQLITE/include" "LIBS+=-L$SQLITE/lib -lsqlite"
tqmake -o Makefile "INCLUDEPATH+=$SQLITE/include" "LIBS+=-L$SQLITE/lib -lsqlite"
make
\endcode
@ -599,7 +599,7 @@ The following assumes Interbase or Firebird is installed in
\code
cd $TQTDIR/plugins/src/sqldrivers/ibase
qmake -o Makefile "INCLUDEPATH+=/opt/interbase/include" "LIBS+=-L/opt/interbase/lib" ibase.pro
tqmake -o Makefile "INCLUDEPATH+=/opt/interbase/include" "LIBS+=-L/opt/interbase/lib" ibase.pro
make
\endcode
@ -610,7 +610,7 @@ The following assumes Interbase or Firebird is installed in
\code
cd %TQTDIR%\plugins\src\sqldrivers\ibase
qmake -o Makefile "INCLUDEPATH+=C:\interbase\include" ibase.pro
tqmake -o Makefile "INCLUDEPATH+=C:\interbase\include" ibase.pro
nmake
\endcode

@ -13,7 +13,7 @@
applications to reach international markets
\i \link assistant.book TQt Assistant \endlink - quickly find the
help you need
\i \link qmake-manual.book qmake \endlink - create Makefiles from
\i \link tqmake-manual.book tqmake \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 tqmoc.html tqmoc\endlink - the Meta Object Compiler

@ -60,7 +60,7 @@ 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
If you use \link tqmake-manual.book tqmake\endlink to create your
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
@ -183,7 +183,7 @@ 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
tqmake-manual.book tqmake\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 tqmoc handling.

@ -185,14 +185,14 @@ You should now try to compile and run this program.
To compile a C++ application you need to create a makefile. The
easiest way to create a makefile for TQt is to use the \link
qmake-manual.book qmake\endlink build tool supplied with Qt. If you've
tqmake-manual.book tqmake\endlink build tool supplied with Qt. If you've
saved \c main.cpp in its own directory, all you have to do is:
\code
qmake -project
qmake
tqmake -project
tqmake
\endcode
The first command tells \link qmake-manual.book qmake\endlink to
The first command tells \link tqmake-manual.book tqmake\endlink to
create a \c .pro (project) file. The second command tells it to create
a (platform-specific) makefile based on the project file. You should
now be able to type \c make (or \c nmake if you're using Visual
@ -829,11 +829,11 @@ Creating a makefile for a multi-file application is no different from
creating one for a single-file application. If you've saved all the
files in this example in their own directory, all you have to do is:
\code
qmake -project
qmake
tqmake -project
tqmake
\endcode
The first command tells \link qmake-manual.book qmake\endlink to
The first command tells \link tqmake-manual.book tqmake\endlink to
create a \c .pro (project) file. The second command tells it to create
a (platform-specific) makefile based on the project file. You should
now be able to type \c make (or \c nmake if you're using Visual

@ -1380,10 +1380,10 @@ chooseFont().
By using a project file we can insulate ourselves from having to
create Makefiles for the platforms we wish to target. To generate a
Makefile all we need do is run \link qmake-manual.book qmake\endlink,
Makefile all we need do is run \link tqmake-manual.book tqmake\endlink,
e.g.
\code
qmake -o Makefile chart.pro
tqmake -o Makefile chart.pro
\endcode
<p align="right">

@ -216,6 +216,6 @@
the application main window.
To build the example go to the helpsystem directory
(TQTDIR/examples/helpsystem) run qmake to generate the makefile,
(TQTDIR/examples/helpsystem) run tqmake to generate the makefile,
and use the make tool to build the library.
*/

@ -1,5 +1,5 @@
##############################################################
# Automatically generated by qmake Thu Jul 26 13:46:03 2001
# Automatically generated by tqmake Thu Jul 26 13:46:03 2001
##############################################################
TEMPLATE = app
TARGET = tablet

@ -127,6 +127,6 @@
\footnote
We use \c TQTDIR to stand for the directory where TQt is installed.
\endfootnote
and run \c qmake to generate the makefile, then use the make tool to
and run \c tqmake to generate the makefile, then use the make tool to
build the library.
*/

@ -1,6 +1,6 @@
#
#
# qmake configuration for aix-g++-64
# tqmake configuration for aix-g++-64
#
MAKEFILE_GENERATOR = UNIX

@ -1,6 +1,6 @@
#
#
# qmake configuration for aix-g++
# tqmake configuration for aix-g++
#
MAKEFILE_GENERATOR = UNIX

@ -1,6 +1,6 @@
#
#
# qmake configuration for aix-xlc
# tqmake configuration for aix-xlc
#
MAKEFILE_GENERATOR = UNIX

@ -1,6 +1,6 @@
#
#
# qmake configuration for aix-xlc
# tqmake configuration for aix-xlc
#
MAKEFILE_GENERATOR = UNIX

@ -1,6 +1,6 @@
#
#
# qmake configuration for bsdi-g++
# tqmake configuration for bsdi-g++
#
# Written for WindRiver BSD/OS 4.0.
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for cygwin-g++
# tqmake configuration for cygwin-g++
#
# Written for TQt/X11 on Cygwin, using the POSIX API.
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for darwin-g++
# tqmake configuration for darwin-g++
#
# Written for TQt/X11 on Darwin and XFree86.
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for dgux-g++
# tqmake configuration for dgux-g++
#
# Written for DG/UX R4.20MU06.
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for dilos-g++
# tqmake configuration for dilos-g++
#
MAKEFILE_GENERATOR = UNIX

@ -1,6 +1,6 @@
#
#
# qmake configuration for freebsd-clang
# tqmake configuration for freebsd-clang
#
MAKEFILE_GENERATOR = UNIX

@ -1,6 +1,6 @@
#
#
# qmake configuration for freebsd-g++
# tqmake configuration for freebsd-g++
#
MAKEFILE_GENERATOR = UNIX

@ -1,6 +1,6 @@
#
#
# qmake configuration for freebsd-g++34 (using g++34 from ports/lang/gcc34)
# tqmake configuration for freebsd-g++34 (using g++34 from ports/lang/gcc34)
#
MAKEFILE_GENERATOR = UNIX

@ -1,6 +1,6 @@
#
#
# qmake configuration for freebsd-icc
# tqmake configuration for freebsd-icc
#
# Written for Intel C++ 7.1 and above.
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for hpux-n64
# tqmake configuration for hpux-n64
#
# We define _POSIX_C_SOURCE to 199506L when using threads, therefore
# we also need to redefine _HPUX_SOURCE.

@ -1,6 +1,6 @@
#
#
# qmake configuration for hpux-o64
# tqmake configuration for hpux-o64
#
# We define _POSIX_C_SOURCE to 199506L when using threads, therefore
# we also need to redefine _HPUX_SOURCE.

@ -1,6 +1,6 @@
#
#
# qmake configuration for hpux-acc
# tqmake configuration for hpux-acc
#
# We define _POSIX_C_SOURCE to 199506L when using threads, therefore
# we also need to redefine _HPUX_SOURCE. See pthread(3t) for more details.

@ -1,6 +1,6 @@
#
#
# qmake configuration for hpux-cc
# tqmake configuration for hpux-cc
#
# We define _POSIX_C_SOURCE to 199506L when using threads, therefore
# we also need to redefine _HPUX_SOURCE.

@ -1,6 +1,6 @@
#
#
# qmake configuration for hpux-g++-64
# tqmake configuration for hpux-g++-64
#
# We define _POSIX_C_SOURCE to 199506L when using threads,
# therefore we also need to redefine _HPUX_SOURCE.

@ -1,6 +1,6 @@
#
#
# qmake configuration for hpux-g++
# tqmake configuration for hpux-g++
#
# We define _POSIX_C_SOURCE to 199506L when using threads,
# therefore we also need to redefine _HPUX_SOURCE.

@ -1,6 +1,6 @@
#
#
# qmake configuration for hpuxi-acc-32
# tqmake configuration for hpuxi-acc-32
#
# We define _POSIX_C_SOURCE to 199506L when using threads, therefore
# we also need to redefine _HPUX_SOURCE.

@ -1,6 +1,6 @@
#
#
# qmake configuration for hpuxi-acc-64
# tqmake configuration for hpuxi-acc-64
#
# We define _POSIX_C_SOURCE to 199506L when using threads, therefore
# we also need to redefine _HPUX_SOURCE.

@ -1,6 +1,6 @@
#
#
# qmake configuration for hurd-g++
# tqmake configuration for hurd-g++
#
# Submitted by uch@nop.or.jp as "gnu-g++".
# Renamed to "hurd-g++" because people were confusing GNU/Hurd with GNU/Linux.

@ -1,6 +1,6 @@
#
#
# qmake configuration for irix-cc-64
# tqmake configuration for irix-cc-64
#
# From cc(1):
# -64

@ -1,6 +1,6 @@
#
#
# qmake configuration for irix-cc-o32
# tqmake configuration for irix-cc-o32
#
# From cc(1):
# -o32 or -32

@ -1,6 +1,6 @@
#
#
# qmake configuration for irix-cc
# tqmake configuration for irix-cc
#
# From cc(1):
# -n32

@ -1,6 +1,6 @@
#
#
# qmake configuration for irix-g++
# tqmake configuration for irix-g++
#
MAKEFILE_GENERATOR = UNIX

@ -1,6 +1,6 @@
#
#
# qmake configuration for linux-clang
# tqmake configuration for linux-clang
#
MAKEFILE_GENERATOR = UNIX

@ -1,6 +1,6 @@
#
#
# qmake configuration for linux-cxx
# tqmake configuration for linux-cxx
#
# Written for Compaq C++ for GNU/Linux on Alpha (discontinued).
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for linux-ecc-64
# tqmake configuration for linux-ecc-64
#
# Written for Intel C++ 7.1, and 8.0 for Linux.
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for linux-g++-32
# tqmake configuration for linux-g++-32
#
MAKEFILE_GENERATOR = UNIX

@ -1,6 +1,6 @@
#
#
# qmake configuration for linux-g++-64
# tqmake configuration for linux-g++-64
#
# mkspec for platforms that have both lib and lib64
# directories, like the AMD Opteron.

@ -1,6 +1,6 @@
#
#
# qmake configuration for linux-g++
# tqmake configuration for linux-g++
#
MAKEFILE_GENERATOR = UNIX

@ -1,6 +1,6 @@
#
#
# qmake configuration for linux-g++
# tqmake configuration for linux-g++
#
MAKEFILE_GENERATOR = UNIX

@ -1,6 +1,6 @@
#
#
# qmake configuration for linux-icc
# tqmake configuration for linux-icc
#
# Written for Intel C++ 5.0.1, 6.0.1, 7.0, and 8.0 for Linux.
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for linux-kcc
# tqmake configuration for linux-kcc
#
# Written for KAI C++ 4.0f for GNU/Linux (discontinued).
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for linux-kylix
# tqmake configuration for linux-kylix
#
MAKEFILE_GENERATOR = UNIX

@ -1,6 +1,6 @@
#
#
# qmake configuration for linux-pgcc
# tqmake configuration for linux-pgcc
#
# Written for Portland Group C++ for Intel.
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for lynxos-g++
# tqmake configuration for lynxos-g++
#
# Written for LynxOS 4.0.
#

@ -7,12 +7,12 @@
<key>CFBundlePackageType</key>
<string>APPL</string>
<key>CFBundleGetInfoString</key>
<string>Created by Qt/QMake</string>
<string>Created by TQt/TQMake</string>
<key>CFBundleSignature</key>
<string>ttxt</string>
<key>CFBundleExecutable</key>
<string>@EXECUTABLE@</string>
<key>NOTE</key>
<string>Please, do NOT change this file -- It was generated by Qt/QMake.</string>
<string>Please, do NOT change this file -- It was generated by TQt/TQMake.</string>
</dict>
</plist>

@ -1,6 +1,6 @@
#
#
# qmake configuration for macx-g++ (Mac OS X + command-line compiler)
# tqmake configuration for macx-g++ (Mac OS X + command-line compiler)
#
MAKEFILE_GENERATOR = UNIX

@ -1,6 +1,6 @@
#
#
# qmake configuration for macx-mwerks (Mac OS X + Metrowerks compiler)
# tqmake configuration for macx-mwerks (Mac OS X + Metrowerks compiler)
#
MAKEFILE_GENERATOR = METROWERKS

@ -7,12 +7,12 @@
<key>CFBundlePackageType</key>
<string>APPL</string>
<key>CFBundleGetInfoString</key>
<string>Created by Qt/QMake</string>
<string>Created by TQt/TQMake</string>
<key>CFBundleSignature</key>
<string>ttxt</string>
<key>CFBundleExecutable</key>
<string>@EXECUTABLE@</string>
<key>NOTE</key>
<string>Please, do NOT change this file -- It was generated by Qt/QMake.</string>
<string>Please, do NOT change this file -- It was generated by TQt/TQMake.</string>
</dict>
</plist>

@ -1,6 +1,6 @@
#
#
# qmake configuration for macx-pbuilder (Mac OS X + Project Builder)
# tqmake configuration for macx-pbuilder (Mac OS X + Project Builder)
#
MAKEFILE_GENERATOR = PROJECTBUILDER

@ -1,6 +1,6 @@
#
#
# qmake configuration for aix-xlc
# tqmake configuration for aix-xlc
#
MAKEFILE_GENERATOR = UNIX

@ -1,6 +1,6 @@
#
#
# qmake configuration for netbsd-g++
# tqmake configuration for netbsd-g++
#
MAKEFILE_GENERATOR = UNIX

@ -1,6 +1,6 @@
#
#
# qmake configuration for openbsd-g++
# tqmake configuration for openbsd-g++
#
MAKEFILE_GENERATOR = UNIX

@ -1,6 +1,6 @@
#
#
# qmake configuration for qnx-g++
# tqmake configuration for qnx-g++
#
# Written for TQNX RTOS v6 with X11.
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for reliant-cds-64
# tqmake configuration for reliant-cds-64
#
# Written for Reliant UNIX 5.45 using the CDS++ C/C++ compiler V2.0C.
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for reliant-cds
# tqmake configuration for reliant-cds
#
# Written for Reliant UNIX 5.45 using the CDS++ C/C++ compiler V2.0C.
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for sco-cc
# tqmake configuration for sco-cc
#
# Written for SCO OpenServer with UDK.
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for sco-g++
# tqmake configuration for sco-g++
#
MAKEFILE_GENERATOR = UNIX

@ -1,6 +1,6 @@
#
#
# qmake configuration for solaris-cc-64
# tqmake configuration for solaris-cc-64
#
# Written for Sun WorkShop 5.0, Forte Developer 6, and Sun ONE Studio 7.
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for solaris-cc
# tqmake configuration for solaris-cc
#
# Written for Sun WorkShop 5.0, Forte Developer 6, and Sun ONE Studio 7.
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for solaris-g++64
# tqmake configuration for solaris-g++64
#
# The X11 header files used to be broken on Solaris until patches were
# released in early 2001 for Solaris 2.6, 7, and 8. On Solaris 2.5.1

@ -1,6 +1,6 @@
#
#
# qmake configuration for solaris-g++
# tqmake configuration for solaris-g++
#
# The X11 header files used to be broken on Solaris until patches were
# released in early 2001 for Solaris 2.6, 7, and 8. On Solaris 2.5.1

@ -1,6 +1,6 @@
#
#
# qmake configuration for tru64-g++
# tqmake configuration for tru64-g++
#
MAKEFILE_GENERATOR = UNIX

@ -1,6 +1,6 @@
#
#
# qmake configuration for unixware-cc
# tqmake configuration for unixware-cc
#
# Written for UnixWare 7 or Open UNIX 8 with UDK or OUDK.
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for unixware-g++
# tqmake configuration for unixware-g++
#
# Written for UnixWare 7 or Open UNIX 8 with OSTK.
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for win32-g++
# tqmake configuration for win32-g++
#
# Written for MinGW
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for win32-icc
# tqmake configuration for win32-icc
#
# Written for Intel C++ 5.0.1, 6.0.1, and 7.0 for Windows.
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for win32-msvc.net
# tqmake configuration for win32-msvc.net
#
# Written for Microsoft C++.NET.
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for win32-msvc
# tqmake configuration for win32-msvc
#
# Written for Microsoft C++.
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for win32-msvc2005
# tqmake configuration for win32-msvc2005
#
# Written for Microsoft Visual C++ 8.0 (2005)
#

@ -1,6 +1,6 @@
#
#
# qmake configuration for win32-watcom
# tqmake configuration for win32-watcom
#
# Written for Watcom C++, now OpenWatcom.
#

@ -1,12 +0,0 @@
\title qmake User Guide
\granularity chapter
\input qmake-preface.leaf
\input qmake-install.leaf
\input qmake-quick.leaf
\input qmake-tutorial.leaf
\input qmake-concepts.leaf
\input qmake-advanced.leaf
\input qmake-pch.leaf
\input qmake-commandreference.leaf

@ -1,18 +0,0 @@
\chapter Introduction to qmake
\section1 Introduction to qmake
\e qmake is a tool created by Trolltech to write makefiles for
different compilers and platforms.
Writing makefiles by hand can be difficult and error prone, especially
if several makefiles are required for different compiler and platform
combinations. With \e qmake, developers create a simple single
'project' file and run \e qmake to generate the appropriate
makefiles. \e qmake takes care of all the compiler and platform
dependencies, freeing developers to focus on their code. Trolltech
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 tqmoc.html tqmoc\endlink and \e tquic.

@ -1,2 +0,0 @@
// This file does nothing, but check your makefile to see if there is a
// reference to hello_win.cpp...there shouldn't be if qmake is used on X11.

@ -1,2 +0,0 @@
// This file does nothing, but check your makefile to see if there is a
// reference to hello_x11.cpp...there shouldn't be if qmake is used on Windows.

@ -6,7 +6,7 @@ DESTDIR = $$QMAKE_LIBDIR_TQT
DLLDESTDIR = ../bin
CONFIG += qt warn_on depend_includepath
CONFIG += qmake_cache
CONFIG += tqmake_cache
win32:!shared:CONFIG += staticlib

@ -102,7 +102,7 @@ public:
TQValueVector<TQVariant::Type> fieldTypes;
};
TQSqlError qMakeError( const TQString& err, int type, const TQMYSQLDriverPrivate* p )
TQSqlError tqMakeError( const TQString& err, int type, const TQMYSQLDriverPrivate* p )
{
return TQSqlError(TQMYSQL_DRIVER_NAME ": " + err, TQString(mysql_error( p->mysql )), type, mysql_errno( p->mysql ));
}
@ -306,7 +306,7 @@ bool TQMYSQLResult::reset ( const TQString& query )
const char *encQuery = query.ascii();
if ( mysql_real_query( d->mysql, encQuery, tqstrlen(encQuery) ) ) {
setLastError( qMakeError("Unable to execute query", TQSqlError::Statement, d ) );
setLastError( tqMakeError("Unable to execute query", TQSqlError::Statement, d ) );
return FALSE;
}
if ( isForwardOnly() ) {
@ -317,7 +317,7 @@ bool TQMYSQLResult::reset ( const TQString& query )
d->result = mysql_store_result( d->mysql );
}
if ( !d->result && mysql_field_count( d->mysql ) > 0 ) {
setLastError( qMakeError( "Unable to store result", TQSqlError::Statement, d ) );
setLastError( tqMakeError( "Unable to store result", TQSqlError::Statement, d ) );
return FALSE;
}
int numFields = mysql_field_count( d->mysql );
@ -511,7 +511,7 @@ bool TQMYSQLDriver::open( const TQString& db,
}
if (!(d->mysql = mysql_init((MYSQL*) 0))) {
setLastError( qMakeError( "Unable to connect", TQSqlError::Connection, d ) );
setLastError( tqMakeError( "Unable to connect", TQSqlError::Connection, d ) );
mysql_close( d->mysql );
setOpenError( TRUE );
return FALSE;
@ -561,13 +561,13 @@ bool TQMYSQLDriver::open( const TQString& db,
clientOptionFlags ) )
{
if ( !db.isEmpty() && mysql_select_db( d->mysql, db )) {
setLastError( qMakeError("Unable open database '" + db + "'", TQSqlError::Connection, d ) );
setLastError( tqMakeError("Unable open database '" + db + "'", TQSqlError::Connection, d ) );
mysql_close( d->mysql );
setOpenError( TRUE );
return FALSE;
}
} else {
setLastError( qMakeError( "Unable to connect", TQSqlError::Connection, d ) );
setLastError( tqMakeError( "Unable to connect", TQSqlError::Connection, d ) );
mysql_close( d->mysql );
setOpenError( TRUE );
return FALSE;
@ -596,7 +596,7 @@ bool TQMYSQLDriver::ping()
return TRUE;
}
else {
setLastError( qMakeError("Unable to execute ping", TQSqlError::Statement, d ) );
setLastError( tqMakeError("Unable to execute ping", TQSqlError::Statement, d ) );
return FALSE;
}
}
@ -758,7 +758,7 @@ bool TQMYSQLDriver::beginTransaction()
return FALSE;
}
if ( mysql_query( d->mysql, "BEGIN WORK" ) ) {
setLastError( qMakeError("Unable to begin transaction", TQSqlError::Statement, d ) );
setLastError( tqMakeError("Unable to begin transaction", TQSqlError::Statement, d ) );
return FALSE;
}
return TRUE;
@ -776,7 +776,7 @@ bool TQMYSQLDriver::commitTransaction()
return FALSE;
}
if ( mysql_query( d->mysql, "COMMIT" ) ) {
setLastError( qMakeError("Unable to commit transaction", TQSqlError::Statement, d ) );
setLastError( tqMakeError("Unable to commit transaction", TQSqlError::Statement, d ) );
return FALSE;
}
return TRUE;
@ -794,7 +794,7 @@ bool TQMYSQLDriver::rollbackTransaction()
return FALSE;
}
if ( mysql_query( d->mysql, "ROLLBACK" ) ) {
setLastError( qMakeError("Unable to rollback transaction", TQSqlError::Statement, d ) );
setLastError( tqMakeError("Unable to rollback transaction", TQSqlError::Statement, d ) );
return FALSE;
}
return TRUE;

@ -193,7 +193,7 @@ static void qSqlWarning( const TQString& message, const TQODBCPrivate* odbc )
#endif
}
static TQSqlError qMakeError( const TQString& err, int type, const TQODBCPrivate* p )
static TQSqlError tqMakeError( const TQString& err, int type, const TQODBCPrivate* p )
{
return TQSqlError( "TQODBC3: " + err, qODBCWarn(p), type );
}
@ -444,7 +444,7 @@ static SQLBIGINT qGetBigIntData( SQLHANDLE hStmt, int column, bool& isNull )
// creates a TQSqlFieldInfo from a valid hStmt generated
// by SQLColumns. The hStmt has to point to a valid position.
static TQSqlFieldInfo qMakeFieldInfo( const SQLHANDLE hStmt, const TQODBCPrivate* p )
static TQSqlFieldInfo tqMakeFieldInfo( const SQLHANDLE hStmt, const TQODBCPrivate* p )
{
bool isNull;
TQString fname = qGetStringData( hStmt, 3, -1, isNull, p->unicode );
@ -463,7 +463,7 @@ static TQSqlFieldInfo qMakeFieldInfo( const SQLHANDLE hStmt, const TQODBCPrivate
return TQSqlFieldInfo( fname, qDecodeODBCType( type, p ), required, size, prec, TQVariant(), type );
}
static TQSqlFieldInfo qMakeFieldInfo( const TQODBCPrivate* p, int i )
static TQSqlFieldInfo tqMakeFieldInfo( const TQODBCPrivate* p, int i )
{
SQLSMALLINT colNameLen;
SQLSMALLINT colType;
@ -484,7 +484,7 @@ static TQSqlFieldInfo qMakeFieldInfo( const TQODBCPrivate* p, int i )
if ( r != SQL_SUCCESS ) {
#ifdef QT_CHECK_RANGE
qSqlWarning( TQString("qMakeField: Unable to describe column %1").arg(i), p );
qSqlWarning( TQString("tqMakeField: Unable to describe column %1").arg(i), p );
#endif
return TQSqlFieldInfo();
}
@ -722,7 +722,7 @@ bool TQODBCResult::reset ( const TQString& query )
(SQLINTEGER) query8.length() );
#endif
if ( r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO ) {
setLastError( qMakeError( "Unable to execute statement", TQSqlError::Statement, d ) );
setLastError( tqMakeError( "Unable to execute statement", TQSqlError::Statement, d ) );
return FALSE;
}
SQLSMALLINT count;
@ -730,7 +730,7 @@ bool TQODBCResult::reset ( const TQString& query )
if ( count ) {
setSelect( TRUE );
for ( int i = 0; i < count; ++i ) {
d->rInf.append( qMakeFieldInfo( d, i ) );
d->rInf.append( tqMakeFieldInfo( d, i ) );
}
} else {
setSelect( FALSE );
@ -1231,7 +1231,7 @@ bool TQODBCResult::exec()
#ifdef QT_CHECK_RANGE
tqWarning( "TQODBCResult::exec: unable to bind variable: %s", qODBCWarn( d ).local8Bit().data() );
#endif
setLastError( qMakeError( "Unable to bind variable", TQSqlError::Statement, d ) );
setLastError( tqMakeError( "Unable to bind variable", TQSqlError::Statement, d ) );
return FALSE;
}
}
@ -1241,7 +1241,7 @@ bool TQODBCResult::exec()
#ifdef QT_CHECK_RANGE
tqWarning( "TQODBCResult::exec: Unable to execute statement: %s", qODBCWarn( d ).local8Bit().data() );
#endif
setLastError( qMakeError( "Unable to execute statement", TQSqlError::Statement, d ) );
setLastError( tqMakeError( "Unable to execute statement", TQSqlError::Statement, d ) );
return FALSE;
}
SQLSMALLINT count;
@ -1249,7 +1249,7 @@ bool TQODBCResult::exec()
if ( count ) {
setSelect( TRUE );
for ( int i = 0; i < count; ++i ) {
d->rInf.append( qMakeFieldInfo( d, i ) );
d->rInf.append( tqMakeFieldInfo( d, i ) );
}
} else {
setSelect( FALSE );
@ -1464,13 +1464,13 @@ bool TQODBCDriver::open( const TQString & db,
&cb,
SQL_DRIVER_NOPROMPT );
if ( r != SQL_SUCCESS && r != SQL_SUCCESS_WITH_INFO ) {
setLastError( qMakeError( "Unable to connect", TQSqlError::Connection, d ) );
setLastError( tqMakeError( "Unable to connect", TQSqlError::Connection, d ) );
setOpenError( TRUE );
return FALSE;
}
if ( !d->checkDriver() ) {
setLastError( qMakeError( "Unable to connect - Driver doesn't support all needed functionality", TQSqlError::Connection, d ) );
setLastError( tqMakeError( "Unable to connect - Driver doesn't support all needed functionality", TQSqlError::Connection, d ) );
setOpenError( TRUE );
return FALSE;
}
@ -1672,7 +1672,7 @@ bool TQODBCDriver::beginTransaction()
(SQLPOINTER)ac,
sizeof(ac) );
if ( r != SQL_SUCCESS ) {
setLastError( qMakeError( "Unable to disable autocommit", TQSqlError::Transaction, d ) );
setLastError( tqMakeError( "Unable to disable autocommit", TQSqlError::Transaction, d ) );
return FALSE;
}
return TRUE;
@ -1690,7 +1690,7 @@ bool TQODBCDriver::commitTransaction()
d->hDbc,
SQL_COMMIT );
if ( r != SQL_SUCCESS ) {
setLastError( qMakeError("Unable to commit transaction", TQSqlError::Transaction, d ) );
setLastError( tqMakeError("Unable to commit transaction", TQSqlError::Transaction, d ) );
return FALSE;
}
return endTrans();
@ -1708,7 +1708,7 @@ bool TQODBCDriver::rollbackTransaction()
d->hDbc,
SQL_ROLLBACK );
if ( r != SQL_SUCCESS ) {
setLastError( qMakeError( "Unable to rollback transaction", TQSqlError::Transaction, d ) );
setLastError( tqMakeError( "Unable to rollback transaction", TQSqlError::Transaction, d ) );
return FALSE;
}
return endTrans();
@ -1722,7 +1722,7 @@ bool TQODBCDriver::endTrans()
(SQLPOINTER)ac,
sizeof(ac));
if ( r != SQL_SUCCESS ) {
setLastError( qMakeError( "Unable to enable autocommit", TQSqlError::Transaction, d ) );
setLastError( tqMakeError( "Unable to enable autocommit", TQSqlError::Transaction, d ) );
return FALSE;
}
return TRUE;
@ -1968,7 +1968,7 @@ TQSqlRecordInfo TQODBCDriver::recordInfo( const TQString& tablename ) const
// Store all fields in a StringList because some drivers can't detail fields in this FETCH loop
while ( r == SQL_SUCCESS ) {
fil.append( qMakeFieldInfo( hStmt, d ) );
fil.append( tqMakeFieldInfo( hStmt, d ) );
r = SQLFetchScroll( hStmt,
SQL_FETCH_NEXT,

@ -120,7 +120,7 @@ bool TQPSQLOpenExtension::open( const TQString& db,
return driver->open( db, user, password, host, port, connOpts );
}
static TQSqlError qMakeError( const TQString& err, int type, const TQPSQLPrivate* p )
static TQSqlError tqMakeError( const TQString& err, int type, const TQPSQLPrivate* p )
{
const char *s = PQerrorMessage(p->connection);
TQString msg = p->isUtf8 ? TQString::fromUtf8(s) : TQString::fromLocal8Bit(s);
@ -484,7 +484,7 @@ bool TQPSQLResult::reset ( const TQString& query )
setActive( TRUE );
return TRUE;
}
setLastError( qMakeError( "Unable to create query", TQSqlError::Statement, d ) );
setLastError( tqMakeError( "Unable to create query", TQSqlError::Statement, d ) );
return FALSE;
}
@ -656,7 +656,7 @@ bool TQPSQLDriver::open( const TQString & db,
d->connection = PQconnectdb( connectString.local8Bit().data() );
if ( PQstatus( d->connection ) == CONNECTION_BAD ) {
setLastError( qMakeError("Unable to connect", TQSqlError::Connection, d ) );
setLastError( tqMakeError("Unable to connect", TQSqlError::Connection, d ) );
setOpenError( TRUE );
return FALSE;
}
@ -697,7 +697,7 @@ bool TQPSQLDriver::ping()
if ( PQstatus( d->connection ) != CONNECTION_OK ) {
PQreset( d->connection );
if ( PQstatus( d->connection ) != CONNECTION_OK ) {
setLastError( qMakeError("Unable to execute ping", TQSqlError::Statement, d ) );
setLastError( tqMakeError("Unable to execute ping", TQSqlError::Statement, d ) );
return FALSE;
}
}
@ -720,7 +720,7 @@ bool TQPSQLDriver::beginTransaction()
PGresult* res = PQexec( d->connection, "BEGIN" );
if ( !res || PQresultStatus( res ) != PGRES_COMMAND_OK ) {
PQclear( res );
setLastError( qMakeError( "Could not begin transaction", TQSqlError::Transaction, d ) );
setLastError( tqMakeError( "Could not begin transaction", TQSqlError::Transaction, d ) );
return FALSE;
}
PQclear( res );
@ -738,7 +738,7 @@ bool TQPSQLDriver::commitTransaction()
PGresult* res = PQexec( d->connection, "COMMIT" );
if ( !res || PQresultStatus( res ) != PGRES_COMMAND_OK ) {
PQclear( res );
setLastError( qMakeError( "Could not commit transaction", TQSqlError::Transaction, d ) );
setLastError( tqMakeError( "Could not commit transaction", TQSqlError::Transaction, d ) );
return FALSE;
}
PQclear( res );
@ -755,7 +755,7 @@ bool TQPSQLDriver::rollbackTransaction()
}
PGresult* res = PQexec( d->connection, "ROLLBACK" );
if ( !res || PQresultStatus( res ) != PGRES_COMMAND_OK ) {
setLastError( qMakeError( "Could not rollback transaction", TQSqlError::Transaction, d ) );
setLastError( tqMakeError( "Could not rollback transaction", TQSqlError::Transaction, d ) );
PQclear( res );
return FALSE;
}

@ -43,7 +43,7 @@ static TQVariant::Type qSqliteType(int tp)
}
}
static TQSqlError qMakeError(sqlite3 *access, const TQString &descr, TQSqlError::Type type,
static TQSqlError tqMakeError(sqlite3 *access, const TQString &descr, TQSqlError::Type type,
int errorCode = -1)
{
return TQSqlError(descr,
@ -191,7 +191,7 @@ bool TQSQLite3ResultPrivate::fetchNext(TQtSqlCachedResult::RowCache* row)
case SQLITE_MISUSE:
default:
// something wrong, don't get col info, but still return false
q->setLastError(qMakeError(access, "Unable to fetch row", TQSqlError::Connection, res));
q->setLastError(tqMakeError(access, "Unable to fetch row", TQSqlError::Connection, res));
finalize();
q->setAt(TQSql::AfterLast);
return false;
@ -229,7 +229,7 @@ bool TQSQLite3Result::reset (const TQString &query)
&d->stmt, 0);
if (res != SQLITE_OK) {
setLastError(qMakeError(d->access, "Unable to execute statement", TQSqlError::Statement, res));
setLastError(tqMakeError(d->access, "Unable to execute statement", TQSqlError::Statement, res));
d->finalize();
return false;
}
@ -309,7 +309,7 @@ bool TQSQLite3Driver::open(const TQString & db, const TQString &, const TQString
setOpenError(false);
return true;
} else {
setLastError(qMakeError(d->access, "Error opening database",
setLastError(tqMakeError(d->access, "Error opening database",
TQSqlError::Connection));
setOpenError(true);
return false;
@ -320,7 +320,7 @@ void TQSQLite3Driver::close()
{
if (isOpen()) {
if (sqlite3_close(d->access) != SQLITE_OK)
setLastError(qMakeError(d->access, "Error closing database",
setLastError(tqMakeError(d->access, "Error closing database",
TQSqlError::Connection));
d->access = 0;
setOpen(false);

@ -57,7 +57,7 @@
// Duplicated from tqobject.h, but we cannot include tqobject.h here since
// it causes qmake to not build on irix g++
// it causes tqmake to not build on irix g++
#define TQT_TRANSLATE_NOOP(scope,x) (x)
const char* qt_fileerr_unknown = TQT_TRANSLATE_NOOP( "TQFile", "Unknown error" );

@ -376,7 +376,7 @@ startup page, and application icon.
When it is started without any options, \QA displays a default set of
documentation. When TQt is installed, the default documentation set in
\QA contains the TQt reference documentation as well as the tools that
come with Qt, such as \QD and qmake.
come with Qt, such as \QD and tqmake.
Documentation can be added or removed from \QA by
adding and removing the content files. The format of the content files are

@ -334,7 +334,7 @@ TQStringList Config::docFiles() const
TQPixmap Config::docIcon( const TQString &title ) const
{
// ### To allow qdoc generated dcf files to reference the doc icons from qmake_image_col
// ### To allow qdoc generated dcf files to reference the doc icons from tqmake_image_col
if (!TQFile::exists(profil->icons[title]))
return TQPixmap::fromMimeSource( TQFileInfo(profil->icons[title]).fileName() );
return TQPixmap::fromMimeSource( profil->icons[title] );

@ -87,7 +87,7 @@ static TQAssistantClientPrivate *data( const TQAssistantClient *client, bool cre
must link against \c libtqassistantclient.a (Unix) or \c
tqassistantclient.lib (Windows), which is built into \c INSTALL/lib
if you built the TQt tools (\c INSTALL is the directory where TQt is
installed). If you use qmake, then you can simply add the following
installed). If you use tqmake, then you can simply add the following
line to your pro file:
\code

@ -41,7 +41,7 @@
#define DESIGNER_TITLE "TQt Designer Manual"
#define ASSISTANT_TITLE "TQt Assistant Manual"
#define LINGUIST_TITLE "Guide to the TQt Translation Tools"
#define QMAKE_TITLE "qmake User Guide"
#define QMAKE_TITLE "tqmake User Guide"
Profile *Profile::createDefaultProfile( const TQString &docPath )
{
@ -64,7 +64,7 @@ Profile *Profile::createDefaultProfile( const TQString &docPath )
profile->addDCFTitle( path + "designer.dcf", DESIGNER_TITLE );
profile->addDCFTitle( path + "assistant.dcf", ASSISTANT_TITLE );
profile->addDCFTitle( path + "linguist.dcf", LINGUIST_TITLE );
profile->addDCFTitle( path + "qmake.dcf", QMAKE_TITLE );
profile->addDCFTitle( path + "tqmake.dcf", QMAKE_TITLE );
profile->addDCFIcon( QT_TITLE, "qt.png" );
profile->addDCFIcon( DESIGNER_TITLE, "designer.png" );
@ -75,7 +75,7 @@ Profile *Profile::createDefaultProfile( const TQString &docPath )
profile->addDCFIndexPage( DESIGNER_TITLE, path + "designer-manual.html" );
profile->addDCFIndexPage( ASSISTANT_TITLE, path + "assistant.html" );
profile->addDCFIndexPage( LINGUIST_TITLE, path + "linguist-manual.html" );
profile->addDCFIndexPage( QMAKE_TITLE, path + "qmake-manual.html" );
profile->addDCFIndexPage( QMAKE_TITLE, path + "tqmake-manual.html" );
profile->addDCFImageDir( QT_TITLE, "../../gif/" );
profile->addDCFImageDir( DESIGNER_TITLE, "../../gif/" );

@ -1,6 +1,6 @@
TEMPLATE = lib
CONFIG += qt warn_on qmake_cache
CONFIG += qt warn_on tqmake_cache
CONFIG += dll
!force_static:!win32:contains(QT_PRODUCT,qt-internal) {
CONFIG -= staticlib

@ -72,7 +72,7 @@
#include <tqregexp.h>
/* qmake ignore TQ_OBJECT */
/* tqmake ignore TQ_OBJECT */
/*
The indenter avoids getting stuck in almost infinite loops by

@ -1,5 +1,5 @@
######################################################################
# Automatically generated by qmake (1.04a) Tue Oct 1 18:34:56 2002
# Automatically generated by tqmake (1.04a) Tue Oct 1 18:34:56 2002
######################################################################
TEMPLATE = app
CONFIG -= moc

@ -373,7 +373,7 @@ void TQUic::createFormDecl( const TQDomElement &e )
out << exportMacro << " ";
out << bareNameOfClass << " : public " << objClass << endl << "{" << endl;
/* qmake ignore TQ_OBJECT */
/* tqmake ignore TQ_OBJECT */
out << " TQ_OBJECT" << endl;
out << endl;
out << "public:" << endl;

@ -3,8 +3,8 @@
\index Release Manager
Two tools are provided for the release manager, \l lupdate and \l
lrelease. These tools depend on \e qmake project files. You don't
have to use \e qmake, though.
lrelease. These tools depend on \e tqmake project files. You don't
have to use \e tqmake, though.
A third tool, \c tqm2ts, can be used for converting TQt 2.x message
files to \c .ts files.
@ -13,7 +13,7 @@ files to \c .ts files.
\index .pro Files
\index Project Files
\index qmake!Project Files
\index tqmake!Project Files
\l lupdate and \l lrelease depend on information in the application's
\c .pro TQt project file. There must be an entry in the \c TRANSLATIONS

@ -61,7 +61,7 @@ application at runtime.
\index .pro Files
\index Project Files
\index qmake!Project Files
\index tqmake!Project Files
For \l lupdate to work successfully, it must know which translation
files to produce. The files are simply listed in the application's \c
@ -393,7 +393,7 @@ is shown when we run the application:
\index Latin
The first step is to create a project file, \c tt1.pro, that lists
all the source files for the project. The project file can be a qmake
all the source files for the project. The project file can be a tqmake
project file, or even an ordinary makefile. Any file that contains
\index SOURCES!in Project Files
@ -527,7 +527,7 @@ saluto!".
\index .pro Files
\index Project Files
\index qmake!Project Files
\index tqmake!Project Files
\include tt2/tt2.pro
\caption tt2.pro
@ -839,7 +839,7 @@ Version 1.0 consists of these files:
\i \c mainwindow.h contains the definition of \c MainWindow;
\i \c mainwindow.cpp contains the implementation of \c MainWindow;
\i \c main.cpp contains main();
\i \c tt3.pro is the \e qmake project file.
\i \c tt3.pro is the \e tqmake project file.
\i \c tt3_pt.ts is the Portuguese message file.
\endlist

@ -45,7 +45,7 @@
#include <stdio.h>
#include <string.h>
/* qmake ignore TQ_OBJECT */
/* tqmake ignore TQ_OBJECT */
static const char MagicComment[] = "TRANSLATOR ";

@ -189,7 +189,7 @@ TQMap<TQString, TQString> proFileTagMap( const TQString& text )
int i = 0;
while ( (i = callToSystem.search((*it), i)) != -1 ) {
/*
This code is stolen from qmake's project.cpp file.
This code is stolen from tqmake's project.cpp file.
Ideally we would use the same parser, so we wouldn't
have this code duplication.
*/

@ -18,10 +18,10 @@
1.05a -
caching of more information (speed ups)
$$list() added to be used as a lambda function in qmake
$$list() added to be used as a lambda function in tqmake
$$files() added to allow regular expression matching
$$fromfile() added to grab one single variable value from a parsed file
$$prompt() added to allow querying for user input from qmake
$$prompt() added to allow querying for user input from tqmake
include() modified to support specifying which variables to import
equals() test added to test for equality
MSVC.net generator added [partial solution files in vcsubdirs]
@ -36,12 +36,12 @@
1.02a -
Dependency / Mocable caching. qmake can cache these expensive operations with qmake_cache
Dependency / Mocable caching. tqmake can cache these expensive operations with tqmake_cache
CONFIG.
The parser has been improved to cover more error cases, as well as more forgiving
qmake now includes a special else scope to invert the previous test
tqmake now includes a special else scope to invert the previous test
Ability to add user defined targets to UnixMakefiles.
@ -49,20 +49,20 @@
New system for library linking. This system allows a user several different features:
1) libtool like library dependencies to static libraries build with qmake
1) libtool like library dependencies to static libraries build with tqmake
2) library dependencies, when on .pro depends on another library - it will
automatically build that other library (unix makefiles only)
3) automatic detection of configurations for Qt, if CONFIG qt is specified
it will find the settings for the most recent TQt itself.
Project Builder for Mac OS X is now a supported backend for qmake.
Project Builder for Mac OS X is now a supported backend for tqmake.
qmake now offers a 'make uninstall' feature, to reverse the actions of a 'make install'.
tqmake now offers a 'make uninstall' feature, to reverse the actions of a 'make install'.
qmake can now do recursive searches in project-file mode (-r option).
tqmake can now do recursive searches in project-file mode (-r option).
1.00a -
First release, shipped with TQt 3.0.
qmake ships with support for Unix make, MSVC (both dsp and nmake), Borland make.
tqmake ships with support for Unix make, MSVC (both dsp and nmake), Borland make.

@ -34,7 +34,7 @@ DEPEND_SRC=project.cpp property.cpp meta.cpp main.cpp qtmd5.cpp generators/makef
CXXFLAGS= @QMAKE_CXXFLAGS@ \
-I. -Igenerators -Igenerators/unix -Igenerators/win32 -Igenerators/mac \
-I@BUILD_PATH@/include/qmake -I@BUILD_PATH@/include -I@SOURCE_PATH@/include \
-I@BUILD_PATH@/include/tqmake -I@BUILD_PATH@/include -I@SOURCE_PATH@/include \
-DTQT_NO_TEXTCODEC -DTQT_NO_UNICODETABLES -DTQT_NO_COMPONENT -DTQT_NO_STL \
-DTQT_NO_COMPRESS -I@QMAKESPEC@ -DHAVE_QCONFIG_CPP
LFLAGS=@QMAKE_LFLAGS@
@ -42,7 +42,7 @@ LFLAGS=@QMAKE_LFLAGS@
tqmake: $(OBJS) $(QOBJS)
$(CXX) -o $@ $(OBJS) $(QOBJS) $(LFLAGS)
rm -f @BUILD_PATH@/bin/$@
ln -s ../qmake/$@ @BUILD_PATH@/bin/$@
ln -s ../tqmake/$@ @BUILD_PATH@/bin/$@
install: tqmake
[ -d @QT_INSTALL_BINS@ ] || mkdir -p @QT_INSTALL_BINS@

@ -1,9 +1,9 @@
\chapter qmake's Advanced Concepts
\chapter tqmake's Advanced Concepts
\section1 qmake's Advanced Concepts
\section1 tqmake's Advanced Concepts
The \e qmake project files we've seen up to now have been very simple,
just a list of \e{name = value} and \e{name += value} lines. \e qmake
The \e tqmake project files we've seen up to now have been very simple,
just a list of \e{name = value} and \e{name += value} lines. \e tqmake
provides a lot more power, for example you can use a single project
file to produce makefiles for multiple platforms.
@ -86,10 +86,10 @@ like this:
}
\endcode
The above code will add the QT_DLL define to the makefile if \e qmake
is used on a Windows platform. If \e qmake is used on a different
The above code will add the QT_DLL define to the makefile if \e tqmake
is used on a Windows platform. If \e tqmake is used on a different
platform than Windows, the define will be ignored. You may also perform
single line conditionals/assignments with qmake like this:
single line conditionals/assignments with tqmake like this:
\code
win32:DEFINES += QT_DLL
@ -183,7 +183,7 @@ it. For example:
\endcode
There are no restricitions on what you do to your own variables, as \e
qmake will just ignore them unless it needs to look at them for a
tqmake will just ignore them unless it needs to look at them for a
scope.
You can also assign the value of a current variable to another
@ -201,7 +201,7 @@ this point in the project file. This is also equivalent to:
\endcode
The second notation allows you to adjoin the variable expansion to another
value without separating by space. \e qmake will allow a variable to
value without separating by space. \e tqmake will allow a variable to
contain anything (including $(VALUE), which will be placed directly into
the Makefile, and allow it to expand as appropriate, usually an environment
variable). However, if you require an environment variable to be replaced
@ -263,7 +263,7 @@ platform for example.
\section1 Test Functions
\e qmake provides built-in functions that perform simple, yet powerful
\e tqmake provides built-in functions that perform simple, yet powerful
tests. These tests may be used in place of scopes (as described above), in
some cases it is more usefull to use the test function by itself ignoring
its test value.
@ -298,7 +298,7 @@ processed. For example:
\section2 error( string )
This function outputs the string given and then makes \e qmake exit.
This function outputs the string given and then makes \e tqmake exit.
For example:
\code
@ -306,7 +306,7 @@ For example:
\endcode
The text "An error has occured" will be displayed on the console and
\e qmake will exit.
\e tqmake will exit.
\section2 exists( filename )
@ -314,12 +314,12 @@ If the specified file exists, then the settings inside the scope will
be processed. For example:
\code
exists( /local/qt/qmake/main.cpp ) {
exists( /local/qt/tqmake/main.cpp ) {
SOURCES += main.cpp
}
\endcode
If \e /local/qt/qmake/main.cpp exists then main.cpp is added to the
If \e /local/qt/tqmake/main.cpp exists then main.cpp is added to the
list of source files.
Note that "/" can be used as a directory separator regardless of the
@ -396,6 +396,6 @@ headers.
\section2 infile( filename, var, val )
This function will succeed if the file \e filename (when parsed
by qmake itself) contains the variable \e var with a value of
by tqmake itself) contains the variable \e var with a value of
\e val. You may also not pass in a third argument (\e val) and the
function will only test if \e var has been assigned to in the file.

@ -1,28 +1,28 @@
\chapter qmake Concepts
\chapter tqmake Concepts
\section1 Introducing qmake
\section1 Introducing tqmake
\e qmake is an easy-to-use tool from Trolltech that creates makefiles
for development projects across different platforms. \e qmake
\e tqmake is an easy-to-use tool from Trolltech that creates makefiles
for development projects across different platforms. \e tqmake
simplifies the generation of makefiles so that only a few lines of
information are needed to create a makefile. \e qmake can be used for
information are needed to create a makefile. \e tqmake can be used for
any software project whether it is written in TQt or not, although it
also contains additional features to support TQt development.
\e qmake generates a makefile based on the information in a project
\e tqmake generates a makefile based on the information in a project
file. Project files are created by the developer. Project files are
usually simple, but can be quite sophisticated if required.
\e qmake can also generate projects for Microsoft Visual studio
\e tqmake can also generate projects for Microsoft Visual studio
without having to change the project file.
\section1 qmake's Concepts
\section1 tqmake's Concepts
\section2 The QMAKESPEC environment variable
Before \e qmake can be used to build makefiles, the QMAKESPEC
Before \e tqmake can be used to build makefiles, the QMAKESPEC
environment variable must be set to the platform-compiler combination
that is being used on the system. The QMAKESPEC environment variable
tells qmake where to look to find platform and compiler specific
tells tqmake where to look to find platform and compiler specific
information. This ensures that the right libraries are used, and that
the generated makefile uses the correct syntax. A list of the
currently supported platform-compiler combinations can be found in
@ -34,16 +34,16 @@ you would set the QMAKESPEC environment variable to \e win32-msvc.
If you are using gcc on Solaris then you would set your QMAKESPEC
environment variable to \e solaris-g++.
Inside each of the directories in qt/mkspecs, there is a \e qmake.conf
Inside each of the directories in qt/mkspecs, there is a \e tqmake.conf
file which contains the platform and compiler specific information.
These settings are applied to any project that is built using \e
qmake and should not be modified unless you're an expert. For example,
tqmake and should not be modified unless you're an expert. For example,
if all your applications had to link against a particular library, you
might add this information to the relevant \e qmake.conf file.
might add this information to the relevant \e tqmake.conf file.
\section2 Project (.pro) files
A project file is used to tell \e qmake the details it needs to know
A project file is used to tell \e tqmake the details it needs to know
about creating a makefile for the application. For instance, a list
of source files and header files that should be put into the project
file; any application specific configuration, such as an extra library
@ -56,7 +56,7 @@ symbol and run to the end of the line.
\section2 Templates
The template variable tells \e qmake what sort of makefile should be
The template variable tells \e tqmake what sort of makefile should be
generated for the application. The following choices are available:
\list
@ -72,8 +72,8 @@ project file and call make on it.
\section3 The 'app' template
The 'app' template tells \e qmake to generate a makefile that will build
an application. When using this template the following \e qmake
The 'app' template tells \e tqmake to generate a makefile that will build
an application. When using this template the following \e tqmake
system variables are recognized. You should use these in your .pro
file to specify information about your application.
@ -99,7 +99,7 @@ automatically).
You only need to use the system variables that you have values for,
for instance, if you don't have any extra INCLUDEPATHs then you don't
need to specify any, \e qmake will add in the default ones needed.
need to specify any, \e tqmake will add in the default ones needed.
For instance, an example project file might look like this:
\code
@ -120,7 +120,7 @@ all other definitions would be deleted.
\section3 The 'lib' template
The 'lib' template tells \e qmake to generate a makefile that will
The 'lib' template tells \e tqmake to generate a makefile that will
build a library. When using this template, in addition to the system variables
mentioned above for the 'app' template the \e VERSION variable is
supported. You should use these in your .pro file to specify
@ -132,7 +132,7 @@ information about the library.
\section3 The 'subdirs' template
The 'subdirs' template tells qmake to generate a makefile that will go
The 'subdirs' template tells tqmake to generate a makefile that will go
into the specified subdirectories and generate a makefile for the
project file in the directory and call make on it.
@ -140,7 +140,7 @@ The only system variable that is recognised for this template is the
\e SUBDIRS variable. This variable contains a list of all the
subdirectories that contain project files to be processed. It is
essential that the project file in the sub directory has the same name
as the subdirectory, so that \e qmake can find it. For
as the subdirectory, so that \e tqmake can find it. For
example, if the subdirectory is called 'myapp' then the project file
in that directory should be called \e myapp.pro in that directory.
@ -149,7 +149,7 @@ in that directory should be called \e myapp.pro in that directory.
The config variable specifies the options that the compiler should use
and the libraries that should be linked against. Anything can be
added to the config variable, but the options covered below are
recognised by qmake internally.
recognised by tqmake internally.
The following options control what compiler flags are used:
@ -181,7 +181,7 @@ will have the following line:
CONFIG += qt thread debug
\endcode
Note, that you must use "+=", not "=", or \e qmake will not be able to
Note, that you must use "+=", not "=", or \e tqmake will not be able to
use the settings used to build TQt as a guide as what type of Qt
library was built.

@ -1,13 +1,13 @@
\chapter Installing qmake
\chapter Installing tqmake
\section1 Installing qmake
\section1 Installing tqmake
\e qmake is built by default when TQt is built.
\e tqmake is built by default when TQt is built.
This section explains how to build \e qmake manually. Skip ahead to
\l{The 10 minute guide to using qmake}, if you already have \e qmake.
This section explains how to build \e tqmake manually. Skip ahead to
\l{The 10 minute guide to using tqmake}, if you already have \e tqmake.
\section2 Installing qmake manually
\section2 Installing tqmake manually
Before building TQt manually the following environment variables must
be set:
@ -35,11 +35,11 @@ hpux-acc irix-n32 solaris-64 unixware7-cc
For example, \e {c:\\qt} and \e {\\local\\qt}
\endlist
Once the environment variables are set go into the qmake directory, \e
$TQTDIR/qmake, e.g. \e{C:\\qt\\qmake}. Now run \e make or \e nmake
Once the environment variables are set go into the tqmake directory, \e
$TQTDIR/tqmake, e.g. \e{C:\\qt\\tqmake}. Now run \e make or \e nmake
depending on your compiler.
When the make has completed, \e qmake is ready for use.
When the make has completed, \e tqmake is ready for use.

@ -0,0 +1,12 @@
\title tqmake User Guide
\granularity chapter
\input tqmake-preface.leaf
\input tqmake-install.leaf
\input tqmake-quick.leaf
\input tqmake-tutorial.leaf
\input tqmake-concepts.leaf
\input tqmake-advanced.leaf
\input tqmake-pch.leaf
\input tqmake-commandreference.leaf

@ -14,7 +14,7 @@ the compiler will load the stored state, and continue compiling the
specified file. Each subsequent compilation is faster because the
stable code does not need to be recompiled.
\e qmake supports the use of precompiled headers (PCH) on some
\e tqmake supports the use of precompiled headers (PCH) on some
platforms and build environments, including:
\list
\i Windows
@ -78,9 +78,9 @@ your project settings (.pro), is to include the PRECOMPILED_HEADER option:
\code
PRECOMPILED_HEADER = stable.h
\endcode
\e qmake will handle the rest, to ensure the creation and use of the
\e tqmake will handle the rest, to ensure the creation and use of the
precompiled header file. You do not need to include the precompiled
header file in HEADERS, as qmake will do this if the configuration
header file in HEADERS, as tqmake will do this if the configuration
supports PCH.
All platforms that support precompiled headers have the configuration
@ -98,7 +98,7 @@ For example:
\section1 Example project
You can find the following source code in the
\e{qt/qmake/examples/precompile} directory:
\e{qt/tqmake/examples/precompile} directory:
\Bold mydialog.ui
\quotefile precompile/mydialog.ui

@ -0,0 +1,18 @@
\chapter Introduction to tqmake
\section1 Introduction to tqmake
\e tqmake is a tool created by Trolltech to write makefiles for
different compilers and platforms.
Writing makefiles by hand can be difficult and error prone, especially
if several makefiles are required for different compiler and platform
combinations. With \e tqmake, developers create a simple single
'project' file and run \e tqmake to generate the appropriate
makefiles. \e tqmake takes care of all the compiler and platform
dependencies, freeing developers to focus on their code. Trolltech
uses \e tqmake as the primary build tool for the TQt library, and for
the tools supplied with Qt.
\e tqmake also takes care of Qt's special requirements, automatically
including build rules for \link tqmoc.html tqmoc\endlink and \e tquic.

@ -1,8 +1,8 @@
\chapter The 10 minute guide to using qmake
\chapter The 10 minute guide to using tqmake
\section1 Creating a project file
\e qmake uses information stored in project (.pro) files to determine
\e tqmake uses information stored in project (.pro) files to determine
what should go in the makefiles it generates.
A basic project file contains information about the application, for
@ -56,7 +56,7 @@ by the application, e.g.
Any of the approaches used to list source files may be used for header
files.
The CONFIG line is used to give \e qmake information about the
The CONFIG line is used to give \e tqmake information about the
application's configuration.
\code
CONFIG += qt warn_on release
@ -66,15 +66,15 @@ The "+=" is used here, because we add our configuration options to any
that are already present. This is safer than using "=" which replaces
all options with just those specified.
The \e qt part of the CONFIG line tells \e qmake that the application
is built using Qt. This means that \e qmake will link against the Qt
The \e qt part of the CONFIG line tells \e tqmake that the application
is built using Qt. This means that \e tqmake will link against the Qt
libraries when linking and add in the neccesary include paths for
compiling.
The \e warn_on part of the CONFIG line tells \e qmake that it should
The \e warn_on part of the CONFIG line tells \e tqmake that it should
set the compiler flags so that warnings are output.
The \e release part of the CONFIG line tells \e qmake that the
The \e release part of the CONFIG line tells \e tqmake that the
application must be built as a release application. During
development, programmers may prefer to replace \e release with \e
debug, which is discussed later.
@ -86,7 +86,7 @@ The last line in the project file is the TARGET line:
\endcode
The target line simply specifies what the name of the target should be
for the application. You shouldn't put an extension here because \e
qmake will do this for you.
tqmake will do this for you.
\endomit
Project files are plain text (i.e. use an editor like notepad, vim
@ -104,11 +104,11 @@ project file and type:
Makefiles are generated from the '.pro' files like this:
\code
qmake -o Makefile hello.pro
tqmake -o Makefile hello.pro
\endcode
For Visual Studio users, \e qmake can also generate '.dsp' files, for
For Visual Studio users, \e tqmake can also generate '.dsp' files, for
example:
\code
qmake -t vcapp -o hello.dsp hello.pro
tqmake -t vcapp -o hello.dsp hello.pro
\endcode

@ -1,9 +1,9 @@
\chapter qmake Tutorial
\chapter tqmake Tutorial
\section1 Introduction to the qmake tutorial
\section1 Introduction to the tqmake tutorial
This tutorial teaches you how to use \e qmake. We recommend that
you read the \e qmake user guide after completing this tutorial.
This tutorial teaches you how to use \e tqmake. We recommend that
you read the \e tqmake user guide after completing this tutorial.
\section1 Starting off simple
@ -16,11 +16,11 @@ your application, and you have created the following files:
\i main.cpp
\endlist
You will find these files in \e {qt/qmake/examples/tutorial}. The
You will find these files in \e {qt/tqmake/examples/tutorial}. The
only other thing you know about the setup of the application is that
it's written in Qt. First, using your favorite plain text editor,
create a file called \e hello.pro in \e {qt/qmake/tutorial}. The
first thing you need to do is add the lines that tell \e qmake about
create a file called \e hello.pro in \e {qt/tqmake/tutorial}. The
first thing you need to do is add the lines that tell \e tqmake about
the source and header files that are part of your development project.
We'll add the source files to the project file first. To do this you
@ -70,7 +70,7 @@ you can set it in the project file:
\endcode
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
application, we need to put 'qt' on the CONFIG line so that \e tqmake
will add the relevant libraries to be linked against and ensure that
build lines for \e tqmoc and \e tquic are included in the makefile.
@ -82,11 +82,11 @@ The finished project file should look like this:
SOURCES += main.cpp
\endcode
You can now use \e qmake to generate a makefile for your application.
You can now use \e tqmake to generate a makefile for your application.
On the command line, in your application directory, type:
\code
qmake -o Makefile hello.pro
tqmake -o Makefile hello.pro
\endcode
Then type \e make or \e nmake depending on the compiler you use.
@ -107,7 +107,7 @@ For example:
SOURCES += main.cpp
\endcode
Use \e qmake as before to generate a makefile and you will be able to
Use \e tqmake as before to generate a makefile and you will be able to
debug your application.
\section1 Adding platform specific source files
@ -119,7 +119,7 @@ include into your project file - \e hellowin.cpp and \e
hellounix.cpp. We can't just add these to the \e SOURCES
variable since this will put both files in the makefile. So what we
need to do here is to use a scope which will be processed depending on
which platform \e qmake is run on.
which platform \e tqmake is run on.
A simple scope which will add in the platform dependent file for
Windows looks like this:
@ -130,8 +130,8 @@ Windows looks like this:
}
\endcode
So if \e qmake is run on Windows, it will add \e hellowin.cpp to the
list of source files. If \e qmake is run on any other platform, it
So if \e tqmake is run on Windows, it will add \e hellowin.cpp to the
list of source files. If \e tqmake is run on any other platform, it
will simply ignore it. Now all that is left to be done is to create a
scope for the unix dependent file.
@ -151,13 +151,13 @@ something like this:
}
\endcode
Use \e qmake as before to generate a makefile.
Use \e tqmake as before to generate a makefile.
\section1 Stopping qmake if a file doesn't exist
\section1 Stopping tqmake if a file doesn't exist
You may not want to create a makefile if a certain file doesn't exist.
We can check if a file exists by using the exists() function. We can
stop \e qmake from processing by using the error() function. This
stop \e tqmake from processing by using the error() function. This
works in the same way as scopes. Simply replace the scope condition
with the function. A check for a main.cpp file looks like this:
@ -187,8 +187,8 @@ file doesn't exist.
}
\endcode
Use \e qmake as before to generate a makefile. If you rename \e
main.cpp temporarily, you will see the message and \e qmake will stop
Use \e tqmake as before to generate a makefile. If you rename \e
main.cpp temporarily, you will see the message and \e tqmake will stop
processing.
\section1 Checking for more than one condition
@ -235,5 +235,5 @@ project file looks like this:
\endcode
That's it! You have now completed the tutorial for \e qmake, and are
That's it! You have now completed the tutorial for \e tqmake, and are
ready to write project files for your development projects.

@ -0,0 +1,2 @@
// This file does nothing, but check your makefile to see if there is a
// reference to hello_win.cpp...there shouldn't be if tqmake is used on X11.

@ -0,0 +1,2 @@
// This file does nothing, but check your makefile to see if there is a
// reference to hello_x11.cpp...there shouldn't be if tqmake is used on Windows.

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
@ -319,7 +319,7 @@ MetrowerksMakefileGenerator::writeMakeParts(TQTextStream &t)
TQStringList list;
if(arg == "INCLUDEPATH") {
list = project->variables()[arg];
list << Option::mkfile::qmakespec;
list << Option::mkfile::tqmakespec;
list << TQDir::current().currentDirPath();
TQStringList &l = project->variables()["QMAKE_LIBS_PATH"];
@ -611,7 +611,7 @@ MetrowerksMakefileGenerator::findTemplate(const TQString &file)
{
TQString ret;
if(!TQFile::exists(ret = file) &&
!TQFile::exists((ret = Option::mkfile::qmakespec + TQDir::separator() + file)) &&
!TQFile::exists((ret = Option::mkfile::tqmakespec + TQDir::separator() + file)) &&
!TQFile::exists((ret = TQString(getenv("TQTDIR")) + "/mkspecs/mac-mwerks/" + file)) &&
!TQFile::exists((ret = (TQString(getenv("HOME")) + "/.tmake/" + file))))
return "";

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
@ -276,9 +276,9 @@ nextfile:
<< "\t\t\t" << "};" << "\n"
<< "\t\t\t" << "dependencies = (" << "\n";
{
const TQStringList &qmake_subdirs = project->variables()["QMAKE_PBX_SUBDIRS"];
for(int i = 0; i < qmake_subdirs.count(); i++)
t << "\t\t\t\t" << keyFor(qmake_subdirs[i] + "_TARGETREF") << "," << "\n";
const TQStringList &tqmake_subdirs = project->variables()["QMAKE_PBX_SUBDIRS"];
for(int i = 0; i < tqmake_subdirs.count(); i++)
t << "\t\t\t\t" << keyFor(tqmake_subdirs[i] + "_TARGETREF") << "," << "\n";
}
t << "\t\t\t" << ");" << "\n"
<< "\t\t\t" << "isa = PBXAggregateTarget;" << "\n"
@ -371,7 +371,7 @@ ProjectBuilderMakefileGenerator::writeMakeParts(TQTextStream &t)
<< "\t\t\t" << "generatedFileNames = (" << "\n"
<< "\t\t\t" << ");" << "\n"
<< "\t\t\t" << "isa = PBXShellScriptBuildPhase;" << "\n"
<< "\t\t\t" << "name = \"TQt Qmake\";" << "\n"
<< "\t\t\t" << "name = \"TQt TQMake\";" << "\n"
<< "\t\t\t" << "neededFileNames = (" << "\n"
<< "\t\t\t" << ");" << "\n"
<< "\t\t\t" << "shellPath = /bin/sh;" << "\n"
@ -407,7 +407,7 @@ ProjectBuilderMakefileGenerator::writeMakeParts(TQTextStream &t)
else if(srcs[i] == "QMAKE_IMAGE_COLLECTION")
src_group = "Sources [images]";
else if(srcs[i] == "QMAKE_INTERNAL_INCLUDED_FILES")
src_group = "Sources [qmake]";
src_group = "Sources [tqmake]";
for(TQStringList::Iterator it = tmp.begin(); it != tmp.end(); ++it) {
TQStringList files = (*it);
@ -1306,7 +1306,7 @@ bool
ProjectBuilderMakefileGenerator::openOutput(TQFile &file) const
{
if(TQDir::isRelativePath(file.name()))
file.setName(Option::output_dir + file.name()); //pwd when qmake was run
file.setName(Option::output_dir + file.name()); //pwd when tqmake was run
TQFileInfo fi(file);
if(fi.extension() != "pbxproj" || file.name().isEmpty()) {
TQString output = file.name();

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
@ -134,7 +134,7 @@ MakefileGenerator::generateMocList(const TQString &fn_target)
bool ignore_tqobject = FALSE;
int line_count = 1;
/* qmake ignore TQ_OBJECT */
/* tqmake ignore TQ_OBJECT */
#define COMP_LEN 9 //strlen("TQ_OBJECT")
#define OBJ_LEN 9 //strlen("TQ_OBJECT")
#define DIS_LEN 10 //strlen("Q_DISPATCH")
@ -151,7 +151,7 @@ MakefileGenerator::generateMocList(const TQString &fn_target)
if(*(big_buffer + x) == 't' || *(big_buffer + x) == 'q') { //ignore
if(total_size_read >= (x + 20)) {
if(!strncmp(big_buffer + x + 1, "make ignore TQ_OBJECT", 20)) {
debug_msg(2, "Mocgen: %s:%d Found \"qmake ignore TQ_OBJECT\"",
debug_msg(2, "Mocgen: %s:%d Found \"tqmake ignore TQ_OBJECT\"",
fn_target.latin1(), line_count);
x += 20;
ignore_tqobject = TRUE;
@ -329,7 +329,7 @@ MakefileGenerator::generateDependencies(TQPtrList<MakefileDependDir> &dirs, cons
!QMAKE_EOL(*(big_buffer + x + inc_len)); inc_len++);
*(big_buffer + x + inc_len) = '\0';
inc = big_buffer + x;
} else if(total_size_read >= x + 14 && !strncmp(big_buffer + x, "qmake_warning ", 14)) {
} else if(total_size_read >= x + 14 && !strncmp(big_buffer + x, "tqmake_warning ", 14)) {
for(x+=14; //skip spaces after keyword
x < total_size_read && (*(big_buffer+x) == ' ' || *(big_buffer+x) == '\t');
x++);
@ -347,7 +347,7 @@ MakefileGenerator::generateDependencies(TQPtrList<MakefileDependDir> &dirs, cons
const char saved_term = *(big_buffer + x + msg_len);
*(big_buffer + x + msg_len) = '\0';
TQString msg = big_buffer + x;
debug_msg(0, "%s:%d qmake_warning -- %s", fix_env_fn.latin1(),
debug_msg(0, "%s:%d tqmake_warning -- %s", fix_env_fn.latin1(),
line_count, msg.latin1());
*(big_buffer + x + msg_len) = saved_term; //put it back
}
@ -561,7 +561,7 @@ MakefileGenerator::generateDependencies(TQPtrList<MakefileDependDir> &dirs, cons
l.remove(it);
} else if(!findMocSource(fqn).endsWith(fileFixify(fn))) {
/* Not really a very good test, but this will at least avoid
confusion if it really does happen (since tmake/qmake
confusion if it really does happen (since tmake/tqmake
previously didn't even allow this the test is mostly accurate) */
warn_msg(WarnLogic,
"Found potential multiple MOC include %s (%s) in '%s'",
@ -736,16 +736,16 @@ MakefileGenerator::init()
/* get deps and mocables */
TQDict<void> cache_found_files;
TQString cache_file(".qmake.internal.cache");
TQString cache_file(".tqmake.internal.cache");
if(!project->isEmpty("QMAKE_INTERNAL_CACHE_FILE"))
cache_file = Option::fixPathToLocalOS(project->first("QMAKE_INTERNAL_CACHE_FILE"));
if(cache_file.find(TQDir::separator()) == -1) //guess they know what they are doing..
cache_file.prepend(Option::output_dir + TQDir::separator());
if((Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT ||
if((Option::tqmake_mode == Option::QMAKE_GENERATE_PROJECT ||
Option::mkfile::do_deps || Option::mkfile::do_mocs) && !noIO()) {
TQPtrList<MakefileDependDir> deplist;
deplist.setAutoDelete(TRUE);
if((Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT || Option::mkfile::do_deps) &&
if((Option::tqmake_mode == Option::QMAKE_GENERATE_PROJECT || Option::mkfile::do_deps) &&
doDepends()) {
TQStringList incDirs = v["DEPENDPATH"] + v["QMAKE_ABSOLUTE_SOURCE_PATH"];
if(project->isActiveConfig("depend_includepath"))
@ -756,7 +756,7 @@ MakefileGenerator::init()
l.replace("\"","")));
}
debug_msg(1, "Dependency Directories: %s", incDirs.join(" :: ").latin1());
if(Option::output.name() != "-" && project->isActiveConfig("qmake_cache")) {
if(Option::output.name() != "-" && project->isActiveConfig("tqmake_cache")) {
TQFile cachef(cache_file);
if(cachef.open(IO_ReadOnly | IO_Translate)) {
TQFileInfo cachefi(cache_file);
@ -778,7 +778,7 @@ MakefileGenerator::init()
line = line.right(line.length() - sep - 1).stripWhiteSpace();
if(state == CacheInfo) {
if(file == "QMAKE_CACHE_VERSION") {
if(line != qmake_version())
if(line != tqmake_version())
break;
} else {
const TQStringList &l = project->variables()[file];
@ -829,7 +829,7 @@ MakefileGenerator::init()
}
}
}
if(found && line != "*qmake_ignore*") {
if(found && line != "*tqmake_ignore*") {
int ext_len = file.length() - file.findRev('.');
bool cpp_ext = FALSE;
for(TQStringList::Iterator cppit = Option::cpp_ext.begin();
@ -936,7 +936,7 @@ MakefileGenerator::init()
for(TQStringList::Iterator val_it = l.begin(); val_it != l.end(); ++val_it) {
bool found_cache_moc = FALSE, found_cache_dep = FALSE;
if(read_cache && Option::output.name() != "-" &&
project->isActiveConfig("qmake_cache")) {
project->isActiveConfig("tqmake_cache")) {
if(processedDependencies((*val_it)))
found_cache_dep = TRUE;
if(cache_found_files[(*val_it)] == (void *)2)
@ -961,7 +961,7 @@ MakefileGenerator::init()
}
}
} else if(tqmocAware() && (sources[x] == "SOURCES" || sources[x] == "HEADERS") &&
(Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT ||
(Option::tqmake_mode == Option::QMAKE_GENERATE_PROJECT ||
Option::mkfile::do_mocs)) {
generateMocList((*val_it));
}
@ -971,13 +971,13 @@ MakefileGenerator::init()
}
}
}
if(project->isActiveConfig("qmake_cache") && (write_cache || !read_cache)) {
if(project->isActiveConfig("tqmake_cache") && (write_cache || !read_cache)) {
TQFile cachef(cache_file);
if(cachef.open(IO_WriteOnly | IO_Translate)) {
debug_msg(2, "Writing internal cache information: %s", cache_file.latin1());
TQTextStream cachet(&cachef);
cachet << "[check]" << "\n"
<< "QMAKE_CACHE_VERSION = " << qmake_version() << "\n"
<< "QMAKE_CACHE_VERSION = " << tqmake_version() << "\n"
<< "QMAKE_ABSOLUTE_SOURCE_PATH = " << var("QMAKE_ABSOLUTE_SOURCE_PATH") << "\n"
<< "MOC_DIR = " << var("MOC_DIR") << "\n"
<< "UI_DIR = " << var("UI_DIR") << "\n"
@ -996,7 +996,7 @@ MakefileGenerator::init()
if(!f.isEmpty()) {
mc = mocablesToMOC[f];
if(mc.isEmpty())
mc = "*qmake_ignore*";
mc = "*tqmake_ignore*";
cachet << f << " = " << mc << endl;
}
}
@ -1171,7 +1171,7 @@ MakefileGenerator::init()
//Image files
if(!project->isEmpty("IMAGES")) {
if(project->isEmpty("QMAKE_IMAGE_COLLECTION"))
v["QMAKE_IMAGE_COLLECTION"].append("qmake_image_collection" + Option::cpp_ext.first());
v["QMAKE_IMAGE_COLLECTION"].append("tqmake_image_collection" + Option::cpp_ext.first());
TQString imgfile = project->first("QMAKE_IMAGE_COLLECTION");
Option::fixPathToTargetOS(imgfile);
if(!project->isEmpty("UI_DIR") || !project->isEmpty("UI_SOURCES_DIR")) {
@ -1418,8 +1418,8 @@ MakefileGenerator::write()
usePlatformDir();
init();
findLibraries();
if((Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE || //write prl
Option::qmake_mode == Option::QMAKE_GENERATE_PRL) &&
if((Option::tqmake_mode == Option::QMAKE_GENERATE_MAKEFILE || //write prl
Option::tqmake_mode == Option::QMAKE_GENERATE_PRL) &&
project->variables()["QMAKE_FAILED_REQUIREMENTS"].isEmpty() &&
project->isActiveConfig("create_prl") && project->first("TEMPLATE") == "lib" &&
!project->isActiveConfig("plugin")) {
@ -1443,12 +1443,12 @@ MakefileGenerator::write()
ft.close();
}
}
if(Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE &&
if(Option::tqmake_mode == Option::QMAKE_GENERATE_MAKEFILE &&
project->isActiveConfig("link_prl")) //load up prl's'
processPrlFiles();
if(Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE || //write prl file
Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT) {
if(Option::tqmake_mode == Option::QMAKE_GENERATE_MAKEFILE || //write prl file
Option::tqmake_mode == Option::QMAKE_GENERATE_PROJECT) {
TQTextStream t(&Option::output);
writeMakefile(t);
}
@ -2084,8 +2084,8 @@ TQString MakefileGenerator::buildArgs()
ret += " -nomoc";
if(!Option::mkfile::do_dep_heuristics)
ret += " -nodependheuristics";
if(!Option::mkfile::qmakespec_commandline.isEmpty())
ret += " -spec " + Option::mkfile::qmakespec_commandline;
if(!Option::mkfile::tqmakespec_commandline.isEmpty())
ret += " -spec " + Option::mkfile::tqmakespec_commandline;
//arguments
for(TQStringList::Iterator it = Option::before_user_vars.begin();
@ -2133,7 +2133,7 @@ MakefileGenerator::writeHeader(TQTextStream &t)
{
t << "#############################################################################" << endl;
t << "# Makefile for building: " << var("TARGET") << endl;
t << "# Generated by qmake (" << qmake_version() << ") (TQt " << TQT_VERSION_STR << ")" << endl;
t << "# Generated by tqmake (" << tqmake_version() << ") (TQt " << TQT_VERSION_STR << ")" << endl;
t << "# Project: " << fileFixify(project->projectFile()) << endl;
t << "# Template: " << var("TEMPLATE") << endl;
t << "# Command: " << build_args() << endl;
@ -2157,24 +2157,24 @@ MakefileGenerator::writeMakeQmake(TQTextStream &t)
TQString pfile = project->projectFile();
if(pfile != "(stdin)") {
TQString qmake = build_args();
TQString tqmake = build_args();
if(!ofile.isEmpty() && !project->isActiveConfig("no_autoqmake")) {
t << ofile << ": " << fileFixify(pfile) << " ";
if(Option::mkfile::do_cache)
t << fileFixify(Option::mkfile::cachefile) << " ";
if(!specdir().isEmpty()) {
if (TQFile::exists(Option::fixPathToLocalOS(specdir()+TQDir::separator()+"qmake.conf")))
t << specdir() << Option::dir_sep << "qmake.conf" << " ";
if (TQFile::exists(Option::fixPathToLocalOS(specdir()+TQDir::separator()+"tqmake.conf")))
t << specdir() << Option::dir_sep << "tqmake.conf" << " ";
else if (TQFile::exists(Option::fixPathToLocalOS(specdir()+TQDir::separator()+"tmake.conf")))
t << specdir() << Option::dir_sep << "tmake.conf" << " ";
}
t << project->variables()["QMAKE_INTERNAL_INCLUDED_FILES"].join(" \\\n\t\t") << "\n\t"
<< qmake <<endl;
<< tqmake <<endl;
}
if(project->first("QMAKE_ORIG_TARGET") != "tqmake") {
t << "qmake: " <<
t << "tqmake: " <<
project->variables()["QMAKE_INTERNAL_QMAKE_DEPS"].join(" \\\n\t\t") << "\n\t"
<< "@" << qmake << endl << endl;
<< "@" << tqmake << endl << endl;
}
}
return TRUE;
@ -2211,8 +2211,8 @@ MakefileGenerator::fileFixify(const TQString& file0, const TQString &out_d,
TQString file = file0;
int depth = 4;
if(Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
Option::qmake_mode == Option::QMAKE_GENERATE_PRL) {
if(Option::tqmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
Option::tqmake_mode == Option::QMAKE_GENERATE_PRL) {
if(project && !project->isEmpty("QMAKE_PROJECT_DEPTH"))
depth = project->first("QMAKE_PROJECT_DEPTH").toInt();
else if(Option::mkfile::cachefile_depth != -1)
@ -2379,7 +2379,7 @@ MakefileGenerator::specdir()
{
if(!spec.isEmpty())
return spec;
spec = Option::mkfile::qmakespec;
spec = Option::mkfile::tqmakespec;
#if 0
if(const char *d = getenv("TQTDIR")) {
TQString tqdir = Option::fixPathToTargetOS(TQString(d));
@ -2408,7 +2408,7 @@ MakefileGenerator::openOutput(TQFile &file) const
TQString outdir;
if(!file.name().isEmpty()) {
if(TQDir::isRelativePath(file.name()))
file.setName(Option::output_dir + file.name()); //pwd when qmake was run
file.setName(Option::output_dir + file.name()); //pwd when tqmake was run
TQFileInfo fi(file);
if(fi.isDir())
outdir = file.name() + TQDir::separator();
@ -2421,7 +2421,7 @@ MakefileGenerator::openOutput(TQFile &file) const
}
}
if(TQDir::isRelativePath(file.name()))
file.setName(Option::output_dir + file.name()); //pwd when qmake was run
file.setName(Option::output_dir + file.name()); //pwd when tqmake was run
if(project->isEmpty("QMAKE_MAKEFILE"))
project->variables()["QMAKE_MAKEFILE"].append(file.name());
int slsh = file.name().findRev(Option::dir_sep);
@ -2453,7 +2453,7 @@ MakefileGenerator::openOutput(TQFile &file) const
MakefileGenerator *
MakefileGenerator::create(TQMakeProject *proj)
{
if(Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT)
if(Option::tqmake_mode == Option::QMAKE_GENERATE_PROJECT)
return new ProjectGenerator(proj);
MakefileGenerator *mkfile = NULL;

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
@ -345,7 +345,7 @@ bool
ProjectGenerator::writeMakefile(TQTextStream &t)
{
t << "######################################################################" << endl;
t << "# Automatically generated by qmake (" << qmake_version() << ") " << endl;
t << "# Automatically generated by tqmake (" << tqmake_version() << ") " << endl;
t << "######################################################################" << endl << endl;
TQStringList::Iterator it;
for(it = Option::before_user_vars.begin(); it != Option::before_user_vars.end(); ++it)

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
@ -67,8 +67,8 @@ UnixMakefileGenerator::init()
project->variables()["MAKEFILE"].append("Makefile");
if(project->isEmpty("QMAKE"))
project->variables()["QMAKE"].append("tqmake");
if(project->variables()["QMAKE_INTERNAL_QMAKE_DEPS"].findIndex("qmake_all") == -1)
project->variables()["QMAKE_INTERNAL_QMAKE_DEPS"].append("qmake_all");
if(project->variables()["QMAKE_INTERNAL_QMAKE_DEPS"].findIndex("tqmake_all") == -1)
project->variables()["QMAKE_INTERNAL_QMAKE_DEPS"].append("tqmake_all");
return; /* subdirs is done */
}

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
@ -1077,7 +1077,7 @@ UnixMakefileGenerator::writeSubdirs(TQTextStream &t, bool direct)
mkfile.prepend((*it)->directory + Option::dir_sep);
if(direct || (*it)->makefile != "$(MAKEFILE)")
out = " -o " + (*it)->makefile;
//qmake it
//tqmake it
t << mkfile << ": " << "\n\t";
if(have_dir)
t << mkdir_p_asstring((*it)->directory) << "\n\t"
@ -1104,11 +1104,11 @@ UnixMakefileGenerator::writeSubdirs(TQTextStream &t, bool direct)
writeMakeQmake(t);
if(project->isEmpty("SUBDIRS")) {
t << "all qmake_all distclean uicables mocables install_subdirs uninstall_subdirs"
t << "all tqmake_all distclean uicables mocables install_subdirs uninstall_subdirs"
<< " uiclean mocclean lexclean yaccclean clean " << var("SUBDIR_TARGETS") << ": FORCE" << endl;
} else {
t << "all: $(SUBTARGETS)" << endl;
t << "qmake_all:";
t << "tqmake_all:";
for( it.toFirst(); it.current(); ++it) {
t << " ";
if(!(*it)->directory.isEmpty())
@ -1119,12 +1119,12 @@ UnixMakefileGenerator::writeSubdirs(TQTextStream &t, bool direct)
t << "\n\t ( ";
if(!(*it)->directory.isEmpty())
t << "[ -d " << (*it)->directory << " ] && cd " << (*it)->directory << " ; ";
t << "grep \"^qmake_all:\" " << (*it)->makefile
<< " && $(MAKE) -f " << (*it)->makefile << " qmake_all" << "; ) || true";
t << "grep \"^tqmake_all:\" " << (*it)->makefile
<< " && $(MAKE) -f " << (*it)->makefile << " tqmake_all" << "; ) || true";
}
t << endl;
t << "clean uicables mocables uiclean mocclean lexclean yaccclean "
<< var("SUBDIR_TARGETS") << ": qmake_all FORCE";
<< var("SUBDIR_TARGETS") << ": tqmake_all FORCE";
for( it.toFirst(); it.current(); ++it) {
t << "\n\t ( ";
if(!(*it)->directory.isEmpty())
@ -1132,7 +1132,7 @@ UnixMakefileGenerator::writeSubdirs(TQTextStream &t, bool direct)
t << "$(MAKE) -f " << (*it)->makefile << " $@" << "; ) || true";
}
t << endl;
t << "uninstall_subdirs: qmake_all FORCE";
t << "uninstall_subdirs: tqmake_all FORCE";
for( it.toFirst(); it.current(); ++it) {
t << "\n\t ( ";
if(!(*it)->directory.isEmpty())
@ -1140,7 +1140,7 @@ UnixMakefileGenerator::writeSubdirs(TQTextStream &t, bool direct)
t << "$(MAKE) -f " << (*it)->makefile << " uninstall" << "; ) || true";
}
t << endl;
t << "install_subdirs: qmake_all FORCE";
t << "install_subdirs: tqmake_all FORCE";
for( it.toFirst(); it.current(); ++it) {
t << "\n\t ( ";
if(!(*it)->directory.isEmpty())
@ -1148,7 +1148,7 @@ UnixMakefileGenerator::writeSubdirs(TQTextStream &t, bool direct)
t << "$(MAKE) -f " << (*it)->makefile << " install" << "; ) || true";
}
t << endl;
t << "distclean: qmake_all FORCE";
t << "distclean: tqmake_all FORCE";
for( it.toFirst(); it.current(); ++it) {
t << "\n\t ( ";
if(!(*it)->directory.isEmpty())
@ -1438,7 +1438,7 @@ UnixMakefileGenerator::writeLibtoolFile()
TQTextStream t(&ft);
t << "# " << lname << " - a libtool library file\n";
t << "# Generated by qmake/libtool (" << qmake_version() << ") (TQt "
t << "# Generated by tqmake/libtool (" << tqmake_version() << ") (TQt "
<< TQT_VERSION_STR << ")\n";
t << "# The name that we can dlopen(3).\n"
@ -1579,7 +1579,7 @@ UnixMakefileGenerator::writePkgConfigFile() // ### does make sense only for
<< endl;
// non-standard entry. Provides useful info normally only
// contained in the internal .qmake.cache file
// contained in the internal .tqmake.cache file
t << varGlue("CONFIG", "qt_config=", " ", "") << endl << endl;
t << "Name: TQt" << endl;

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
@ -139,7 +139,7 @@ MingwMakefileGenerator::writeMingwParts(TQTextStream &t)
Option::fixPathToTargetOS(var("QMAKE_MOC"), FALSE)) << endl;
t << "TQUIC = " << (project->isEmpty("QMAKE_UIC") ? TQString("tquic") :
Option::fixPathToTargetOS(var("QMAKE_UIC"), FALSE)) << endl;
t << "QMAKE = " << (project->isEmpty("QMAKE_QMAKE") ? TQString("qmake") :
t << "QMAKE = " << (project->isEmpty("QMAKE_QMAKE") ? TQString("tqmake") :
Option::fixPathToTargetOS(var("QMAKE_QMAKE"), FALSE)) << endl;
t << "IDC = " << (project->isEmpty("QMAKE_IDC") ? TQString("idc") :
Option::fixPathToTargetOS(var("QMAKE_IDC"), FALSE)) << endl;
@ -367,7 +367,7 @@ MingwMakefileGenerator::init()
if(project->variables()["MAKEFILE"].isEmpty())
project->variables()["MAKEFILE"].append("Makefile");
if(project->variables()["QMAKE"].isEmpty())
project->variables()["QMAKE"].append("qmake");
project->variables()["QMAKE"].append("tqmake");
return;
}

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
@ -979,7 +979,7 @@ DspMakefileGenerator::findTemplate(const TQString &file)
{
TQString ret;
if(!TQFile::exists((ret = file)) &&
!TQFile::exists((ret = TQString(Option::mkfile::qmakespec + "/" + file))) &&
!TQFile::exists((ret = TQString(Option::mkfile::tqmakespec + "/" + file))) &&
!TQFile::exists((ret = TQString(getenv("TQTDIR")) + "/mkspecs/win32-msvc/" + file)) &&
!TQFile::exists((ret = (TQString(getenv("HOME")) + "/.tmake/" + file))))
return "";
@ -1066,7 +1066,7 @@ DspMakefileGenerator::openOutput(TQFile &file) const
TQString outdir;
if(!file.name().isEmpty()) {
if(TQDir::isRelativePath(file.name()))
file.setName(Option::output_dir + file.name()); //pwd when qmake was run
file.setName(Option::output_dir + file.name()); //pwd when tqmake was run
TQFileInfo fi(file);
if(fi.isDir())
outdir = file.name() + TQDir::separator();

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
@ -149,7 +149,7 @@ NmakeMakefileGenerator::writeNmakeParts(TQTextStream &t)
Option::fixPathToTargetOS(var("QMAKE_MOC"), FALSE)) << endl;
t << "TQUIC = " << (project->isEmpty("QMAKE_UIC") ? TQString("tquic") :
Option::fixPathToTargetOS(var("QMAKE_UIC"), FALSE)) << endl;
t << "QMAKE = " << (project->isEmpty("QMAKE_QMAKE") ? TQString("qmake") :
t << "QMAKE = " << (project->isEmpty("QMAKE_QMAKE") ? TQString("tqmake") :
Option::fixPathToTargetOS(var("QMAKE_QMAKE"), FALSE)) << endl;
t << "IDC = " << (project->isEmpty("QMAKE_IDC") ? TQString("idc") :
Option::fixPathToTargetOS(var("QMAKE_IDC"), FALSE)) << endl;
@ -452,7 +452,7 @@ NmakeMakefileGenerator::init()
if(project->variables()["MAKEFILE"].isEmpty())
project->variables()["MAKEFILE"].append("Makefile");
if(project->variables()["QMAKE"].isEmpty())
project->variables()["QMAKE"].append("qmake");
project->variables()["QMAKE"].append("tqmake");
return;
}

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free

@ -4,7 +4,7 @@
**
** Copyright (C) 2002-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
@ -489,7 +489,7 @@ bool VCCLCompilerTool::parseOption( const char* option )
found = FALSE;
break;
case 'l':
tqWarning( "Generator: Option '/link': qmake generator does not support passing link options through the compiler tool" );
tqWarning( "Generator: Option '/link': tqmake generator does not support passing link options through the compiler tool" );
found = FALSE;
break;
case 'A':
@ -773,7 +773,7 @@ bool VCCLCompilerTool::parseOption( const char* option )
} else if ( second == 'P' ) {
CompileAs = compileAsCPlusPlus;
} else {
tqWarning( "Generator: Options '/Tp<filename>' and '/Tc<filename>' are not supported by qmake" );
tqWarning( "Generator: Options '/Tp<filename>' and '/Tc<filename>' are not supported by tqmake" );
found = FALSE; break;
}
break;

@ -4,7 +4,7 @@
**
** Copyright (C) 2002-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
@ -54,7 +54,7 @@ enum DotNET {
This Object model is of course VERY simplyfied,
and does not actually follow the original MSVC
object model. However, it fulfilles the basic
needs for qmake
needs for tqmake
*/
/*

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
@ -233,7 +233,7 @@ TQUuid VcprojGenerator::getProjectUUID(const TQString &filename)
if (uuid.isNull() || !validUUID) {
uuid = TQUuid::createUuid();
fprintf(stderr,
"qmake couldn't create a GUID based on filepath, and we couldn't\nfind a valid GUID in the .pro file (Consider adding\n'GUID = %s' to the .pro file)\n",
"tqmake couldn't create a GUID based on filepath, and we couldn't\nfind a valid GUID in the .pro file (Consider adding\n'GUID = %s' to the .pro file)\n",
uuid.toString().upper().latin1());
}
@ -723,7 +723,7 @@ void VcprojGenerator::initCompilerTool()
RConf.compiler.PreprocessorDefinitions += project->variables()["MSVCPROJ_WINCONDEF"];
// Can this be set for ALL configs?
// If so, use qmake.conf!
// If so, use tqmake.conf!
if ( projectTarget == SharedLib )
RConf.compiler.PreprocessorDefinitions += "_WINDOWS";
@ -1422,7 +1422,7 @@ TQString VcprojGenerator::findTemplate(TQString file)
{
TQString ret;
if(!TQFile::exists((ret = file)) &&
!TQFile::exists((ret = TQString(Option::mkfile::qmakespec + "/" + file))) &&
!TQFile::exists((ret = TQString(Option::mkfile::tqmakespec + "/" + file))) &&
!TQFile::exists((ret = TQString(getenv("TQTDIR")) + "/mkspecs/win32-msvc.net/" + file)) &&
!TQFile::exists((ret = (TQString(getenv("HOME")) + "/.tmake/" + file))))
return "";

@ -5,7 +5,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
@ -100,7 +100,7 @@ Win32MakefileGenerator::writeSubDirs(TQTextStream &t)
TQPtrListIterator<SubDir> it(subdirs);
t << "MAKEFILE = " << (project->isEmpty("MAKEFILE") ? TQString("Makefile") : var("MAKEFILE")) << endl;
t << "QMAKE = " << (project->isEmpty("QMAKE_QMAKE") ? TQString("qmake") : var("QMAKE_QMAKE")) << endl;
t << "QMAKE = " << (project->isEmpty("QMAKE_QMAKE") ? TQString("tqmake") : var("QMAKE_QMAKE")) << endl;
t << "SUBTARGETS = ";
for( it.toFirst(); it.current(); ++it)
t << " \\\n\t\t" << it.current()->target;
@ -154,11 +154,11 @@ Win32MakefileGenerator::writeSubDirs(TQTextStream &t)
t << endl;
}
if(project->variables()["QMAKE_INTERNAL_QMAKE_DEPS"].findIndex("qmake_all") == -1)
project->variables()["QMAKE_INTERNAL_QMAKE_DEPS"].append("qmake_all");
if(project->variables()["QMAKE_INTERNAL_QMAKE_DEPS"].findIndex("tqmake_all") == -1)
project->variables()["QMAKE_INTERNAL_QMAKE_DEPS"].append("tqmake_all");
writeMakeQmake(t);
t << "qmake_all:";
t << "tqmake_all:";
if ( !subdirs.isEmpty() ) {
for( it.toFirst(); it.current(); ++it) {
bool have_dir = !(*it)->directory.isEmpty();
@ -192,7 +192,7 @@ Win32MakefileGenerator::writeSubDirs(TQTextStream &t)
targs << "clean" << "install_subdirs" << "mocables" << "uicables" << "uiclean" << "mocclean";
targs += project->values("SUBDIR_TARGETS");
for(TQStringList::Iterator targ_it = targs.begin(); targ_it != targs.end(); ++targ_it) {
t << (*targ_it) << ": qmake_all";
t << (*targ_it) << ": tqmake_all";
TQString targ = (*targ_it);
if(targ == "install_subdirs")
targ = "install";

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
@ -98,19 +98,19 @@ int main(int argc, char **argv)
}
TQMakeProperty prop;
if(Option::qmake_mode == Option::QMAKE_QUERY_PROPERTY || Option::qmake_mode == Option::QMAKE_SET_PROPERTY)
if(Option::tqmake_mode == Option::QMAKE_QUERY_PROPERTY || Option::tqmake_mode == Option::QMAKE_SET_PROPERTY)
return prop.exec() ? 0 : 101;
TQMakeProject proj(&prop);
int exit_val = 0;
TQStringList files;
if(Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT)
if(Option::tqmake_mode == Option::QMAKE_GENERATE_PROJECT)
files << "(*hack*)"; //we don't even use files, but we do the for() body once
else
files = Option::mkfile::project_files;
for(TQStringList::Iterator pfile = files.begin(); pfile != files.end(); pfile++) {
if(Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
Option::qmake_mode == Option::QMAKE_GENERATE_PRL) {
if(Option::tqmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
Option::tqmake_mode == Option::QMAKE_GENERATE_PRL) {
TQString fn = Option::fixPathToLocalOS((*pfile));
//setup pwd properly
@ -145,8 +145,8 @@ int main(int argc, char **argv)
bool using_stdout = FALSE;
MakefileGenerator *mkfile = MakefileGenerator::create(&proj); //figure out generator
if(mkfile && (Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT)) {
if(mkfile && (Option::tqmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
Option::tqmake_mode == Option::QMAKE_GENERATE_PROJECT)) {
//open output
if(!(Option::output.state() & IO_Open)) {
if(Option::output.name() == "-") {
@ -155,7 +155,7 @@ int main(int argc, char **argv)
Option::output.open(IO_WriteOnly | IO_Translate, stdout);
using_stdout = TRUE;
} else {
if(Option::output.name().isEmpty() && Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE)
if(Option::output.name().isEmpty() && Option::tqmake_mode == Option::QMAKE_GENERATE_MAKEFILE)
Option::output.setName(proj.first("QMAKE_MAKEFILE"));
Option::output_dir = oldpwd;
if(!mkfile->openOutput(Option::output)) {
@ -169,7 +169,7 @@ int main(int argc, char **argv)
using_stdout = TRUE; //kind of..
}
if(mkfile && !mkfile->write()) {
if(Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT)
if(Option::tqmake_mode == Option::QMAKE_GENERATE_PROJECT)
fprintf(stderr, "Unable to generate project file.\n");
else
fprintf(stderr, "Unable to generate makefile for: %s\n", (*pfile).latin1());

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
@ -62,7 +62,7 @@ TQString Option::yacc_mod;
TQString Option::lex_mod;
//mode
Option::QMAKE_MODE Option::qmake_mode = Option::QMAKE_GENERATE_NOTHING;
Option::QMAKE_MODE Option::tqmake_mode = Option::QMAKE_GENERATE_NOTHING;
//all modes
int Option::warn_level = WarnLogic;
@ -94,7 +94,7 @@ bool Option::projfile::do_recursive = TRUE;
TQStringList Option::projfile::project_dirs;
//QMAKE_GENERATE_MAKEFILE stuff
TQString Option::mkfile::qmakespec;
TQString Option::mkfile::tqmakespec;
int Option::mkfile::cachefile_depth = -1;
bool Option::mkfile::do_deps = TRUE;
bool Option::mkfile::do_mocs = TRUE;
@ -103,14 +103,14 @@ bool Option::mkfile::do_preprocess = FALSE;
bool Option::mkfile::do_cache = TRUE;
TQString Option::mkfile::cachefile;
TQStringList Option::mkfile::project_files;
TQString Option::mkfile::qmakespec_commandline;
TQString Option::mkfile::tqmakespec_commandline;
static Option::QMAKE_MODE default_mode(TQString progname)
{
int s = progname.findRev(Option::dir_sep);
if(s != -1)
progname = progname.right(progname.length() - (s + 1));
if(progname == "qmakegen")
if(progname == "tqmakegen")
return Option::QMAKE_GENERATE_PROJECT;
else if(progname == "qt-config")
return Option::QMAKE_QUERY_PROPERTY;
@ -125,16 +125,16 @@ bool usage(const char *a0)
" TQMake has two modes, one mode for generating project files based on\n"
"some heuristics, and the other for generating makefiles. Normally you\n"
"shouldn't need to specify a mode, as makefile generation is the default\n"
"mode for qmake, but you may use this to test qmake on an existing project\n"
"mode for tqmake, but you may use this to test tqmake on an existing project\n"
"\n"
"Mode:\n"
"\t-project Put qmake into project file generation mode%s\n"
"\t In this mode qmake interprets files as files to\n"
"\t-project Put tqmake into project file generation mode%s\n"
"\t In this mode tqmake interprets files as files to\n"
"\t be built,\n"
"\t defaults to %s\n"
"\t-makefile Put qmake into makefile generation mode%s\n"
"\t In this mode qmake interprets files as project files to\n"
"\t be processed, if skipped qmake will try to find a project\n"
"\t-makefile Put tqmake into makefile generation mode%s\n"
"\t In this mode tqmake interprets files as project files to\n"
"\t be processed, if skipped tqmake will try to find a project\n"
"\t file in your current working directory\n"
"\n"
"Warnings Options:\n"
@ -188,17 +188,17 @@ Option::internalParseCommandLine(int argc, char **argv, int skip)
if(x == 1) {
bool specified = TRUE;
if(opt == "project") {
Option::qmake_mode = Option::QMAKE_GENERATE_PROJECT;
Option::tqmake_mode = Option::QMAKE_GENERATE_PROJECT;
} else if(opt == "prl") {
Option::mkfile::do_deps = FALSE;
Option::mkfile::do_mocs = FALSE;
Option::qmake_mode = Option::QMAKE_GENERATE_PRL;
Option::tqmake_mode = Option::QMAKE_GENERATE_PRL;
} else if(opt == "set") {
Option::qmake_mode = Option::QMAKE_SET_PROPERTY;
Option::tqmake_mode = Option::QMAKE_SET_PROPERTY;
} else if(opt == "query") {
Option::qmake_mode = Option::QMAKE_QUERY_PROPERTY;
Option::tqmake_mode = Option::QMAKE_QUERY_PROPERTY;
} else if(opt == "makefile") {
Option::qmake_mode = Option::QMAKE_GENERATE_MAKEFILE;
Option::tqmake_mode = Option::QMAKE_GENERATE_MAKEFILE;
} else {
specified = FALSE;
}
@ -225,8 +225,8 @@ Option::internalParseCommandLine(int argc, char **argv, int skip)
} else if(opt == "d") {
Option::debug_level++;
} else if(opt == "version" || opt == "v" || opt == "-version") {
fprintf(stderr, "Qmake version: %s (TQt %s)\n", qmake_version(), TQT_VERSION_STR);
fprintf(stderr, "Qmake is free software from Trolltech ASA.\n");
fprintf(stderr, "TQMake version: %s (TQt %s)\n", tqmake_version(), TQT_VERSION_STR);
fprintf(stderr, "TQMake is free software from Trolltech ASA.\n");
return QMAKE_CMDLINE_BAIL;
} else if(opt == "h" || opt == "help") {
return QMAKE_CMDLINE_SHOW_USAGE;
@ -239,8 +239,8 @@ Option::internalParseCommandLine(int argc, char **argv, int skip)
} else if(opt == "Wnone") {
Option::warn_level = WarnNone;
} else {
if(Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
Option::qmake_mode == Option::QMAKE_GENERATE_PRL) {
if(Option::tqmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
Option::tqmake_mode == Option::QMAKE_GENERATE_PRL) {
if(opt == "nodepend") {
Option::mkfile::do_deps = FALSE;
} else if(opt == "nomoc") {
@ -254,13 +254,13 @@ Option::internalParseCommandLine(int argc, char **argv, int skip)
} else if(opt == "cache") {
Option::mkfile::cachefile = argv[++x];
} else if(opt == "platform" || opt == "spec") {
Option::mkfile::qmakespec = argv[++x];
Option::mkfile::qmakespec_commandline = argv[x];
Option::mkfile::tqmakespec = argv[++x];
Option::mkfile::tqmakespec_commandline = argv[x];
} else {
fprintf(stderr, "***Unknown option -%s\n", opt.latin1());
return QMAKE_CMDLINE_SHOW_USAGE;
}
} else if(Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT) {
} else if(Option::tqmake_mode == Option::QMAKE_GENERATE_PROJECT) {
if(opt == "nopwd") {
Option::projfile::do_pwd = FALSE;
} else if(opt == "r") {
@ -282,17 +282,17 @@ Option::internalParseCommandLine(int argc, char **argv, int skip)
Option::after_user_vars.append(arg);
} else {
bool handled = TRUE;
if(Option::qmake_mode == Option::QMAKE_QUERY_PROPERTY ||
Option::qmake_mode == Option::QMAKE_SET_PROPERTY) {
if(Option::tqmake_mode == Option::QMAKE_QUERY_PROPERTY ||
Option::tqmake_mode == Option::QMAKE_SET_PROPERTY) {
Option::prop::properties.append(arg);
} else {
TQFileInfo fi(arg);
if(!fi.convertToAbs()) //strange
arg = fi.filePath();
if(Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
Option::qmake_mode == Option::QMAKE_GENERATE_PRL)
if(Option::tqmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
Option::tqmake_mode == Option::QMAKE_GENERATE_PRL)
Option::mkfile::project_files.append(arg);
else if(Option::qmake_mode == Option::QMAKE_GENERATE_PROJECT)
else if(Option::tqmake_mode == Option::QMAKE_GENERATE_PROJECT)
Option::projfile::project_dirs.append(arg);
else
handled = FALSE;
@ -325,8 +325,8 @@ Option::parseCommandLine(int argc, char **argv)
Option::lex_ext = ".l";
Option::yacc_ext = ".y";
if(Option::qmake_mode == Option::QMAKE_GENERATE_NOTHING)
Option::qmake_mode = default_mode(argv[0]);
if(Option::tqmake_mode == Option::QMAKE_GENERATE_NOTHING)
Option::tqmake_mode = default_mode(argv[0]);
if(const char *envflags = getenv("QMAKEFLAGS")) {
int env_argc = 0, env_size = 0, currlen=0;
char quote = 0, **env_argv = NULL;
@ -374,10 +374,10 @@ Option::parseCommandLine(int argc, char **argv)
}
//last chance for defaults
if(Option::qmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
Option::qmake_mode == Option::QMAKE_GENERATE_PRL) {
if(Option::mkfile::qmakespec.isNull() || Option::mkfile::qmakespec.isEmpty())
Option::mkfile::qmakespec = getenv("QMAKESPEC");
if(Option::tqmake_mode == Option::QMAKE_GENERATE_MAKEFILE ||
Option::tqmake_mode == Option::QMAKE_GENERATE_PRL) {
if(Option::mkfile::tqmakespec.isNull() || Option::mkfile::tqmakespec.isEmpty())
Option::mkfile::tqmakespec = getenv("QMAKESPEC");
//try REALLY hard to do it for them, lazy..
if(Option::mkfile::project_files.isEmpty()) {
@ -509,7 +509,7 @@ Option::fixPathToLocalOS(const TQString& in, bool fix_env, bool canonical)
#endif
}
const char *qmake_version()
const char *tqmake_version()
{
static char *ret = NULL;
if(ret)

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
@ -47,7 +47,7 @@
#define QMAKE_VERSION_MAJOR 1
#define QMAKE_VERSION_MINOR 7
#define QMAKE_VERSION_PATCH 0
const char *qmake_version();
const char *tqmake_version();
void fixEnvVariables(TQString &x);
void debug_msg(int level, const char *fmt, ...);
@ -87,10 +87,10 @@ struct Option
static TQString fixPathToLocalOS(const TQString& in, bool fix_env=TRUE, bool canonical=TRUE);
static TQString fixPathToTargetOS(const TQString& in, bool fix_env=TRUE, bool canonical=TRUE);
//global qmake mode, can only be in one mode per invocation!
//global tqmake mode, can only be in one mode per invocation!
enum QMAKE_MODE { QMAKE_GENERATE_NOTHING, QMAKE_GENERATE_PROJECT, QMAKE_GENERATE_MAKEFILE,
QMAKE_GENERATE_PRL, QMAKE_SET_PROPERTY, QMAKE_QUERY_PROPERTY };
static QMAKE_MODE qmake_mode;
static QMAKE_MODE tqmake_mode;
//all modes
static TQFile output;
@ -117,7 +117,7 @@ struct Option
//QMAKE_GENERATE_MAKEFILE options
struct mkfile {
static TQString qmakespec;
static TQString tqmakespec;
static bool do_cache;
static bool do_deps;
static bool do_mocs;
@ -126,7 +126,7 @@ struct Option
static TQString cachefile;
static int cachefile_depth;
static TQStringList project_files;
static TQString qmakespec_commandline;
static TQString tqmakespec_commandline;
};
private:

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
@ -61,25 +61,25 @@ struct parser_info {
int line_no;
} parser;
static void qmake_error_msg(const char *msg)
static void tqmake_error_msg(const char *msg)
{
fprintf(stderr, "%s:%d: %s\n", parser.file.latin1(), parser.line_no, msg);
}
TQStringList qmake_mkspec_paths()
TQStringList tqmake_mkspec_paths()
{
TQStringList ret;
const TQString concat = TQDir::separator() + TQString("mkspecs");
if(const char *qmakepath = getenv("QMAKEPATH")) {
if(const char *tqmakepath = getenv("QMAKEPATH")) {
#ifdef Q_OS_WIN
TQStringList lst = TQStringList::split(';', qmakepath);
TQStringList lst = TQStringList::split(';', tqmakepath);
for(TQStringList::Iterator it = lst.begin(); it != lst.end(); ++it) {
TQStringList lst2 = TQStringList::split(':', (*it));
for(TQStringList::Iterator it2 = lst2.begin(); it2 != lst2.end(); ++it2)
ret << ((*it2) + concat);
}
#else
TQStringList lst = TQStringList::split(':', qmakepath);
TQStringList lst = TQStringList::split(':', tqmakepath);
for(TQStringList::Iterator it = lst.begin(); it != lst.end(); ++it)
ret << ((*it) + concat);
#endif
@ -254,7 +254,7 @@ TQMakeProject::parse(const TQString &t, TQMap<TQString, TQStringList> &place)
SKIP_WS(k);
if(*k == '=') {
TQString msg;
qmake_error_msg(*d + "must be followed immediately by =");
tqmake_error_msg(*d + "must be followed immediately by =");
return FALSE;
}
}
@ -276,7 +276,7 @@ TQMakeProject::parse(const TQString &t, TQMap<TQString, TQStringList> &place)
bool test = scope_failed;
if(scope.lower() == "else") {
if(scope_count != 1 || test_status == TestNone) {
qmake_error_msg("Unexpected " + scope + " ('" + s + "')");
tqmake_error_msg("Unexpected " + scope + " ('" + s + "')");
return FALSE;
}
else_line = TRUE;
@ -297,7 +297,7 @@ TQMakeProject::parse(const TQString &t, TQMap<TQString, TQStringList> &place)
TQCString error;
error.sprintf("Function missing right paren: %s ('%s')",
comp_scope.latin1(), s.latin1());
qmake_error_msg(error);
tqmake_error_msg(error);
return FALSE;
}
TQString func = comp_scope.left(lparen);
@ -349,7 +349,7 @@ TQMakeProject::parse(const TQString &t, TQMap<TQString, TQStringList> &place)
test_status = (scope_failed ? TestSeek : TestFound);
if(!*d) {
if(!var.stripWhiteSpace().isEmpty())
qmake_error_msg("Parse Error ('" + s + "')");
tqmake_error_msg("Parse Error ('" + s + "')");
return var.isEmpty(); /* allow just a scope */
}
@ -399,20 +399,20 @@ TQMakeProject::parse(const TQString &t, TQMap<TQString, TQStringList> &place)
/* now do the operation */
if(op == "~=") {
if(vallist.count() != 1) {
qmake_error_msg("~= operator only accepts one right hand paramater ('" +
tqmake_error_msg("~= operator only accepts one right hand paramater ('" +
s + "')");
return FALSE;
}
TQString val(vallist.first());
if(val.length() < 4 || val.at(0) != 's') {
qmake_error_msg("~= operator only can handle s/// function ('" +
tqmake_error_msg("~= operator only can handle s/// function ('" +
s + "')");
return FALSE;
}
TQChar sep = val.at(1);
TQStringList func = TQStringList::split(sep, val, TRUE);
if(func.count() < 3 || func.count() > 4) {
qmake_error_msg("~= operator only can handle s/// function ('" +
tqmake_error_msg("~= operator only can handle s/// function ('" +
s + "')");
return FALSE;
}
@ -533,7 +533,7 @@ TQMakeProject::read(uchar cmd)
if(Option::mkfile::cachefile.isEmpty()) { //find it as it has not been specified
TQString dir = TQDir::convertSeparators(Option::output_dir);
while(!TQFile::exists((Option::mkfile::cachefile = dir +
TQDir::separator() + ".qmake.cache"))) {
TQDir::separator() + ".tqmake.cache"))) {
dir = dir.left(dir.findRev(TQDir::separator()));
if(dir.isEmpty() || dir.find(TQDir::separator()) == -1) {
Option::mkfile::cachefile = "";
@ -547,34 +547,34 @@ TQMakeProject::read(uchar cmd)
}
if(!Option::mkfile::cachefile.isEmpty()) {
read(Option::mkfile::cachefile, cache);
if(Option::mkfile::qmakespec.isEmpty() && !cache["QMAKESPEC"].isEmpty())
Option::mkfile::qmakespec = cache["QMAKESPEC"].first();
if(Option::mkfile::tqmakespec.isEmpty() && !cache["QMAKESPEC"].isEmpty())
Option::mkfile::tqmakespec = cache["QMAKESPEC"].first();
}
}
if(cmd & ReadConf) { /* parse mkspec */
TQStringList mkspec_roots = qmake_mkspec_paths();
if(Option::mkfile::qmakespec.isEmpty()) {
TQStringList mkspec_roots = tqmake_mkspec_paths();
if(Option::mkfile::tqmakespec.isEmpty()) {
for(TQStringList::Iterator it = mkspec_roots.begin(); it != mkspec_roots.end(); ++it) {
TQString mkspec = (*it) + TQDir::separator() + "default";
TQFileInfo default_info(mkspec);
if(default_info.exists() && default_info.isSymLink()) {
Option::mkfile::qmakespec = mkspec;
Option::mkfile::tqmakespec = mkspec;
break;
}
}
if(Option::mkfile::qmakespec.isEmpty()) {
if(Option::mkfile::tqmakespec.isEmpty()) {
fprintf(stderr, "QMAKESPEC has not been set, so configuration cannot be deduced.\n");
return FALSE;
}
}
if(TQDir::isRelativePath(Option::mkfile::qmakespec)) {
if(TQDir::isRelativePath(Option::mkfile::tqmakespec)) {
bool found_mkspec = FALSE;
for(TQStringList::Iterator it = mkspec_roots.begin(); it != mkspec_roots.end(); ++it) {
TQString mkspec = (*it) + TQDir::separator() + Option::mkfile::qmakespec;
TQString mkspec = (*it) + TQDir::separator() + Option::mkfile::tqmakespec;
if(TQFile::exists(mkspec)) {
found_mkspec = TRUE;
Option::mkfile::qmakespec = mkspec;
Option::mkfile::tqmakespec = mkspec;
break;
}
}
@ -585,13 +585,13 @@ TQMakeProject::read(uchar cmd)
}
}
/* parse qmake configuration */
while(Option::mkfile::qmakespec.endsWith(TQString(TQChar(TQDir::separator()))))
Option::mkfile::qmakespec.truncate(Option::mkfile::qmakespec.length()-1);
TQString spec = Option::mkfile::qmakespec + TQDir::separator() + "qmake.conf";
/* parse tqmake configuration */
while(Option::mkfile::tqmakespec.endsWith(TQString(TQChar(TQDir::separator()))))
Option::mkfile::tqmakespec.truncate(Option::mkfile::tqmakespec.length()-1);
TQString spec = Option::mkfile::tqmakespec + TQDir::separator() + "tqmake.conf";
if(!TQFile::exists(spec) &&
TQFile::exists(Option::mkfile::qmakespec + TQDir::separator() + "tmake.conf"))
spec = Option::mkfile::qmakespec + TQDir::separator() + "tmake.conf";
TQFile::exists(Option::mkfile::tqmakespec + TQDir::separator() + "tmake.conf"))
spec = Option::mkfile::tqmakespec + TQDir::separator() + "tmake.conf";
debug_msg(1, "QMAKESPEC conf: reading %s", spec.latin1());
if(!read(spec, base_vars)) {
fprintf(stderr, "Failure to read QMAKESPEC conf file %s.\n", spec.latin1());
@ -715,8 +715,8 @@ TQMakeProject::isActiveConfig(const TQString &x, bool regex, TQMap<TQString, TQS
TQRegExp re(x, FALSE, TRUE);
TQString spec = Option::mkfile::qmakespec.right(Option::mkfile::qmakespec.length() -
(Option::mkfile::qmakespec.findRev(TQDir::separator())+1));
TQString spec = Option::mkfile::tqmakespec.right(Option::mkfile::tqmakespec.length() -
(Option::mkfile::tqmakespec.findRev(TQDir::separator())+1));
if((regex && re.exactMatch(spec)) || (!regex && spec == x))
return TRUE;
#ifdef Q_OS_UNIX
@ -724,7 +724,7 @@ TQMakeProject::isActiveConfig(const TQString &x, bool regex, TQMap<TQString, TQS
static char *buffer = NULL;
if(!buffer)
buffer = (char *)malloc(1024);
int l = readlink(Option::mkfile::qmakespec, buffer, 1023);
int l = readlink(Option::mkfile::tqmakespec, buffer, 1023);
if(l != -1) {
buffer[l] = '\0';
TQString r = buffer;
@ -910,21 +910,21 @@ TQMakeProject::doProjectTest(const TQString& func, TQStringList args, TQMap<TQSt
feature_roots += TQStringList::split(':', mkspec_path);
#endif
}
if(const char *qmakepath = getenv("QMAKEPATH")) {
if(const char *tqmakepath = getenv("QMAKEPATH")) {
#ifdef Q_OS_WIN
TQStringList lst = TQStringList::split(';', qmakepath);
TQStringList lst = TQStringList::split(';', tqmakepath);
for(TQStringList::Iterator it = lst.begin(); it != lst.end(); ++it) {
TQStringList lst2 = TQStringList::split(':', (*it));
for(TQStringList::Iterator it2 = lst2.begin(); it2 != lst2.end(); ++it2)
feature_roots << ((*it2) + concat);
}
#else
TQStringList lst = TQStringList::split(':', qmakepath);
TQStringList lst = TQStringList::split(':', tqmakepath);
for(TQStringList::Iterator it = lst.begin(); it != lst.end(); ++it)
feature_roots << ((*it) + concat);
#endif
}
feature_roots << Option::mkfile::qmakespec;
feature_roots << Option::mkfile::tqmakespec;
if(const char *qtdir = getenv("TQTDIR"))
feature_roots << (qtdir + concat);
#ifdef QT_INSTALL_PREFIX
@ -1051,7 +1051,7 @@ TQMakeProject::doProjectCheckReqs(const TQStringList &deps, TQMap<TQString, TQSt
if(rparen == -1) {
TQCString error;
error.sprintf("Function (in REQUIRES) missing right paren: %s", chk.latin1());
qmake_error_msg(error);
tqmake_error_msg(error);
} else {
TQString func = chk.left(lparen);
test = doProjectTest(func, chk.mid(lparen+1, rparen - lparen - 1), place);

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
@ -44,7 +44,7 @@
#include <tqstringlist.h>
#include <stdio.h>
TQStringList qmake_mkspec_paths(); //project.cpp
TQStringList tqmake_mkspec_paths(); //project.cpp
TQMakeProperty::TQMakeProperty() : sett(NULL)
{
@ -70,7 +70,7 @@ TQMakeProperty::keyBase(bool version) const
{
TQString ret = "/TQMake/properties/";
if(version)
ret += TQString(qmake_version()) + "/";
ret += TQString(tqmake_version()) + "/";
return ret;
}
@ -91,9 +91,9 @@ TQMakeProperty::value(TQString v, bool just_check)
return tqInstallPathData();
#endif
} else if(v == "QMAKE_MKSPECS") {
return qmake_mkspec_paths().join(Option::target_mode == Option::TARG_WIN_MODE ? ";" : ":");
return tqmake_mkspec_paths().join(Option::target_mode == Option::TARG_WIN_MODE ? ";" : ":");
} else if(v == "QMAKE_VERSION") {
return qmake_version();
return tqmake_version();
}
if(initSettings()) {
@ -101,7 +101,7 @@ TQMakeProperty::value(TQString v, bool just_check)
int slash = v.findRev('/');
TQString ret = sett->readEntry(keyBase(slash == -1) + v, TQString::null, &ok);
if(!ok) {
TQString version = qmake_version();
TQString version = tqmake_version();
if(slash != -1) {
version = v.left(slash-1);
v = v.mid(slash+1);
@ -144,7 +144,7 @@ bool
TQMakeProperty::exec()
{
bool ret = TRUE;
if(Option::qmake_mode == Option::QMAKE_QUERY_PROPERTY) {
if(Option::tqmake_mode == Option::QMAKE_QUERY_PROPERTY) {
if(Option::prop::properties.isEmpty() && initSettings()) {
TQStringList subs = sett->subkeyList(keyBase(FALSE));
subs.sort();
@ -154,7 +154,7 @@ TQMakeProperty::exec()
TQStringList keys = sett->entryList(keyBase(FALSE) + (*it));
for(TQStringList::Iterator it2 = keys.begin(); it2 != keys.end(); it2++) {
TQString ret = sett->readEntry(keyBase(FALSE) + (*it) + "/" + (*it2));
if((*it) != qmake_version())
if((*it) != tqmake_version())
fprintf(stdout, "%s/", (*it).latin1());
fprintf(stdout, "%s:%s\n", (*it2).latin1(), ret.latin1());
}
@ -172,7 +172,7 @@ TQMakeProperty::exec()
fprintf(stdout, "%s\n", value((*it)).latin1());
}
}
} else if(Option::qmake_mode == Option::QMAKE_SET_PROPERTY) {
} else if(Option::tqmake_mode == Option::QMAKE_SET_PROPERTY) {
for(TQStringList::Iterator it = Option::prop::properties.begin();
it != Option::prop::properties.end(); it++) {
TQString var = (*it);

@ -4,7 +4,7 @@
**
** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
**
** This file is part of qmake.
** This file is part of tqmake.
**
** This file may be used under the terms of the GNU General
** Public License versions 2.0 or 3.0 as published by the Free
Loading…
Cancel
Save