--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/corelib/global/qglobal.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,3535 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtCore module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qplatformdefs.h"
+#include "qstring.h"
+#include "qvector.h"
+#include "qlist.h"
+#include "qthreadstorage.h"
+#include "qdir.h"
+#include "qstringlist.h"
+#include "qdatetime.h"
+
+#ifndef QT_NO_QOBJECT
+#include <private/qthread_p.h>
+#endif
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <limits.h>
+#include <stdarg.h>
+#include <string.h>
+
+#if !defined(Q_OS_WINCE)
+# include <errno.h>
+# if defined(Q_CC_MSVC)
+# include <crtdbg.h>
+# endif
+#endif
+
+#if defined(Q_OS_VXWORKS)
+# include <envLib.h>
+#endif
+
+#if defined(Q_CC_MWERKS) && defined(Q_OS_MACX)
+#include <CoreServices/CoreServices.h>
+#endif
+
+#if defined(Q_OS_SYMBIAN)
+#include <e32def.h>
+#include <e32debug.h>
+#include <flogger.h>
+#include <f32file.h>
+# include "private/qcore_symbian_p.h"
+_LIT(qt_S60Filter, "Series60v?.*.sis");
+_LIT(qt_S60SystemInstallDir, "z:\\system\\install\\");
+
+#endif
+
+QT_BEGIN_NAMESPACE
+
+
+/*!
+ \class QFlag
+ \brief The QFlag class is a helper data type for QFlags.
+
+ It is equivalent to a plain \c int, except with respect to
+ function overloading and type conversions. You should never need
+ to use this class in your applications.
+
+ \sa QFlags
+*/
+
+/*!
+ \fn QFlag::QFlag(int value)
+
+ Constructs a QFlag object that stores the given \a value.
+*/
+
+/*!
+ \fn QFlag::operator int() const
+
+ Returns the value stored by the QFlag object.
+*/
+
+/*!
+ \class QFlags
+ \brief The QFlags class provides a type-safe way of storing
+ OR-combinations of enum values.
+
+
+ \ingroup tools
+
+ The QFlags<Enum> class is a template class, where Enum is an enum
+ type. QFlags is used throughout Qt for storing combinations of
+ enum values.
+
+ The traditional C++ approach for storing OR-combinations of enum
+ values is to use an \c int or \c uint variable. The inconvenience
+ with this approach is that there's no type checking at all; any
+ enum value can be OR'd with any other enum value and passed on to
+ a function that takes an \c int or \c uint.
+
+ Qt uses QFlags to provide type safety. For example, the
+ Qt::Alignment type is simply a typedef for
+ QFlags<Qt::AlignmentFlag>. QLabel::setAlignment() takes a
+ Qt::Alignment parameter, which means that any combination of
+ Qt::AlignmentFlag values,or 0, is legal:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 0
+
+ If you try to pass a value from another enum or just a plain
+ integer other than 0, the compiler will report an error. If you
+ need to cast integer values to flags in a untyped fashion, you can
+ use the explicit QFlags constructor as cast operator.
+
+ If you want to use QFlags for your own enum types, use
+ the Q_DECLARE_FLAGS() and Q_DECLARE_OPERATORS_FOR_FLAGS().
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 1
+
+ You can then use the \c MyClass::Options type to store
+ combinations of \c MyClass::Option values.
+
+ \section1 Flags and the Meta-Object System
+
+ The Q_DECLARE_FLAGS() macro does not expose the flags to the meta-object
+ system, so they cannot be used by Qt Script or edited in Qt Designer.
+ To make the flags available for these purposes, the Q_FLAGS() macro must
+ be used:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp meta-object flags
+
+ \section1 Naming Convention
+
+ A sensible naming convention for enum types and associated QFlags
+ types is to give a singular name to the enum type (e.g., \c
+ Option) and a plural name to the QFlags type (e.g., \c Options).
+ When a singular name is desired for the QFlags type (e.g., \c
+ Alignment), you can use \c Flag as the suffix for the enum type
+ (e.g., \c AlignmentFlag).
+
+ \sa QFlag
+*/
+
+/*!
+ \typedef QFlags::enum_type
+
+ Typedef for the Enum template type.
+*/
+
+/*!
+ \fn QFlags::QFlags(const QFlags &other)
+
+ Constructs a copy of \a other.
+*/
+
+/*!
+ \fn QFlags::QFlags(Enum flag)
+
+ Constructs a QFlags object storing the given \a flag.
+*/
+
+/*!
+ \fn QFlags::QFlags(Zero zero)
+
+ Constructs a QFlags object with no flags set. \a zero must be a
+ literal 0 value.
+*/
+
+/*!
+ \fn QFlags::QFlags(QFlag value)
+
+ Constructs a QFlags object initialized with the given integer \a
+ value.
+
+ The QFlag type is a helper type. By using it here instead of \c
+ int, we effectively ensure that arbitrary enum values cannot be
+ cast to a QFlags, whereas untyped enum values (i.e., \c int
+ values) can.
+*/
+
+/*!
+ \fn QFlags &QFlags::operator=(const QFlags &other)
+
+ Assigns \a other to this object and returns a reference to this
+ object.
+*/
+
+/*!
+ \fn QFlags &QFlags::operator&=(int mask)
+
+ Performs a bitwise AND operation with \a mask and stores the
+ result in this QFlags object. Returns a reference to this object.
+
+ \sa operator&(), operator|=(), operator^=()
+*/
+
+/*!
+ \fn QFlags &QFlags::operator&=(uint mask)
+
+ \overload
+*/
+
+/*!
+ \fn QFlags &QFlags::operator|=(QFlags other)
+
+ Performs a bitwise OR operation with \a other and stores the
+ result in this QFlags object. Returns a reference to this object.
+
+ \sa operator|(), operator&=(), operator^=()
+*/
+
+/*!
+ \fn QFlags &QFlags::operator|=(Enum other)
+
+ \overload
+*/
+
+/*!
+ \fn QFlags &QFlags::operator^=(QFlags other)
+
+ Performs a bitwise XOR operation with \a other and stores the
+ result in this QFlags object. Returns a reference to this object.
+
+ \sa operator^(), operator&=(), operator|=()
+*/
+
+/*!
+ \fn QFlags &QFlags::operator^=(Enum other)
+
+ \overload
+*/
+
+/*!
+ \fn QFlags::operator int() const
+
+ Returns the value stored in the QFlags object as an integer.
+*/
+
+/*!
+ \fn QFlags QFlags::operator|(QFlags other) const
+
+ Returns a QFlags object containing the result of the bitwise OR
+ operation on this object and \a other.
+
+ \sa operator|=(), operator^(), operator&(), operator~()
+*/
+
+/*!
+ \fn QFlags QFlags::operator|(Enum other) const
+
+ \overload
+*/
+
+/*!
+ \fn QFlags QFlags::operator^(QFlags other) const
+
+ Returns a QFlags object containing the result of the bitwise XOR
+ operation on this object and \a other.
+
+ \sa operator^=(), operator&(), operator|(), operator~()
+*/
+
+/*!
+ \fn QFlags QFlags::operator^(Enum other) const
+
+ \overload
+*/
+
+/*!
+ \fn QFlags QFlags::operator&(int mask) const
+
+ Returns a QFlags object containing the result of the bitwise AND
+ operation on this object and \a mask.
+
+ \sa operator&=(), operator|(), operator^(), operator~()
+*/
+
+/*!
+ \fn QFlags QFlags::operator&(uint mask) const
+
+ \overload
+*/
+
+/*!
+ \fn QFlags QFlags::operator&(Enum mask) const
+
+ \overload
+*/
+
+/*!
+ \fn QFlags QFlags::operator~() const
+
+ Returns a QFlags object that contains the bitwise negation of
+ this object.
+
+ \sa operator&(), operator|(), operator^()
+*/
+
+/*!
+ \fn bool QFlags::operator!() const
+
+ Returns true if no flag is set (i.e., if the value stored by the
+ QFlags object is 0); otherwise returns false.
+*/
+
+/*!
+ \fn bool QFlags::testFlag(Enum flag) const
+ \since 4.2
+
+ Returns true if the \a flag is set, otherwise false.
+*/
+
+/*!
+ \macro Q_DISABLE_COPY(Class)
+ \relates QObject
+
+ Disables the use of copy constructors and assignment operators
+ for the given \a Class.
+
+ Instances of subclasses of QObject should not be thought of as
+ values that can be copied or assigned, but as unique identities.
+ This means that when you create your own subclass of QObject
+ (director or indirect), you should \e not give it a copy constructor
+ or an assignment operator. However, it may not enough to simply
+ omit them from your class, because, if you mistakenly write some code
+ that requires a copy constructor or an assignment operator (it's easy
+ to do), your compiler will thoughtfully create it for you. You must
+ do more.
+
+ The curious user will have seen that the Qt classes derived
+ from QObject typically include this macro in a private section:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 43
+
+ It declares a copy constructor and an assignment operator in the
+ private section, so that if you use them by mistake, the compiler
+ will report an error.
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 44
+
+ But even this might not catch absolutely every case. You might be
+ tempted to do something like this:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 45
+
+ First of all, don't do that. Most compilers will generate code that
+ uses the copy constructor, so the privacy violation error will be
+ reported, but your C++ compiler is not required to generate code for
+ this statement in a specific way. It could generate code using
+ \e{neither} the copy constructor \e{nor} the assignment operator we
+ made private. In that case, no error would be reported, but your
+ application would probably crash when you called a member function
+ of \c{w}.
+*/
+
+/*!
+ \macro Q_DECLARE_FLAGS(Flags, Enum)
+ \relates QFlags
+
+ The Q_DECLARE_FLAGS() macro expands to
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 2
+
+ \a Enum is the name of an existing enum type, whereas \a Flags is
+ the name of the QFlags<\e{Enum}> typedef.
+
+ See the QFlags documentation for details.
+
+ \sa Q_DECLARE_OPERATORS_FOR_FLAGS()
+*/
+
+/*!
+ \macro Q_DECLARE_OPERATORS_FOR_FLAGS(Flags)
+ \relates QFlags
+
+ The Q_DECLARE_OPERATORS_FOR_FLAGS() macro declares global \c
+ operator|() functions for \a Flags, which is of type QFlags<T>.
+
+ See the QFlags documentation for details.
+
+ \sa Q_DECLARE_FLAGS()
+*/
+
+/*!
+ \headerfile <QtGlobal>
+ \title Global Qt Declarations
+ \ingroup funclists
+
+ \brief The <QtGlobal> header file includes the fundamental global
+ declarations. It is included by most other Qt header files.
+
+ The global declarations include \l{types}, \l{functions} and
+ \l{macros}.
+
+ The type definitions are partly convenience definitions for basic
+ types (some of which guarantee certain bit-sizes on all platforms
+ supported by Qt), partly types related to Qt message handling. The
+ functions are related to generating messages, Qt version handling
+ and comparing and adjusting object values. And finally, some of
+ the declared macros enable programmers to add compiler or platform
+ specific code to their applications, while others are convenience
+ macros for larger operations.
+
+ \section1 Types
+
+ The header file declares several type definitions that guarantee a
+ specified bit-size on all platforms supported by Qt for various
+ basic types, for example \l qint8 which is a signed char
+ guaranteed to be 8-bit on all platforms supported by Qt. The
+ header file also declares the \l qlonglong type definition for \c
+ {long long int } (\c __int64 on Windows).
+
+ Several convenience type definitions are declared: \l qreal for \c
+ double, \l uchar for \c unsigned char, \l uint for \c unsigned
+ int, \l ulong for \c unsigned long and \l ushort for \c unsigned
+ short.
+
+ Finally, the QtMsgType definition identifies the various messages
+ that can be generated and sent to a Qt message handler;
+ QtMsgHandler is a type definition for a pointer to a function with
+ the signature \c {void myMsgHandler(QtMsgType, const char *)}.
+
+ \section1 Functions
+
+ The <QtGlobal> header file contains several functions comparing
+ and adjusting an object's value. These functions take a template
+ type as argument: You can retrieve the absolute value of an object
+ using the qAbs() function, and you can bound a given object's
+ value by given minimum and maximum values using the qBound()
+ function. You can retrieve the minimum and maximum of two given
+ objects using qMin() and qMax() respectively. All these functions
+ return a corresponding template type; the template types can be
+ replaced by any other type.
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 3
+
+ <QtGlobal> also contains functions that generate messages from the
+ given string argument: qCritical(), qDebug(), qFatal() and
+ qWarning(). These functions call the message handler with the
+ given message.
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 4
+
+ The remaining functions are qRound() and qRound64(), which both
+ accept a \l qreal value as their argument returning the value
+ rounded up to the nearest integer and 64-bit integer respectively,
+ the qInstallMsgHandler() function which installs the given
+ QtMsgHandler, and the qVersion() function which returns the
+ version number of Qt at run-time as a string.
+
+ \section1 Macros
+
+ The <QtGlobal> header file provides a range of macros (Q_CC_*)
+ that are defined if the application is compiled using the
+ specified platforms. For example, the Q_CC_SUN macro is defined if
+ the application is compiled using Forte Developer, or Sun Studio
+ C++. The header file also declares a range of macros (Q_OS_*)
+ that are defined for the specified platforms. For example,
+ Q_OS_X11 which is defined for the X Window System.
+
+ The purpose of these macros is to enable programmers to add
+ compiler or platform specific code to their application.
+
+ The remaining macros are convenience macros for larger operations:
+ The QT_TRANSLATE_NOOP() and QT_TR_NOOP() macros provide the
+ possibility of marking text for dynamic translation,
+ i.e. translation without changing the stored source text. The
+ Q_ASSERT() and Q_ASSERT_X() enables warning messages of various
+ level of refinement. The Q_FOREACH() and foreach() macros
+ implement Qt's foreach loop.
+
+ The Q_INT64_C() and Q_UINT64_C() macros wrap signed and unsigned
+ 64-bit integer literals in a platform-independent way. The
+ Q_CHECK_PTR() macro prints a warning containing the source code's
+ file name and line number, saying that the program ran out of
+ memory, if the pointer is 0. The qPrintable() macro represent an
+ easy way of printing text.
+
+ Finally, the QT_POINTER_SIZE macro expands to the size of a
+ pointer in bytes, and the QT_VERSION and QT_VERSION_STR macros
+ expand to a numeric value or a string, respectively, specifying
+ Qt's version number, i.e the version the application is compiled
+ against.
+
+ \sa <QtAlgorithms>, QSysInfo
+*/
+
+/*!
+ \typedef qreal
+ \relates <QtGlobal>
+
+ Typedef for \c double on all platforms except for those using CPUs with
+ ARM architectures.
+ On ARM-based platforms, \c qreal is a typedef for \c float for performance
+ reasons.
+*/
+
+/*! \typedef uchar
+ \relates <QtGlobal>
+
+ Convenience typedef for \c{unsigned char}.
+*/
+
+/*!
+ \fn qt_set_sequence_auto_mnemonic(bool on)
+ \relates <QtGlobal>
+
+ Enables automatic mnemonics on Mac if \a on is true; otherwise
+ this feature is disabled.
+
+ Note that this function is only available on Mac where mnemonics
+ are disabled by default.
+
+ To access to this function, use an extern declaration:
+ extern void qt_set_sequence_auto_mnemonic(bool b);
+
+ \sa {QShortcut#mnemonic}{QShortcut}
+*/
+
+/*! \typedef ushort
+ \relates <QtGlobal>
+
+ Convenience typedef for \c{unsigned short}.
+*/
+
+/*! \typedef uint
+ \relates <QtGlobal>
+
+ Convenience typedef for \c{unsigned int}.
+*/
+
+/*! \typedef ulong
+ \relates <QtGlobal>
+
+ Convenience typedef for \c{unsigned long}.
+*/
+
+/*! \typedef qint8
+ \relates <QtGlobal>
+
+ Typedef for \c{signed char}. This type is guaranteed to be 8-bit
+ on all platforms supported by Qt.
+*/
+
+/*!
+ \typedef quint8
+ \relates <QtGlobal>
+
+ Typedef for \c{unsigned char}. This type is guaranteed to
+ be 8-bit on all platforms supported by Qt.
+*/
+
+/*! \typedef qint16
+ \relates <QtGlobal>
+
+ Typedef for \c{signed short}. This type is guaranteed to be
+ 16-bit on all platforms supported by Qt.
+*/
+
+/*!
+ \typedef quint16
+ \relates <QtGlobal>
+
+ Typedef for \c{unsigned short}. This type is guaranteed to
+ be 16-bit on all platforms supported by Qt.
+*/
+
+/*! \typedef qint32
+ \relates <QtGlobal>
+
+ Typedef for \c{signed int}. This type is guaranteed to be 32-bit
+ on all platforms supported by Qt.
+*/
+
+/*!
+ \typedef quint32
+ \relates <QtGlobal>
+
+ Typedef for \c{unsigned int}. This type is guaranteed to
+ be 32-bit on all platforms supported by Qt.
+*/
+
+/*! \typedef qint64
+ \relates <QtGlobal>
+
+ Typedef for \c{long long int} (\c __int64 on Windows). This type
+ is guaranteed to be 64-bit on all platforms supported by Qt.
+
+ Literals of this type can be created using the Q_INT64_C() macro:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 5
+
+ \sa Q_INT64_C(), quint64, qlonglong
+*/
+
+/*!
+ \typedef quint64
+ \relates <QtGlobal>
+
+ Typedef for \c{unsigned long long int} (\c{unsigned __int64} on
+ Windows). This type is guaranteed to be 64-bit on all platforms
+ supported by Qt.
+
+ Literals of this type can be created using the Q_UINT64_C()
+ macro:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 6
+
+ \sa Q_UINT64_C(), qint64, qulonglong
+*/
+
+/*!
+ \typedef quintptr
+ \relates <QtGlobal>
+
+ Integral type for representing a pointers (useful for hashing,
+ etc.).
+
+ Typedef for either quint32 or quint64. This type is guaranteed to
+ be the same size as a pointer on all platforms supported by Qt. On
+ a system with 32-bit pointers, quintptr is a typedef for quint32;
+ on a system with 64-bit pointers, quintptr is a typedef for
+ quint64.
+
+ Note that quintptr is unsigned. Use qptrdiff for signed values.
+
+ \sa qptrdiff, quint32, quint64
+*/
+
+/*!
+ \typedef qptrdiff
+ \relates <QtGlobal>
+
+ Integral type for representing pointer differences.
+
+ Typedef for either qint32 or qint64. This type is guaranteed to be
+ the same size as a pointer on all platforms supported by Qt. On a
+ system with 32-bit pointers, quintptr is a typedef for quint32; on
+ a system with 64-bit pointers, quintptr is a typedef for quint64.
+
+ Note that qptrdiff is signed. Use quintptr for unsigned values.
+
+ \sa quintptr, qint32, qint64
+*/
+
+/*!
+ \typedef QtMsgHandler
+ \relates <QtGlobal>
+
+ This is a typedef for a pointer to a function with the following
+ signature:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 7
+
+ \sa QtMsgType, qInstallMsgHandler()
+*/
+
+/*!
+ \enum QtMsgType
+ \relates <QtGlobal>
+
+ This enum describes the messages that can be sent to a message
+ handler (QtMsgHandler). You can use the enum to identify and
+ associate the various message types with the appropriate
+ actions.
+
+ \value QtDebugMsg
+ A message generated by the qDebug() function.
+ \value QtWarningMsg
+ A message generated by the qWarning() function.
+ \value QtCriticalMsg
+ A message generated by the qCritical() function.
+ \value QtFatalMsg
+ A message generated by the qFatal() function.
+ \value QtSystemMsg
+
+
+ \sa QtMsgHandler, qInstallMsgHandler()
+*/
+
+/*! \macro qint64 Q_INT64_C(literal)
+ \relates <QtGlobal>
+
+ Wraps the signed 64-bit integer \a literal in a
+ platform-independent way.
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 8
+
+ \sa qint64, Q_UINT64_C()
+*/
+
+/*! \macro quint64 Q_UINT64_C(literal)
+ \relates <QtGlobal>
+
+ Wraps the unsigned 64-bit integer \a literal in a
+ platform-independent way.
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 9
+
+ \sa quint64, Q_INT64_C()
+*/
+
+/*! \typedef qlonglong
+ \relates <QtGlobal>
+
+ Typedef for \c{long long int} (\c __int64 on Windows). This is
+ the same as \l qint64.
+
+ \sa qulonglong, qint64
+*/
+
+/*!
+ \typedef qulonglong
+ \relates <QtGlobal>
+
+ Typedef for \c{unsigned long long int} (\c{unsigned __int64} on
+ Windows). This is the same as \l quint64.
+
+ \sa quint64, qlonglong
+*/
+
+/*! \fn const T &qAbs(const T &value)
+ \relates <QtGlobal>
+
+ Compares \a value to the 0 of type T and returns the absolute
+ value. Thus if T is \e {double}, then \a value is compared to
+ \e{(double) 0}.
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 10
+*/
+
+/*! \fn int qRound(qreal value)
+ \relates <QtGlobal>
+
+ Rounds \a value to the nearest integer.
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 11
+*/
+
+/*! \fn qint64 qRound64(qreal value)
+ \relates <QtGlobal>
+
+ Rounds \a value to the nearest 64-bit integer.
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 12
+*/
+
+/*! \fn const T &qMin(const T &value1, const T &value2)
+ \relates <QtGlobal>
+
+ Returns the minimum of \a value1 and \a value2.
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 13
+
+ \sa qMax(), qBound()
+*/
+
+/*! \fn const T &qMax(const T &value1, const T &value2)
+ \relates <QtGlobal>
+
+ Returns the maximum of \a value1 and \a value2.
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 14
+
+ \sa qMin(), qBound()
+*/
+
+/*! \fn const T &qBound(const T &min, const T &value, const T &max)
+ \relates <QtGlobal>
+
+ Returns \a value bounded by \a min and \a max. This is equivalent
+ to qMax(\a min, qMin(\a value, \a max)).
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 15
+
+ \sa qMin(), qMax()
+*/
+
+/*!
+ \typedef Q_INT8
+ \relates <QtGlobal>
+ \compat
+
+ Use \l qint8 instead.
+*/
+
+/*!
+ \typedef Q_UINT8
+ \relates <QtGlobal>
+ \compat
+
+ Use \l quint8 instead.
+*/
+
+/*!
+ \typedef Q_INT16
+ \relates <QtGlobal>
+ \compat
+
+ Use \l qint16 instead.
+*/
+
+/*!
+ \typedef Q_UINT16
+ \relates <QtGlobal>
+ \compat
+
+ Use \l quint16 instead.
+*/
+
+/*!
+ \typedef Q_INT32
+ \relates <QtGlobal>
+ \compat
+
+ Use \l qint32 instead.
+*/
+
+/*!
+ \typedef Q_UINT32
+ \relates <QtGlobal>
+ \compat
+
+ Use \l quint32 instead.
+*/
+
+/*!
+ \typedef Q_INT64
+ \relates <QtGlobal>
+ \compat
+
+ Use \l qint64 instead.
+*/
+
+/*!
+ \typedef Q_UINT64
+ \relates <QtGlobal>
+ \compat
+
+ Use \l quint64 instead.
+*/
+
+/*!
+ \typedef Q_LLONG
+ \relates <QtGlobal>
+ \compat
+
+ Use \l qint64 instead.
+*/
+
+/*!
+ \typedef Q_ULLONG
+ \relates <QtGlobal>
+ \compat
+
+ Use \l quint64 instead.
+*/
+
+/*!
+ \typedef Q_LONG
+ \relates <QtGlobal>
+ \compat
+
+ Use \c{void *} instead.
+*/
+
+/*!
+ \typedef Q_ULONG
+ \relates <QtGlobal>
+ \compat
+
+ Use \c{void *} instead.
+*/
+
+/*! \fn bool qSysInfo(int *wordSize, bool *bigEndian)
+ \relates <QtGlobal>
+
+ Use QSysInfo::WordSize and QSysInfo::ByteOrder instead.
+*/
+
+/*!
+ \fn bool qt_winUnicode()
+ \relates <QtGlobal>
+
+ This function always returns true.
+
+ \sa QSysInfo
+*/
+
+/*!
+ \fn int qWinVersion()
+ \relates <QtGlobal>
+
+ Use QSysInfo::WindowsVersion instead.
+
+ \sa QSysInfo
+*/
+
+/*!
+ \fn int qMacVersion()
+ \relates <QtGlobal>
+
+ Use QSysInfo::MacintoshVersion instead.
+
+ \sa QSysInfo
+*/
+
+/*!
+ \macro QT_VERSION_CHECK
+ \relates <QtGlobal>
+
+ Turns the major, minor and patch numbers of a version into an
+ integer, 0xMMNNPP (MM = major, NN = minor, PP = patch). This can
+ be compared with another similarly processed version id.
+
+ \sa QT_VERSION
+*/
+
+/*!
+ \macro QT_VERSION
+ \relates <QtGlobal>
+
+ This macro expands a numeric value of the form 0xMMNNPP (MM =
+ major, NN = minor, PP = patch) that specifies Qt's version
+ number. For example, if you compile your application against Qt
+ 4.1.2, the QT_VERSION macro will expand to 0x040102.
+
+ You can use QT_VERSION to use the latest Qt features where
+ available.
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 16
+
+ \sa QT_VERSION_STR, qVersion()
+*/
+
+/*!
+ \macro QT_VERSION_STR
+ \relates <QtGlobal>
+
+ This macro expands to a string that specifies Qt's version number
+ (for example, "4.1.2"). This is the version against which the
+ application is compiled.
+
+ \sa qVersion(), QT_VERSION
+*/
+
+/*!
+ \relates <QtGlobal>
+
+ Returns the version number of Qt at run-time as a string (for
+ example, "4.1.2"). This may be a different version than the
+ version the application was compiled against.
+
+ \sa QT_VERSION_STR
+*/
+
+const char *qVersion()
+{
+ return QT_VERSION_STR;
+}
+
+bool qSharedBuild()
+{
+#ifdef QT_SHARED
+ return true;
+#else
+ return false;
+#endif
+}
+
+/*****************************************************************************
+ System detection routines
+ *****************************************************************************/
+
+/*!
+ \class QSysInfo
+ \brief The QSysInfo class provides information about the system.
+
+ \list
+ \o \l WordSize specifies the size of a pointer for the platform
+ on which the application is compiled.
+ \o \l ByteOrder specifies whether the platform is big-endian or
+ little-endian.
+ \o \l WindowsVersion specifies the version of the Windows operating
+ system on which the application is run (Windows only)
+ \o \l MacintoshVersion specifies the version of the Macintosh
+ operating system on which the application is run (Mac only).
+ \endlist
+
+ Some constants are defined only on certain platforms. You can use
+ the preprocessor symbols Q_WS_WIN and Q_WS_MAC to test that
+ the application is compiled under Windows or Mac.
+
+ \sa QLibraryInfo
+*/
+
+/*!
+ \enum QSysInfo::Sizes
+
+ This enum provides platform-specific information about the sizes of data
+ structures used by the underlying architecture.
+
+ \value WordSize The size in bits of a pointer for the platform on which
+ the application is compiled (32 or 64).
+*/
+
+/*!
+ \variable QSysInfo::WindowsVersion
+ \brief the version of the Windows operating system on which the
+ application is run (Windows only)
+*/
+
+/*!
+ \fn QSysInfo::WindowsVersion QSysInfo::windowsVersion()
+ \since 4.4
+
+ Returns the version of the Windows operating system on which the
+ application is run (Windows only).
+*/
+
+/*!
+ \variable QSysInfo::MacintoshVersion
+ \brief the version of the Macintosh operating system on which
+ the application is run (Mac only).
+*/
+
+/*!
+ \fn QSysInfo::SymbianVersion QSysInfo::symbianVersion()
+ \since 4.6
+
+ Returns the version of the Symbian operating system on which the
+ application is run (Symbian only).
+*/
+
+/*!
+ \fn QSysInfo::S60Version QSysInfo::s60Version()
+ \since 4.6
+
+ Returns the version of the S60 SDK system on which the
+ application is run (S60 only).
+*/
+
+/*!
+ \enum QSysInfo::Endian
+
+ \value BigEndian Big-endian byte order (also called Network byte order)
+ \value LittleEndian Little-endian byte order
+ \value ByteOrder Equals BigEndian or LittleEndian, depending on
+ the platform's byte order.
+*/
+
+/*!
+ \enum QSysInfo::WinVersion
+
+ This enum provides symbolic names for the various versions of the
+ Windows operating system. On Windows, the
+ QSysInfo::WindowsVersion variable gives the version of the system
+ on which the application is run.
+
+ MS-DOS-based versions:
+
+ \value WV_32s Windows 3.1 with Win 32s
+ \value WV_95 Windows 95
+ \value WV_98 Windows 98
+ \value WV_Me Windows Me
+
+ NT-based versions (note that each operating system version is only represented once rather than each Windows edition):
+
+ \value WV_NT Windows NT (operating system version 4.0)
+ \value WV_2000 Windows 2000 (operating system version 5.0)
+ \value WV_XP Windows XP (operating system version 5.1)
+ \value WV_2003 Windows Server 2003, Windows Server 2003 R2, Windows Home Server, Windows XP Professional x64 Edition (operating system version 5.2)
+ \value WV_VISTA Windows Vista, Windows Server 2008 (operating system version 6.0)
+ \value WV_WINDOWS7 Windows 7, Windows Server 2008 R2 (operating system version 6.1)
+
+ Alternatively, you may use the following macros which correspond directly to the Windows operating system version number:
+
+ \value WV_4_0 Operating system version 4.0, corresponds to Windows NT
+ \value WV_5_0 Operating system version 5.0, corresponds to Windows 2000
+ \value WV_5_1 Operating system version 5.1, corresponds to Windows XP
+ \value WV_5_2 Operating system version 5.2, corresponds to Windows Server 2003, Windows Server 2003 R2, Windows Home Server, and Windows XP Professional x64 Edition
+ \value WV_6_0 Operating system version 6.0, corresponds to Windows Vista and Windows Server 2008
+ \value WV_6_1 Operating system version 6.1, corresponds to Windows 7 and Windows Server 2008 R2
+
+ CE-based versions:
+
+ \value WV_CE Windows CE
+ \value WV_CENET Windows CE .NET
+ \value WV_CE_5 Windows CE 5.x
+ \value WV_CE_6 Windows CE 6.x
+
+ The following masks can be used for testing whether a Windows
+ version is MS-DOS-based, NT-based, or CE-based:
+
+ \value WV_DOS_based MS-DOS-based version of Windows
+ \value WV_NT_based NT-based version of Windows
+ \value WV_CE_based CE-based version of Windows
+
+ \sa MacVersion, SymbianVersion
+*/
+
+/*!
+ \enum QSysInfo::MacVersion
+
+ This enum provides symbolic names for the various versions of the
+ Macintosh operating system. On Mac, the
+ QSysInfo::MacintoshVersion variable gives the version of the
+ system on which the application is run.
+
+ \value MV_9 Mac OS 9 (unsupported)
+ \value MV_10_0 Mac OS X 10.0 (unsupported)
+ \value MV_10_1 Mac OS X 10.1 (unsupported)
+ \value MV_10_2 Mac OS X 10.2 (unsupported)
+ \value MV_10_3 Mac OS X 10.3
+ \value MV_10_4 Mac OS X 10.4
+ \value MV_10_5 Mac OS X 10.5
+ \value MV_10_6 Mac OS X 10.6
+ \value MV_Unknown An unknown and currently unsupported platform
+
+ \value MV_CHEETAH Apple codename for MV_10_0
+ \value MV_PUMA Apple codename for MV_10_1
+ \value MV_JAGUAR Apple codename for MV_10_2
+ \value MV_PANTHER Apple codename for MV_10_3
+ \value MV_TIGER Apple codename for MV_10_4
+ \value MV_LEOPARD Apple codename for MV_10_5
+ \value MV_SNOWLEOPARD Apple codename for MV_10_6
+
+ \sa WinVersion, SymbianVersion
+*/
+
+/*!
+ \enum QSysInfo::SymbianVersion
+
+ This enum provides symbolic names for the various versions of the
+ Symbian operating system. On Symbian, the
+ QSysInfo::symbianVersion() function gives the version of the
+ system on which the application is run.
+
+ \value SV_9_2 Symbian OS v9.2
+ \value SV_9_3 Symbian OS v9.3
+ \value SV_9_4 Symbian OS v9.4
+ \value SV_Unknown An unknown and currently unsupported platform
+
+ \sa S60Version, WinVersion, MacVersion
+*/
+
+/*!
+ \enum QSysInfo::S60Version
+
+ This enum provides symbolic names for the various versions of the
+ S60 SDK. On S60, the
+ QSysInfo::s60Version() function gives the version of the
+ SDK on which the application is run.
+
+ \value SV_S60_3_1 S60 3rd Edition Feature Pack 1
+ \value SV_S60_3_2 S60 3rd Edition Feature Pack 2
+ \value SV_S60_5_0 S60 5th Edition
+ \value SV_S60_Unknown An unknown and currently unsupported platform
+ \omitvalue SV_S60_None
+
+ \sa SymbianVersion, WinVersion, MacVersion
+*/
+
+/*!
+ \macro Q_WS_MAC
+ \relates <QtGlobal>
+
+ Defined on Mac OS X.
+
+ \sa Q_WS_WIN, Q_WS_X11, Q_WS_QWS
+*/
+
+/*!
+ \macro Q_WS_WIN
+ \relates <QtGlobal>
+
+ Defined on Windows.
+
+ \sa Q_WS_MAC, Q_WS_X11, Q_WS_QWS
+*/
+
+/*!
+ \macro Q_WS_X11
+ \relates <QtGlobal>
+
+ Defined on X11.
+
+ \sa Q_WS_MAC, Q_WS_WIN, Q_WS_QWS
+*/
+
+/*!
+ \macro Q_WS_QWS
+ \relates <QtGlobal>
+
+ Defined on Qt for Embedded Linux.
+
+ \sa Q_WS_MAC, Q_WS_WIN, Q_WS_X11
+*/
+
+/*!
+ \macro Q_OS_DARWIN
+ \relates <QtGlobal>
+
+ Defined on Darwin OS (synonym for Q_OS_MAC).
+*/
+
+/*!
+ \macro Q_OS_MSDOS
+ \relates <QtGlobal>
+
+ Defined on MS-DOS and Windows.
+*/
+
+/*!
+ \macro Q_OS_OS2
+ \relates <QtGlobal>
+
+ Defined on OS/2.
+*/
+
+/*!
+ \macro Q_OS_OS2EMX
+ \relates <QtGlobal>
+
+ Defined on XFree86 on OS/2 (not PM).
+*/
+
+/*!
+ \macro Q_OS_WIN32
+ \relates <QtGlobal>
+
+ Defined on all supported versions of Windows.
+*/
+
+/*!
+ \macro Q_OS_WINCE
+ \relates <QtGlobal>
+
+ Defined on Windows CE.
+*/
+
+/*!
+ \macro Q_OS_CYGWIN
+ \relates <QtGlobal>
+
+ Defined on Cygwin.
+*/
+
+/*!
+ \macro Q_OS_SOLARIS
+ \relates <QtGlobal>
+
+ Defined on Sun Solaris.
+*/
+
+/*!
+ \macro Q_OS_HPUX
+ \relates <QtGlobal>
+
+ Defined on HP-UX.
+*/
+
+/*!
+ \macro Q_OS_ULTRIX
+ \relates <QtGlobal>
+
+ Defined on DEC Ultrix.
+*/
+
+/*!
+ \macro Q_OS_LINUX
+ \relates <QtGlobal>
+
+ Defined on Linux.
+*/
+
+/*!
+ \macro Q_OS_FREEBSD
+ \relates <QtGlobal>
+
+ Defined on FreeBSD.
+*/
+
+/*!
+ \macro Q_OS_NETBSD
+ \relates <QtGlobal>
+
+ Defined on NetBSD.
+*/
+
+/*!
+ \macro Q_OS_OPENBSD
+ \relates <QtGlobal>
+
+ Defined on OpenBSD.
+*/
+
+/*!
+ \macro Q_OS_BSDI
+ \relates <QtGlobal>
+
+ Defined on BSD/OS.
+*/
+
+/*!
+ \macro Q_OS_IRIX
+ \relates <QtGlobal>
+
+ Defined on SGI Irix.
+*/
+
+/*!
+ \macro Q_OS_OSF
+ \relates <QtGlobal>
+
+ Defined on HP Tru64 UNIX.
+*/
+
+/*!
+ \macro Q_OS_SCO
+ \relates <QtGlobal>
+
+ Defined on SCO OpenServer 5.
+*/
+
+/*!
+ \macro Q_OS_UNIXWARE
+ \relates <QtGlobal>
+
+ Defined on UnixWare 7, Open UNIX 8.
+*/
+
+/*!
+ \macro Q_OS_AIX
+ \relates <QtGlobal>
+
+ Defined on AIX.
+*/
+
+/*!
+ \macro Q_OS_HURD
+ \relates <QtGlobal>
+
+ Defined on GNU Hurd.
+*/
+
+/*!
+ \macro Q_OS_DGUX
+ \relates <QtGlobal>
+
+ Defined on DG/UX.
+*/
+
+/*!
+ \macro Q_OS_RELIANT
+ \relates <QtGlobal>
+
+ Defined on Reliant UNIX.
+*/
+
+/*!
+ \macro Q_OS_DYNIX
+ \relates <QtGlobal>
+
+ Defined on DYNIX/ptx.
+*/
+
+/*!
+ \macro Q_OS_QNX
+ \relates <QtGlobal>
+
+ Defined on QNX Neutrino.
+*/
+
+/*!
+ \macro Q_OS_LYNX
+ \relates <QtGlobal>
+
+ Defined on LynxOS.
+*/
+
+/*!
+ \macro Q_OS_BSD4
+ \relates <QtGlobal>
+
+ Defined on Any BSD 4.4 system.
+*/
+
+/*!
+ \macro Q_OS_UNIX
+ \relates <QtGlobal>
+
+ Defined on Any UNIX BSD/SYSV system.
+*/
+
+/*!
+ \macro Q_CC_SYM
+ \relates <QtGlobal>
+
+ Defined if the application is compiled using Digital Mars C/C++
+ (used to be Symantec C++).
+*/
+
+/*!
+ \macro Q_CC_MWERKS
+ \relates <QtGlobal>
+
+ Defined if the application is compiled using Metrowerks
+ CodeWarrior.
+*/
+
+/*!
+ \macro Q_CC_MSVC
+ \relates <QtGlobal>
+
+ Defined if the application is compiled using Microsoft Visual
+ C/C++, Intel C++ for Windows.
+*/
+
+/*!
+ \macro Q_CC_BOR
+ \relates <QtGlobal>
+
+ Defined if the application is compiled using Borland/Turbo C++.
+*/
+
+/*!
+ \macro Q_CC_WAT
+ \relates <QtGlobal>
+
+ Defined if the application is compiled using Watcom C++.
+*/
+
+/*!
+ \macro Q_CC_GNU
+ \relates <QtGlobal>
+
+ Defined if the application is compiled using GNU C++.
+*/
+
+/*!
+ \macro Q_CC_COMEAU
+ \relates <QtGlobal>
+
+ Defined if the application is compiled using Comeau C++.
+*/
+
+/*!
+ \macro Q_CC_EDG
+ \relates <QtGlobal>
+
+ Defined if the application is compiled using Edison Design Group
+ C++.
+*/
+
+/*!
+ \macro Q_CC_OC
+ \relates <QtGlobal>
+
+ Defined if the application is compiled using CenterLine C++.
+*/
+
+/*!
+ \macro Q_CC_SUN
+ \relates <QtGlobal>
+
+ Defined if the application is compiled using Forte Developer, or
+ Sun Studio C++.
+*/
+
+/*!
+ \macro Q_CC_MIPS
+ \relates <QtGlobal>
+
+ Defined if the application is compiled using MIPSpro C++.
+*/
+
+/*!
+ \macro Q_CC_DEC
+ \relates <QtGlobal>
+
+ Defined if the application is compiled using DEC C++.
+*/
+
+/*!
+ \macro Q_CC_HPACC
+ \relates <QtGlobal>
+
+ Defined if the application is compiled using HP aC++.
+*/
+
+/*!
+ \macro Q_CC_USLC
+ \relates <QtGlobal>
+
+ Defined if the application is compiled using SCO OUDK and UDK.
+*/
+
+/*!
+ \macro Q_CC_CDS
+ \relates <QtGlobal>
+
+ Defined if the application is compiled using Reliant C++.
+*/
+
+/*!
+ \macro Q_CC_KAI
+ \relates <QtGlobal>
+
+ Defined if the application is compiled using KAI C++.
+*/
+
+/*!
+ \macro Q_CC_INTEL
+ \relates <QtGlobal>
+
+ Defined if the application is compiled using Intel C++ for Linux,
+ Intel C++ for Windows.
+*/
+
+/*!
+ \macro Q_CC_HIGHC
+ \relates <QtGlobal>
+
+ Defined if the application is compiled using MetaWare High C/C++.
+*/
+
+/*!
+ \macro Q_CC_PGI
+ \relates <QtGlobal>
+
+ Defined if the application is compiled using Portland Group C++.
+*/
+
+/*!
+ \macro Q_CC_GHS
+ \relates <QtGlobal>
+
+ Defined if the application is compiled using Green Hills
+ Optimizing C++ Compilers.
+*/
+
+#if defined(QT_BUILD_QMAKE)
+// needed to bootstrap qmake
+static const unsigned int qt_one = 1;
+const int QSysInfo::ByteOrder = ((*((unsigned char *) &qt_one) == 0) ? BigEndian : LittleEndian);
+#endif
+
+#if !defined(QWS) && defined(Q_OS_MAC)
+
+QT_BEGIN_INCLUDE_NAMESPACE
+#include "private/qcore_mac_p.h"
+#include "qnamespace.h"
+QT_END_INCLUDE_NAMESPACE
+
+Q_CORE_EXPORT OSErr qt_mac_create_fsref(const QString &file, FSRef *fsref)
+{
+ return FSPathMakeRef(reinterpret_cast<const UInt8 *>(file.toUtf8().constData()), fsref, 0);
+}
+
+// Don't use this function, it won't work in 10.5 (Leopard) and up
+Q_CORE_EXPORT OSErr qt_mac_create_fsspec(const QString &file, FSSpec *spec)
+{
+ FSRef fsref;
+ OSErr ret = qt_mac_create_fsref(file, &fsref);
+ if (ret == noErr)
+ ret = FSGetCatalogInfo(&fsref, kFSCatInfoNone, 0, 0, spec, 0);
+ return ret;
+}
+
+Q_CORE_EXPORT void qt_mac_to_pascal_string(QString s, Str255 str, TextEncoding encoding=0, int len=-1)
+{
+ if(len == -1)
+ len = s.length();
+#if 0
+ UnicodeMapping mapping;
+ mapping.unicodeEncoding = CreateTextEncoding(kTextEncodingUnicodeDefault,
+ kTextEncodingDefaultVariant,
+ kUnicode16BitFormat);
+ mapping.otherEncoding = (encoding ? encoding : );
+ mapping.mappingVersion = kUnicodeUseLatestMapping;
+
+ UnicodeToTextInfo info;
+ OSStatus err = CreateUnicodeToTextInfo(&mapping, &info);
+ if(err != noErr) {
+ qDebug("Qt: internal: Unable to create pascal string '%s'::%d [%ld]",
+ s.left(len).latin1(), (int)encoding, err);
+ return;
+ }
+ const int unilen = len * 2;
+ const UniChar *unibuf = (UniChar *)s.unicode();
+ ConvertFromUnicodeToPString(info, unilen, unibuf, str);
+ DisposeUnicodeToTextInfo(&info);
+#else
+ Q_UNUSED(encoding);
+ CFStringGetPascalString(QCFString(s), str, 256, CFStringGetSystemEncoding());
+#endif
+}
+
+Q_CORE_EXPORT QString qt_mac_from_pascal_string(const Str255 pstr) {
+ return QCFString(CFStringCreateWithPascalString(0, pstr, CFStringGetSystemEncoding()));
+}
+
+
+
+static QSysInfo::MacVersion macVersion()
+{
+ SInt32 gestalt_version;
+ if (Gestalt(gestaltSystemVersion, &gestalt_version) == noErr) {
+ return QSysInfo::MacVersion(((gestalt_version & 0x00F0) >> 4) + 2);
+ }
+ return QSysInfo::MV_Unknown;
+}
+const QSysInfo::MacVersion QSysInfo::MacintoshVersion = macVersion();
+
+#elif defined(Q_OS_WIN32) || defined(Q_OS_CYGWIN) || defined(Q_OS_WINCE)
+
+QT_BEGIN_INCLUDE_NAMESPACE
+#include "qt_windows.h"
+QT_END_INCLUDE_NAMESPACE
+
+QSysInfo::WinVersion QSysInfo::windowsVersion()
+{
+#ifndef VER_PLATFORM_WIN32s
+#define VER_PLATFORM_WIN32s 0
+#endif
+#ifndef VER_PLATFORM_WIN32_WINDOWS
+#define VER_PLATFORM_WIN32_WINDOWS 1
+#endif
+#ifndef VER_PLATFORM_WIN32_NT
+#define VER_PLATFORM_WIN32_NT 2
+#endif
+#ifndef VER_PLATFORM_WIN32_CE
+#define VER_PLATFORM_WIN32_CE 3
+#endif
+
+ static QSysInfo::WinVersion winver;
+ if (winver)
+ return winver;
+ winver = QSysInfo::WV_NT;
+ OSVERSIONINFOW osver;
+ osver.dwOSVersionInfoSize = sizeof(osver);
+ GetVersionEx(&osver);
+#ifdef Q_OS_WINCE
+ DWORD qt_cever = 0;
+ qt_cever = osver.dwMajorVersion * 100;
+ qt_cever += osver.dwMinorVersion * 10;
+#endif
+ switch (osver.dwPlatformId) {
+ case VER_PLATFORM_WIN32s:
+ winver = QSysInfo::WV_32s;
+ break;
+ case VER_PLATFORM_WIN32_WINDOWS:
+ // We treat Windows Me (minor 90) the same as Windows 98
+ if (osver.dwMinorVersion == 90)
+ winver = QSysInfo::WV_Me;
+ else if (osver.dwMinorVersion == 10)
+ winver = QSysInfo::WV_98;
+ else
+ winver = QSysInfo::WV_95;
+ break;
+#ifdef Q_OS_WINCE
+ case VER_PLATFORM_WIN32_CE:
+ if (qt_cever >= 600)
+ winver = QSysInfo::WV_CE_6;
+ if (qt_cever >= 500)
+ winver = QSysInfo::WV_CE_5;
+ else if (qt_cever >= 400)
+ winver = QSysInfo::WV_CENET;
+ else
+ winver = QSysInfo::WV_CE;
+ break;
+#endif
+ default: // VER_PLATFORM_WIN32_NT
+ if (osver.dwMajorVersion < 5) {
+ winver = QSysInfo::WV_NT;
+ } else if (osver.dwMajorVersion == 5 && osver.dwMinorVersion == 0) {
+ winver = QSysInfo::WV_2000;
+ } else if (osver.dwMajorVersion == 5 && osver.dwMinorVersion == 1) {
+ winver = QSysInfo::WV_XP;
+ } else if (osver.dwMajorVersion == 5 && osver.dwMinorVersion == 2) {
+ winver = QSysInfo::WV_2003;
+ } else if (osver.dwMajorVersion == 6 && osver.dwMinorVersion == 0) {
+ winver = QSysInfo::WV_VISTA;
+ } else if (osver.dwMajorVersion == 6 && osver.dwMinorVersion == 1) {
+ winver = QSysInfo::WV_WINDOWS7;
+ } else {
+ qWarning("Qt: Untested Windows version %d.%d detected!",
+ int(osver.dwMajorVersion), int(osver.dwMinorVersion));
+ winver = QSysInfo::WV_NT_based;
+ }
+ }
+
+#ifdef QT_DEBUG
+ {
+ QByteArray override = qgetenv("QT_WINVER_OVERRIDE");
+ if (override.isEmpty())
+ return winver;
+
+ if (override == "Me")
+ winver = QSysInfo::WV_Me;
+ if (override == "95")
+ winver = QSysInfo::WV_95;
+ else if (override == "98")
+ winver = QSysInfo::WV_98;
+ else if (override == "NT")
+ winver = QSysInfo::WV_NT;
+ else if (override == "2000")
+ winver = QSysInfo::WV_2000;
+ else if (override == "2003")
+ winver = QSysInfo::WV_2003;
+ else if (override == "XP")
+ winver = QSysInfo::WV_XP;
+ else if (override == "VISTA")
+ winver = QSysInfo::WV_VISTA;
+ else if (override == "WINDOWS7")
+ winver = QSysInfo::WV_WINDOWS7;
+ }
+#endif
+
+ return winver;
+}
+
+const QSysInfo::WinVersion QSysInfo::WindowsVersion = QSysInfo::windowsVersion();
+
+#endif
+
+#ifdef Q_OS_SYMBIAN
+# ifdef Q_WS_S60
+static QSysInfo::S60Version cachedS60Version = QSysInfo::S60Version(-1);
+
+QSysInfo::S60Version QSysInfo::s60Version()
+{
+ if (cachedS60Version != -1)
+ return cachedS60Version;
+
+ // Use pure Symbian code, because if done using QDir, there will be a call back
+ // to this method, resulting doing this expensive operation twice before the cache kicks in.
+ // Pure Symbian code also makes this method ~10x faster, speeding up the application launch.
+ RFs rfs = qt_s60GetRFs();
+ TFindFile fileFinder(rfs);
+ CDir* contents;
+ TInt err = fileFinder.FindWildByDir(qt_S60Filter, qt_S60SystemInstallDir, contents);
+ if (err == KErrNone) {
+ err = contents->Sort(EDescending|ESortByName);
+ if (err == KErrNone) {
+ TInt major = (*contents)[0].iName[9] - '0';
+ TInt minor = (*contents)[0].iName[11] - '0';
+ if (major == 3) {
+ if (minor == 1) {
+ return cachedS60Version = SV_S60_3_1;
+ } else if (minor == 2) {
+ return cachedS60Version = SV_S60_3_2;
+ }
+ } else if (major == 5) {
+ if (minor == 0) {
+ return cachedS60Version = SV_S60_5_0;
+ }
+ }
+ }
+ delete contents;
+ }
+
+# ifdef Q_CC_NOKIAX86
+ // Some emulator environments may not contain the version specific .sis files, so
+ // simply hardcode the version on those environments.
+# if defined(__SERIES60_31__)
+ return cachedS60Version = SV_S60_3_1;
+# elif defined(__S60_32__)
+ return cachedS60Version = SV_S60_3_2;
+# elif defined(__S60_50__)
+ return cachedS60Version = SV_S60_5_0;
+# else
+ return cachedS60Version = SV_S60_Unknown;
+# endif
+# else
+ return cachedS60Version = SV_S60_Unknown;
+# endif
+}
+QSysInfo::SymbianVersion QSysInfo::symbianVersion()
+{
+ switch (s60Version()) {
+ case SV_S60_3_1:
+ return SV_9_2;
+ case SV_S60_3_2:
+ return SV_9_3;
+ case SV_S60_5_0:
+ return SV_9_4;
+ default:
+ return SV_Unknown;
+ }
+}
+#else
+QSysInfo::S60Version QSysInfo::s60Version()
+{
+ return SV_S60_None;
+}
+
+QSysInfo::SymbianVersion QSysInfo::symbianVersion()
+{
+ return SV_Unknown;
+}
+# endif // ifdef Q_WS_S60
+#endif // ifdef Q_OS_SYMBIAN
+
+/*!
+ \macro void Q_ASSERT(bool test)
+ \relates <QtGlobal>
+
+ Prints a warning message containing the source code file name and
+ line number if \a test is false.
+
+ Q_ASSERT() is useful for testing pre- and post-conditions
+ during development. It does nothing if \c QT_NO_DEBUG was defined
+ during compilation.
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 17
+
+ If \c b is zero, the Q_ASSERT statement will output the following
+ message using the qFatal() function:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 18
+
+ \sa Q_ASSERT_X(), qFatal(), {Debugging Techniques}
+*/
+
+/*!
+ \macro void Q_ASSERT_X(bool test, const char *where, const char *what)
+ \relates <QtGlobal>
+
+ Prints the message \a what together with the location \a where,
+ the source file name and line number if \a test is false.
+
+ Q_ASSERT_X is useful for testing pre- and post-conditions during
+ development. It does nothing if \c QT_NO_DEBUG was defined during
+ compilation.
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 19
+
+ If \c b is zero, the Q_ASSERT_X statement will output the following
+ message using the qFatal() function:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 20
+
+ \sa Q_ASSERT(), qFatal(), {Debugging Techniques}
+*/
+
+/*!
+ \macro void Q_CHECK_PTR(void *pointer)
+ \relates <QtGlobal>
+
+ If \a pointer is 0, prints a warning message containing the source
+ code's file name and line number, saying that the program ran out
+ of memory.
+
+ Q_CHECK_PTR does nothing if \c QT_NO_DEBUG was defined during
+ compilation.
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 21
+
+ \sa qWarning(), {Debugging Techniques}
+*/
+
+/*!
+ \fn T *q_check_ptr(T *pointer)
+ \relates <QtGlobal>
+
+ Users Q_CHECK_PTR on \a pointer, then returns \a pointer.
+
+ This can be used as an inline version of Q_CHECK_PTR.
+*/
+
+/*!
+ \macro const char* Q_FUNC_INFO()
+ \relates <QtGlobal>
+
+ Expands to a string that describe the function the macro resides in. How this string looks
+ more specifically is compiler dependent. With GNU GCC it is typically the function signature,
+ while with other compilers it might be the line and column number.
+
+ Q_FUNC_INFO can be conveniently used with qDebug(). For example, this function:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 22
+
+ when instantiated with the integer type, will with the GCC compiler produce:
+
+ \tt{const TInputType& myMin(const TInputType&, const TInputType&) [with TInputType = int] was called with value1: 3 value2: 4}
+
+ If this macro is used outside a function, the behavior is undefined.
+ */
+
+/*
+ The Q_CHECK_PTR macro calls this function if an allocation check
+ fails.
+*/
+void qt_check_pointer(const char *n, int l)
+{
+ qWarning("In file %s, line %d: Out of memory", n, l);
+}
+
+#ifndef QT_NO_EXCEPTIONS
+/* \internal
+ Allows you to throw an exception without including <new>
+ Called internally from Q_CHECK_PTR on certain OS combinations
+*/
+void qBadAlloc()
+{
+ QT_THROW(std::bad_alloc());
+}
+#endif
+
+/*
+ The Q_ASSERT macro calls this function when the test fails.
+*/
+void qt_assert(const char *assertion, const char *file, int line)
+{
+ qFatal("ASSERT: \"%s\" in file %s, line %d", assertion, file, line);
+}
+
+/*
+ The Q_ASSERT_X macro calls this function when the test fails.
+*/
+void qt_assert_x(const char *where, const char *what, const char *file, int line)
+{
+ qFatal("ASSERT failure in %s: \"%s\", file %s, line %d", where, what, file, line);
+}
+
+
+/*
+ Dijkstra's bisection algorithm to find the square root of an integer.
+ Deliberately not exported as part of the Qt API, but used in both
+ qsimplerichtext.cpp and qgfxraster_qws.cpp
+*/
+Q_CORE_EXPORT unsigned int qt_int_sqrt(unsigned int n)
+{
+ // n must be in the range 0...UINT_MAX/2-1
+ if (n >= (UINT_MAX>>2)) {
+ unsigned int r = 2 * qt_int_sqrt(n / 4);
+ unsigned int r2 = r + 1;
+ return (n >= r2 * r2) ? r2 : r;
+ }
+ uint h, p= 0, q= 1, r= n;
+ while (q <= n)
+ q <<= 2;
+ while (q != 1) {
+ q >>= 2;
+ h= p + q;
+ p >>= 1;
+ if (r >= h) {
+ p += q;
+ r -= h;
+ }
+ }
+ return p;
+}
+
+#if defined(qMemCopy)
+# undef qMemCopy
+#endif
+#if defined(qMemSet)
+# undef qMemSet
+#endif
+
+void *qMemCopy(void *dest, const void *src, size_t n) { return memcpy(dest, src, n); }
+void *qMemSet(void *dest, int c, size_t n) { return memset(dest, c, n); }
+
+static QtMsgHandler handler = 0; // pointer to debug handler
+
+#if defined(Q_CC_MWERKS) && defined(Q_OS_MACX)
+extern bool qt_is_gui_used;
+static void mac_default_handler(const char *msg)
+{
+ if (qt_is_gui_used) {
+ Str255 pmsg;
+ qt_mac_to_pascal_string(msg, pmsg);
+ DebugStr(pmsg);
+ } else {
+ fprintf(stderr, msg);
+ }
+}
+#endif // Q_CC_MWERKS && Q_OS_MACX
+
+
+
+QString qt_error_string(int errorCode)
+{
+ const char *s = 0;
+ QString ret;
+ if (errorCode == -1) {
+#if defined(Q_OS_WIN)
+ errorCode = GetLastError();
+#else
+ errorCode = errno;
+#endif
+ }
+ switch (errorCode) {
+ case 0:
+ break;
+ case EACCES:
+ s = QT_TRANSLATE_NOOP("QIODevice", "Permission denied");
+ break;
+ case EMFILE:
+ s = QT_TRANSLATE_NOOP("QIODevice", "Too many open files");
+ break;
+ case ENOENT:
+ s = QT_TRANSLATE_NOOP("QIODevice", "No such file or directory");
+ break;
+ case ENOSPC:
+ s = QT_TRANSLATE_NOOP("QIODevice", "No space left on device");
+ break;
+ default: {
+#ifdef Q_OS_WIN
+ wchar_t *string = 0;
+ FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM,
+ NULL,
+ errorCode,
+ MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
+ (LPWSTR)&string,
+ 0,
+ NULL);
+ ret = QString::fromWCharArray(string);
+ LocalFree((HLOCAL)string);
+
+ if (ret.isEmpty() && errorCode == ERROR_MOD_NOT_FOUND)
+ ret = QString::fromLatin1("The specified module could not be found.");
+
+#elif !defined(QT_NO_THREAD) && defined(_POSIX_THREAD_SAFE_FUNCTIONS) && _POSIX_VERSION >= 200112L && !defined(Q_OS_INTEGRITY) && !defined(Q_OS_QNX)
+
+ QByteArray buf(1024, '\0');
+ strerror_r(errorCode, buf.data(), buf.size());
+ ret = QString::fromLocal8Bit(buf.constData());
+#else
+ ret = QString::fromLocal8Bit(strerror(errorCode));
+#endif
+ break; }
+ }
+ if (s)
+ // ######## this breaks moc build currently
+// ret = QCoreApplication::translate("QIODevice", s);
+ ret = QString::fromLatin1(s);
+ return ret.trimmed();
+}
+
+
+/*!
+ \fn QtMsgHandler qInstallMsgHandler(QtMsgHandler handler)
+ \relates <QtGlobal>
+
+ Installs a Qt message \a handler which has been defined
+ previously. Returns a pointer to the previous message handler
+ (which may be 0).
+
+ The message handler is a function that prints out debug messages,
+ warnings, critical and fatal error messages. The Qt library (debug
+ mode) contains hundreds of warning messages that are printed
+ when internal errors (usually invalid function arguments)
+ occur. Qt built in release mode also contains such warnings unless
+ QT_NO_WARNING_OUTPUT and/or QT_NO_DEBUG_OUTPUT have been set during
+ compilation. If you implement your own message handler, you get total
+ control of these messages.
+
+ The default message handler prints the message to the standard
+ output under X11 or to the debugger under Windows. If it is a
+ fatal message, the application aborts immediately.
+
+ Only one message handler can be defined, since this is usually
+ done on an application-wide basis to control debug output.
+
+ To restore the message handler, call \c qInstallMsgHandler(0).
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 23
+
+ \sa qDebug(), qWarning(), qCritical(), qFatal(), QtMsgType,
+ {Debugging Techniques}
+*/
+#if defined(Q_OS_WIN) && defined(QT_BUILD_CORE_LIB)
+extern bool usingWinMain;
+extern Q_CORE_EXPORT void qWinMsgHandler(QtMsgType t, const char* str);
+#endif
+
+QtMsgHandler qInstallMsgHandler(QtMsgHandler h)
+{
+ QtMsgHandler old = handler;
+ handler = h;
+#if defined(Q_OS_WIN) && defined(QT_BUILD_CORE_LIB)
+ if (!handler && usingWinMain)
+ handler = qWinMsgHandler;
+#endif
+ return old;
+}
+
+/*!
+ \internal
+*/
+void qt_message_output(QtMsgType msgType, const char *buf)
+{
+ if (handler) {
+ (*handler)(msgType, buf);
+ } else {
+#if defined(Q_CC_MWERKS) && defined(Q_OS_MACX)
+ mac_default_handler(buf);
+#elif defined(Q_OS_WINCE)
+ QString fstr = QString::fromLatin1(buf);
+ fstr += QLatin1Char('\n');
+ OutputDebugString(reinterpret_cast<const wchar_t *> (fstr.utf16()));
+#elif defined(Q_OS_SYMBIAN)
+ _LIT(format, "[Qt Message] %S");
+ const TPtrC8 ptr(reinterpret_cast<const TUint8*>(buf));
+#if !defined(QT_WARNING_FILE_OUTPUT)
+ // RDebug::Print has a cap of 256 characters so break it up
+ const int maxBlockSize = 256 - ((const TDesC &)format).Length();
+ HBufC* hbuffer = q_check_ptr(HBufC::New(qMin(maxBlockSize, ptr.Length())));
+ for (int i = 0; i < ptr.Length(); i += hbuffer->Length()) {
+ hbuffer->Des().Copy(ptr.Mid(i, qMin(maxBlockSize, ptr.Length()-i)));
+ RDebug::Print(format, hbuffer);
+ }
+ delete hbuffer;
+#else
+ _LIT( KLogDir, "QT" );
+ _LIT( KLogFile, "QT.log" );
+ _LIT( KLogStarting, "*** Starting new Qt application ***");
+ static bool logStarted;
+ if ( !logStarted ){
+ RFileLogger::Write( KLogDir, KLogFile, EFileLoggingModeAppend, KLogStarting );
+ logStarted = true;
+ }
+
+ RFileLogger::Write( KLogDir, KLogFile, EFileLoggingModeAppend, ptr );
+#endif
+#else
+ fprintf(stderr, "%s\n", buf);
+ fflush(stderr);
+#endif
+ }
+
+ if (msgType == QtFatalMsg
+ || (msgType == QtWarningMsg
+ && (!qgetenv("QT_FATAL_WARNINGS").isNull())) ) {
+
+#if defined(Q_CC_MSVC) && defined(QT_DEBUG) && defined(_DEBUG) && defined(_CRT_ERROR)
+ // get the current report mode
+ int reportMode = _CrtSetReportMode(_CRT_ERROR, _CRTDBG_MODE_WNDW);
+ _CrtSetReportMode(_CRT_ERROR, reportMode);
+#if !defined(Q_OS_WINCE)
+ int ret = _CrtDbgReport(_CRT_ERROR, __FILE__, __LINE__, QT_VERSION_STR, buf);
+#else
+ int ret = _CrtDbgReportW(_CRT_ERROR, _CRT_WIDE(__FILE__),
+ __LINE__, _CRT_WIDE(QT_VERSION_STR), reinterpret_cast<const wchar_t *> (QString::fromLatin1(buf).utf16()));
+#endif
+ if (ret == 0 && reportMode & _CRTDBG_MODE_WNDW)
+ return; // ignore
+ else if (ret == 1)
+ _CrtDbgBreak();
+#endif
+
+#if defined(Q_OS_SYMBIAN)
+ __DEBUGGER(); // on the emulator, get the debugger to kick in if there's one around
+ TBuf<256> tmp;
+ TPtrC8 ptr(reinterpret_cast<const TUint8*>(buf));
+ TInt len = Min(tmp.MaxLength(), ptr.Length());
+ tmp.Copy(ptr.Left(len));
+ // Panic the current thread. We don't use real panic codes, so 0 has no special meaning.
+ User::Panic(tmp, 0);
+#elif (defined(Q_OS_UNIX) || defined(Q_CC_MINGW))
+ abort(); // trap; generates core dump
+#else
+ exit(1); // goodbye cruel world
+#endif
+ }
+}
+
+#if !defined(QT_NO_EXCEPTIONS)
+/*!
+ \internal
+ Uses a local buffer to output the message. Not locale safe + cuts off
+ everything after character 255, but will work in out of memory situations.
+*/
+static void qEmergencyOut(QtMsgType msgType, const char *msg, va_list ap)
+{
+ char emergency_buf[256] = { '\0' };
+ emergency_buf[255] = '\0';
+ if (msg)
+ qvsnprintf(emergency_buf, 255, msg, ap);
+ qt_message_output(msgType, emergency_buf);
+}
+#endif
+
+/*!
+ \internal
+*/
+static void qt_message(QtMsgType msgType, const char *msg, va_list ap)
+{
+#if !defined(QT_NO_EXCEPTIONS)
+ if (std::uncaught_exception()) {
+ qEmergencyOut(msgType, msg, ap);
+ return;
+ }
+#endif
+ QByteArray buf;
+ if (msg) {
+ QT_TRY {
+ buf = QString().vsprintf(msg, ap).toLocal8Bit();
+ } QT_CATCH(const std::bad_alloc &) {
+#if !defined(QT_NO_EXCEPTIONS)
+ qEmergencyOut(msgType, msg, ap);
+ // don't rethrow - we use qWarning and friends in destructors.
+ return;
+#endif
+ }
+ }
+ qt_message_output(msgType, buf.constData());
+}
+
+#undef qDebug
+/*!
+ \relates <QtGlobal>
+
+ Calls the message handler with the debug message \a msg. If no
+ message handler has been installed, the message is printed to
+ stderr. Under Windows, the message is sent to the console, if it is a
+ console application; otherwise, it is sent to the debugger. This
+ function does nothing if \c QT_NO_DEBUG_OUTPUT was defined
+ during compilation.
+
+ If you pass the function a format string and a list of arguments,
+ it works in similar way to the C printf() function. The format
+ should be a Latin-1 string.
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 24
+
+ If you include \c <QtDebug>, a more convenient syntax is also
+ available:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 25
+
+ With this syntax, the function returns a QDebug object that is
+ configured to use the QtDebugMsg message type. It automatically
+ puts a single space between each item, and outputs a newline at
+ the end. It supports many C++ and Qt types.
+
+ To suppress the output at run-time, install your own message handler
+ with qInstallMsgHandler().
+
+ \sa qWarning(), qCritical(), qFatal(), qInstallMsgHandler(),
+ {Debugging Techniques}
+*/
+void qDebug(const char *msg, ...)
+{
+ va_list ap;
+ va_start(ap, msg); // use variable arg list
+ qt_message(QtDebugMsg, msg, ap);
+ va_end(ap);
+}
+
+#undef qWarning
+/*!
+ \relates <QtGlobal>
+
+ Calls the message handler with the warning message \a msg. If no
+ message handler has been installed, the message is printed to
+ stderr. Under Windows, the message is sent to the debugger. This
+ function does nothing if \c QT_NO_WARNING_OUTPUT was defined
+ during compilation; it exits if the environment variable \c
+ QT_FATAL_WARNINGS is defined.
+
+ This function takes a format string and a list of arguments,
+ similar to the C printf() function. The format should be a Latin-1
+ string.
+
+ Example:
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 26
+
+ If you include <QtDebug>, a more convenient syntax is
+ also available:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 27
+
+ This syntax inserts a space between each item, and
+ appends a newline at the end.
+
+ To supress the output at runtime, install your own message handler
+ with qInstallMsgHandler().
+
+ \sa qDebug(), qCritical(), qFatal(), qInstallMsgHandler(),
+ {Debugging Techniques}
+*/
+void qWarning(const char *msg, ...)
+{
+ va_list ap;
+ va_start(ap, msg); // use variable arg list
+ qt_message(QtWarningMsg, msg, ap);
+ va_end(ap);
+}
+
+/*!
+ \relates <QtGlobal>
+
+ Calls the message handler with the critical message \a msg. If no
+ message handler has been installed, the message is printed to
+ stderr. Under Windows, the message is sent to the debugger.
+
+ This function takes a format string and a list of arguments,
+ similar to the C printf() function. The format should be a Latin-1
+ string.
+
+ Example:
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 28
+
+ If you include <QtDebug>, a more convenient syntax is
+ also available:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 29
+
+ A space is inserted between the items, and a newline is
+ appended at the end.
+
+ To supress the output at runtime, install your own message handler
+ with qInstallMsgHandler().
+
+ \sa qDebug(), qWarning(), qFatal(), qInstallMsgHandler(),
+ {Debugging Techniques}
+*/
+void qCritical(const char *msg, ...)
+{
+ va_list ap;
+ va_start(ap, msg); // use variable arg list
+ qt_message(QtCriticalMsg, msg, ap);
+ va_end(ap);
+}
+
+#ifdef QT3_SUPPORT
+void qSystemWarning(const char *msg, int code)
+ { qCritical("%s (%s)", msg, qt_error_string(code).toLocal8Bit().constData()); }
+#endif // QT3_SUPPORT
+
+void qErrnoWarning(const char *msg, ...)
+{
+ // qt_error_string() will allocate anyway, so we don't have
+ // to be careful here (like we do in plain qWarning())
+ QString buf;
+ va_list ap;
+ va_start(ap, msg);
+ if (msg)
+ buf.vsprintf(msg, ap);
+ va_end(ap);
+
+ qCritical("%s (%s)", buf.toLocal8Bit().constData(), qt_error_string(-1).toLocal8Bit().constData());
+}
+
+void qErrnoWarning(int code, const char *msg, ...)
+{
+ // qt_error_string() will allocate anyway, so we don't have
+ // to be careful here (like we do in plain qWarning())
+ QString buf;
+ va_list ap;
+ va_start(ap, msg);
+ if (msg)
+ buf.vsprintf(msg, ap);
+ va_end(ap);
+
+ qCritical("%s (%s)", buf.toLocal8Bit().constData(), qt_error_string(code).toLocal8Bit().constData());
+}
+
+/*!
+ \relates <QtGlobal>
+
+ Calls the message handler with the fatal message \a msg. If no
+ message handler has been installed, the message is printed to
+ stderr. Under Windows, the message is sent to the debugger.
+
+ If you are using the \bold{default message handler} this function will
+ abort on Unix systems to create a core dump. On Windows, for debug builds,
+ this function will report a _CRT_ERROR enabling you to connect a debugger
+ to the application.
+
+ This function takes a format string and a list of arguments,
+ similar to the C printf() function.
+
+ Example:
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 30
+
+ To supress the output at runtime, install your own message handler
+ with qInstallMsgHandler().
+
+ \sa qDebug(), qCritical(), qWarning(), qInstallMsgHandler(),
+ {Debugging Techniques}
+*/
+void qFatal(const char *msg, ...)
+{
+ va_list ap;
+ va_start(ap, msg); // use variable arg list
+ qt_message(QtFatalMsg, msg, ap);
+ va_end(ap);
+}
+
+// getenv is declared as deprecated in VS2005. This function
+// makes use of the new secure getenv function.
+QByteArray qgetenv(const char *varName)
+{
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+ size_t requiredSize = 0;
+ QByteArray buffer;
+ getenv_s(&requiredSize, 0, 0, varName);
+ if (requiredSize == 0)
+ return buffer;
+ buffer.resize(int(requiredSize));
+ getenv_s(&requiredSize, buffer.data(), requiredSize, varName);
+ // requiredSize includes the terminating null, which we don't want.
+ Q_ASSERT(buffer.endsWith('\0'));
+ buffer.chop(1);
+ return buffer;
+#else
+ return QByteArray(::getenv(varName));
+#endif
+}
+
+bool qputenv(const char *varName, const QByteArray& value)
+{
+#if defined(_MSC_VER) && _MSC_VER >= 1400
+ return _putenv_s(varName, value.constData()) == 0;
+#else
+ QByteArray buffer(varName);
+ buffer += '=';
+ buffer += value;
+ char* envVar = qstrdup(buffer.constData());
+ int result = putenv(envVar);
+ if (result != 0) // error. we have to delete the string.
+ delete[] envVar;
+ return result == 0;
+#endif
+}
+
+#if (defined(Q_OS_UNIX) || defined(Q_OS_WIN)) && !defined(QT_NO_THREAD) && !defined(Q_OS_SYMBIAN)
+
+# if defined(Q_OS_INTEGRITY) && defined(__GHS_VERSION_NUMBER) && (__GHS_VERSION_NUMBER < 500)
+// older versions of INTEGRITY used a long instead of a uint for the seed.
+typedef long SeedStorageType;
+# else
+typedef uint SeedStorageType;
+# endif
+
+typedef QThreadStorage<SeedStorageType *> SeedStorage;
+Q_GLOBAL_STATIC(SeedStorage, randTLS) // Thread Local Storage for seed value
+
+#endif
+
+/*!
+ \relates <QtGlobal>
+ \since 4.2
+
+ Thread-safe version of the standard C++ \c srand() function.
+
+ Sets the argument \a seed to be used to generate a new random number sequence of
+ pseudo random integers to be returned by qrand().
+
+ If no seed value is provided, qrand() is automatically seeded with a value of 1.
+
+ The sequence of random numbers generated is deterministic per thread. For example,
+ if two threads call qsrand(1) and subsequently calls qrand(), the threads will get
+ the same random number sequence.
+
+ \sa qrand()
+*/
+void qsrand(uint seed)
+{
+#if defined(Q_OS_UNIX) && !defined(QT_NO_THREAD) && !defined(Q_OS_SYMBIAN)
+ SeedStorageType *pseed = randTLS()->localData();
+ if (!pseed)
+ randTLS()->setLocalData(pseed = new SeedStorageType);
+ *pseed = seed;
+#else
+ // On Windows srand() and rand() already use Thread-Local-Storage
+ // to store the seed between calls
+ srand(seed);
+#endif
+}
+
+/*! \internal
+ \relates <QtGlobal>
+ \since 4.6
+
+ Seed the PRNG, but only if it has not already been seeded.
+
+ The default seed is a combination of current time, a stack address and a
+ serial counter (since thread stack addresses are re-used).
+*/
+void qsrand()
+{
+#if (defined(Q_OS_UNIX) || defined(Q_OS_WIN)) && !defined(QT_NO_THREAD) && !defined(Q_OS_SYMBIAN)
+ SeedStorageType *pseed = randTLS()->localData();
+ if (pseed) {
+ // already seeded
+ return;
+ }
+ randTLS()->setLocalData(pseed = new SeedStorageType);
+ // start beyond 1 to avoid the sequence reset
+ static QBasicAtomicInt serial = Q_BASIC_ATOMIC_INITIALIZER(2);
+ *pseed = QDateTime::currentDateTime().toTime_t()
+ + quintptr(&pseed)
+ + serial.fetchAndAddRelaxed(1);
+#if defined(Q_OS_WIN)
+ // for Windows the srand function must still be called.
+ srand(*pseed);
+#endif
+
+#elif defined(Q_OS_WIN)
+ static unsigned int seed = 0;
+
+ if (seed)
+ return;
+
+ seed = GetTickCount();
+ srand(seed);
+#else
+ // Symbian?
+
+#endif // defined(Q_OS_UNIX) || defined(Q_OS_WIN)) && !defined(QT_NO_THREAD) && !defined(Q_OS_SYMBIAN)
+}
+
+/*!
+ \relates <QtGlobal>
+ \since 4.2
+
+ Thread-safe version of the standard C++ \c rand() function.
+
+ Returns a value between 0 and \c RAND_MAX (defined in \c <cstdlib> and
+ \c <stdlib.h>), the next number in the current sequence of pseudo-random
+ integers.
+
+ Use \c qsrand() to initialize the pseudo-random number generator with
+ a seed value.
+
+ \sa qsrand()
+*/
+int qrand()
+{
+#if defined(Q_OS_UNIX) && !defined(QT_NO_THREAD) && !defined(Q_OS_SYMBIAN)
+ SeedStorageType *pseed = randTLS()->localData();
+ if (!pseed) {
+ randTLS()->setLocalData(pseed = new SeedStorageType);
+ *pseed = 1;
+ }
+ return rand_r(pseed);
+#else
+ // On Windows srand() and rand() already use Thread-Local-Storage
+ // to store the seed between calls
+ return rand();
+#endif
+}
+
+/*!
+ \macro forever
+ \relates <QtGlobal>
+
+ This macro is provided for convenience for writing infinite
+ loops.
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 31
+
+ It is equivalent to \c{for (;;)}.
+
+ If you're worried about namespace pollution, you can disable this
+ macro by adding the following line to your \c .pro file:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 32
+
+ \sa Q_FOREVER
+*/
+
+/*!
+ \macro Q_FOREVER
+ \relates <QtGlobal>
+
+ Same as \l{forever}.
+
+ This macro is available even when \c no_keywords is specified
+ using the \c .pro file's \c CONFIG variable.
+
+ \sa foreach()
+*/
+
+/*!
+ \macro foreach(variable, container)
+ \relates <QtGlobal>
+
+ This macro is used to implement Qt's \c foreach loop. The \a
+ variable parameter is a variable name or variable definition; the
+ \a container parameter is a Qt container whose value type
+ corresponds to the type of the variable. See \l{The foreach
+ Keyword} for details.
+
+ If you're worried about namespace pollution, you can disable this
+ macro by adding the following line to your \c .pro file:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 33
+
+ \sa Q_FOREACH()
+*/
+
+/*!
+ \macro Q_FOREACH(variable, container)
+ \relates <QtGlobal>
+
+ Same as foreach(\a variable, \a container).
+
+ This macro is available even when \c no_keywords is specified
+ using the \c .pro file's \c CONFIG variable.
+
+ \sa foreach()
+*/
+
+/*!
+ \macro QT_TR_NOOP(sourceText)
+ \relates <QtGlobal>
+
+ Marks the string literal \a sourceText for dynamic translation in
+ the current context (class), i.e the stored \a sourceText will not
+ be altered.
+
+ The macro expands to \a sourceText.
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 34
+
+ The macro QT_TR_NOOP_UTF8() is identical except that it tells lupdate
+ that the source string is encoded in UTF-8. Corresponding variants
+ exist in the QT_TRANSLATE_NOOP() family of macros, too. Note that
+ using these macros is not required if \c CODECFORTR is already set to
+ UTF-8 in the qmake project file.
+
+ \sa QT_TRANSLATE_NOOP(), {Internationalization with Qt}
+*/
+
+/*!
+ \macro QT_TRANSLATE_NOOP(context, sourceText)
+ \relates <QtGlobal>
+
+ Marks the string literal \a sourceText for dynamic translation in
+ the given \a context; i.e, the stored \a sourceText will not be
+ altered. The \a context is typically a class and also needs to
+ be specified as string literal.
+
+ The macro expands to \a sourceText.
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 35
+
+ \sa QT_TR_NOOP(), QT_TRANSLATE_NOOP3(), {Internationalization with Qt}
+*/
+
+/*!
+ \macro QT_TRANSLATE_NOOP3(context, sourceText, comment)
+ \relates <QtGlobal>
+ \since 4.4
+
+ Marks the string literal \a sourceText for dynamic translation in the
+ given \a context and with \a comment, i.e the stored \a sourceText will
+ not be altered. The \a context is typically a class and also needs to
+ be specified as string literal. The string literal \a comment
+ will be available for translators using e.g. Qt Linguist.
+
+ The macro expands to anonymous struct of the two string
+ literals passed as \a sourceText and \a comment.
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 36
+
+ \sa QT_TR_NOOP(), QT_TRANSLATE_NOOP(), {Internationalization with Qt}
+*/
+
+/*!
+ \fn QString qtTrId(const char *id, int n = -1)
+ \relates <QtGlobal>
+ \reentrant
+ \since 4.6
+
+ \brief The qtTrId function finds and returns a translated string.
+
+ Returns a translated string identified by \a id.
+ If no matching string is found, the id itself is returned. This
+ should not happen under normal conditions.
+
+ If \a n >= 0, all occurrences of \c %n in the resulting string
+ are replaced with a decimal representation of \a n. In addition,
+ depending on \a n's value, the translation text may vary.
+
+ Meta data and comments can be passed as documented for QObject::tr().
+ In addition, it is possible to supply a source string template like that:
+
+ \tt{//% <C string>}
+
+ or
+
+ \tt{\begincomment% <C string> \endcomment}
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp qttrid
+
+ Creating QM files suitable for use with this function requires passing
+ the \c -idbased option to the \c lrelease tool.
+
+ \warning This method is reentrant only if all translators are
+ installed \e before calling this method. Installing or removing
+ translators while performing translations is not supported. Doing
+ so will probably result in crashes or other undesirable behavior.
+
+ \sa QObject::tr(), QCoreApplication::translate(), {Internationalization with Qt}
+*/
+
+/*!
+ \macro QT_TRID_NOOP(id)
+ \relates <QtGlobal>
+ \since 4.6
+
+ \brief The QT_TRID_NOOP macro marks an id for dynamic translation.
+
+ The only purpose of this macro is to provide an anchor for attaching
+ meta data like to qtTrId().
+
+ The macro expands to \a id.
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp qttrid_noop
+
+ \sa qtTrId(), {Internationalization with Qt}
+*/
+
+/*!
+ \macro QT_POINTER_SIZE
+ \relates <QtGlobal>
+
+ Expands to the size of a pointer in bytes (4 or 8). This is
+ equivalent to \c sizeof(void *) but can be used in a preprocessor
+ directive.
+*/
+
+/*!
+ \macro TRUE
+ \relates <QtGlobal>
+ \obsolete
+
+ Synonym for \c true.
+
+ \sa FALSE
+*/
+
+/*!
+ \macro FALSE
+ \relates <QtGlobal>
+ \obsolete
+
+ Synonym for \c false.
+
+ \sa TRUE
+*/
+
+/*!
+ \macro QABS(n)
+ \relates <QtGlobal>
+ \obsolete
+
+ Use qAbs(\a n) instead.
+
+ \sa QMIN(), QMAX()
+*/
+
+/*!
+ \macro QMIN(x, y)
+ \relates <QtGlobal>
+ \obsolete
+
+ Use qMin(\a x, \a y) instead.
+
+ \sa QMAX(), QABS()
+*/
+
+/*!
+ \macro QMAX(x, y)
+ \relates <QtGlobal>
+ \obsolete
+
+ Use qMax(\a x, \a y) instead.
+
+ \sa QMIN(), QABS()
+*/
+
+/*!
+ \macro const char *qPrintable(const QString &str)
+ \relates <QtGlobal>
+
+ Returns \a str as a \c{const char *}. This is equivalent to
+ \a{str}.toLocal8Bit().constData().
+
+ The char pointer will be invalid after the statement in which
+ qPrintable() is used. This is because the array returned by
+ toLocal8Bit() will fall out of scope.
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 37
+
+
+ \sa qDebug(), qWarning(), qCritical(), qFatal()
+*/
+
+/*!
+ \macro Q_DECLARE_TYPEINFO(Type, Flags)
+ \relates <QtGlobal>
+
+ You can use this macro to specify information about a custom type
+ \a Type. With accurate type information, Qt's \l{generic
+ containers} can choose appropriate storage methods and algorithms.
+
+ \a Flags can be one of the following:
+
+ \list
+ \o \c Q_PRIMITIVE_TYPE specifies that \a Type is a POD (plain old
+ data) type with no constructor or destructor.
+ \o \c Q_MOVABLE_TYPE specifies that \a Type has a constructor
+ and/or a destructor but can be moved in memory using \c
+ memcpy().
+ \o \c Q_COMPLEX_TYPE (the default) specifies that \a Type has
+ constructors and/or a destructor and that it may not be moved
+ in memory.
+ \endlist
+
+ Example of a "primitive" type:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 38
+
+ Example of a movable type:
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 39
+*/
+
+/*!
+ \macro Q_UNUSED(name)
+ \relates <QtGlobal>
+
+ Indicates to the compiler that the parameter with the specified
+ \a name is not used in the body of a function. This can be used to
+ suppress compiler warnings while allowing functions to be defined
+ with meaningful parameter names in their signatures.
+*/
+
+#if defined(QT3_SUPPORT) && !defined(QT_NO_SETTINGS)
+QT_BEGIN_INCLUDE_NAMESPACE
+#include <qlibraryinfo.h>
+QT_END_INCLUDE_NAMESPACE
+
+static const char *qInstallLocation(QLibraryInfo::LibraryLocation loc)
+{
+ static QByteArray ret;
+ ret = QLibraryInfo::location(loc).toLatin1();
+ return ret.constData();
+}
+const char *qInstallPath()
+{
+ return qInstallLocation(QLibraryInfo::PrefixPath);
+}
+const char *qInstallPathDocs()
+{
+ return qInstallLocation(QLibraryInfo::DocumentationPath);
+}
+const char *qInstallPathHeaders()
+{
+ return qInstallLocation(QLibraryInfo::HeadersPath);
+}
+const char *qInstallPathLibs()
+{
+ return qInstallLocation(QLibraryInfo::LibrariesPath);
+}
+const char *qInstallPathBins()
+{
+ return qInstallLocation(QLibraryInfo::BinariesPath);
+}
+const char *qInstallPathPlugins()
+{
+ return qInstallLocation(QLibraryInfo::PluginsPath);
+}
+const char *qInstallPathData()
+{
+ return qInstallLocation(QLibraryInfo::DataPath);
+}
+const char *qInstallPathTranslations()
+{
+ return qInstallLocation(QLibraryInfo::TranslationsPath);
+}
+const char *qInstallPathSysconf()
+{
+ return qInstallLocation(QLibraryInfo::SettingsPath);
+}
+#endif
+
+struct QInternal_CallBackTable {
+ QVector<QList<qInternalCallback> > callbacks;
+};
+
+Q_GLOBAL_STATIC(QInternal_CallBackTable, global_callback_table)
+
+bool QInternal::registerCallback(Callback cb, qInternalCallback callback)
+{
+ if (cb >= 0 && cb < QInternal::LastCallback) {
+ QInternal_CallBackTable *cbt = global_callback_table();
+ cbt->callbacks.resize(cb + 1);
+ cbt->callbacks[cb].append(callback);
+ return true;
+ }
+ return false;
+}
+
+bool QInternal::unregisterCallback(Callback cb, qInternalCallback callback)
+{
+ if (cb >= 0 && cb < QInternal::LastCallback) {
+ QInternal_CallBackTable *cbt = global_callback_table();
+ return (bool) cbt->callbacks[cb].removeAll(callback);
+ }
+ return false;
+}
+
+bool QInternal::activateCallbacks(Callback cb, void **parameters)
+{
+ Q_ASSERT_X(cb >= 0, "QInternal::activateCallback()", "Callback id must be a valid id");
+
+ QInternal_CallBackTable *cbt = global_callback_table();
+ if (cbt && cb < cbt->callbacks.size()) {
+ QList<qInternalCallback> callbacks = cbt->callbacks[cb];
+ bool ret = false;
+ for (int i=0; i<callbacks.size(); ++i)
+ ret |= (callbacks.at(i))(parameters);
+ return ret;
+ }
+ return false;
+}
+
+extern void qt_set_current_thread_to_main_thread();
+
+bool QInternal::callFunction(InternalFunction func, void **args)
+{
+ Q_ASSERT_X(func >= 0,
+ "QInternal::callFunction()", "Callback id must be a valid id");
+#ifndef QT_NO_QOBJECT
+ switch (func) {
+#ifndef QT_NO_THREAD
+ case QInternal::CreateThreadForAdoption:
+ *args = QAdoptedThread::createThreadForAdoption();
+ return true;
+#endif
+ case QInternal::RefAdoptedThread:
+ QThreadData::get2((QThread *) *args)->ref();
+ return true;
+ case QInternal::DerefAdoptedThread:
+ QThreadData::get2((QThread *) *args)->deref();
+ return true;
+ case QInternal::SetCurrentThreadToMainThread:
+ qt_set_current_thread_to_main_thread();
+ return true;
+ case QInternal::SetQObjectSender: {
+ QObject *receiver = (QObject *) args[0];
+ QObjectPrivate::Sender *sender = new QObjectPrivate::Sender;
+ sender->sender = (QObject *) args[1];
+ sender->signal = *(int *) args[2];
+ sender->ref = 1;
+
+ // Store the old sender as "return value"
+ args[3] = QObjectPrivate::setCurrentSender(receiver, sender);
+ args[4] = sender;
+ return true;
+ }
+ case QInternal::GetQObjectSender: {
+ QObject *receiver = (QObject *) args[0];
+ QObjectPrivate *d = QObjectPrivate::get(receiver);
+ args[1] = d->currentSender ? d->currentSender->sender : 0;
+ return true;
+ }
+ case QInternal::ResetQObjectSender: {
+ QObject *receiver = (QObject *) args[0];
+ QObjectPrivate::Sender *oldSender = (QObjectPrivate::Sender *) args[1];
+ QObjectPrivate::Sender *sender = (QObjectPrivate::Sender *) args[2];
+ QObjectPrivate::resetCurrentSender(receiver, sender, oldSender);
+ delete sender;
+ return true;
+ }
+
+ default:
+ break;
+ }
+#else
+ Q_UNUSED(args);
+ Q_UNUSED(func);
+#endif
+
+ return false;
+}
+
+/*!
+ \macro Q_BYTE_ORDER
+ \relates <QtGlobal>
+
+ This macro can be used to determine the byte order your system
+ uses for storing data in memory. i.e., whether your system is
+ little-endian or big-endian. It is set by Qt to one of the macros
+ Q_LITTLE_ENDIAN or Q_BIG_ENDIAN. You normally won't need to worry
+ about endian-ness, but you might, for example if you need to know
+ which byte of an integer or UTF-16 character is stored in the
+ lowest address. Endian-ness is important in networking, where
+ computers with different values for Q_BYTE_ORDER must pass data
+ back and forth.
+
+ Use this macro as in the following examples.
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 40
+
+ \sa Q_BIG_ENDIAN, Q_LITTLE_ENDIAN
+*/
+
+/*!
+ \macro Q_LITTLE_ENDIAN
+ \relates <QtGlobal>
+
+ This macro represents a value you can compare to the macro
+ Q_BYTE_ORDER to determine the endian-ness of your system. In a
+ little-endian system, the least significant byte is stored at the
+ lowest address. The other bytes follow in increasing order of
+ significance.
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 41
+
+ \sa Q_BYTE_ORDER, Q_BIG_ENDIAN
+*/
+
+/*!
+ \macro Q_BIG_ENDIAN
+ \relates <QtGlobal>
+
+ This macro represents a value you can compare to the macro
+ Q_BYTE_ORDER to determine the endian-ness of your system. In a
+ big-endian system, the most significant byte is stored at the
+ lowest address. The other bytes follow in decreasing order of
+ significance.
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 42
+
+ \sa Q_BYTE_ORDER, Q_LITTLE_ENDIAN
+*/
+
+/*!
+ \macro Q_GLOBAL_STATIC(type, name)
+ \internal
+
+ Declares a global static variable with the given \a type and \a name.
+
+ Use this macro to instantiate an object in a thread-safe way, creating
+ a global pointer that can be used to refer to it.
+
+ \warning This macro is subject to a race condition that can cause the object
+ to be constructed twice. However, if this occurs, the second instance will
+ be immediately deleted.
+
+ See also
+ \l{http://www.aristeia.com/publications.html}{"C++ and the perils of Double-Checked Locking"}
+ by Scott Meyers and Andrei Alexandrescu.
+*/
+
+/*!
+ \macro Q_GLOBAL_STATIC_WITH_ARGS(type, name, arguments)
+ \internal
+
+ Declares a global static variable with the specified \a type and \a name.
+
+ Use this macro to instantiate an object using the \a arguments specified
+ in a thread-safe way, creating a global pointer that can be used to refer
+ to it.
+
+ \warning This macro is subject to a race condition that can cause the object
+ to be constructed twice. However, if this occurs, the second instance will
+ be immediately deleted.
+
+ See also
+ \l{http://www.aristeia.com/publications.html}{"C++ and the perils of Double-Checked Locking"}
+ by Scott Meyers and Andrei Alexandrescu.
+*/
+
+/*!
+ \macro QT_NAMESPACE
+ \internal
+
+ If this macro is defined to \c ns all Qt classes are put in a namespace
+ called \c ns. Also, moc will output code putting metaobjects etc.
+ into namespace \c ns.
+
+ \sa QT_BEGIN_NAMESPACE, QT_END_NAMESPACE,
+ QT_PREPEND_NAMESPACE, QT_USE_NAMESPACE,
+ QT_BEGIN_INCLUDE_NAMESPACE, QT_END_INCLUDE_NAMESPACE,
+ QT_BEGIN_MOC_NAMESPACE, QT_END_MOC_NAMESPACE,
+*/
+
+/*!
+ \macro QT_PREPEND_NAMESPACE(identifier)
+ \internal
+
+ This macro qualifies \a identifier with the full namespace.
+ It expands to \c{::QT_NAMESPACE::identifier} if \c QT_NAMESPACE is defined
+ and only \a identifier otherwise.
+
+ \sa QT_NAMESPACE
+*/
+
+/*!
+ \macro QT_USE_NAMESPACE
+ \internal
+
+ This macro expands to using QT_NAMESPACE if QT_NAMESPACE is defined
+ and nothing otherwise.
+
+ \sa QT_NAMESPACE
+*/
+
+/*!
+ \macro QT_BEGIN_NAMESPACE
+ \internal
+
+ This macro expands to
+
+ \snippet snippets/code/src_corelib_global_qglobal.cpp begin namespace macro
+
+ if \c QT_NAMESPACE is defined and nothing otherwise. If should always
+ appear in the file-level scope and be followed by \c QT_END_NAMESPACE
+ at the same logical level with respect to preprocessor conditionals
+ in the same file.
+
+ As a rule of thumb, \c QT_BEGIN_NAMESPACE should appear in all Qt header
+ and Qt source files after the last \c{#include} line and before the first
+ declaration. In Qt headers using \c QT_BEGIN_HEADER, \c QT_BEGIN_NAMESPACE
+ follows \c QT_BEGIN_HEADER immediately.
+
+ If that rule can't be followed because, e.g., \c{#include} lines and
+ declarations are wildly mixed, place \c QT_BEGIN_NAMESPACE before
+ the first declaration and wrap the \c{#include} lines in
+ \c QT_BEGIN_INCLUDE_NAMESPACE and \c QT_END_INCLUDE_NAMESPACE.
+
+ When using the \c QT_NAMESPACE feature in user code
+ (e.g., when building plugins statically linked to Qt) where
+ the user code is not intended to go into the \c QT_NAMESPACE
+ namespace, all forward declarations of Qt classes need to
+ be wrapped in \c QT_BEGIN_NAMESPACE and \c QT_END_NAMESPACE.
+ After that, a \c QT_USE_NAMESPACE should follow.
+ No further changes should be needed.
+
+ \sa QT_NAMESPACE
+*/
+
+/*!
+ \macro QT_END_NAMESPACE
+ \internal
+
+ This macro expands to
+
+ \snippet snippets/code/src_corelib_global_qglobal.cpp end namespace macro
+
+ if \c QT_NAMESPACE is defined and nothing otherwise. It is used to cancel
+ the effect of \c QT_BEGIN_NAMESPACE.
+
+ If a source file ends with a \c{#include} directive that includes a moc file,
+ \c QT_END_NAMESPACE should be placed before that \c{#include}.
+
+ \sa QT_NAMESPACE
+*/
+
+/*!
+ \macro QT_BEGIN_INCLUDE_NAMESPACE
+ \internal
+
+ This macro is equivalent to \c QT_END_NAMESPACE.
+ It only serves as syntactic sugar and is intended
+ to be used before #include lines within a
+ \c QT_BEGIN_NAMESPACE ... \c QT_END_NAMESPACE block.
+
+ \sa QT_NAMESPACE
+*/
+
+/*!
+ \macro QT_END_INCLUDE_NAMESPACE
+ \internal
+
+ This macro is equivalent to \c QT_BEGIN_NAMESPACE.
+ It only serves as syntactic sugar and is intended
+ to be used after #include lines within a
+ \c QT_BEGIN_NAMESPACE ... \c QT_END_NAMESPACE block.
+
+ \sa QT_NAMESPACE
+*/
+
+/*!
+ \macro QT_BEGIN_MOC_NAMESPACE
+ \internal
+
+ This macro is output by moc at the beginning of
+ moc files. It is equivalent to \c QT_USE_NAMESPACE.
+
+ \sa QT_NAMESPACE
+*/
+
+/*!
+ \macro QT_END_MOC_NAMESPACE
+ \internal
+
+ This macro is output by moc at the beginning of
+ moc files. It expands to nothing.
+
+ \sa QT_NAMESPACE
+*/
+
+/*!
+ \fn bool qFuzzyCompare(double p1, double p2)
+ \relates <QtGlobal>
+ \since 4.4
+ \threadsafe
+
+ Compares the floating point value \a p1 and \a p2 and
+ returns \c true if they are considered equal, otherwise \c false.
+
+ Note that comparing values where either \a p1 or \a p2 is 0.0 will not work.
+ The solution to this is to compare against values greater than or equal to 1.0.
+
+ \snippet doc/src/snippets/code/src_corelib_global_qglobal.cpp 46
+
+ The two numbers are compared in a relative way, where the
+ exactness is stronger the smaller the numbers are.
+ */
+
+/*!
+ \fn bool qFuzzyCompare(float p1, float p2)
+ \relates <QtGlobal>
+ \since 4.4
+ \threadsafe
+
+ Compares the floating point value \a p1 and \a p2 and
+ returns \c true if they are considered equal, otherwise \c false.
+
+ The two numbers are compared in a relative way, where the
+ exactness is stronger the smaller the numbers are.
+ */
+
+/*!
+ \macro QT_REQUIRE_VERSION(int argc, char **argv, const char *version)
+ \relates <QtGlobal>
+
+ This macro can be used to ensure that the application is run
+ against a recent enough version of Qt. This is especially useful
+ if your application depends on a specific bug fix introduced in a
+ bug-fix release (e.g., 4.0.2).
+
+ The \a argc and \a argv parameters are the \c main() function's
+ \c argc and \c argv parameters. The \a version parameter is a
+ string literal that specifies which version of Qt the application
+ requires (e.g., "4.0.2").
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_gui_dialogs_qmessagebox.cpp 4
+*/
+
+/*!
+ \macro Q_DECL_EXPORT
+ \relates <QtGlobal>
+
+ This macro marks a symbol for shared library export (see
+ \l{sharedlibrary.html}{Creating Shared Libraries}).
+
+ \sa Q_DECL_IMPORT
+*/
+
+/*!
+ \macro Q_DECL_IMPORT
+ \relates <QtGlobal>
+
+ This macro declares a symbol to be an import from a shared library (see
+ \l{sharedlibrary.html}{Creating Shared Libraries}).
+
+ \sa Q_DECL_EXPORT
+*/
+
+#if defined(Q_OS_SYMBIAN)
+
+#include <typeinfo>
+
+/*! \macro QT_TRAP_THROWING(function)
+ \relates <QtGlobal>
+ \ingroup qts60
+
+ TRAP leaves from Symbian \a function and throws an appropriate
+ standard C++ exception instead.
+ This must be used when calling Symbian OS leaving functions
+ from inside Qt or standard C++ code, so that the code can respond
+ correctly to the exception.
+
+ \warning This macro is only available on Symbian.
+
+ Example:
+
+ \code
+ // A Symbian leaving function is being called within a Qt function.
+ // Any leave must be converted to an exception
+ CAknTitlePane* titlePane = S60->titlePane();
+ if (titlePane) {
+ TPtrC captionPtr(qt_QString2TPtrC(caption));
+ QT_TRAP_THROWING(titlePane->SetTextL(captionPtr));
+ }
+ \endcode
+
+ \sa QT_TRYCATCH_ERROR(), QT_TRYCATCH_LEAVING()
+*/
+
+/*! \macro QT_TRYCATCH_ERROR(error, function)
+ \relates <QtGlobal>
+ \ingroup qts60
+
+ Catch standard C++ exceptions from a \a function and convert them to a Symbian OS
+ \a error code, or \c KErrNone if there is no exception.
+ This must be used inside Qt or standard C++ code when using exception throwing
+ code (practically anything) and returning an error code to Symbian OS.
+
+ \warning This macro is only available on Symbian.
+
+ Example:
+
+ \code
+ // An exception might be thrown in this Symbian TInt error returning function.
+ // It is caught and translated to an error code
+ TInt QServerApp::Connect(const QString &serverName)
+ {
+ TPtrC name;
+ TInt err;
+ QT_TRYCATCH_ERROR(err, name.Set(qt_QString2TPtrC(serverName)));
+ if (err != KErrNone)
+ return err;
+ return iServer.Connect(name);
+ }
+ \endcode
+}
+
+ \sa QT_TRYCATCH_LEAVING(), QT_TRAP_THROWING()
+*/
+
+/*! \macro QT_TRYCATCH_LEAVING(function)
+ \relates <QtGlobal>
+ \ingroup qts60
+
+ Catch standard C++ exceptions from \a function and convert them to Symbian OS
+ leaves. This must be used inside Qt or standard C++ code when using exception
+ throwing code (practically anything) and returning to Symbian OS from a leaving function.
+ For example inside a Symbian active object's \c RunL function implemented with Qt code.
+
+ \warning This macro is only available on Symbian.
+
+ Example:
+
+ \code
+ // This active object signals Qt code
+ // Exceptions from the Qt code must be converted to Symbian OS leaves for the active scheduler
+ void QWakeUpActiveObject::RunL()
+ {
+ iStatus = KRequestPending;
+ SetActive();
+ QT_TRYCATCH_LEAVING(m_dispatcher->wakeUpWasCalled());
+ }
+ \endcode
+
+ \sa QT_TRAP_THROWING(), QT_TRYCATCH_ERROR()
+*/
+
+#include <stdexcept>
+
+class QSymbianLeaveException : public std::exception
+{
+public:
+ inline QSymbianLeaveException(int err) : error(err) {}
+ inline const char* what() const throw() { return "Symbian leave exception"; }
+
+public:
+ int error;
+};
+
+/*! \relates <QtGlobal>
+ \ingroup qts60
+
+ Throws an exception if the \a error parameter is a symbian error code.
+ This is the exception throwing equivalent of Symbian's User::LeaveIfError.
+
+ \warning This function is only available on Symbian.
+
+ \sa qt_symbian_exception2LeaveL(), qt_symbian_exception2Error()
+*/
+void qt_symbian_throwIfError(int error)
+{
+ if (error >= KErrNone)
+ return; // do nothing - not an exception
+ switch (error) {
+ case KErrNoMemory:
+ throw std::bad_alloc();
+ case KErrArgument:
+ throw std::invalid_argument("from Symbian error");
+ case KErrOverflow:
+ throw std::overflow_error("from Symbian error");
+ case KErrUnderflow:
+ throw std::underflow_error("from Symbian error");
+ default:
+ throw QSymbianLeaveException(error);
+ }
+}
+
+/*! \relates <QtGlobal>
+ \ingroup qts60
+
+ Convert a caught standard C++ exception \a aThrow to a Symbian leave
+
+ \warning This function is only available on Symbian.
+
+ \sa qt_symbian_throwIfError(), qt_symbian_exception2Error()
+*/
+void qt_symbian_exception2LeaveL(const std::exception& aThrow)
+{
+ User::Leave(qt_symbian_exception2Error(aThrow));
+}
+
+/*! \relates <QtGlobal>
+ \ingroup qts60
+
+ Convert a caught standard C++ exception \a aThrow to a Symbian error code
+
+ \warning This function is only available on Symbian.
+
+ \sa qt_symbian_throwIfError(), qt_symbian_exception2LeaveL()
+*/
+int qt_symbian_exception2Error(const std::exception& aThrow)
+{
+ const std::type_info& atype = typeid(aThrow);
+ int err = KErrGeneral;
+
+ if(atype == typeid (std::bad_alloc))
+ err = KErrNoMemory;
+ else if(atype == typeid(QSymbianLeaveException))
+ err = static_cast<const QSymbianLeaveException&>(aThrow).error;
+ else {
+ if(atype == typeid(std::invalid_argument))
+ err = KErrArgument;
+ else if(atype == typeid(std::out_of_range))
+ // std::out_of_range is of type logic_error which by definition means that it is
+ // "presumably detectable before the program executes".
+ // std::out_of_range is used to report an argument is not within the expected range.
+ // The description of KErrArgument says an argument is out of range. Hence the mapping.
+ err = KErrArgument;
+ else if(atype == typeid(std::overflow_error))
+ err = KErrOverflow;
+ else if(atype == typeid(std::underflow_error))
+ err = KErrUnderflow;
+ qWarning("translation from std exception \"%s\" to %d", aThrow.what(), err);
+ }
+
+ return err;
+}
+#endif
+
+QT_END_NAMESPACE