diff options
Diffstat (limited to 'tqtinterface/qt4/src/tools/tqglobal.h')
| -rw-r--r-- | tqtinterface/qt4/src/tools/tqglobal.h | 1135 |
1 files changed, 1135 insertions, 0 deletions
diff --git a/tqtinterface/qt4/src/tools/tqglobal.h b/tqtinterface/qt4/src/tools/tqglobal.h new file mode 100644 index 0000000..3fe0fb0 --- /dev/null +++ b/tqtinterface/qt4/src/tools/tqglobal.h @@ -0,0 +1,1135 @@ +/**************************************************************************** +** +** Global type declarations and definitions +** +** Created : 920529 +** +** Copyright (C) 2010 Timothy Pearson and (C) 1992-2008 Trolltech ASA. +** +** This file is part of the tools module of the TQt GUI Toolkit. +** +** 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 +** Software Foundation and appearing in the files LICENSE.GPL2 +** and LICENSE.GPL3 included in the packaging of this file. +** Alternatively you may (at your option) use any later version +** of the GNU General Public License if such license has been +** publicly approved by Trolltech ASA (or its successors, if any) +** and the KDE Free TQt Foundation. +** +** Please review the following information to ensure GNU General +** Public Licensing requirements will be met: +** http://trolltech.com/products/qt/licenses/licensing/opensource/. +** If you are unsure which license is appropriate for your use, please +** review the following information: +** http://trolltech.com/products/qt/licenses/licensing/licensingoverview +** or contact the sales department at sales@trolltech.com. +** +** This file may be used under the terms of the Q Public License as +** defined by Trolltech ASA and appearing in the file LICENSE.TQPL +** included in the packaging of this file. Licensees holding valid TQt +** Commercial licenses may use this file in accordance with the TQt +** Commercial License Agreement provided with the Software. +** +** This file is provided "AS IS" with NO WARRANTY OF ANY KIND, +** INCLUDING THE WARRANTIES OF DESIGN, MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE. Trolltech reserves all rights not granted +** herein. +** +**********************************************************************/ + +#ifndef TQGLOBAL_H +#define TQGLOBAL_H + +#define TQT_VERSION_STR "3.4.0" +/* + TQT_VERSION is (major << 16) + (minor << 8) + patch. + */ +#define TQT_VERSION 0x030400 + +/* + The operating system, must be one of: (TQ_OS_x) + + MACX - Mac OS X + MAC9 - Mac OS 9 + DARWIN - Darwin OS (Without Mac OS X) + MSDOS - MS-DOS and Windows + OS2 - OS/2 + OS2EMX - XFree86 on OS/2 (not PM) + WIN32 - Win32 (Windows 95/98/ME and Windows NT/2000/XP) + CYGWIN - Cygwin + SOLARIS - Sun Solaris + HPUX - HP-UX + ULTRIX - DEC Ultrix + LINUX - Linux + FREEBSD - FreeBSD + NETBSD - NetBSD + OPENBSD - OpenBSD + BSDI - BSD/OS + IRIX - SGI Irix + OSF - HP Tru64 UNIX + SCO - SCO OpenServer 5 + UNIXWARE - UnixWare 7, Open UNIX 8 + AIX - AIX + HURD - GNU Hurd + DGUX - DG/UX + RELIANT - Reliant UNIX + DYNIX - DYNIX/ptx + TQNX - TQNX + TQNX6 - TQNX RTP 6.1 + LYNX - LynxOS + BSD4 - Any BSD 4.4 system + UNIX - Any UNIX BSD/SYSV system +*/ + +#if defined(__DARWIN_X11__) +# define TQ_OS_DARWIN +#elif defined(__APPLE__) && (defined(__GNUC__) || defined(__xlC__)) +# define TQ_OS_MACX +#elif defined(__MACOSX__) +# define TQ_OS_MACX +#elif defined(macintosh) +# define TQ_OS_MAC9 +#elif defined(__CYGWIN__) +# define TQ_OS_CYGWIN +#elif defined(MSDOS) || defined(_MSDOS) +# define TQ_OS_MSDOS +#elif defined(__OS2__) +# if defined(__EMX__) +# define TQ_OS_OS2EMX +# else +# define TQ_OS_OS2 +# endif +#elif !defined(SAG_COM) && (defined(WIN64) || defined(_WIN64) || defined(__WIN64__)) +# define TQ_OS_WIN32 +# define TQ_OS_WIN64 +#elif !defined(SAG_COM) && (defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)) +# define TQ_OS_WIN32 +#elif defined(__MWERKS__) && defined(__INTEL__) +# define TQ_OS_WIN32 +#elif defined(__sun) || defined(sun) +# define TQ_OS_SOLARIS +#elif defined(hpux) || defined(__hpux) +# define TQ_OS_HPUX +#elif defined(__ultrix) || defined(ultrix) +# define TQ_OS_ULTRIX +#elif defined(sinix) +# define TQ_OS_RELIANT +#elif defined(__linux__) || defined(__linux) +# define TQ_OS_LINUX +#elif defined(__FreeBSD__) || defined(__DragonFly__) +# define TQ_OS_FREEBSD +# define TQ_OS_BSD4 +#elif defined(__NetBSD__) +# define TQ_OS_NETBSD +# define TQ_OS_BSD4 +#elif defined(__OpenBSD__) +# define TQ_OS_OPENBSD +# define TQ_OS_BSD4 +#elif defined(__bsdi__) +# define TQ_OS_BSDI +# define TQ_OS_BSD4 +#elif defined(__sgi) +# define TQ_OS_IRIX +#elif defined(__osf__) +# define TQ_OS_OSF +#elif defined(_AIX) +# define TQ_OS_AIX +#elif defined(__Lynx__) +# define TQ_OS_LYNX +#elif defined(__GNU_HURD__) +# define TQ_OS_HURD +#elif defined(__DGUX__) +# define TQ_OS_DGUX +#elif defined(__TQNXNTO__) +# define TQ_OS_TQNX6 +#elif defined(__TQNX__) +# define TQ_OS_TQNX +#elif defined(_SETQUENT_) +# define TQ_OS_DYNIX +#elif defined(_SCO_DS) /* SCO OpenServer 5 + GCC */ +# define TQ_OS_SCO +#elif defined(__USLC__) /* all SCO platforms + UDK or OUDK */ +# define TQ_OS_UNIXWARE +# define TQ_OS_UNIXWARE7 +#elif defined(__svr4__) && defined(i386) /* Open UNIX 8 + GCC */ +# define TQ_OS_UNIXWARE +# define TQ_OS_UNIXWARE7 +#elif defined(__MAKEDEPEND__) +#else +# error "TQt has not been ported to this OS - talk to qt-bugs@trolltech.com" +#endif + +#if defined(TQ_OS_WIN32) || defined(TQ_OS_WIN64) +# define TQ_OS_WIN +#endif + +#if defined(TQ_OS_MAC9) || defined(TQ_OS_MACX) +# define TQ_OS_MAC +#endif + +#if defined(TQ_OS_MAC9) || defined(TQ_OS_MSDOS) || defined(TQ_OS_OS2) || defined(TQ_OS_WIN) +# undef TQ_OS_UNIX +#elif !defined(TQ_OS_UNIX) +# define TQ_OS_UNIX +#endif + +#if defined(TQ_OS_MACX) +# ifdef MAC_OS_X_VERSION_MIN_RETQUIRED +# undef MAC_OS_X_VERSION_MIN_RETQUIRED +# endif +# define MAC_OS_X_VERSION_MIN_RETQUIRED MAC_OS_X_VERSION_10_2 +# include <AvailabilityMacros.h> +# if !defined(MAC_OS_X_VERSION_10_3) +# define MAC_OS_X_VERSION_10_3 MAC_OS_X_VERSION_10_2 + 1 +# endif +# if !defined(MAC_OS_X_VERSION_10_4) +# define MAC_OS_X_VERSION_10_4 MAC_OS_X_VERSION_10_3 + 1 +# endif +# if (MAC_OS_X_VERSION_MAX_ALLOWED > MAC_OS_X_VERSION_10_4) +# error "This version of Mac OS X is unsupported" +# endif +#endif + + +/* + The compiler, must be one of: (TQ_CC_x) + + SYM - Symantec C++ for both PC and Macintosh + MPW - MPW C++ + MWERKS - Metrowerks CodeWarrior + MSVC - Microsoft Visual C/C++, Intel C++ for Windows + BOR - Borland/Turbo C++ + WAT - Watcom C++ + GNU - GNU C++ + COMEAU - Comeau C++ + EDG - Edison Design Group C++ + OC - CenterLine C++ + SUN - Sun WorkShop, Forte Developer, or Sun ONE Studio C++ + MIPS - MIPSpro C++ + DEC - DEC C++ + HP - HPUX C++ + HPACC - HPUX ANSI C++ + USLC - SCO OUDK, UDK, and UnixWare 2.X C++ + CDS - Reliant C++ + KAI - KAI C++ + INTEL - Intel C++ for Linux, Intel C++ for Windows + HIGHC - MetaWare High C/C++ + PGI - Portland Group C++ + GHS - Green Hills Optimizing C++ Compilers + + Should be sorted most to least authoritative. +*/ + +/* Symantec C++ is now Digital Mars */ +#if defined(__DMC__) || defined(__SC__) +# define TQ_CC_SYM +/* "explicit" semantics implemented in 8.1e but keyword recognized since 7.5 */ +# if defined(__SC__) && __SC__ < 0x750 +# define TQ_NO_EXPLICIT_KEYWORD +# endif +# define TQ_NO_USING_KEYWORD +# if !defined(_CPPUNWIND) +# define TQ_NO_EXCEPTIONS +# endif + +#elif defined(applec) +# define TQ_CC_MPW +# define TQ_NO_BOOL_TYPE +# define TQ_NO_EXPLICIT_KEYWORD +# define TQ_NO_USING_KEYWORD + +#elif defined(__MWERKS__) +# define TQ_CC_MWERKS +/* "explicit" recognized since 4.0d1 */ +# define TQMAC_PASCAL pascal + +#elif defined(_MSC_VER) +# define TQ_CC_MSVC +/* proper support of bool for _MSC_VER >= 1100 */ +# define TQ_CANNOT_DELETE_CONSTANT +# define TQ_INLINE_TEMPLATES inline +/* Visual C++.Net issues for _MSC_VER >= 1300 */ +# if _MSC_VER >= 1300 +# define TQ_CC_MSVC_NET +# if _MSC_VER < 1310 || (defined(TQ_OS_WIN64) && defined(_M_IA64)) +# define TQ_TYPENAME +# endif +# endif +/* Intel C++ disguising as Visual C++: the `using' keyword avoids warnings */ +# if defined(__INTEL_COMPILER) +# define TQ_CC_INTEL +# if !defined(__EXCEPTIONS) +# define TQ_NO_EXCEPTIONS +# endif +# else +# define TQ_NO_USING_KEYWORD /* ### check "using" status */ +# endif + +#elif defined(__BORLANDC__) || defined(__TURBOC__) +# define TQ_CC_BOR +# if __BORLANDC__ < 0x502 +# define TQ_NO_BOOL_TYPE +# define TQ_NO_EXPLICIT_KEYWORD +# endif +# define TQ_NO_USING_KEYWORD /* ### check "using" status */ + +#elif defined(__WATCOMC__) +# define TQ_CC_WAT +# if defined(TQ_OS_TQNX4) +/* compiler flags */ +# define TQ_TYPENAME +# define TQ_NO_BOOL_TYPE +# define TQ_CANNOT_DELETE_CONSTANT +# define mutable +/* ??? */ +# define TQ_BROKEN_TEMPLATE_SPECIALIZATION +/* no template classes in TQVariant */ +# define TQT_NO_TEMPLATE_VARIANT +/* Wcc does not fill in functions needed by valuelists, maps, and + valuestacks implicitly */ +# define TQ_FULL_TEMPLATE_INSTANTIATION +/* can we just compare the structures? */ +# define TQ_FULL_TEMPLATE_INSTANTIATION_MEMCMP +/* these are not useful to our customers */ +# define TQT_TQWS_NO_SHM +# define TQT_NO_TQWS_MULTIPROCESS +# define TQT_NO_SQL +# define TQT_NO_TQWS_CURSOR +# endif + +#elif defined(__GNUC__) +# define TQ_CC_GNU +# define TQ_C_CALLBACKS +# if __GNUC__ == 2 && __GNUC_MINOR__ <= 7 +# define TQ_FULL_TEMPLATE_INSTANTIATION +# endif +/* GCC 2.95 knows "using" but does not support it correctly */ +# if __GNUC__ == 2 && __GNUC_MINOR__ <= 95 +# define TQ_NO_USING_KEYWORD +# endif +/* GCC 3.1 and GCC 3.2 wrongly define _SB_CTYPE_MACROS on HP-UX */ +# if defined(TQ_OS_HPUX) && __GNUC__ == 3 && __GNUC_MINOR__ >= 1 +# define TQ_WRONG_SB_CTYPE_MACROS +# endif + +/* ARM gcc pads structs to 32 bits, even when they contain a single + char, or short. We tell gcc to pack TQChars to 16 bits, to avoid + TQString bloat. However, gcc 3.4 doesn't allow us to create references to + members of a packed struct. (Pointers are OK, because then you + supposedly know what you are doing.) */ +# if (defined(__arm__) || defined(__ARMEL__)) && !defined(TQT_TQMOC_CPP) +# define TQ_PACKED __attribute__ ((packed)) +# if __GNUC__ == 3 && __GNUC_MINOR__ >= 4 +# define TQ_NO_PACKED_REFERENCE +# endif +# endif +# if !defined(__EXCEPTIONS) +# define TQ_NO_EXCEPTIONS +# endif + +/* IBM compiler versions are a bit messy. There are actually two products: + the C product, and the C++ product. The C++ compiler is always packaged + with the latest version of the C compiler. Version numbers do not always + match. This little table (I'm not sure it's accurate) should be helpful: + + C++ product C product + + C Set 3.1 C Compiler 3.0 + ... ... + C++ Compiler 3.6.6 C Compiler 4.3 + ... ... + Visual Age C++ 4.0 ... + ... ... + Visual Age C++ 5.0 C Compiler 5.0 + ... ... + Visual Age C++ 6.0 C Compiler 6.0 + + Now: + __xlC__ is the version of the C compiler in hexadecimal notation + is only an approximation of the C++ compiler version + __IBMCPP__ is the version of the C++ compiler in decimal notation + but it is not defined on older compilers like C Set 3.1 */ +#elif defined(__xlC__) +# define TQ_CC_XLC +# define TQ_FULL_TEMPLATE_INSTANTIATION +# if __xlC__ < 0x400 +# define TQ_NO_BOOL_TYPE +# define TQ_NO_EXPLICIT_KEYWORD +# define TQ_NO_USING_KEYWORD +# define TQ_TYPENAME +# define TQ_INLINE_TEMPLATES inline +# define TQ_BROKEN_TEMPLATE_SPECIALIZATION +# define TQ_CANNOT_DELETE_CONSTANT +# endif + +/* Older versions of DEC C++ do not define __EDG__ or __EDG - observed + on DEC C++ V5.5-004. New versions do define __EDG__ - observed on + Compaq C++ V6.3-002. + This compiler is different enough from other EDG compilers to handle + it separately anyway. */ +#elif defined(__DECCXX) || defined(__DECC) +# define TQ_CC_DEC +/* Compaq C++ V6 compilers are EDG-based but I'm not sure about older + DEC C++ V5 compilers. */ +# if defined(__EDG__) +# define TQ_CC_EDG +# endif +/* Compaq have disabled EDG's _BOOL macro and use _BOOL_EXISTS instead + - observed on Compaq C++ V6.3-002. + In any case versions prior to Compaq C++ V6.0-005 do not have bool. */ +# if !defined(_BOOL_EXISTS) +# define TQ_NO_BOOL_TYPE +# endif +/* Spurious (?) error messages observed on Compaq C++ V6.5-014. */ +# define TQ_NO_USING_KEYWORD +/* Apply to all versions prior to Compaq C++ V6.0-000 - observed on + DEC C++ V5.5-004. */ +# if __DECCXX_VER < 60060000 +# define TQ_TYPENAME +# define TQ_BROKEN_TEMPLATE_SPECIALIZATION +# define TQ_CANNOT_DELETE_CONSTANT +# endif +/* avoid undefined symbol problems with out-of-line template members */ +# define TQ_INLINE_TEMPLATES inline + +/* Compilers with EDG front end are similar. To detect them we test: + __EDG documented by SGI, observed on MIPSpro 7.3.1.1 and KAI C++ 4.0b + __EDG__ documented in EDG online docs, observed on Compaq C++ V6.3-002 */ +#elif defined(__EDG) || defined(__EDG__) +# define TQ_CC_EDG +/* From the EDG documentation (does not seem to apply to Compaq C++): + _BOOL + Defined in C++ mode when bool is a keyword. The name of this + predefined macro is specified by a configuration flag. _BOOL + is the default. + __BOOL_DEFINED + Defined in Microsoft C++ mode when bool is a keyword. */ +# if !defined(_BOOL) && !defined(__BOOL_DEFINED) +# define TQ_NO_BOOL_TYPE +# endif + +/* The Comeau compiler is based on EDG and does define __EDG__ */ +# if defined(__COMO__) +# define TQ_CC_COMEAU +# define TQ_C_CALLBACKS + +/* The `using' keyword was introduced to avoid KAI C++ warnings + but it's now causing KAI C++ errors instead. The standard is + unclear about the use of this keyword, and in practice every + compiler is using its own set of rules. Forget it. */ +# elif defined(__KCC) +# define TQ_CC_KAI +# if !defined(_EXCEPTIONS) +# define TQ_NO_EXCEPTIONS +# endif +# define TQ_NO_USING_KEYWORD + +/* Using the `using' keyword avoids Intel C++ for Linux warnings */ +# elif defined(__INTEL_COMPILER) +# define TQ_CC_INTEL +# if !defined(__EXCEPTIONS) +# define TQ_NO_EXCEPTIONS +# endif + +/* The Portland Group compiler is based on EDG and does define __EDG__ */ +# elif defined(__PGI) +# define TQ_CC_PGI +# if !defined(__EXCEPTIONS) +# define TQ_NO_EXCEPTIONS +# endif + +/* Never tested! */ +# elif defined(__ghs) +# define TQ_CC_GHS + +/* The UnixWare 7 UDK compiler is based on EDG and does define __EDG__ */ +# elif defined(__USLC__) && defined(__SCO_VERSION__) +# define TQ_CC_USLC +/* The latest UDK 7.1.1b does not need this, but previous versions do */ +# if !defined(__SCO_VERSION__) || (__SCO_VERSION__ < 302200010) +# define TQ_INLINE_TEMPLATES inline +# endif +# define TQ_NO_USING_KEYWORD /* ### check "using" status */ + +/* Never tested! */ +# elif defined(CENTERLINE_CLPP) || defined(OBJECTCENTER) +# define TQ_CC_OC +# define TQ_NO_USING_KEYWORD + +/* CDS++ defines __EDG__ although this is not documented in the Reliant + documentation. It also follows conventions like _BOOL and this documented */ +# elif defined(sinix) +# define TQ_CC_CDS +# define TQ_NO_USING_KEYWORD +# if defined(__cplusplus) && (__cplusplus < 2) /* Cfront C++ mode */ +# define TQ_NO_EXCEPTIONS +# endif + +/* The MIPSpro compiler in o32 mode is based on EDG but disables features + such as template specialization nevertheless */ +# elif defined(__sgi) +# define TQ_CC_MIPS +# if defined(_MIPS_SIM) && (_MIPS_SIM == _ABIO32) /* o32 ABI */ +# define TQ_TYPENAME +# define TQ_BROKEN_TEMPLATE_SPECIALIZATION +# define TQ_NO_EXPLICIT_KEYWORD +# define TQ_INLINE_TEMPLATES inline +# elif defined(_COMPILER_VERSION) && (_COMPILER_VERSION < 730) /* 7.2 */ +# define TQ_TYPENAME +# define TQ_BROKEN_TEMPLATE_SPECIALIZATION +# endif +# define TQ_NO_USING_KEYWORD /* ### check "using" status */ +# if defined(_COMPILER_VERSION) && (_COMPILER_VERSION >= 740) +# pragma set woff 3624,3625, 3649 /* turn off some harmless warnings */ +# endif +# endif + +/* The older UnixWare 2.X compiler? */ +#elif defined(__USLC__) +# define TQ_CC_USLC +# define TQ_TYPENAME +# define TQ_NO_BOOL_TYPE +# define TQ_NO_EXPLICIT_KEYWORD +# define TQ_NO_USING_KEYWORD +# define TQ_INLINE_TEMPLATES inline + +/* Never tested! */ +#elif defined(__HIGHC__) +# define TQ_CC_HIGHC + +#elif defined(__SUNPRO_CC) || defined(__SUNPRO_C) +# define TQ_CC_SUN +/* 5.0 compiler or better + 'bool' is enabled by default but can be disabled using -features=nobool + in which case _BOOL is not defined + this is the default in 4.2 compatibility mode triggered by -compat=4 */ +# if __SUNPRO_CC >= 0x500 +# if !defined(_BOOL) +# define TQ_NO_BOOL_TYPE +# endif +# if defined(__SUNPRO_CC_COMPAT) && (__SUNPRO_CC_COMPAT <= 4) +# define TQ_NO_USING_KEYWORD +# endif +# define TQ_C_CALLBACKS +/* 4.2 compiler or older */ +# else +# define TQ_NO_BOOL_TYPE +# define TQ_NO_EXPLICIT_KEYWORD +# define TQ_NO_USING_KEYWORD +# endif + +/* CDS++ does not seem to define __EDG__ or __EDG according to Reliant + documentation but nevertheless uses EDG conventions like _BOOL */ +#elif defined(sinix) +# define TQ_CC_EDG +# define TQ_CC_CDS +# if !defined(_BOOL) +# define TQ_NO_BOOL_TYPE +# endif +# define TQ_BROKEN_TEMPLATE_SPECIALIZATION + +#elif defined(TQ_OS_HPUX) +/* __HP_aCC was not defined in first aCC releases */ +# if defined(__HP_aCC) || __cplusplus >= 199707L +# define TQ_CC_HPACC +# else +# define TQ_CC_HP +# define TQ_NO_BOOL_TYPE +# define TQ_FULL_TEMPLATE_INSTANTIATION +# define TQ_BROKEN_TEMPLATE_SPECIALIZATION +# define TQ_NO_EXPLICIT_KEYWORD +# endif +# define TQ_NO_USING_KEYWORD /* ### check "using" status */ + +#else +# error "TQt has not been tested with this compiler - talk to qt-bugs@trolltech.com" +#endif + +#ifndef TQ_PACKED +# define TQ_PACKED +#endif + + +/* + The window system, must be one of: (TQ_WS_x) + + MACX - Mac OS X + MAC9 - Mac OS 9 + TQWS - TQt/Embedded + WIN32 - Windows + X11 - X Window System + PM - unsupported + WIN16 - unsupported +*/ + +#if defined(TQ_OS_MAC9) +# define TQ_WS_MAC9 +#elif defined(TQ_OS_MSDOS) +# define TQ_WS_WIN16 +# error "TQt requires Win32 and does not work with Windows 3.x" +#elif defined(_WIN32_X11_) +# define TQ_WS_X11 +#elif defined(TQ_OS_WIN32) +# define TQ_WS_WIN32 +# if defined(TQ_OS_WIN64) +# define TQ_WS_WIN64 +# endif +#elif defined(TQ_OS_OS2) +# define TQ_WS_PM +# error "TQt does not work with OS/2 Presentation Manager or Workplace Shell" +#elif defined(TQ_OS_UNIX) +# if defined(TQWS) +# define TQ_WS_TQWS +# define TQT_NO_TQWS_IM +# elif defined(TQ_OS_MACX) +# define TQ_WS_MACX +# else +# define TQ_WS_X11 +# endif +#endif +#if defined(TQ_OS_MAC) && !defined(TQMAC_PASCAL) +# define TQMAC_PASCAL +#endif + +#if defined(TQ_WS_WIN16) || defined(TQ_WS_WIN32) +# define TQ_WS_WIN +#endif + +#if (defined(TQ_WS_MAC9) || defined(TQ_WS_MACX)) && !defined(TQ_WS_TQWS) && !defined(TQ_WS_X11) +# define TQ_WS_MAC +#endif + + +/* + Some classes do not permit copies to be made of an object. + These classes tqcontains a private copy constructor and operator= + to disable copying (the compiler gives an error message). + Undefine TQ_DISABLE_COPY to turn off this checking. +*/ + +#define TQ_DISABLE_COPY + +#if defined(__cplusplus) + + +// +// Useful type definitions for TQt +// + +#if defined(TQ_NO_BOOL_TYPE) +#if defined(TQ_CC_HP) +// bool is an unsupported reserved keyword in later versions +#define bool int +#else +typedef int bool; +#endif +#endif + +typedef unsigned char uchar; +typedef unsigned short ushort; +typedef unsigned uint; +typedef unsigned long ulong; +typedef char *pchar; +typedef uchar *puchar; +typedef const char *pcchar; + + +// +// Constant bool values +// + +#ifndef TRUE +const bool FALSE = 0; +const bool TRUE = !0; +#endif +#if defined(__WATCOMC__) +# if defined(TQ_OS_TQNX4) +const bool false = FALSE; +const bool true = TRUE; +# endif +#endif + +// +// Proper for-scoping +// ### turn on in 4.0 + +#if 0 && defined(TQ_CC_MSVC) && !defined(TQ_CC_MSVC_NET) +# define for if(0){}else for +#endif + +// +// Use the "explicit" keyword on platforms that support it. +// + +#if !defined(TQ_NO_EXPLICIT_KEYWORD) +# define TQ_EXPLICIT explicit +#else +# define TQ_EXPLICIT +#endif + + +// +// Workaround for static const members on MSVC++. +// + +#if defined(TQ_CC_MSVC) +# define TQT_STATIC_CONST static +# define TQT_STATIC_CONST_IMPL +#else +# define TQT_STATIC_CONST static const +# define TQT_STATIC_CONST_IMPL const +#endif + + +// +// Utility macros and inline functions +// + +#define TQMAX(a, b) ((b) < (a) ? (a) : (b)) +#define TQMIN(a, b) ((a) < (b) ? (a) : (b)) +#define TQABS(a) ((a) >= 0 ? (a) : -(a)) + +inline int tqRound( double d ) +{ + return d >= 0.0 ? int(d + 0.5) : int( d - ((int)d-1) + 0.5 ) + ((int)d-1); +} + + +// +// Size-dependent types (architechture-dependent byte order) +// + +#if !defined(TQT_CLEAN_NAMESPACE) +// source compatibility with TQt 1.x +typedef signed char INT8; // 8 bit signed +typedef unsigned char UINT8; // 8 bit unsigned +typedef short INT16; // 16 bit signed +typedef unsigned short UINT16; // 16 bit unsigned +// typedef int INT32; // 32 bit signed // [FIXME] Conflicts with Xorg headers +typedef unsigned int UINT32; // 32 bit unsigned +#endif + +typedef signed char TQ_INT8; // 8 bit signed +typedef unsigned char TQ_UINT8; // 8 bit unsigned +typedef short TQ_INT16; // 16 bit signed +typedef unsigned short TQ_UINT16; // 16 bit unsigned +typedef int TQ_INT32; // 32 bit signed +typedef unsigned int TQ_UINT32; // 32 bit unsigned +#if defined(TQ_OS_WIN64) +typedef __int64 TQ_LONG; // word up to 64 bit signed +typedef unsigned __int64 TQ_ULONG; // word up to 64 bit unsigned +#else +typedef long TQ_LONG; // word up to 64 bit signed +typedef unsigned long TQ_ULONG; // word up to 64 bit unsigned +#endif +#if defined(TQ_OS_WIN) && !defined(TQ_CC_GNU) +# define TQ_INT64_C(c) c ## i64 // signed 64 bit constant +# define TQ_UINT64_C(c) c ## ui64 // unsigned 64 bit constant +typedef __int64 TQ_INT64; // 64 bit signed +typedef unsigned __int64 TQ_UINT64; // 64 bit unsigned +#else +# define TQ_INT64_C(c) c ## LL // signed 64 bit constant +# define TQ_UINT64_C(c) c ## ULL // unsigned 64 bit constant +typedef long long TQ_INT64; // 64 bit signed +typedef unsigned long long TQ_UINT64; // 64 bit unsigned +#endif +typedef TQ_INT64 TQ_LLONG; // signed long long +typedef TQ_UINT64 TQ_ULLONG; // unsigned long long + +#if defined(TQ_OS_MACX) && !defined(TQT_LARGEFILE_SUPPORT) +# define TQT_LARGEFILE_SUPPORT 64 +#endif +#if defined(TQT_LARGEFILE_SUPPORT) + typedef TQ_ULLONG TQtOffset; +#else + typedef TQ_ULONG TQtOffset; +#endif + + +// +// Data stream functions is provided by many classes (defined in tqdatastream.h) +// + +class TQDataStream; + + +// +// Feature subsetting +// +// Note that disabling some features will produce a libtqt that is not +// compatible with other libtqt builds. Such modifications are only +// supported on TQt/Embedded where reducing the library size is important +// and where the application-suite is often a fixed set. +// + +#if !defined(TQT_TQMOC) +#if defined(TQCONFIG_LOCAL) +#include "tqconfig-local.h" +#elif defined(TQCONFIG_MINIMAL) +#include "tqconfig-minimal.h" +#elif defined(TQCONFIG_SMALL) +#include "tqconfig-small.h" +#elif defined(TQCONFIG_MEDIUM) +#include "tqconfig-medium.h" +#elif defined(TQCONFIG_LARGE) +#include "tqconfig-large.h" +#else // everything... +#include "tqconfig.h" +#endif +#endif + + +#ifndef TQT_BUILD_KEY +#define TQT_BUILD_KEY "unspecified" +#endif + +// prune to local config +#include "tqmodules.h" +#ifndef TQT_MODULE_DIALOGS +# define TQT_NO_DIALOG +#endif +#ifndef TQT_MODULE_ICONVIEW +# define TQT_NO_ICONVIEW +#endif +#ifndef TQT_MODULE_WORKSPACE +# define TQT_NO_WORKSPACE +#endif +#ifndef TQT_MODULE_NETWORK +#define TQT_NO_NETWORK +#endif +#ifndef TQT_MODULE_CANVAS +# define TQT_NO_CANVAS +#endif +#ifndef TQT_MODULE_TABLE +#define TQT_NO_TABLE +#endif +#ifndef TQT_MODULE_XML +# define TQT_NO_XML +#endif +#ifndef TQT_MODULE_OPENGL +# define TQT_NO_OPENGL +#endif +#if !defined(TQT_MODULE_SQL) +# define TQT_NO_SQL +#endif + +#if defined(TQ_WS_MAC9) +//No need for menu merging +# ifndef TQMAC_TQMENUBAR_NO_MERGE +# define TQMAC_TQMENUBAR_NO_MERGE +# endif +//Mac9 does not use quartz +# ifndef TQMAC_NO_TQUARTZ +# define TQMAC_NO_TQUARTZ +# endif +# ifndef TQMAC_TQMENUBAR_NO_EVENT +# define TQMAC_TQMENUBAR_NO_EVENT +# endif +#endif +#if defined(TQ_WS_MACX) //for no nobody uses quartz, just putting in first level hooks +# ifndef TQMAC_NO_TQUARTZ +# define TQMAC_NO_TQUARTZ +# endif +# ifndef TQMAC_TQMENUBAR_NO_EVENT +# define TQMAC_TQMENUBAR_NO_EVENT +# endif +#endif + +#if !defined(TQ_WS_TQWS) && !defined(TQT_NO_COP) +# define TQT_NO_COP +#endif + +#ifndef TQT_H +#include "tqfeatures.h" +#endif /* TQT_H */ + + +// +// Create TQt DLL if TQT_DLL is defined (Windows only) +// or TQT_SHARED is defined (Kylix only) +// + +#if defined(TQ_OS_WIN) +# if defined(TQT_NODLL) +# undef TQT_MAKEDLL +# undef TQT_DLL +# elif defined(TQT_MAKEDLL) /* create a TQt DLL library */ +# if defined(TQT_DLL) +# undef TQT_DLL +# endif +# define TQ_EXPORT __declspec(dllexport) +# define TQ_TEMPLATEDLL +# define TQ_TEMPLATE_EXTERN +# undef TQ_DISABLE_COPY /* avoid unresolved externals */ +# elif defined(TQT_DLL) /* use a TQt DLL library */ +# define TQ_EXPORT __declspec(dllimport) +# define TQ_TEMPLATEDLL +# ifndef TQ_TEMPLATE_EXTERN +# if defined(TQ_CC_MSVC_NET) +# define TQ_TEMPLATE_EXTERN extern +# else +# define TQ_TEMPLATE_EXTERN +# endif +# endif +# undef TQ_DISABLE_COPY /* avoid unresolved externals */ +# endif +#elif defined(TQ_OS_LINUX) && defined(TQ_CC_BOR) +# if defined(TQT_SHARED) /* create a TQt shared library */ +# define TQ_EXPORT __declspec(dllexport) +# define TQ_TEMPLATEDLL +# define TQ_TEMPLATE_EXTERN +# undef TQ_DISABLE_COPY /* avoid unresolved externals */ +# else +# define TQ_TEMPLATEDLL +# define TQ_TEMPLATE_EXTERN +# undef TQ_DISABLE_COPY /* avoid unresolved externals */ +# endif +#else +# undef TQT_MAKEDLL /* ignore these for other platforms */ +# undef TQT_DLL +#endif + +#ifndef TQ_EXPORT +# define TQ_EXPORT +#endif + + +// +// Some platform specific stuff +// + +#if defined(TQ_WS_WIN) +extern TQ_EXPORT bool qt_wintqunicode; +#endif + + +// +// System information +// + +TQ_EXPORT const char *qVersion(); +TQ_EXPORT bool qSysInfo( int *wordSize, bool *bigEndian ); +TQ_EXPORT bool qSharedBuild(); +#if defined(TQ_OS_MAC) +int qMacVersion(); +#elif defined(TQ_WS_WIN) +TQ_EXPORT int qWinVersion(); +#if defined(UNICODE) +#define TQT_WA( uni, ansi ) if ( qt_wintqunicode ) { uni } else { ansi } +#define TQT_WA_INLINE( uni, ansi ) ( qt_wintqunicode ? uni : ansi ) +#else +#define TQT_WA( uni, ansi ) ansi +#define TQT_WA_INLINE( uni, ansi ) ansi +#endif +#endif + +#ifdef TQ_OS_TEMP +#ifdef TQT_WA +#undef TQT_WA +#undef TQT_WA_INLINE +#endif +#define TQT_WA( uni, ansi ) uni +#define TQT_WA_INLINE( uni, ansi ) ( uni ) +#endif + +#ifndef TQ_INLINE_TEMPLATES +# define TQ_INLINE_TEMPLATES +#endif + +#ifndef TQ_TYPENAME +# define TQ_TYPENAME typename +#endif + +// +// Use to avoid "unused parameter" warnings +// +#define TQ_UNUSED(x) (void)x; + +// +// Debugging and error handling +// + +#if !defined(TQT_NO_CHECK) +# define TQT_CHECK_STATE // check state of objects etc. +# define TQT_CHECK_RANGE // check range of indexes etc. +# define TQT_CHECK_NULL // check null pointers +# define TQT_CHECK_MATH // check math functions +#endif + +#if !defined(TQT_NO_DEBUG) && !defined(TQT_DEBUG) +# define TQT_DEBUG // display debug messages +# if !defined(TQT_NO_COMPAT) // compatibility with TQt 2 +# if !defined(NO_DEBUG) && !defined(DEBUG) +# if !defined(TQ_OS_MACX) // clash with MacOS X headers +# define DEBUG +# endif +# endif +# endif +#endif + + +TQ_EXPORT void qDebug( const char *, ... ) // print debug message +#if defined(TQ_CC_GNU) && !defined(__INSURE__) + __attribute__ ((format (printf, 1, 2))) +#endif +; + +TQ_EXPORT void qWarning( const char *, ... ) // print warning message +#if defined(TQ_CC_GNU) && !defined(__INSURE__) + __attribute__ ((format (printf, 1, 2))) +#endif +; + +TQ_EXPORT void qFatal( const char *, ... ) // print fatal message and exit +#if defined(TQ_CC_GNU) + __attribute__ ((format (printf, 1, 2))) +#endif +; + +TQ_EXPORT void tqSystemWarning( const char *, int code = -1 ); + +#if !defined(TQT_CLEAN_NAMESPACE) // compatibility with TQt 1 + +TQ_EXPORT void debug( const char *, ... ) // print debug message +#if defined(TQ_CC_GNU) && !defined(__INSURE__) + __attribute__ ((format (printf, 1, 2))) +#endif +; + +TQ_EXPORT void warning( const char *, ... ) // print warning message +#if defined(TQ_CC_GNU) && !defined(__INSURE__) + __attribute__ ((format (printf, 1, 2))) +#endif +; + +TQ_EXPORT void fatal( const char *, ... ) // print fatal message and exit +#if defined(TQ_CC_GNU) && !defined(__INSURE__) + __attribute__ ((format (printf, 1, 2))) +#endif +; + +#endif // TQT_CLEAN_NAMESPACE + + +#if !defined(TQ_ASSERT) +# if defined(TQT_CHECK_STATE) +# if defined(TQT_FATAL_ASSERT) +# define TQ_ASSERT(x) ((x) ? (void)0 : qFatal("ASSERT: \"%s\" in %s (%d)",#x,__FILE__,__LINE__)) +# else +# define TQ_ASSERT(x) ((x) ? (void)0 : qWarning("ASSERT: \"%s\" in %s (%d)",#x,__FILE__,__LINE__)) +# endif +# else +# define TQ_ASSERT(x) +# endif +#endif + +#if !defined(TQT_NO_COMPAT) // compatibility with TQt 2 +# if !defined(ASSERT) +# if !defined(TQ_OS_TEMP) +# define ASSERT(x) TQ_ASSERT(x) +# endif +# endif +#endif // TQT_NO_COMPAT + + +TQ_EXPORT bool qt_check_pointer( bool c, const char *, int ); + +#if defined(TQT_CHECK_NULL) +# define TQ_CHECK_PTR(p) (qt_check_pointer((p)==0,__FILE__,__LINE__)) +#else +# define TQ_CHECK_PTR(p) +#endif + +#if !defined(TQT_NO_COMPAT) // compatibility with TQt 2 +# if !defined(CHECK_PTR) +# define CHECK_PTR(x) TQ_CHECK_PTR(x) +# endif +#endif // TQT_NO_COMPAT + +enum TQtMsgType { TQtDebugMsg, TQtWarningMsg, TQtFatalMsg }; + +typedef void (*TQtMsgHandler)(TQtMsgType, const char *); +TQ_EXPORT TQtMsgHandler tqInstallMsgHandler( TQtMsgHandler ); + +#if !defined(TQT_NO_COMPAT) // compatibility with TQt 2 +typedef TQtMsgHandler msg_handler; +#endif // TQT_NO_COMPAT + +TQ_EXPORT void tqSuppressObsoleteWarnings( bool = TRUE ); + +TQ_EXPORT void qObsolete( const char *obj, const char *oldfunc, + const char *newfunc ); +TQ_EXPORT void qObsolete( const char *obj, const char *oldfunc ); +TQ_EXPORT void qObsolete( const char *message ); + + +// +// Install paths from configure +// + +TQ_EXPORT const char *qInstallPath(); +TQ_EXPORT const char *qInstallPathDocs(); +TQ_EXPORT const char *qInstallPathHeaders(); +TQ_EXPORT const char *qInstallPathLibs(); +TQ_EXPORT const char *qInstallPathBins(); +TQ_EXPORT const char *qInstallPathPlugins(); +TQ_EXPORT const char *qInstallPathData(); +TQ_EXPORT const char *qInstallPathTranslations(); +TQ_EXPORT const char *qInstallPathSysconf(); + +#endif /* __cplusplus */ + +/* + compilers which follow outdated template instantiation rules + require a class to have a comparison operator to exist when + a TQValueList of this type is instantiated. It's not actually + used in the list, though. Hence the dummy implementation. + Just in case other code relies on it we better trigger a warning + mandating a real implementation. +*/ +#ifdef TQ_FULL_TEMPLATE_INSTANTIATION +# define TQ_DUMMY_COMPARISON_OPERATOR(C) \ + bool operator==( const C& ) const { \ + qWarning( #C"::operator==( const "#C"& ) got called." ); \ + return FALSE; \ + } +#else +# define TQ_DUMMY_COMPARISON_OPERATOR(C) +#endif + +#endif /* TQGLOBAL_H */ + +/* + Avoid some particularly useless warnings from some stupid compilers. + To get ALL C++ compiler warnings, define TQT_CC_WARNINGS or comment out + the line "#define TQT_NO_WARNINGS" +*/ + +#if !defined(TQT_CC_WARNINGS) +# define TQT_NO_WARNINGS +#endif +#if defined(TQT_NO_WARNINGS) +# if defined(TQ_CC_MSVC) +# pragma warning(disable: 4244) // 'conversion' conversion from 'type1' to 'type2', possible loss of data +# pragma warning(disable: 4275) // non - DLL-interface classkey 'identifier' used as base for DLL-interface classkey 'identifier' +# pragma warning(disable: 4514) // unreferenced inline/local function has been removed +# pragma warning(disable: 4800) // 'type' : forcing value to bool 'true' or 'false' (performance warning) +# pragma warning(disable: 4097) // typedef-name 'identifier1' used as synonym for class-name 'identifier2' +# pragma warning(disable: 4706) // assignment within conditional expression +# pragma warning(disable: 4786) // truncating debug info after 255 characters +# pragma warning(disable: 4660) // template-class specialization 'identifier' is already instantiated +# pragma warning(disable: 4355) // 'this' : used in base member initializer list +# pragma warning(disable: 4231) // nonstandard extension used : 'extern' before template explicit instantiation +# pragma warning(disable: 4710) // function not inlined +# elif defined(TQ_CC_BOR) +# pragma option -w-inl +# pragma option -w-aus +# pragma warn -inl +# pragma warn -pia +# pragma warn -ccc +# pragma warn -rch +# pragma warn -sig +# endif +#endif + |