public inbox for gcc-prs@sourceware.org
help / color / mirror / Atom feed
* Re: optimization/8241: g++ ICE for optimization -O2
@ 2003-03-11 22:35 neroden
0 siblings, 0 replies; 2+ messages in thread
From: neroden @ 2003-03-11 22:35 UTC (permalink / raw)
To: christoph.kluge, gcc-bugs, gcc-prs, nobody
Synopsis: g++ ICE for optimization -O2
State-Changed-From-To: feedback->closed
State-Changed-By: neroden
State-Changed-When: Tue Mar 11 22:35:42 2003
State-Changed-Why:
No feedback 3 mo.
http://gcc.gnu.org/cgi-bin/gnatsweb.pl?cmd=view%20audit-trail&database=gcc&pr=8241
^ permalink raw reply [flat|nested] 2+ messages in thread
* optimization/8241: g++ ICE for optimization -O2
@ 2002-10-16 8:26 christoph.kluge
0 siblings, 0 replies; 2+ messages in thread
From: christoph.kluge @ 2002-10-16 8:26 UTC (permalink / raw)
To: gcc-gnats; +Cc: christoph.kluge
>Number: 8241
>Category: optimization
>Synopsis: g++ ICE for optimization -O2
>Confidential: no
>Severity: serious
>Priority: medium
>Responsible: unassigned
>State: open
>Class: ice-on-legal-code
>Submitter-Id: net
>Arrival-Date: Wed Oct 16 08:26:04 PDT 2002
>Closed-Date:
>Last-Modified:
>Originator:
>Release: 3.2
>Organization:
>Environment:
System: Linux pallas 2.4.19-4GB #1 Fri Sep 13 13:19:15 UTC 2002 i686 unknown
Architecture: i686
host: i486-suse-linux-gnu
build: i486-suse-linux-gnu
target: i486-suse-linux-gnu
configured with: ../configure --enable-threads=posix --prefix=/usr --with-local-prefix=/usr/local --infodir=/usr/share/info --mandir=/usr/share/man --libdir=/usr/lib --enable-languages=c,c++,f77,objc,java,ada --enable-libgcj --with-gxx-include-dir=/usr/include/g++ --with-slibdir=/lib --with-system-zlib --enable-shared --enable-__cxa_atexit i486-suse-linux
Thread model: posix
gcc version 3.2
>Description:
g++ terminates with an ICE when compiling class member functions (virtual, non-virtual, static,
neither inlined ), when optimization (-O2) is turned on.
The ICE always is reported with the location set to the closing bracket of the member
function's definition. I've not been able to find any pattern for this behaviour apart
from the fact that g++ does not segfault if optimization is turned off. Surprisingly g++ also
does *not* report an ICE for the optimization levels -O1, -O3 applied to the same code.
The command line for the prototypical example included in the 'How-To-Repeat' section is:
g++ -c -pipe -fno-exceptions -Wall -W -O2 -D_REENTRANT -fPIC -DQT_SHARED -DQT_NO_DEBUG -DQT_THREAD_SUPPORT -DQT_THREAD_SUPPORT -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -DQT_NO_IMAGEIO_MNG -DQT_NO_IMAGEIO_JPEG -DQT_NO_IMAGEIO_PNG -DQT_BUILTIN_GIF_READER=1 -DQT_NO_STYLE_MAC -DQT_NO_STYLE_AQUA -DQT_NO_STYLE_INTERLACE -DQT_NO_STYLE_WINDOWSXP -DQT_NO_STYLE_COMPACT -I../../../include/freetype2 -I../include -I../../../X11R6/include -I../../../X11R6/include -I.moc/release-shared-mt/ -I/usr/local/qt-copy/mkspecs/linux-g++ -o .obj/release-shared-mt/qobject.o kernel/qobject.cpp
with the compiler running until:
kernel/qobject.cpp: In member function `virtual void
QObject::removeChild(QObject*)':
kernel/qobject.cpp:1216: internal error: Segmentation fault
Please submit a full bug report,
with preprocessed source if appropriate.
See <URL:http://www.gnu.org/software/gcc/bugs.html> for instructions.
>How-To-Repeat:
The preprocessor output of
g++ -c -save-temps -fno-exceptions -Wall -W -O2 -D_REENTRANT -fPIC -DQT_SHARED -DQT_NO_DEBUG -DQT_THREAD_SUPPORT -DQT_THREAD_SUPPORT -D_LARGEFILE_SOURCE -D_FILE_OFFSET_BITS=64 -DQT_NO_IMAGEIO_MNG -DQT_NO_IMAGEIO_JPEG -DQT_NO_IMAGEIO_PNG -DQT_BUILTIN_GIF_READER=1 -DQT_NO_STYLE_MAC -DQT_NO_STYLE_AQUA -DQT_NO_STYLE_INTERLACE -DQT_NO_STYLE_WINDOWSXP -DQT_NO_STYLE_COMPACT -I../../../include/freetype2 -I../include -I../../../X11R6/include -I../../../X11R6/include -I.moc/release-shared-mt/ -I/usr/local/qt-copy/mkspecs/linux-g++
is as follows (sorry for the lengthy example, but currently I've nothin else handy):
# 1 "kernel/qobject.cpp"
# 1 "<built-in>"
# 1 "<command line>"
# 1 "kernel/qobject.cpp"
# 38 "kernel/qobject.cpp"
# 1 "kernel/qvariant.h" 1
# 42 "kernel/qvariant.h"
# 1 "../include/qstring.h" 1
# 43 "../include/qstring.h"
# 1 "../include/qcstring.h" 1
# 43 "../include/qcstring.h"
# 1 "../include/qmemarray.h" 1
# 42 "../include/qmemarray.h"
# 1 "../include/qgarray.h" 1
# 42 "../include/qgarray.h"
# 1 "../include/qshared.h" 1
# 42 "../include/qshared.h"
# 1 "../include/qglobal.h" 1
# 553 "../include/qglobal.h"
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;
const bool FALSE = 0;
const bool TRUE = !0;
# 610 "../include/qglobal.h"
inline int qRound( double d )
{
return d >= 0.0 ? int(d + 0.5) : int( d - ((int)d-1) + 0.5 ) + ((int)d-1);
}
# 622 "../include/qglobal.h"
typedef signed char INT8;
typedef unsigned char UINT8;
typedef short INT16;
typedef unsigned short UINT16;
typedef int INT32;
typedef unsigned int UINT32;
typedef signed char Q_INT8;
typedef unsigned char Q_UINT8;
typedef short Q_INT16;
typedef unsigned short Q_UINT16;
typedef int Q_INT32;
typedef unsigned int Q_UINT32;
typedef long Q_LONG;
typedef unsigned long Q_ULONG;
# 658 "../include/qglobal.h"
typedef Q_ULONG QtOffset;
class QDataStream;
# 690 "../include/qglobal.h"
# 1 "../include/qconfig.h" 1
# 691 "../include/qglobal.h" 2
# 700 "../include/qglobal.h"
# 1 "../include/qmodules.h" 1
# 701 "../include/qglobal.h" 2
# 749 "../include/qglobal.h"
# 1 "../include/qfeatures.h" 1
# 750 "../include/qglobal.h" 2
# 804 "../include/qglobal.h"
const char *qVersion();
bool qSysInfo( int *wordSize, bool *bigEndian );
# 863 "../include/qglobal.h"
void qDebug( const char *, ... )
__attribute__ ((format (printf, 1, 2)))
;
void qWarning( const char *, ... )
__attribute__ ((format (printf, 1, 2)))
;
void qFatal( const char *, ... )
__attribute__ ((format (printf, 1, 2)))
;
void qSystemWarning( const char *, int code = -1 );
void debug( const char *, ... )
__attribute__ ((format (printf, 1, 2)))
;
void warning( const char *, ... )
__attribute__ ((format (printf, 1, 2)))
;
void fatal( const char *, ... )
__attribute__ ((format (printf, 1, 2)))
;
# 927 "../include/qglobal.h"
bool qt_check_pointer( bool c, const char *, int );
# 941 "../include/qglobal.h"
enum QtMsgType { QtDebugMsg, QtWarningMsg, QtFatalMsg };
typedef void (*QtMsgHandler)(QtMsgType, const char *);
QtMsgHandler qInstallMsgHandler( QtMsgHandler );
typedef QtMsgHandler msg_handler;
void qSuppressObsoleteWarnings( bool = TRUE );
void qObsolete( const char *obj, const char *oldfunc,
const char *newfunc );
void qObsolete( const char *obj, const char *oldfunc );
void qObsolete( const char *message );
const char *qInstallPath();
const char *qInstallPathDocs();
const char *qInstallPathHeaders();
const char *qInstallPathLibs();
const char *qInstallPathBins();
const char *qInstallPathPlugins();
const char *qInstallPathData();
# 43 "../include/qshared.h" 2
struct QShared
{
QShared() : count( 1 ) { }
void ref() { count++; }
bool deref() { return !--count; }
uint count;
};
# 43 "../include/qgarray.h" 2
class QGArray
{
friend class QBuffer;
public:
struct array_data : public QShared {
array_data() { data=0; len=0; }
char *data;
uint len;
};
QGArray();
protected:
QGArray( int, int );
QGArray( int size );
QGArray( const QGArray &a );
virtual ~QGArray();
QGArray &operator=( const QGArray &a ) { return assign( a ); }
virtual void detach() { duplicate(*this); }
char *data() const { return shd->data; }
uint nrefs() const { return shd->count; }
uint size() const { return shd->len; }
bool isEqual( const QGArray &a ) const;
bool resize( uint newsize );
bool fill( const char *d, int len, uint sz );
QGArray &assign( const QGArray &a );
QGArray &assign( const char *d, uint len );
QGArray &duplicate( const QGArray &a );
QGArray &duplicate( const char *d, uint len );
void store( const char *d, uint len );
array_data *sharedBlock() const { return shd; }
void setSharedBlock( array_data *p ) { shd=(array_data*)p; }
QGArray &setRawData( const char *d, uint len );
void resetRawData( const char *d, uint len );
int find( const char *d, uint index, uint sz ) const;
int contains( const char *d, uint sz ) const;
void sort( uint sz );
int bsearch( const char *d, uint sz ) const;
char *at( uint index ) const;
bool setExpand( uint index, const char *d, uint sz );
protected:
virtual array_data *newData();
virtual void deleteData( array_data *p );
private:
static void msg_index( uint );
array_data *shd;
};
inline char *QGArray::at( uint index ) const
{
if ( index >= size() ) {
msg_index( index );
index = 0;
}
return &shd->data[index];
}
# 43 "../include/qmemarray.h" 2
template<class type>
class QMemArray : public QGArray
{
public:
typedef type* Iterator;
typedef const type* ConstIterator;
typedef type ValueType;
protected:
QMemArray( int, int ) : QGArray( 0, 0 ) {}
public:
QMemArray() {}
QMemArray( int size ) : QGArray(size*sizeof(type)) {}
QMemArray( const QMemArray<type> &a ) : QGArray(a) {}
~QMemArray() {}
QMemArray<type> &operator=(const QMemArray<type> &a)
{ return (QMemArray<type>&)QGArray::assign(a); }
type *data() const { return (type *)QGArray::data(); }
uint nrefs() const { return QGArray::nrefs(); }
uint size() const { return QGArray::size()/sizeof(type); }
uint count() const { return size(); }
bool isEmpty() const { return QGArray::size() == 0; }
bool isNull() const { return QGArray::data() == 0; }
bool resize( uint size ) { return QGArray::resize(size*sizeof(type)); }
bool truncate( uint pos ) { return QGArray::resize(pos*sizeof(type)); }
bool fill( const type &d, int size = -1 )
{ return QGArray::fill((char*)&d,size,sizeof(type) ); }
void detach() { QGArray::detach(); }
QMemArray<type> copy() const
{ QMemArray<type> tmp; return tmp.duplicate(*this); }
QMemArray<type>& assign( const QMemArray<type>& a )
{ return (QMemArray<type>&)QGArray::assign(a); }
QMemArray<type>& assign( const type *a, uint n )
{ return (QMemArray<type>&)QGArray::assign((char*)a,n*sizeof(type)); }
QMemArray<type>& duplicate( const QMemArray<type>& a )
{ return (QMemArray<type>&)QGArray::duplicate(a); }
QMemArray<type>& duplicate( const type *a, uint n )
{ return (QMemArray<type>&)QGArray::duplicate((char*)a,n*sizeof(type)); }
QMemArray<type>& setRawData( const type *a, uint n )
{ return (QMemArray<type>&)QGArray::setRawData((char*)a,
n*sizeof(type)); }
void resetRawData( const type *a, uint n )
{ QGArray::resetRawData((char*)a,n*sizeof(type)); }
int find( const type &d, uint i=0 ) const
{ return QGArray::find((char*)&d,i,sizeof(type)); }
int contains( const type &d ) const
{ return QGArray::contains((char*)&d,sizeof(type)); }
void sort() { QGArray::sort(sizeof(type)); }
int bsearch( const type &d ) const
{ return QGArray::bsearch((const char*)&d,sizeof(type)); }
type& operator[]( int i ) const
{ return (type &)(*(type *)QGArray::at(i*sizeof(type))); }
type& at( uint i ) const
{ return (type &)(*(type *)QGArray::at(i*sizeof(type))); }
operator const type*() const { return (const type *)QGArray::data(); }
bool operator==( const QMemArray<type> &a ) const { return isEqual(a); }
bool operator!=( const QMemArray<type> &a ) const { return !isEqual(a); }
Iterator begin() { return data(); }
Iterator end() { return data() + size(); }
ConstIterator begin() const { return data(); }
ConstIterator end() const { return data() + size(); }
};
# 44 "../include/qcstring.h" 2
# 1 "/usr/include/string.h" 1 3
# 26 "/usr/include/string.h" 3
# 1 "/usr/include/features.h" 1 3
# 283 "/usr/include/features.h" 3
# 1 "/usr/include/sys/cdefs.h" 1 3
# 284 "/usr/include/features.h" 2 3
# 312 "/usr/include/features.h" 3
# 1 "/usr/include/gnu/stubs.h" 1 3
# 313 "/usr/include/features.h" 2 3
# 27 "/usr/include/string.h" 2 3
extern "C" {
# 1 "/usr/lib/gcc-lib/i486-suse-linux/3.2/include/stddef.h" 1 3
# 201 "/usr/lib/gcc-lib/i486-suse-linux/3.2/include/stddef.h" 3
typedef unsigned int size_t;
# 34 "/usr/include/string.h" 2 3
extern void *memcpy (void *__restrict __dest,
__const void *__restrict __src, size_t __n) throw ();
extern void *memmove (void *__dest, __const void *__src, size_t __n)
throw ();
extern void *memccpy (void *__restrict __dest, __const void *__restrict __src,
int __c, size_t __n)
throw ();
extern void *memset (void *__s, int __c, size_t __n) throw ();
extern int memcmp (__const void *__s1, __const void *__s2, size_t __n)
throw () __attribute__ ((__pure__));
extern void *memchr (__const void *__s, int __c, size_t __n)
throw () __attribute__ ((__pure__));
extern void *rawmemchr (__const void *__s, int __c) throw () __attribute__ ((__pure__));
extern void *memrchr (__const void *__s, int __c, size_t __n)
throw () __attribute__ ((__pure__));
extern char *strcpy (char *__restrict __dest, __const char *__restrict __src)
throw ();
extern char *strncpy (char *__restrict __dest,
__const char *__restrict __src, size_t __n) throw ();
extern char *strcat (char *__restrict __dest, __const char *__restrict __src)
throw ();
extern char *strncat (char *__restrict __dest, __const char *__restrict __src,
size_t __n) throw ();
extern int strcmp (__const char *__s1, __const char *__s2)
throw () __attribute__ ((__pure__));
extern int strncmp (__const char *__s1, __const char *__s2, size_t __n)
throw () __attribute__ ((__pure__));
extern int strcoll (__const char *__s1, __const char *__s2)
throw () __attribute__ ((__pure__));
extern size_t strxfrm (char *__restrict __dest,
__const char *__restrict __src, size_t __n) throw ();
# 1 "/usr/include/xlocale.h" 1 3
# 28 "/usr/include/xlocale.h" 3
typedef struct __locale_struct
{
struct locale_data *__locales[13];
const unsigned short int *__ctype_b;
const int *__ctype_tolower;
const int *__ctype_toupper;
} *__locale_t;
# 109 "/usr/include/string.h" 2 3
extern int __strcoll_l (__const char *__s1, __const char *__s2, __locale_t __l)
throw () __attribute__ ((__pure__));
extern size_t __strxfrm_l (char *__dest, __const char *__src, size_t __n,
__locale_t __l) throw ();
extern char *strdup (__const char *__s) throw () __attribute__ ((__malloc__));
extern char *strndup (__const char *__string, size_t __n)
throw () __attribute__ ((__malloc__));
# 155 "/usr/include/string.h" 3
extern char *strchr (__const char *__s, int __c) throw () __attribute__ ((__pure__));
extern char *strrchr (__const char *__s, int __c) throw () __attribute__ ((__pure__));
extern char *strchrnul (__const char *__s, int __c) throw () __attribute__ ((__pure__));
extern size_t strcspn (__const char *__s, __const char *__reject)
throw () __attribute__ ((__pure__));
extern size_t strspn (__const char *__s, __const char *__accept)
throw () __attribute__ ((__pure__));
extern char *strpbrk (__const char *__s, __const char *__accept)
throw () __attribute__ ((__pure__));
extern char *strstr (__const char *__haystack, __const char *__needle)
throw () __attribute__ ((__pure__));
extern char *strcasestr (__const char *__haystack, __const char *__needle)
throw () __attribute__ ((__pure__));
extern char *strtok (char *__restrict __s, __const char *__restrict __delim)
throw ();
extern char *__strtok_r (char *__restrict __s,
__const char *__restrict __delim,
char **__restrict __save_ptr) throw ();
extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim,
char **__restrict __save_ptr) throw ();
extern void *memmem (__const void *__haystack, size_t __haystacklen,
__const void *__needle, size_t __needlelen)
throw () __attribute__ ((__pure__));
extern void *__mempcpy (void *__restrict __dest,
__const void *__restrict __src, size_t __n) throw ();
extern void *mempcpy (void *__restrict __dest,
__const void *__restrict __src, size_t __n) throw ();
extern size_t strlen (__const char *__s) throw () __attribute__ ((__pure__));
extern size_t strnlen (__const char *__string, size_t __maxlen)
throw () __attribute__ ((__pure__));
extern char *strerror (int __errnum) throw ();
extern char *strerror_r (int __errnum, char *__buf, size_t __buflen) throw ();
extern void __bzero (void *__s, size_t __n) throw ();
extern void bcopy (__const void *__src, void *__dest, size_t __n) throw ();
extern void bzero (void *__s, size_t __n) throw ();
extern int bcmp (__const void *__s1, __const void *__s2, size_t __n)
throw () __attribute__ ((__pure__));
extern char *index (__const char *__s, int __c) throw () __attribute__ ((__pure__));
extern char *rindex (__const char *__s, int __c) throw () __attribute__ ((__pure__));
extern int ffs (int __i) throw () __attribute__ ((__const__));
extern int ffsl (long int __l) throw () __attribute__ ((__const__));
__extension__ extern int ffsll (long long int __ll)
throw () __attribute__ ((__const__));
extern int strcasecmp (__const char *__s1, __const char *__s2)
throw () __attribute__ ((__pure__));
extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n)
throw () __attribute__ ((__pure__));
extern int __strcasecmp_l (__const char *__s1, __const char *__s2,
__locale_t __loc) throw () __attribute__ ((__pure__));
extern int __strncasecmp_l (__const char *__s1, __const char *__s2,
size_t __n, __locale_t __loc)
throw () __attribute__ ((__pure__));
extern char *strsep (char **__restrict __stringp,
__const char *__restrict __delim) throw ();
extern int strverscmp (__const char *__s1, __const char *__s2)
throw () __attribute__ ((__pure__));
extern char *strsignal (int __sig) throw ();
extern char *__stpcpy (char *__restrict __dest, __const char *__restrict __src)
throw ();
extern char *stpcpy (char *__restrict __dest, __const char *__restrict __src)
throw ();
extern char *__stpncpy (char *__restrict __dest,
__const char *__restrict __src, size_t __n) throw ();
extern char *stpncpy (char *__restrict __dest,
__const char *__restrict __src, size_t __n) throw ();
extern char *strfry (char *__string) throw ();
extern void *memfrob (void *__s, size_t __n) throw ();
extern char *basename (__const char *__filename) throw ();
# 364 "/usr/include/string.h" 3
}
# 47 "../include/qcstring.h" 2
void *qmemmove( void *dst, const void *src, uint len );
char *qstrdup( const char * );
inline uint qstrlen( const char *str )
{ return str ? (uint)strlen(str) : 0; }
inline char *qstrcpy( char *dst, const char *src )
{ return src ? strcpy(dst, src) : 0; }
char *qstrncpy( char *dst, const char *src, uint len );
inline int qstrcmp( const char *str1, const char *str2 )
{
return ( str1 && str2 ) ? strcmp( str1, str2 )
: ( str1 ? 1 : ( str2 ? -1 : 0 ) );
}
inline int qstrncmp( const char *str1, const char *str2, uint len )
{
return ( str1 && str2 ) ? strncmp( str1, str2, len )
: ( str1 ? 1 : ( str2 ? -1 : 0 ) );
}
int qstricmp( const char *, const char * );
int qstrnicmp( const char *, const char *, uint len );
inline uint cstrlen( const char *str )
{ return (uint)strlen(str); }
inline char *cstrcpy( char *dst, const char *src )
{ return strcpy(dst,src); }
inline int cstrcmp( const char *str1, const char *str2 )
{ return strcmp(str1,str2); }
inline int cstrncmp( const char *str1, const char *str2, uint len )
{ return strncmp(str1,str2,len); }
Q_UINT16 qChecksum( const char *s, uint len );
# 120 "../include/qcstring.h"
typedef QMemArray<char> QByteArray;
QByteArray qCompress( const uchar* data, int nbytes );
QByteArray qUncompress( const uchar* data, int nbytes );
inline QByteArray qCompress( const QByteArray& data)
{ return qCompress( (const uchar*)data.data(), data.size() ); }
inline QByteArray qUncompress( const QByteArray& data )
{ return qUncompress( (const uchar*)data.data(), data.size() ); }
QDataStream &operator<<( QDataStream &, const QByteArray & );
QDataStream &operator>>( QDataStream &, QByteArray & );
class QRegExp;
class QCString : public QByteArray
{
public:
QCString() {}
QCString( int size );
QCString( const QCString &s ) : QByteArray( s ) {}
QCString( const char *str );
QCString( const char *str, uint maxlen );
~QCString();
QCString &operator=( const QCString &s );
QCString &operator=( const char *str );
bool isNull() const;
bool isEmpty() const;
uint length() const;
bool resize( uint newlen );
bool truncate( uint pos );
bool fill( char c, int len = -1 );
QCString copy() const;
QCString &sprintf( const char *format, ... );
int find( char c, int index=0, bool cs=TRUE ) const;
int find( const char *str, int index=0, bool cs=TRUE ) const;
int find( const QRegExp &, int index=0 ) const;
int findRev( char c, int index=-1, bool cs=TRUE) const;
int findRev( const char *str, int index=-1, bool cs=TRUE) const;
int findRev( const QRegExp &, int index=-1 ) const;
int contains( char c, bool cs=TRUE ) const;
int contains( const char *str, bool cs=TRUE ) const;
int contains( const QRegExp & ) const;
QCString left( uint len ) const;
QCString right( uint len ) const;
QCString mid( uint index, uint len=0xffffffff) const;
QCString leftJustify( uint width, char fill=' ', bool trunc=FALSE)const;
QCString rightJustify( uint width, char fill=' ',bool trunc=FALSE)const;
QCString lower() const;
QCString upper() const;
QCString stripWhiteSpace() const;
QCString simplifyWhiteSpace() const;
QCString &insert( uint index, const char * );
QCString &insert( uint index, char );
QCString &append( const char * );
QCString &prepend( const char * );
QCString &remove( uint index, uint len );
QCString &replace( uint index, uint len, const char * );
QCString &replace( const QRegExp &, const char * );
QCString &replace( char c, const char *after );
QCString &replace( const char *, const char * );
QCString &replace( char, char );
short toShort( bool *ok=0 ) const;
ushort toUShort( bool *ok=0 ) const;
int toInt( bool *ok=0 ) const;
uint toUInt( bool *ok=0 ) const;
long toLong( bool *ok=0 ) const;
ulong toULong( bool *ok=0 ) const;
float toFloat( bool *ok=0 ) const;
double toDouble( bool *ok=0 ) const;
QCString &setStr( const char *s );
QCString &setNum( short );
QCString &setNum( ushort );
QCString &setNum( int );
QCString &setNum( uint );
QCString &setNum( long );
QCString &setNum( ulong );
QCString &setNum( float, char f='g', int prec=6 );
QCString &setNum( double, char f='g', int prec=6 );
bool setExpand( uint index, char c );
operator const char *() const;
QCString &operator+=( const char *str );
QCString &operator+=( char c );
};
QDataStream &operator<<( QDataStream &, const QCString & );
QDataStream &operator>>( QDataStream &, QCString & );
inline QCString &QCString::operator=( const QCString &s )
{ return (QCString&)assign( s ); }
inline QCString &QCString::operator=( const char *str )
{ return (QCString&)duplicate( str, qstrlen(str)+1 ); }
inline bool QCString::isNull() const
{ return data() == 0; }
inline bool QCString::isEmpty() const
{ return data() == 0 || *data() == '\0'; }
inline uint QCString::length() const
{ return qstrlen( data() ); }
inline bool QCString::truncate( uint pos )
{ return resize(pos+1); }
inline QCString QCString::copy() const
{ return QCString( data() ); }
inline QCString &QCString::prepend( const char *s )
{ return insert(0,s); }
inline QCString &QCString::append( const char *s )
{ return operator+=(s); }
inline QCString &QCString::setNum( short n )
{ return setNum((long)n); }
inline QCString &QCString::setNum( ushort n )
{ return setNum((ulong)n); }
inline QCString &QCString::setNum( int n )
{ return setNum((long)n); }
inline QCString &QCString::setNum( uint n )
{ return setNum((ulong)n); }
inline QCString &QCString::setNum( float n, char f, int prec )
{ return setNum((double)n,f,prec); }
inline QCString::operator const char *() const
{ return (const char *)data(); }
inline bool operator==( const QCString &s1, const QCString &s2 )
{ return qstrcmp( s1.data(), s2.data() ) == 0; }
inline bool operator==( const QCString &s1, const char *s2 )
{ return qstrcmp( s1.data(), s2 ) == 0; }
inline bool operator==( const char *s1, const QCString &s2 )
{ return qstrcmp( s1, s2.data() ) == 0; }
inline bool operator!=( const QCString &s1, const QCString &s2 )
{ return qstrcmp( s1.data(), s2.data() ) != 0; }
inline bool operator!=( const QCString &s1, const char *s2 )
{ return qstrcmp( s1.data(), s2 ) != 0; }
inline bool operator!=( const char *s1, const QCString &s2 )
{ return qstrcmp( s1, s2.data() ) != 0; }
inline bool operator<( const QCString &s1, const QCString& s2 )
{ return qstrcmp( s1.data(), s2.data() ) < 0; }
inline bool operator<( const QCString &s1, const char *s2 )
{ return qstrcmp( s1.data(), s2 ) < 0; }
inline bool operator<( const char *s1, const QCString &s2 )
{ return qstrcmp( s1, s2.data() ) < 0; }
inline bool operator<=( const QCString &s1, const QCString &s2 )
{ return qstrcmp( s1.data(), s2.data() ) <= 0; }
inline bool operator<=( const QCString &s1, const char *s2 )
{ return qstrcmp( s1.data(), s2 ) <= 0; }
inline bool operator<=( const char *s1, const QCString &s2 )
{ return qstrcmp( s1, s2.data() ) <= 0; }
inline bool operator>( const QCString &s1, const QCString &s2 )
{ return qstrcmp( s1.data(), s2.data() ) > 0; }
inline bool operator>( const QCString &s1, const char *s2 )
{ return qstrcmp( s1.data(), s2 ) > 0; }
inline bool operator>( const char *s1, const QCString &s2 )
{ return qstrcmp( s1, s2.data() ) > 0; }
inline bool operator>=( const QCString &s1, const QCString& s2 )
{ return qstrcmp( s1.data(), s2.data() ) >= 0; }
inline bool operator>=( const QCString &s1, const char *s2 )
{ return qstrcmp( s1.data(), s2 ) >= 0; }
inline bool operator>=( const char *s1, const QCString &s2 )
{ return qstrcmp( s1, s2.data() ) >= 0; }
inline const QCString operator+( const QCString &s1,
const QCString &s2 )
{
QCString tmp( s1.data() );
tmp += s2;
return tmp;
}
inline const QCString operator+( const QCString &s1, const char *s2 )
{
QCString tmp( s1.data() );
tmp += s2;
return tmp;
}
inline const QCString operator+( const char *s1, const QCString &s2 )
{
QCString tmp( s1 );
tmp += s2;
return tmp;
}
inline const QCString operator+( const QCString &s1, char c2 )
{
QCString tmp( s1.data() );
tmp += c2;
return tmp;
}
inline const QCString operator+( char c1, const QCString &s2 )
{
QCString tmp;
tmp += c1;
tmp += s2;
return tmp;
}
# 44 "../include/qstring.h" 2
class QRegExp;
class QString;
class QCharRef;
template <class T> class QDeepCopy;
class QChar {
public:
QChar();
QChar( char c );
QChar( uchar c );
QChar( uchar c, uchar r );
QChar( const QChar& c );
QChar( ushort rc );
QChar( short rc );
QChar( uint rc );
QChar( int rc );
static const QChar null;
static const QChar replacement;
static const QChar byteOrderMark;
static const QChar byteOrderSwapped;
static const QChar nbsp;
enum Category
{
NoCategory,
Mark_NonSpacing,
Mark_SpacingCombining,
Mark_Enclosing,
Number_DecimalDigit,
Number_Letter,
Number_Other,
Separator_Space,
Separator_Line,
Separator_Paragraph,
Other_Control,
Other_Format,
Other_Surrogate,
Other_PrivateUse,
Other_NotAssigned,
Letter_Uppercase,
Letter_Lowercase,
Letter_Titlecase,
Letter_Modifier,
Letter_Other,
Punctuation_Connector,
Punctuation_Dash,
Punctuation_Dask = Punctuation_Dash,
Punctuation_Open,
Punctuation_Close,
Punctuation_InitialQuote,
Punctuation_FinalQuote,
Punctuation_Other,
Symbol_Math,
Symbol_Currency,
Symbol_Modifier,
Symbol_Other
};
enum Direction
{
DirL, DirR, DirEN, DirES, DirET, DirAN, DirCS, DirB, DirS, DirWS, DirON,
DirLRE, DirLRO, DirAL, DirRLE, DirRLO, DirPDF, DirNSM, DirBN
};
enum Decomposition
{
Single, Canonical, Font, NoBreak, Initial, Medial,
Final, Isolated, Circle, Super, Sub, Vertical,
Wide, Narrow, Small, Square, Compat, Fraction
};
enum Joining
{
OtherJoining, Dual, Right, Center
};
enum CombiningClass
{
Combining_BelowLeftAttached = 200,
Combining_BelowAttached = 202,
Combining_BelowRightAttached = 204,
Combining_LeftAttached = 208,
Combining_RightAttached = 210,
Combining_AboveLeftAttached = 212,
Combining_AboveAttached = 214,
Combining_AboveRightAttached = 216,
Combining_BelowLeft = 218,
Combining_Below = 220,
Combining_BelowRight = 222,
Combining_Left = 224,
Combining_Right = 226,
Combining_AboveLeft = 228,
Combining_Above = 230,
Combining_AboveRight = 232,
Combining_DoubleBelow = 233,
Combining_DoubleAbove = 234,
Combining_IotaSubscript = 240
};
int digitValue() const;
QChar lower() const;
QChar upper() const;
Category category() const;
Direction direction() const;
Joining joining() const;
bool mirrored() const;
QChar mirroredChar() const;
const QString &decomposition() const;
Decomposition decompositionTag() const;
unsigned char combiningClass() const;
char latin1() const { return ucs > 0xff ? 0 : (char) ucs; }
ushort unicode() const { return ucs; }
ushort &unicode() { return ucs; }
operator char() const { return latin1(); }
bool isNull() const { return unicode()==0; }
bool isPrint() const;
bool isPunct() const;
bool isSpace() const;
bool isMark() const;
bool isLetter() const;
bool isNumber() const;
bool isLetterOrNumber() const;
bool isDigit() const;
bool isSymbol() const;
uchar cell() const { return ((uchar) ucs & 0xff); }
uchar row() const { return ((uchar) (ucs>>8)&0xff); }
void setCell( uchar cell ) { ucs = (ucs & 0xff00) + cell; }
void setRow( uchar row ) { ucs = (((ushort) row)<<8) + (ucs&0xff); }
static bool networkOrdered() {
int wordSize;
bool bigEndian = FALSE;
qSysInfo( &wordSize, &bigEndian );
return bigEndian;
}
friend inline bool operator==( char ch, QChar c );
friend inline bool operator==( QChar c, char ch );
friend inline bool operator==( QChar c1, QChar c2 );
friend inline bool operator!=( QChar c1, QChar c2 );
friend inline bool operator!=( char ch, QChar c );
friend inline bool operator!=( QChar c, char ch );
friend inline bool operator<=( QChar c, char ch );
friend inline bool operator<=( char ch, QChar c );
friend inline bool operator<=( QChar c1, QChar c2 );
private:
ushort ucs;
} ;
inline QChar::QChar() : ucs( 0 )
{
}
inline QChar::QChar( char c ) : ucs( (uchar)c )
{
}
inline QChar::QChar( uchar c ) : ucs( c )
{
}
inline QChar::QChar( uchar c, uchar r ) : ucs( (r << 8) | c )
{
}
inline QChar::QChar( const QChar& c ) : ucs( c.ucs )
{
}
inline QChar::QChar( ushort rc ) : ucs( rc )
{
}
inline QChar::QChar( short rc ) : ucs( (ushort) rc )
{
}
inline QChar::QChar( uint rc ) : ucs( (ushort ) (rc & 0xffff) )
{
}
inline QChar::QChar( int rc ) : ucs( (ushort) (rc & 0xffff) )
{
}
inline bool operator==( char ch, QChar c )
{
return ((uchar) ch) == c.ucs;
}
inline bool operator==( QChar c, char ch )
{
return ((uchar) ch) == c.ucs;
}
inline bool operator==( QChar c1, QChar c2 )
{
return c1.ucs == c2.ucs;
}
inline bool operator!=( QChar c1, QChar c2 )
{
return c1.ucs != c2.ucs;
}
inline bool operator!=( char ch, QChar c )
{
return ((uchar)ch) != c.ucs;
}
inline bool operator!=( QChar c, char ch )
{
return ((uchar) ch) != c.ucs;
}
inline bool operator<=( QChar c, char ch )
{
return c.ucs <= ((uchar) ch);
}
inline bool operator<=( char ch, QChar c )
{
return ((uchar) ch) <= c.ucs;
}
inline bool operator<=( QChar c1, QChar c2 )
{
return c1.ucs <= c2.ucs;
}
inline bool operator>=( QChar c, char ch ) { return ch <= c; }
inline bool operator>=( char ch, QChar c ) { return c <= ch; }
inline bool operator>=( QChar c1, QChar c2 ) { return c2 <= c1; }
inline bool operator<( QChar c, char ch ) { return !(ch<=c); }
inline bool operator<( char ch, QChar c ) { return !(c<=ch); }
inline bool operator<( QChar c1, QChar c2 ) { return !(c2<=c1); }
inline bool operator>( QChar c, char ch ) { return !(ch>=c); }
inline bool operator>( char ch, QChar c ) { return !(c>=ch); }
inline bool operator>( QChar c1, QChar c2 ) { return !(c2>=c1); }
struct QStringData : public QShared {
QStringData() :
QShared(), unicode(0), ascii(0), len(0), simpletext(1), maxl(0), dirty(0) { ref(); }
QStringData(QChar *u, uint l, uint m) :
QShared(), unicode(u), ascii(0), len(l), simpletext(1), maxl(m), dirty(1) { }
~QStringData() { if ( unicode ) delete[] ((char*)unicode);
if ( ascii ) delete[] ascii; }
void deleteSelf();
QChar *unicode;
char *ascii;
void setDirty() {
if ( ascii ) {
delete [] ascii;
ascii = 0;
}
dirty = 1;
}
uint len : 30;
uint simpletext : 1;
uint maxl : 30;
uint dirty : 1;
private:
QStringData( const QStringData& );
QStringData& operator=( const QStringData& );
};
class QString
{
public:
QString();
QString( QChar );
QString( const QString & );
QString( const QByteArray& );
QString( const QChar* unicode, uint length );
QString( const char *str );
~QString();
QString &operator=( const QString & );
QString &operator=( const char * );
QString &operator=( const QCString& );
QString &operator=( QChar c );
QString &operator=( char c );
static const QString null;
bool isNull() const;
bool isEmpty() const;
uint length() const;
void truncate( uint pos );
QString & fill( QChar c, int len = -1 );
QString copy() const;
QString arg( long a, int fieldwidth=0, int base=10 ) const;
QString arg( ulong a, int fieldwidth=0, int base=10 ) const;
QString arg( int a, int fieldwidth=0, int base=10 ) const;
QString arg( uint a, int fieldwidth=0, int base=10 ) const;
QString arg( short a, int fieldwidth=0, int base=10 ) const;
QString arg( ushort a, int fieldwidth=0, int base=10 ) const;
QString arg( char a, int fieldwidth=0 ) const;
QString arg( QChar a, int fieldwidth=0 ) const;
QString arg( const QString& a, int fieldwidth=0 ) const;
QString arg( double a, int fieldwidth=0, char fmt='g', int prec=-1 ) const;
QString &sprintf( const char* format, ... )
__attribute__ ((format (printf, 2, 3)))
;
int find( QChar c, int index=0, bool cs=TRUE ) const;
int find( char c, int index=0, bool cs=TRUE ) const;
int find( const QString &str, int index=0, bool cs=TRUE ) const;
int find( const QRegExp &, int index=0 ) const;
int find( const char* str, int index=0 ) const;
int findRev( QChar c, int index=-1, bool cs=TRUE) const;
int findRev( char c, int index=-1, bool cs=TRUE) const;
int findRev( const QString &str, int index=-1, bool cs=TRUE) const;
int findRev( const QRegExp &, int index=-1 ) const;
int findRev( const char* str, int index=-1 ) const;
int contains( QChar c, bool cs=TRUE ) const;
int contains( char c, bool cs=TRUE ) const
{ return contains(QChar(c), cs); }
int contains( const char* str, bool cs=TRUE ) const;
int contains( const QString &str, bool cs=TRUE ) const;
int contains( const QRegExp & ) const;
enum SectionFlags {
SectionDefault = 0x00,
SectionSkipEmpty = 0x01,
SectionIncludeLeadingSep = 0x02,
SectionIncludeTrailingSep = 0x04,
SectionCaseInsensitiveSeps = 0x08
};
QString section( QChar sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const;
QString section( char sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const;
QString section( const char *in_sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const;
QString section( const QString &in_sep, int start, int end = 0xffffffff, int flags = SectionDefault ) const;
QString section( const QRegExp ®, int start, int end = 0xffffffff, int flags = SectionDefault ) const;
QString left( uint len ) const;
QString right( uint len ) const;
QString mid( uint index, uint len=0xffffffff) const;
QString leftJustify( uint width, QChar fill=' ', bool trunc=FALSE)const;
QString rightJustify( uint width, QChar fill=' ',bool trunc=FALSE)const;
QString lower() const;
QString upper() const;
QString stripWhiteSpace() const;
QString simplifyWhiteSpace() const;
QString &insert( uint index, const QString & );
QString &insert( uint index, const QChar*, uint len );
QString &insert( uint index, QChar );
QString &insert( uint index, char c ) { return insert(index,QChar(c)); }
QString &append( char );
QString &append( QChar );
QString &append( const QString & );
QString &append( const QByteArray & );
QString &append( const char * );
QString &prepend( char );
QString &prepend( QChar );
QString &prepend( const QString & );
QString &prepend( const QByteArray & );
QString &prepend( const char * );
QString &remove( uint index, uint len );
QString &remove( QChar c );
QString &remove( char c ) { return remove( QChar(c) ); }
QString &remove( const QString & );
QString &remove( const QRegExp & );
QString &remove( const char * );
QString &replace( uint index, uint len, const QString & );
QString &replace( uint index, uint len, const QChar*, uint clen );
QString &replace( uint index, uint len, QChar );
QString &replace( uint index, uint len, char c )
{ return replace( index, len, QChar(c) ); }
QString &replace( QChar c, const QString & );
QString &replace( char c, const QString & after )
{ return replace( QChar(c), after ); }
QString &replace( const QString &, const QString & );
QString &replace( const QRegExp &, const QString & );
QString &replace( QChar, QChar );
short toShort( bool *ok=0, int base=10 ) const;
ushort toUShort( bool *ok=0, int base=10 ) const;
int toInt( bool *ok=0, int base=10 ) const;
uint toUInt( bool *ok=0, int base=10 ) const;
long toLong( bool *ok=0, int base=10 ) const;
ulong toULong( bool *ok=0, int base=10 ) const;
float toFloat( bool *ok=0 ) const;
double toDouble( bool *ok=0 ) const;
QString &setNum( short, int base=10 );
QString &setNum( ushort, int base=10 );
QString &setNum( int, int base=10 );
QString &setNum( uint, int base=10 );
QString &setNum( long, int base=10 );
QString &setNum( ulong, int base=10 );
QString &setNum( float, char f='g', int prec=6 );
QString &setNum( double, char f='g', int prec=6 );
static QString number( long, int base=10 );
static QString number( ulong, int base=10);
static QString number( int, int base=10 );
static QString number( uint, int base=10);
static QString number( double, char f='g', int prec=6 );
void setExpand( uint index, QChar c );
QString &operator+=( const QString &str );
QString &operator+=( const QByteArray &str );
QString &operator+=( const char *str );
QString &operator+=( QChar c );
QString &operator+=( char c );
QChar at( uint i ) const
{ return i < d->len ? d->unicode[i] : QChar::null; }
QChar operator[]( int i ) const { return at((uint)i); }
QCharRef at( uint i );
QCharRef operator[]( int i );
QChar constref(uint i) const
{ return at(i); }
QChar& ref(uint i)
{
if ( d->count != 1 || i >= d->len )
subat( i );
d->setDirty();
return d->unicode[i];
}
const QChar* unicode() const { return d->unicode; }
const char* ascii() const { return latin1(); }
const char* latin1() const;
static QString fromLatin1(const char*, int len=-1);
QCString utf8() const;
static QString fromUtf8(const char*, int len=-1);
QCString local8Bit() const;
static QString fromLocal8Bit(const char*, int len=-1);
bool operator!() const;
operator const char *() const { return latin1(); }
static QString fromUcs2( const unsigned short *ucs2 );
const unsigned short *ucs2() const;
QString &setUnicode( const QChar* unicode, uint len );
QString &setUnicodeCodes( const ushort* unicode_as_ushorts, uint len );
QString &setLatin1( const char*, int len=-1 );
int compare( const QString& s ) const;
static int compare( const QString& s1, const QString& s2 )
{ return s1.compare( s2 ); }
int localeAwareCompare( const QString& s ) const;
static int localeAwareCompare( const QString& s1, const QString& s2 )
{ return s1.localeAwareCompare( s2 ); }
friend QDataStream &operator>>( QDataStream &, QString & );
void compose();
const char* data() const { return latin1(); }
bool startsWith( const QString& ) const;
bool endsWith( const QString& ) const;
void setLength( uint newLength );
bool simpleText() const { if ( d->dirty ) checkSimpleText(); return (bool)d->simpletext; }
bool isRightToLeft() const;
private:
QString( int size, bool );
void deref();
void real_detach();
void subat( uint );
bool findArg(int& pos, int& len) const;
void checkSimpleText() const;
static QChar* asciiToUnicode( const char*, uint * len, uint maxlen=(uint)-1 );
static QChar* asciiToUnicode( const QByteArray&, uint * len );
static char* unicodeToAscii( const QChar*, uint len );
QStringData *d;
static QStringData* shared_null;
static QStringData* makeSharedNull();
friend class QConstString;
friend class QTextStream;
QString( QStringData* dd, bool ) : d(dd) { }
void detach();
friend class QDeepCopy<QString>;
};
class QCharRef {
friend class QString;
QString& s;
uint p;
QCharRef(QString* str, uint pos) : s(*str), p(pos) { }
public:
ushort unicode() const { return s.constref(p).unicode(); }
char latin1() const { return s.constref(p).latin1(); }
QCharRef operator=(char c ) { s.ref(p)=c; return *this; }
QCharRef operator=(uchar c ) { s.ref(p)=c; return *this; }
QCharRef operator=(QChar c ) { s.ref(p)=c; return *this; }
QCharRef operator=(const QCharRef& c ) { s.ref(p)=c.unicode(); return *this; }
QCharRef operator=(ushort rc ) { s.ref(p)=rc; return *this; }
QCharRef operator=(short rc ) { s.ref(p)=rc; return *this; }
QCharRef operator=(uint rc ) { s.ref(p)=rc; return *this; }
QCharRef operator=(int rc ) { s.ref(p)=rc; return *this; }
operator QChar () const { return s.constref(p); }
bool isNull() const { return unicode()==0; }
bool isPrint() const { return s.constref(p).isPrint(); }
bool isPunct() const { return s.constref(p).isPunct(); }
bool isSpace() const { return s.constref(p).isSpace(); }
bool isMark() const { return s.constref(p).isMark(); }
bool isLetter() const { return s.constref(p).isLetter(); }
bool isNumber() const { return s.constref(p).isNumber(); }
bool isLetterOrNumber() { return s.constref(p).isLetterOrNumber(); }
bool isDigit() const { return s.constref(p).isDigit(); }
int digitValue() const { return s.constref(p).digitValue(); }
QChar lower() const { return s.constref(p).lower(); }
QChar upper() const { return s.constref(p).upper(); }
QChar::Category category() const { return s.constref(p).category(); }
QChar::Direction direction() const { return s.constref(p).direction(); }
QChar::Joining joining() const { return s.constref(p).joining(); }
bool mirrored() const { return s.constref(p).mirrored(); }
QChar mirroredChar() const { return s.constref(p).mirroredChar(); }
const QString &decomposition() const { return s.constref(p).decomposition(); }
QChar::Decomposition decompositionTag() const { return s.constref(p).decompositionTag(); }
unsigned char combiningClass() const { return s.constref(p).combiningClass(); }
uchar cell() const { return s.constref(p).cell(); }
uchar row() const { return s.constref(p).row(); }
};
inline QCharRef QString::at( uint i ) { return QCharRef(this,i); }
inline QCharRef QString::operator[]( int i ) { return at((uint)i); }
class QConstString : private QString {
public:
QConstString( const QChar* unicode, uint length );
~QConstString();
const QString& string() const { return *this; }
};
QDataStream &operator<<( QDataStream &, const QString & );
QDataStream &operator>>( QDataStream &, QString & );
# 736 "../include/qstring.h"
inline QString::QString() :
d(shared_null ? shared_null : makeSharedNull())
{
d->ref();
}
inline QString::~QString()
{
if ( d->deref() ) {
if ( d != shared_null )
d->deleteSelf();
}
}
inline void QString::detach()
{ real_detach(); }
inline QString QString::section( QChar sep, int start, int end, int flags ) const
{ return section(QString(sep), start, end, flags); }
inline QString QString::section( char sep, int start, int end, int flags ) const
{ return section(QChar(sep), start, end, flags); }
inline QString QString::section( const char *in_sep, int start, int end, int flags ) const
{ return section(QString(in_sep), start, end, flags); }
inline QString &QString::operator=( QChar c )
{ *this = QString(c); return *this; }
inline QString &QString::operator=( char c )
{ *this = QString(QChar(c)); return *this; }
inline bool QString::isNull() const
{ return unicode() == 0; }
inline bool QString::operator!() const
{ return isNull(); }
inline uint QString::length() const
{ return d->len; }
inline bool QString::isEmpty() const
{ return length() == 0; }
inline QString QString::copy() const
{ return QString( *this ); }
inline QString &QString::prepend( const QString & s )
{ return insert(0,s); }
inline QString &QString::prepend( QChar c )
{ return insert(0,c); }
inline QString &QString::prepend( char c )
{ return insert(0,c); }
inline QString &QString::prepend( const QByteArray & s )
{ return insert(0,s.data()); }
inline QString &QString::append( const QString & s )
{ return operator+=(s); }
inline QString &QString::append( const QByteArray &s )
{ return operator+=(s.data()); }
inline QString &QString::append( const char * s )
{ return operator+=(s); }
inline QString &QString::append( QChar c )
{ return operator+=(c); }
inline QString &QString::append( char c )
{ return operator+=(c); }
inline QString &QString::operator+=( const QByteArray &s )
{ return operator+=(s.data()); }
inline QString &QString::setNum( short n, int base )
{ return setNum((long)n, base); }
inline QString &QString::setNum( ushort n, int base )
{ return setNum((ulong)n, base); }
inline QString &QString::setNum( int n, int base )
{ return setNum((long)n, base); }
inline QString &QString::setNum( uint n, int base )
{ return setNum((ulong)n, base); }
inline QString &QString::setNum( float n, char f, int prec )
{ return setNum((double)n,f,prec); }
inline QString QString::arg(int a, int fieldwidth, int base) const
{ return arg((long)a, fieldwidth, base); }
inline QString QString::arg(uint a, int fieldwidth, int base) const
{ return arg((ulong)a, fieldwidth, base); }
inline QString QString::arg(short a, int fieldwidth, int base) const
{ return arg((long)a, fieldwidth, base); }
inline QString QString::arg(ushort a, int fieldwidth, int base) const
{ return arg((ulong)a, fieldwidth, base); }
inline int QString::find( char c, int index, bool cs ) const
{ return find(QChar(c), index, cs); }
inline int QString::findRev( char c, int index, bool cs) const
{ return findRev( QChar(c), index, cs ); }
inline int QString::find( const char* str, int index ) const
{ return find(QString::fromLatin1(str), index); }
inline int QString::findRev( const char* str, int index ) const
{ return findRev(QString::fromLatin1(str), index); }
bool operator!=( const QString &s1, const QString &s2 );
bool operator<( const QString &s1, const QString &s2 );
bool operator<=( const QString &s1, const QString &s2 );
bool operator==( const QString &s1, const QString &s2 );
bool operator>( const QString &s1, const QString &s2 );
bool operator>=( const QString &s1, const QString &s2 );
bool operator!=( const QString &s1, const char *s2 );
bool operator<( const QString &s1, const char *s2 );
bool operator<=( const QString &s1, const char *s2 );
bool operator==( const QString &s1, const char *s2 );
bool operator>( const QString &s1, const char *s2 );
bool operator>=( const QString &s1, const char *s2 );
bool operator!=( const char *s1, const QString &s2 );
bool operator<( const char *s1, const QString &s2 );
bool operator<=( const char *s1, const QString &s2 );
bool operator==( const char *s1, const QString &s2 );
bool operator>=( const char *s1, const QString &s2 );
inline const QString operator+( const QString &s1, const QString &s2 )
{
QString tmp( s1 );
tmp += s2;
return tmp;
}
inline const QString operator+( const QString &s1, const char *s2 )
{
QString tmp( s1 );
tmp += QString::fromLatin1(s2);
return tmp;
}
inline const QString operator+( const char *s1, const QString &s2 )
{
QString tmp = QString::fromLatin1( s1 );
tmp += s2;
return tmp;
}
inline const QString operator+( const QString &s1, QChar c2 )
{
QString tmp( s1 );
tmp += c2;
return tmp;
}
inline const QString operator+( const QString &s1, char c2 )
{
QString tmp( s1 );
tmp += c2;
return tmp;
}
inline const QString operator+( QChar c1, const QString &s2 )
{
QString tmp;
tmp += c1;
tmp += s2;
return tmp;
}
inline const QString operator+( char c1, const QString &s2 )
{
QString tmp;
tmp += c1;
tmp += s2;
return tmp;
}
# 43 "kernel/qvariant.h" 2
class QString;
class QCString;
class QFont;
class QPixmap;
class QBrush;
class QRect;
class QPoint;
class QImage;
class QSize;
class QColor;
class QPalette;
class QColorGroup;
class QIconSet;
class QDataStream;
class QPointArray;
class QRegion;
class QBitmap;
class QCursor;
class QStringList;
class QSizePolicy;
class QDate;
class QTime;
class QDateTime;
class QBitArray;
class QKeySequence;
class QPen;
class QVariant;
template <class T> class QValueList;
template <class T> class QValueListConstIterator;
template <class T> class QValueListNode;
template <class Key, class T> class QMap;
template <class Key, class T> class QMapConstIterator;
class QVariant
{
public:
enum Type {
Invalid,
Map,
List,
String,
StringList,
Font,
Pixmap,
Brush,
Rect,
Size,
Color,
Palette,
ColorGroup,
IconSet,
Point,
Image,
Int,
UInt,
Bool,
Double,
CString,
PointArray,
Region,
Bitmap,
Cursor,
SizePolicy,
Date,
Time,
DateTime,
ByteArray,
BitArray,
KeySequence,
Pen
};
QVariant();
~QVariant();
QVariant( const QVariant& );
QVariant( QDataStream& s );
QVariant( const QString& );
QVariant( const QCString& );
QVariant( const char* );
QVariant( const QStringList& );
QVariant( const QFont& );
QVariant( const QPixmap& );
QVariant( const QImage& );
QVariant( const QBrush& );
QVariant( const QPoint& );
QVariant( const QRect& );
QVariant( const QSize& );
QVariant( const QColor& );
QVariant( const QPalette& );
QVariant( const QColorGroup& );
QVariant( const QIconSet& );
QVariant( const QPointArray& );
QVariant( const QRegion& );
QVariant( const QBitmap& );
QVariant( const QCursor& );
QVariant( const QDate& );
QVariant( const QTime& );
QVariant( const QDateTime& );
QVariant( const QByteArray& );
QVariant( const QBitArray& );
QVariant( const QKeySequence& );
QVariant( const QPen& );
QVariant( const QValueList<QVariant>& );
QVariant( const QMap<QString,QVariant>& );
QVariant( int );
QVariant( uint );
QVariant( bool, int );
QVariant( double );
QVariant( QSizePolicy );
QVariant& operator= ( const QVariant& );
bool operator==( const QVariant& ) const;
bool operator!=( const QVariant& ) const;
Type type() const;
const char* typeName() const;
bool canCast( Type ) const;
bool cast( Type );
bool isValid() const;
bool isNull() const;
void clear();
const QString toString() const;
const QCString toCString() const;
const QStringList toStringList() const;
const QFont toFont() const;
const QPixmap toPixmap() const;
const QImage toImage() const;
const QBrush toBrush() const;
const QPoint toPoint() const;
const QRect toRect() const;
const QSize toSize() const;
const QColor toColor() const;
const QPalette toPalette() const;
const QColorGroup toColorGroup() const;
const QIconSet toIconSet() const;
const QPointArray toPointArray() const;
const QBitmap toBitmap() const;
const QRegion toRegion() const;
const QCursor toCursor() const;
const QDate toDate() const;
const QTime toTime() const;
const QDateTime toDateTime() const;
const QByteArray toByteArray() const;
const QBitArray toBitArray() const;
const QKeySequence toKeySequence() const;
const QPen toPen() const;
int toInt( bool * ok=0 ) const;
uint toUInt( bool * ok=0 ) const;
bool toBool() const;
double toDouble( bool * ok=0 ) const;
const QValueList<QVariant> toList() const;
const QMap<QString,QVariant> toMap() const;
QSizePolicy toSizePolicy() const;
QValueListConstIterator<QString> stringListBegin() const;
QValueListConstIterator<QString> stringListEnd() const;
QValueListConstIterator<QVariant> listBegin() const;
QValueListConstIterator<QVariant> listEnd() const;
QMapConstIterator<QString,QVariant> mapBegin() const;
QMapConstIterator<QString,QVariant> mapEnd() const;
QMapConstIterator<QString,QVariant> mapFind( const QString& ) const;
QString& asString();
QCString& asCString();
QStringList& asStringList();
QFont& asFont();
QPixmap& asPixmap();
QImage& asImage();
QBrush& asBrush();
QPoint& asPoint();
QRect& asRect();
QSize& asSize();
QColor& asColor();
QPalette& asPalette();
QColorGroup& asColorGroup();
QIconSet& asIconSet();
QPointArray& asPointArray();
QBitmap& asBitmap();
QRegion& asRegion();
QCursor& asCursor();
QDate& asDate();
QTime& asTime();
QDateTime& asDateTime();
QByteArray& asByteArray();
QBitArray& asBitArray();
QKeySequence& asKeySequence();
QPen& asPen();
int& asInt();
uint& asUInt();
bool& asBool();
double& asDouble();
QValueList<QVariant>& asList();
QMap<QString,QVariant>& asMap();
QSizePolicy& asSizePolicy();
void load( QDataStream& );
void save( QDataStream& ) const;
static const char* typeToName( Type typ );
static Type nameToType( const char* name );
private:
void detach();
class Private : public QShared
{
public:
Private();
Private( Private* );
~Private();
void clear();
Type typ;
union
{
uint u;
int i;
bool b;
double d;
void *ptr;
} value;
uint is_null : 1;
};
Private* d;
public:
void* rawAccess( void* ptr = 0, Type typ = Invalid, bool deepCopy = FALSE );
};
# 1 "../include/qvaluelist.h" 1
# 42 "../include/qvaluelist.h"
# 1 "../include/qtl.h" 1
# 42 "../include/qtl.h"
# 1 "../include/qglobal.h" 1
# 43 "../include/qtl.h" 2
# 1 "../include/qtextstream.h" 1
# 42 "../include/qtextstream.h"
# 1 "../include/qiodevice.h" 1
# 42 "../include/qiodevice.h"
# 1 "../include/qglobal.h" 1
# 43 "../include/qiodevice.h" 2
# 88 "../include/qiodevice.h"
class QIODevice
{
public:
typedef Q_ULONG Offset;
QIODevice();
virtual ~QIODevice();
int flags() const { return ioMode; }
int mode() const { return ioMode & 0x00ff; }
int state() const { return ioMode & 0xf000; }
bool isDirectAccess() const { return ((ioMode & 0x0100) == 0x0100); }
bool isSequentialAccess() const { return ((ioMode & 0x0200) == 0x0200); }
bool isCombinedAccess() const { return ((ioMode & 0x0300) == 0x0300); }
bool isBuffered() const { return ((ioMode & 0x0040) != 0x0040); }
bool isRaw() const { return ((ioMode & 0x0040) == 0x0040); }
bool isSynchronous() const { return ((ioMode & 0x0080) != 0x0080); }
bool isAsynchronous() const { return ((ioMode & 0x0080) == 0x0080); }
bool isTranslated() const { return ((ioMode & 0x0010) == 0x0010); }
bool isReadable() const { return ((ioMode & 0x0001) == 0x0001); }
bool isWritable() const { return ((ioMode & 0x0002) == 0x0002); }
bool isReadWrite() const { return ((ioMode & 0x0003) == 0x0003); }
bool isInactive() const { return state() == 0; }
bool isOpen() const { return state() == 0x1000; }
int status() const { return ioSt; }
void resetStatus() { ioSt = 0; }
virtual bool open( int mode ) = 0;
virtual void close() = 0;
virtual void flush() = 0;
virtual Offset size() const = 0;
virtual Offset at() const;
virtual bool at( Offset );
virtual bool atEnd() const;
bool reset() { return at(0); }
virtual Q_LONG readBlock( char *data, Q_ULONG maxlen ) = 0;
virtual Q_LONG writeBlock( const char *data, Q_ULONG len ) = 0;
virtual Q_LONG readLine( char *data, Q_ULONG maxlen );
Q_LONG writeBlock( const QByteArray& data );
virtual QByteArray readAll();
virtual int getch() = 0;
virtual int putch( int ) = 0;
virtual int ungetch( int ) = 0;
protected:
void setFlags( int f ) { ioMode = f; }
void setType( int );
void setMode( int );
void setState( int );
void setStatus( int );
Offset ioIndex;
private:
int ioMode;
int ioSt;
private:
QIODevice( const QIODevice & );
QIODevice &operator=( const QIODevice & );
};
# 43 "../include/qtextstream.h" 2
# 1 "/usr/include/stdio.h" 1 3
# 30 "/usr/include/stdio.h" 3
extern "C" {
# 1 "/usr/lib/gcc-lib/i486-suse-linux/3.2/include/stddef.h" 1 3
# 35 "/usr/include/stdio.h" 2 3
# 1 "/usr/include/bits/types.h" 1 3
# 29 "/usr/include/bits/types.h" 3
# 1 "/usr/lib/gcc-lib/i486-suse-linux/3.2/include/stddef.h" 1 3
# 30 "/usr/include/bits/types.h" 2 3
typedef unsigned char __u_char;
typedef unsigned short __u_short;
typedef unsigned int __u_int;
typedef unsigned long __u_long;
__extension__ typedef unsigned long long int __u_quad_t;
__extension__ typedef long long int __quad_t;
# 49 "/usr/include/bits/types.h" 3
typedef signed char __int8_t;
typedef unsigned char __uint8_t;
typedef signed short int __int16_t;
typedef unsigned short int __uint16_t;
typedef signed int __int32_t;
typedef unsigned int __uint32_t;
__extension__ typedef signed long long int __int64_t;
__extension__ typedef unsigned long long int __uint64_t;
typedef __quad_t *__qaddr_t;
typedef __u_quad_t __dev_t;
typedef __u_int __uid_t;
typedef __u_int __gid_t;
typedef __u_long __ino_t;
typedef __u_int __mode_t;
typedef __u_int __nlink_t;
typedef long int __off_t;
typedef __quad_t __loff_t;
typedef int __pid_t;
typedef int __ssize_t;
typedef __u_long __rlim_t;
typedef __u_quad_t __rlim64_t;
typedef __u_int __id_t;
typedef struct
{
int __val[2];
} __fsid_t;
typedef int __daddr_t;
typedef char *__caddr_t;
typedef long int __time_t;
typedef unsigned int __useconds_t;
typedef long int __suseconds_t;
typedef long int __swblk_t;
typedef long int __clock_t;
typedef int __clockid_t;
typedef int __timer_t;
typedef int __key_t;
typedef unsigned short int __ipc_pid_t;
typedef long int __blksize_t;
typedef long int __blkcnt_t;
typedef __quad_t __blkcnt64_t;
typedef __u_long __fsblkcnt_t;
typedef __u_quad_t __fsblkcnt64_t;
typedef __u_long __fsfilcnt_t;
typedef __u_quad_t __fsfilcnt64_t;
typedef __u_quad_t __ino64_t;
typedef __loff_t __off64_t;
typedef long int __t_scalar_t;
typedef unsigned long int __t_uscalar_t;
typedef int __intptr_t;
typedef unsigned int __socklen_t;
# 1 "/usr/include/bits/pthreadtypes.h" 1 3
# 23 "/usr/include/bits/pthreadtypes.h" 3
# 1 "/usr/include/bits/sched.h" 1 3
# 68 "/usr/include/bits/sched.h" 3
struct __sched_param
{
int __sched_priority;
};
# 24 "/usr/include/bits/pthreadtypes.h" 2 3
struct _pthread_fastlock
{
long int __status;
int __spinlock;
};
typedef struct _pthread_descr_struct *_pthread_descr;
typedef struct __pthread_attr_s
{
int __detachstate;
int __schedpolicy;
struct __sched_param __schedparam;
int __inheritsched;
int __scope;
size_t __guardsize;
int __stackaddr_set;
void *__stackaddr;
size_t __stacksize;
} pthread_attr_t;
typedef struct
{
struct _pthread_fastlock __c_lock;
_pthread_descr __c_waiting;
} pthread_cond_t;
typedef struct
{
int __dummy;
} pthread_condattr_t;
typedef unsigned int pthread_key_t;
typedef struct
{
int __m_reserved;
int __m_count;
_pthread_descr __m_owner;
int __m_kind;
struct _pthread_fastlock __m_lock;
} pthread_mutex_t;
typedef struct
{
int __mutexkind;
} pthread_mutexattr_t;
typedef int pthread_once_t;
typedef struct _pthread_rwlock_t
{
struct _pthread_fastlock __rw_lock;
int __rw_readers;
_pthread_descr __rw_writer;
_pthread_descr __rw_read_waiting;
_pthread_descr __rw_write_waiting;
int __rw_kind;
int __rw_pshared;
} pthread_rwlock_t;
typedef struct
{
int __lockkind;
int __pshared;
} pthread_rwlockattr_t;
typedef volatile int pthread_spinlock_t;
typedef struct {
struct _pthread_fastlock __ba_lock;
int __ba_required;
int __ba_present;
_pthread_descr __ba_waiting;
} pthread_barrier_t;
typedef struct {
int __pshared;
} pthread_barrierattr_t;
typedef unsigned long int pthread_t;
# 144 "/usr/include/bits/types.h" 2 3
# 37 "/usr/include/stdio.h" 2 3
# 45 "/usr/include/stdio.h" 3
typedef struct _IO_FILE FILE;
# 55 "/usr/include/stdio.h" 3
typedef struct _IO_FILE __FILE;
# 65 "/usr/include/stdio.h" 3
# 1 "/usr/include/libio.h" 1 3
# 32 "/usr/include/libio.h" 3
# 1 "/usr/include/_G_config.h" 1 3
# 14 "/usr/include/_G_config.h" 3
# 1 "/usr/lib/gcc-lib/i486-suse-linux/3.2/include/stddef.h" 1 3
# 321 "/usr/lib/gcc-lib/i486-suse-linux/3.2/include/stddef.h" 3
typedef unsigned int wint_t;
# 15 "/usr/include/_G_config.h" 2 3
# 24 "/usr/include/_G_config.h" 3
# 1 "/usr/include/wchar.h" 1 3
# 48 "/usr/include/wchar.h" 3
# 1 "/usr/lib/gcc-lib/i486-suse-linux/3.2/include/stddef.h" 1 3
# 49 "/usr/include/wchar.h" 2 3
# 1 "/usr/include/bits/wchar.h" 1 3
# 51 "/usr/include/wchar.h" 2 3
# 67 "/usr/include/wchar.h" 3
typedef struct
{
int __count;
union
{
wint_t __wch;
char __wchb[4];
} __value;
} __mbstate_t;
# 25 "/usr/include/_G_config.h" 2 3
typedef struct
{
__off_t __pos;
__mbstate_t __state;
} _G_fpos_t;
typedef struct
{
__off64_t __pos;
__mbstate_t __state;
} _G_fpos64_t;
# 44 "/usr/include/_G_config.h" 3
# 1 "/usr/include/gconv.h" 1 3
# 28 "/usr/include/gconv.h" 3
# 1 "/usr/include/wchar.h" 1 3
# 48 "/usr/include/wchar.h" 3
# 1 "/usr/lib/gcc-lib/i486-suse-linux/3.2/include/stddef.h" 1 3
# 49 "/usr/include/wchar.h" 2 3
# 29 "/usr/include/gconv.h" 2 3
# 1 "/usr/lib/gcc-lib/i486-suse-linux/3.2/include/stddef.h" 1 3
# 32 "/usr/include/gconv.h" 2 3
enum
{
__GCONV_OK = 0,
__GCONV_NOCONV,
__GCONV_NODB,
__GCONV_NOMEM,
__GCONV_EMPTY_INPUT,
__GCONV_FULL_OUTPUT,
__GCONV_ILLEGAL_INPUT,
__GCONV_INCOMPLETE_INPUT,
__GCONV_ILLEGAL_DESCRIPTOR,
__GCONV_INTERNAL_ERROR
};
enum
{
__GCONV_IS_LAST = 0x0001,
__GCONV_IGNORE_ERRORS = 0x0002
};
struct __gconv_step;
struct __gconv_step_data;
struct __gconv_loaded_object;
struct __gconv_trans_data;
typedef int (*__gconv_fct) (struct __gconv_step *, struct __gconv_step_data *,
__const unsigned char **, __const unsigned char *,
unsigned char **, size_t *, int, int);
typedef int (*__gconv_init_fct) (struct __gconv_step *);
typedef void (*__gconv_end_fct) (struct __gconv_step *);
typedef int (*__gconv_trans_fct) (struct __gconv_step *,
struct __gconv_step_data *, void *,
__const unsigned char *,
__const unsigned char **,
__const unsigned char *, unsigned char **,
size_t *);
typedef int (*__gconv_trans_context_fct) (void *, __const unsigned char *,
__const unsigned char *,
unsigned char *, unsigned char *);
typedef int (*__gconv_trans_query_fct) (__const char *, __const char ***,
size_t *);
typedef int (*__gconv_trans_init_fct) (void **, const char *);
typedef void (*__gconv_trans_end_fct) (void *);
struct __gconv_trans_data
{
__gconv_trans_fct __trans_fct;
__gconv_trans_context_fct __trans_context_fct;
__gconv_trans_end_fct __trans_end_fct;
void *__data;
struct __gconv_trans_data *__next;
};
struct __gconv_step
{
struct __gconv_loaded_object *__shlib_handle;
__const char *__modname;
int __counter;
char *__from_name;
char *__to_name;
__gconv_fct __fct;
__gconv_init_fct __init_fct;
__gconv_end_fct __end_fct;
int __min_needed_from;
int __max_needed_from;
int __min_needed_to;
int __max_needed_to;
int __stateful;
void *__data;
};
struct __gconv_step_data
{
unsigned char *__outbuf;
unsigned char *__outbufend;
int __flags;
int __invocation_counter;
int __internal_use;
__mbstate_t *__statep;
__mbstate_t __state;
struct __gconv_trans_data *__trans;
};
typedef struct __gconv_info
{
size_t __nsteps;
struct __gconv_step *__steps;
__extension__ struct __gconv_step_data __data [];
} *__gconv_t;
# 45 "/usr/include/_G_config.h" 2 3
typedef union
{
struct __gconv_info __cd;
struct
{
struct __gconv_info __cd;
struct __gconv_step_data __data;
} __combined;
} _G_iconv_t;
typedef int _G_int16_t __attribute__ ((__mode__ (__HI__)));
typedef int _G_int32_t __attribute__ ((__mode__ (__SI__)));
typedef unsigned int _G_uint16_t __attribute__ ((__mode__ (__HI__)));
typedef unsigned int _G_uint32_t __attribute__ ((__mode__ (__SI__)));
# 33 "/usr/include/libio.h" 2 3
# 53 "/usr/include/libio.h" 3
# 1 "/usr/lib/gcc-lib/i486-suse-linux/3.2/include/stdarg.h" 1 3
# 43 "/usr/lib/gcc-lib/i486-suse-linux/3.2/include/stdarg.h" 3
typedef __builtin_va_list __gnuc_va_list;
# 54 "/usr/include/libio.h" 2 3
# 160 "/usr/include/libio.h" 3
struct _IO_jump_t; struct _IO_FILE;
# 170 "/usr/include/libio.h" 3
typedef void _IO_lock_t;
struct _IO_marker {
struct _IO_marker *_next;
struct _IO_FILE *_sbuf;
int _pos;
# 193 "/usr/include/libio.h" 3
};
enum __codecvt_result
{
__codecvt_ok,
__codecvt_partial,
__codecvt_error,
__codecvt_noconv
};
# 261 "/usr/include/libio.h" 3
struct _IO_FILE {
int _flags;
char* _IO_read_ptr;
char* _IO_read_end;
char* _IO_read_base;
char* _IO_write_base;
char* _IO_write_ptr;
char* _IO_write_end;
char* _IO_buf_base;
char* _IO_buf_end;
char *_IO_save_base;
char *_IO_backup_base;
char *_IO_save_end;
struct _IO_marker *_markers;
struct _IO_FILE *_chain;
int _fileno;
int _blksize;
__off_t _old_offset;
unsigned short _cur_column;
signed char _vtable_offset;
char _shortbuf[1];
_IO_lock_t *_lock;
# 305 "/usr/include/libio.h" 3
__off64_t _offset;
void *__pad1;
void *__pad2;
int _mode;
char _unused2[15 * sizeof (int) - 2 * sizeof (void *)];
};
struct _IO_FILE_plus;
extern struct _IO_FILE_plus _IO_2_1_stdin_;
extern struct _IO_FILE_plus _IO_2_1_stdout_;
extern struct _IO_FILE_plus _IO_2_1_stderr_;
# 344 "/usr/include/libio.h" 3
typedef __ssize_t __io_read_fn (void *__cookie, char *__buf, size_t __nbytes);
typedef __ssize_t __io_write_fn (void *__cookie, __const char *__buf,
size_t __n);
typedef int __io_seek_fn (void *__cookie, __off64_t *__pos, int __w);
typedef int __io_close_fn (void *__cookie);
typedef __io_read_fn cookie_read_function_t;
typedef __io_write_fn cookie_write_function_t;
typedef __io_seek_fn cookie_seek_function_t;
typedef __io_close_fn cookie_close_function_t;
typedef struct
{
__io_read_fn *read;
__io_write_fn *write;
__io_seek_fn *seek;
__io_close_fn *close;
} _IO_cookie_io_functions_t;
typedef _IO_cookie_io_functions_t cookie_io_functions_t;
struct _IO_cookie_file;
extern void _IO_cookie_init (struct _IO_cookie_file *__cfile, int __read_write,
void *__cookie, _IO_cookie_io_functions_t __fns);
extern "C" {
extern int __underflow (_IO_FILE *) throw ();
extern int __uflow (_IO_FILE *) throw ();
extern int __overflow (_IO_FILE *, int) throw ();
extern wint_t __wunderflow (_IO_FILE *) throw ();
extern wint_t __wuflow (_IO_FILE *) throw ();
extern wint_t __woverflow (_IO_FILE *, wint_t) throw ();
# 426 "/usr/include/libio.h" 3
extern int _IO_getc (_IO_FILE *__fp) throw ();
extern int _IO_putc (int __c, _IO_FILE *__fp) throw ();
extern int _IO_feof (_IO_FILE *__fp) throw ();
extern int _IO_ferror (_IO_FILE *__fp) throw ();
extern int _IO_peekc_locked (_IO_FILE *__fp) throw ();
extern void _IO_flockfile (_IO_FILE *) throw ();
extern void _IO_funlockfile (_IO_FILE *) throw ();
extern int _IO_ftrylockfile (_IO_FILE *) throw ();
# 456 "/usr/include/libio.h" 3
extern int _IO_vfscanf (_IO_FILE * __restrict, const char * __restrict,
__gnuc_va_list, int *__restrict) throw ();
extern int _IO_vfprintf (_IO_FILE *__restrict, const char *__restrict,
__gnuc_va_list) throw ();
extern __ssize_t _IO_padn (_IO_FILE *, int, __ssize_t) throw ();
extern size_t _IO_sgetn (_IO_FILE *, void *, size_t) throw ();
extern __off64_t _IO_seekoff (_IO_FILE *, __off64_t, int, int) throw ();
extern __off64_t _IO_seekpos (_IO_FILE *, __off64_t, int) throw ();
extern void _IO_free_backup_area (_IO_FILE *) throw ();
# 514 "/usr/include/libio.h" 3
}
# 66 "/usr/include/stdio.h" 2 3
typedef __gnuc_va_list va_list;
# 82 "/usr/include/stdio.h" 3
typedef _G_fpos64_t fpos_t;
typedef _G_fpos64_t fpos64_t;
# 129 "/usr/include/stdio.h" 3
# 1 "/usr/include/bits/stdio_lim.h" 1 3
# 130 "/usr/include/stdio.h" 2 3
extern FILE *stdin;
extern FILE *stdout;
extern FILE *stderr;
extern int remove (__const char *__filename) throw ();
extern int rename (__const char *__old, __const char *__new) throw ();
extern FILE *tmpfile (void) throw () __asm__ ("" "tmpfile64");
extern FILE *tmpfile64 (void) throw ();
extern char *tmpnam (char *__s) throw ();
extern char *tmpnam_r (char *__s) throw ();
# 178 "/usr/include/stdio.h" 3
extern char *tempnam (__const char *__dir, __const char *__pfx)
throw () __attribute__ ((__malloc__));
extern int fclose (FILE *__stream) throw ();
extern int fflush (FILE *__stream) throw ();
extern int fflush_unlocked (FILE *__stream) throw ();
extern int fcloseall (void) throw ();
# 209 "/usr/include/stdio.h" 3
extern FILE *fopen (__const char *__restrict __filename, __const char *__restrict __modes) throw () __asm__ ("" "fopen64");
extern FILE *freopen (__const char *__restrict __filename, __const char *__restrict __modes, FILE *__restrict __stream) throw () __asm__ ("" "freopen64");
# 222 "/usr/include/stdio.h" 3
extern FILE *fopen64 (__const char *__restrict __filename,
__const char *__restrict __modes) throw ();
extern FILE *freopen64 (__const char *__restrict __filename,
__const char *__restrict __modes,
FILE *__restrict __stream) throw ();
extern FILE *fdopen (int __fd, __const char *__modes) throw ();
extern FILE *fopencookie (void *__restrict __magic_cookie,
__const char *__restrict __modes,
_IO_cookie_io_functions_t __io_funcs) throw ();
extern FILE *fmemopen (void *__s, size_t __len, __const char *__modes) throw ();
extern FILE *open_memstream (char **__restrict __bufloc,
size_t *__restrict __sizeloc) throw ();
extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw ();
extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf,
int __modes, size_t __n) throw ();
extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf,
size_t __size) throw ();
extern void setlinebuf (FILE *__stream) throw ();
extern int fprintf (FILE *__restrict __stream,
__const char *__restrict __format, ...) throw ();
extern int printf (__const char *__restrict __format, ...) throw ();
extern int sprintf (char *__restrict __s,
__const char *__restrict __format, ...) throw ();
extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format,
__gnuc_va_list __arg) throw ();
extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg)
throw ();
extern int vsprintf (char *__restrict __s, __const char *__restrict __format,
__gnuc_va_list __arg) throw ();
extern int snprintf (char *__restrict __s, size_t __maxlen,
__const char *__restrict __format, ...)
throw () __attribute__ ((__format__ (__printf__, 3, 4)));
extern int vsnprintf (char *__restrict __s, size_t __maxlen,
__const char *__restrict __format, __gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__printf__, 3, 0)));
extern int vasprintf (char **__restrict __ptr, __const char *__restrict __f,
__gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__printf__, 2, 0)));
extern int __asprintf (char **__restrict __ptr,
__const char *__restrict __fmt, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int asprintf (char **__restrict __ptr,
__const char *__restrict __fmt, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int vdprintf (int __fd, __const char *__restrict __fmt,
__gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__printf__, 2, 0)));
extern int dprintf (int __fd, __const char *__restrict __fmt, ...)
throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int fscanf (FILE *__restrict __stream,
__const char *__restrict __format, ...) throw ();
extern int scanf (__const char *__restrict __format, ...) throw ();
extern int sscanf (__const char *__restrict __s,
__const char *__restrict __format, ...) throw ();
extern int vfscanf (FILE *__restrict __s, __const char *__restrict __format,
__gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
extern int vscanf (__const char *__restrict __format, __gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__scanf__, 1, 0)));
extern int vsscanf (__const char *__restrict __s,
__const char *__restrict __format, __gnuc_va_list __arg)
throw () __attribute__ ((__format__ (__scanf__, 2, 0)));
extern int fgetc (FILE *__stream) throw ();
extern int getc (FILE *__stream) throw ();
extern int getchar (void) throw ();
extern int getc_unlocked (FILE *__stream) throw ();
extern int getchar_unlocked (void) throw ();
extern int fgetc_unlocked (FILE *__stream) throw ();
extern int fputc (int __c, FILE *__stream) throw ();
extern int putc (int __c, FILE *__stream) throw ();
extern int putchar (int __c) throw ();
extern int fputc_unlocked (int __c, FILE *__stream) throw ();
extern int putc_unlocked (int __c, FILE *__stream) throw ();
extern int putchar_unlocked (int __c) throw ();
extern int getw (FILE *__stream) throw ();
extern int putw (int __w, FILE *__stream) throw ();
extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream)
throw ();
extern char *fgets_unlocked (char *__restrict __s, int __n,
FILE *__restrict __stream) throw ();
extern char *gets (char *__s) throw ();
# 426 "/usr/include/stdio.h" 3
extern __ssize_t __getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) throw ();
extern __ssize_t getdelim (char **__restrict __lineptr,
size_t *__restrict __n, int __delimiter,
FILE *__restrict __stream) throw ();
extern __ssize_t getline (char **__restrict __lineptr,
size_t *__restrict __n,
FILE *__restrict __stream) throw ();
extern int fputs (__const char *__restrict __s, FILE *__restrict __stream)
throw ();
extern int fputs_unlocked (__const char *__restrict __s,
FILE *__restrict __stream) throw ();
extern int puts (__const char *__s) throw ();
extern int ungetc (int __c, FILE *__stream) throw ();
extern size_t fread (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) throw ();
extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __s) throw ();
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) throw ();
extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
size_t __n, FILE *__restrict __stream) throw ();
extern int fseek (FILE *__stream, long int __off, int __whence) throw ();
extern long int ftell (FILE *__stream) throw ();
extern void rewind (FILE *__stream) throw ();
# 502 "/usr/include/stdio.h" 3
extern int fseeko (FILE *__stream, __off64_t __off, int __whence) throw () __asm__ ("" "fseeko64");
extern __off64_t ftello (FILE *__stream) throw () __asm__ ("" "ftello64");
extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos) throw () __asm__ ("" "fgetpos64");
extern int fsetpos (FILE *__stream, __const fpos_t *__pos) throw () __asm__ ("" "fsetpos64");
# 523 "/usr/include/stdio.h" 3
extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence) throw ();
extern __off64_t ftello64 (FILE *__stream) throw ();
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos)
throw ();
extern int fsetpos64 (FILE *__stream, __const fpos64_t *__pos) throw ();
extern void clearerr (FILE *__stream) throw ();
extern int feof (FILE *__stream) throw ();
extern int ferror (FILE *__stream) throw ();
extern void clearerr_unlocked (FILE *__stream) throw ();
extern int feof_unlocked (FILE *__stream) throw ();
extern int ferror_unlocked (FILE *__stream) throw ();
extern void perror (__const char *__s) throw ();
# 1 "/usr/include/bits/sys_errlist.h" 1 3
# 27 "/usr/include/bits/sys_errlist.h" 3
extern int sys_nerr;
extern __const char *__const sys_errlist[];
extern int _sys_nerr;
extern __const char *__const _sys_errlist[];
# 553 "/usr/include/stdio.h" 2 3
extern int fileno (FILE *__stream) throw ();
extern int fileno_unlocked (FILE *__stream) throw ();
extern FILE *popen (__const char *__command, __const char *__modes) throw ();
extern int pclose (FILE *__stream) throw ();
extern char *ctermid (char *__s) throw ();
extern char *cuserid (char *__s) throw ();
struct obstack;
extern int obstack_printf (struct obstack *__restrict __obstack,
__const char *__restrict __format, ...) throw ();
extern int obstack_vprintf (struct obstack *__restrict __obstack,
__const char *__restrict __format,
__gnuc_va_list __args) throw ();
extern void flockfile (FILE *__stream) throw ();
extern int ftrylockfile (FILE *__stream) throw ();
extern void funlockfile (FILE *__stream) throw ();
# 625 "/usr/include/stdio.h" 3
# 1 "/usr/include/bits/stdio.h" 1 3
# 33 "/usr/include/bits/stdio.h" 3
inline int
vprintf (__const char *__restrict __fmt, __gnuc_va_list __arg) throw ()
{
return vfprintf (stdout, __fmt, __arg);
}
inline int
getchar (void) throw ()
{
return _IO_getc (stdin);
}
inline int
getc_unlocked (FILE *__fp) throw ()
{
return ((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
}
inline int
getchar_unlocked (void) throw ()
{
return ((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
}
inline int
putchar (int __c) throw ()
{
return _IO_putc (__c, stdout);
}
inline int
fputc_unlocked (int __c, FILE *__stream) throw ()
{
return (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}
inline int
putc_unlocked (int __c, FILE *__stream) throw ()
{
return (((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}
inline int
putchar_unlocked (int __c) throw ()
{
return (((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
}
inline __ssize_t
getline (char **__lineptr, size_t *__n, FILE *__stream) throw ()
{
return __getdelim (__lineptr, __n, '\n', __stream);
}
inline int
feof_unlocked (FILE *__stream) throw ()
{
return (((__stream)->_flags & 0x10) != 0);
}
inline int
ferror_unlocked (FILE *__stream) throw ()
{
return (((__stream)->_flags & 0x20) != 0);
}
# 626 "/usr/include/stdio.h" 2 3
}
# 45 "../include/qtextstream.h" 2
class QTextCodec;
class QTextDecoder;
class QTextStreamPrivate;
class QTextStream
{
public:
enum Encoding { Locale, Latin1, Unicode, UnicodeNetworkOrder,
UnicodeReverse, RawUnicode, UnicodeUTF8 };
void setEncoding( Encoding );
void setCodec( QTextCodec* );
QTextCodec *codec();
QTextStream();
QTextStream( QIODevice * );
QTextStream( QString*, int mode );
QTextStream( QString&, int mode );
QTextStream( QByteArray, int mode );
QTextStream( FILE *, int mode );
virtual ~QTextStream();
QIODevice *device() const;
void setDevice( QIODevice * );
void unsetDevice();
bool atEnd() const;
bool eof() const;
QTextStream &operator>>( QChar & );
QTextStream &operator>>( char & );
QTextStream &operator>>( signed short & );
QTextStream &operator>>( unsigned short & );
QTextStream &operator>>( signed int & );
QTextStream &operator>>( unsigned int & );
QTextStream &operator>>( signed long & );
QTextStream &operator>>( unsigned long & );
QTextStream &operator>>( float & );
QTextStream &operator>>( double & );
QTextStream &operator>>( char * );
QTextStream &operator>>( QString & );
QTextStream &operator>>( QCString & );
QTextStream &operator<<( QChar );
QTextStream &operator<<( char );
QTextStream &operator<<( signed short );
QTextStream &operator<<( unsigned short );
QTextStream &operator<<( signed int );
QTextStream &operator<<( unsigned int );
QTextStream &operator<<( signed long );
QTextStream &operator<<( unsigned long );
QTextStream &operator<<( float );
QTextStream &operator<<( double );
QTextStream &operator<<( const char* );
QTextStream &operator<<( const QString & );
QTextStream &operator<<( const QCString & );
QTextStream &operator<<( void * );
QTextStream &readRawBytes( char *, uint len );
QTextStream &writeRawBytes( const char* , uint len );
QString readLine();
QString read();
void skipWhiteSpace();
enum {
skipws = 0x0001,
left = 0x0002,
right = 0x0004,
internal = 0x0008,
bin = 0x0010,
oct = 0x0020,
dec = 0x0040,
hex = 0x0080,
showbase = 0x0100,
showpoint = 0x0200,
uppercase = 0x0400,
showpos = 0x0800,
scientific= 0x1000,
fixed = 0x2000
};
static const int basefield;
static const int adjustfield;
static const int floatfield;
int flags() const;
int flags( int f );
int setf( int bits );
int setf( int bits, int mask );
int unsetf( int bits );
void reset();
int width() const;
int width( int );
int fill() const;
int fill( int );
int precision() const;
int precision( int );
private:
long input_int();
void init();
QTextStream &output_int( int, ulong, bool );
QIODevice *dev;
int fflags;
int fwidth;
int fillchar;
int fprec;
bool doUnicodeHeader;
bool owndev;
QTextCodec *mapper;
QTextStreamPrivate * d;
QChar unused1;
bool latin1;
bool internalOrder;
bool networkOrder;
void *unused2;
QChar eat_ws();
uint ts_getline( QChar* );
void ts_ungetc( QChar );
QChar ts_getc();
uint ts_getbuf( QChar*, uint );
void ts_putc(int);
void ts_putc(QChar);
bool ts_isspace(QChar);
bool ts_isdigit(QChar);
ulong input_bin();
ulong input_oct();
ulong input_dec();
ulong input_hex();
double input_double();
QTextStream &writeBlock( const char* p, uint len );
QTextStream &writeBlock( const QChar* p, uint len );
private:
QTextStream( const QTextStream & );
QTextStream &operator=( const QTextStream & );
};
typedef QTextStream QTS;
class QTextIStream : public QTextStream {
public:
QTextIStream( const QString* s ) :
QTextStream((QString*)s,0x0001) { }
QTextIStream( QByteArray ba ) :
QTextStream(ba,0x0001) { }
QTextIStream( FILE *f ) :
QTextStream(f,0x0001) { }
private:
QTextIStream( const QTextIStream & );
QTextIStream &operator=( const QTextIStream & );
};
class QTextOStream : public QTextStream {
public:
QTextOStream( QString* s ) :
QTextStream(s,0x0002) { }
QTextOStream( QByteArray ba ) :
QTextStream(ba,0x0002) { }
QTextOStream( FILE *f ) :
QTextStream(f,0x0002) { }
private:
QTextOStream( const QTextOStream & );
QTextOStream &operator=( const QTextOStream & );
};
inline QIODevice *QTextStream::device() const
{ return dev; }
inline bool QTextStream::atEnd() const
{ return dev ? dev->atEnd() : FALSE; }
inline bool QTextStream::eof() const
{ return atEnd(); }
inline int QTextStream::flags() const
{ return fflags; }
inline int QTextStream::flags( int f )
{ int oldf = fflags; fflags = f; return oldf; }
inline int QTextStream::setf( int bits )
{ int oldf = fflags; fflags |= bits; return oldf; }
inline int QTextStream::setf( int bits, int mask )
{ int oldf = fflags; fflags = (fflags & ~mask) | (bits & mask); return oldf; }
inline int QTextStream::unsetf( int bits )
{ int oldf = fflags; fflags &= ~bits; return oldf; }
inline int QTextStream::width() const
{ return fwidth; }
inline int QTextStream::width( int w )
{ int oldw = fwidth; fwidth = w; return oldw; }
inline int QTextStream::fill() const
{ return fillchar; }
inline int QTextStream::fill( int f )
{ int oldc = fillchar; fillchar = f; return oldc; }
inline int QTextStream::precision() const
{ return fprec; }
inline int QTextStream::precision( int p )
{ int oldp = fprec; fprec = p; return oldp; }
inline QChar QTextStream::ts_getc()
{ QChar r; return ( ts_getbuf( &r,1 ) == 1 ? r : QChar((ushort)0xffff) ); }
typedef QTextStream & (*QTSFUNC)(QTextStream &);
typedef int (QTextStream::*QTSMFI)(int);
class QTSManip {
public:
QTSManip( QTSMFI m, int a ) { mf=m; arg=a; }
void exec( QTextStream &s ) { (s.*mf)(arg); }
private:
QTSMFI mf;
int arg;
};
inline QTextStream &operator>>( QTextStream &s, QTSFUNC f )
{ return (*f)( s ); }
inline QTextStream &operator<<( QTextStream &s, QTSFUNC f )
{ return (*f)( s ); }
inline QTextStream &operator<<( QTextStream &s, QTSManip m )
{ m.exec(s); return s; }
QTextStream &bin( QTextStream &s );
QTextStream &oct( QTextStream &s );
QTextStream &dec( QTextStream &s );
QTextStream &hex( QTextStream &s );
QTextStream &endl( QTextStream &s );
QTextStream &flush( QTextStream &s );
QTextStream &ws( QTextStream &s );
QTextStream &reset( QTextStream &s );
inline QTSManip qSetW( int w )
{
QTSMFI func = &QTextStream::width;
return QTSManip(func,w);
}
inline QTSManip qSetFill( int f )
{
QTSMFI func = &QTextStream::fill;
return QTSManip(func,f);
}
inline QTSManip qSetPrecision( int p )
{
QTSMFI func = &QTextStream::precision;
return QTSManip(func,p);
}
# 44 "../include/qtl.h" 2
template <class T>
class QTextOStreamIterator
{
protected:
QTextOStream& stream;
QString separator;
public:
QTextOStreamIterator( QTextOStream& s) : stream( s ) {}
QTextOStreamIterator( QTextOStream& s, const QString& sep )
: stream( s ), separator( sep ) {}
QTextOStreamIterator<T>& operator= ( const T& x ) {
stream << x;
if ( !separator.isEmpty() )
stream << separator;
return *this;
}
QTextOStreamIterator<T>& operator*() { return *this; }
QTextOStreamIterator<T>& operator++() { return *this; }
QTextOStreamIterator<T>& operator++(int) { return *this; }
};
template <class InputIterator, class OutputIterator>
inline OutputIterator qCopy( InputIterator _begin, InputIterator _end,
OutputIterator _dest )
{
while( _begin != _end )
*_dest++ = *_begin++;
return _dest;
}
template <class BiIterator, class BiOutputIterator>
inline BiOutputIterator qCopyBackward( BiIterator _begin, BiIterator _end,
BiOutputIterator _dest )
{
while ( _begin != _end )
*--_dest = *--_end;
return _dest;
}
template <class InputIterator1, class InputIterator2>
inline bool qEqual( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2 )
{
for ( ; first1 != last1; ++first1, ++first2 )
if ( *first1 != *first2 )
return FALSE;
return TRUE;
}
template <class ForwardIterator, class T>
inline void qFill( ForwardIterator first, ForwardIterator last, const T& val )
{
for ( ; first != last; ++first )
*first = val;
}
# 120 "../include/qtl.h"
template <class InputIterator, class T>
inline InputIterator qFind( InputIterator first, InputIterator last,
const T& val )
{
while ( first != last && *first != val )
++first;
return first;
}
template <class InputIterator, class T, class Size>
inline void qCount( InputIterator first, InputIterator last, const T& value,
Size& n )
{
for ( ; first != last; ++first )
if ( *first == value )
++n;
}
template <class T>
inline void qSwap( T& _value1, T& _value2 )
{
T tmp = _value1;
_value1 = _value2;
_value2 = tmp;
}
template <class InputIterator>
void qBubbleSort( InputIterator b, InputIterator e )
{
InputIterator last = e;
--last;
if ( last == b )
return;
while( b != last ) {
bool swapped = FALSE;
InputIterator swap_pos = b;
InputIterator x = e;
InputIterator y = x;
y--;
do {
--x;
--y;
if ( *x < *y ) {
swapped = TRUE;
qSwap( *x, *y );
swap_pos = y;
}
} while( y != b );
if ( !swapped )
return;
b = swap_pos;
b++;
}
}
template <class Container>
inline void qBubbleSort( Container &c )
{
qBubbleSort( c.begin(), c.end() );
}
template <class Value>
void qHeapSortPushDown( Value* heap, int first, int last )
{
int r = first;
while ( r <= last / 2 ) {
if ( last == 2 * r ) {
if ( heap[2 * r] < heap[r] )
qSwap( heap[r], heap[2 * r] );
r = last;
} else {
if ( heap[2 * r] < heap[r] && !(heap[2 * r + 1] < heap[2 * r]) ) {
qSwap( heap[r], heap[2 * r] );
r *= 2;
} else if ( heap[2 * r + 1] < heap[r]
&& heap[2 * r + 1] < heap[2 * r] ) {
qSwap( heap[r], heap[2 * r + 1] );
r = 2 * r + 1;
} else {
r = last;
}
}
}
}
template <class InputIterator, class Value>
void qHeapSortHelper( InputIterator b, InputIterator e, Value, uint n )
{
InputIterator insert = b;
Value* realheap = new Value[n];
Value* heap = realheap - 1;
int size = 0;
for( ; insert != e; ++insert ) {
heap[++size] = *insert;
int i = size;
while( i > 1 && heap[i] < heap[i / 2] ) {
qSwap( heap[i], heap[i / 2] );
i /= 2;
}
}
for( uint i = n; i > 0; i-- ) {
*b++ = heap[1];
if ( i > 1 ) {
heap[1] = heap[i];
qHeapSortPushDown( heap, 1, (int)i - 1 );
}
}
delete[] realheap;
}
template <class InputIterator>
void qHeapSort( InputIterator b, InputIterator e )
{
if ( b == e )
return;
InputIterator it = b;
uint n = 0;
while ( it != e ) {
++n;
++it;
}
qHeapSortHelper( b, e, *b, n );
}
template <class Container>
void qHeapSort( Container &c )
{
if ( c.begin() == c.end() )
return;
qHeapSortHelper( c.begin(), c.end(), *(c.begin()), (uint)c.count() );
}
template <class Container>
class QBackInsertIterator
{
public:
explicit QBackInsertIterator( Container &c )
: container( &c )
{
}
QBackInsertIterator<Container>&
operator=( const typename Container::value_type &value )
{
container->push_back( value );
return *this;
}
QBackInsertIterator<Container>& operator*()
{
return *this;
}
QBackInsertIterator<Container>& operator++()
{
return *this;
}
QBackInsertIterator<Container>& operator++(int)
{
return *this;
}
protected:
Container *container;
};
template <class Container>
inline QBackInsertIterator<Container> qBackInserter( Container &c )
{
return QBackInsertIterator<Container>( c );
}
# 43 "../include/qvaluelist.h" 2
# 1 "../include/qdatastream.h" 1
# 47 "../include/qdatastream.h"
class QDataStream
{
public:
QDataStream();
QDataStream( QIODevice * );
QDataStream( QByteArray, int mode );
virtual ~QDataStream();
QIODevice *device() const;
void setDevice( QIODevice * );
void unsetDevice();
bool atEnd() const;
bool eof() const;
enum ByteOrder { BigEndian, LittleEndian };
int byteOrder() const;
void setByteOrder( int );
bool isPrintableData() const;
void setPrintableData( bool );
int version() const;
void setVersion( int );
QDataStream &operator>>( Q_INT8 &i );
QDataStream &operator>>( Q_UINT8 &i );
QDataStream &operator>>( Q_INT16 &i );
QDataStream &operator>>( Q_UINT16 &i );
QDataStream &operator>>( Q_INT32 &i );
QDataStream &operator>>( Q_UINT32 &i );
QDataStream &operator>>( Q_LONG &i );
QDataStream &operator>>( Q_ULONG &i );
QDataStream &operator>>( float &f );
QDataStream &operator>>( double &f );
QDataStream &operator>>( char *&str );
QDataStream &operator<<( Q_INT8 i );
QDataStream &operator<<( Q_UINT8 i );
QDataStream &operator<<( Q_INT16 i );
QDataStream &operator<<( Q_UINT16 i );
QDataStream &operator<<( Q_INT32 i );
QDataStream &operator<<( Q_UINT32 i );
QDataStream &operator<<( Q_LONG i );
QDataStream &operator<<( Q_ULONG i );
QDataStream &operator<<( float f );
QDataStream &operator<<( double f );
QDataStream &operator<<( const char *str );
QDataStream &readBytes( char *&, uint &len );
QDataStream &readRawBytes( char *, uint len );
QDataStream &writeBytes( const char *, uint len );
QDataStream &writeRawBytes( const char *, uint len );
private:
QIODevice *dev;
bool owndev;
int byteorder;
bool printable;
bool noswap;
int ver;
private:
QDataStream( const QDataStream & );
QDataStream &operator=( const QDataStream & );
};
inline QIODevice *QDataStream::device() const
{ return dev; }
inline bool QDataStream::atEnd() const
{ return dev ? dev->atEnd() : TRUE; }
inline bool QDataStream::eof() const
{ return atEnd(); }
inline int QDataStream::byteOrder() const
{ return byteorder; }
inline bool QDataStream::isPrintableData() const
{ return printable; }
inline void QDataStream::setPrintableData( bool p )
{ printable = p; }
inline int QDataStream::version() const
{ return ver; }
inline void QDataStream::setVersion( int v )
{ ver = v; }
inline QDataStream &QDataStream::operator>>( Q_UINT8 &i )
{ return *this >> (Q_INT8&)i; }
inline QDataStream &QDataStream::operator>>( Q_UINT16 &i )
{ return *this >> (Q_INT16&)i; }
inline QDataStream &QDataStream::operator>>( Q_UINT32 &i )
{ return *this >> (Q_INT32&)i; }
inline QDataStream &QDataStream::operator>>( Q_ULONG &i )
{ return *this >> (Q_LONG&)i; }
inline QDataStream &QDataStream::operator<<( Q_UINT8 i )
{ return *this << (Q_INT8)i; }
inline QDataStream &QDataStream::operator<<( Q_UINT16 i )
{ return *this << (Q_INT16)i; }
inline QDataStream &QDataStream::operator<<( Q_UINT32 i )
{ return *this << (Q_INT32)i; }
inline QDataStream &QDataStream::operator<<( Q_ULONG i )
{ return *this << (Q_LONG)i; }
# 45 "../include/qvaluelist.h" 2
# 58 "../include/qvaluelist.h"
template <class T>
class QValueListNode
{
public:
QValueListNode( const T& t ) : data( t ) { }
QValueListNode() { }
QValueListNode<T>* next;
QValueListNode<T>* prev;
T data;
};
template<class T>
class QValueListIterator
{
public:
typedef QValueListNode<T>* NodePtr;
typedef T value_type;
typedef size_t size_type;
typedef int difference_type;
typedef T* pointer;
typedef T& reference;
NodePtr node;
QValueListIterator() : node( 0 ) {}
QValueListIterator( NodePtr p ) : node( p ) {}
QValueListIterator( const QValueListIterator<T>& it ) : node( it.node ) {}
bool operator==( const QValueListIterator<T>& it ) const { return node == it.node; }
bool operator!=( const QValueListIterator<T>& it ) const { return node != it.node; }
const T& operator*() const { return node->data; }
T& operator*() { return node->data; }
QValueListIterator<T>& operator++() {
node = node->next;
return *this;
}
QValueListIterator<T> operator++(int) {
QValueListIterator<T> tmp = *this;
node = node->next;
return tmp;
}
QValueListIterator<T>& operator--() {
node = node->prev;
return *this;
}
QValueListIterator<T> operator--(int) {
QValueListIterator<T> tmp = *this;
node = node->prev;
return tmp;
}
QValueListIterator<T>& operator+=( int j ) {
while ( j-- )
node = node->next;
return *this;
}
QValueListIterator<T>& operator-=( int j ) {
while ( j-- )
node = node->prev;
return *this;
}
};
template<class T>
class QValueListConstIterator
{
public:
typedef QValueListNode<T>* NodePtr;
typedef T value_type;
typedef size_t size_type;
typedef int difference_type;
typedef const T* pointer;
typedef const T& reference;
NodePtr node;
QValueListConstIterator() : node( 0 ) {}
QValueListConstIterator( NodePtr p ) : node( p ) {}
QValueListConstIterator( const QValueListConstIterator<T>& it ) : node( it.node ) {}
QValueListConstIterator( const QValueListIterator<T>& it ) : node( it.node ) {}
bool operator==( const QValueListConstIterator<T>& it ) const { return node == it.node; }
bool operator!=( const QValueListConstIterator<T>& it ) const { return node != it.node; }
const T& operator*() const { return node->data; }
QValueListConstIterator<T>& operator++() {
node = node->next;
return *this;
}
QValueListConstIterator<T> operator++(int) {
QValueListConstIterator<T> tmp = *this;
node = node->next;
return tmp;
}
QValueListConstIterator<T>& operator--() {
node = node->prev;
return *this;
}
QValueListConstIterator<T> operator--(int) {
QValueListConstIterator<T> tmp = *this;
node = node->prev;
return tmp;
}
};
template <class T>
class QValueListPrivate : public QShared
{
public:
typedef QValueListIterator<T> Iterator;
typedef QValueListConstIterator<T> ConstIterator;
typedef QValueListNode<T> Node;
typedef QValueListNode<T>* NodePtr;
typedef size_t size_type;
QValueListPrivate();
QValueListPrivate( const QValueListPrivate<T>& _p );
void derefAndDelete()
{
if ( deref() )
delete this;
}
~QValueListPrivate();
Iterator insert( Iterator it, const T& x );
Iterator remove( Iterator it );
NodePtr find( NodePtr start, const T& x ) const;
int findIndex( NodePtr start, const T& x ) const;
uint contains( const T& x ) const;
uint remove( const T& x );
NodePtr at( size_type i ) const;
void clear();
NodePtr node;
size_type nodes;
};
template <class T>
QValueListPrivate<T>::QValueListPrivate()
{
node = new Node; node->next = node->prev = node; nodes = 0;
}
template <class T>
QValueListPrivate<T>::QValueListPrivate( const QValueListPrivate<T>& _p )
: QShared()
{
node = new Node; node->next = node->prev = node; nodes = 0;
Iterator b( _p.node->next );
Iterator e( _p.node );
Iterator i( node );
while( b != e )
insert( i, *b++ );
}
template <class T>
QValueListPrivate<T>::~QValueListPrivate() {
NodePtr p = node->next;
while( p != node ) {
NodePtr x = p->next;
delete p;
p = x;
}
delete node;
}
template <class T>
typename QValueListPrivate<T>::Iterator QValueListPrivate<T>::insert( typename QValueListPrivate<T>::Iterator it, const T& x )
{
NodePtr p = new Node( x );
p->next = it.node;
p->prev = it.node->prev;
it.node->prev->next = p;
it.node->prev = p;
nodes++;
return p;
}
template <class T>
typename QValueListPrivate<T>::Iterator QValueListPrivate<T>::remove( typename QValueListPrivate<T>::Iterator it )
{
((it.node != node) ? (void)0 : qWarning("ASSERT: \"%s\" in %s (%d)","it.node != node","../include/qvaluelist.h",301));
NodePtr next = it.node->next;
NodePtr prev = it.node->prev;
prev->next = next;
next->prev = prev;
delete it.node;
nodes--;
return Iterator( next );
}
template <class T>
typename QValueListPrivate<T>::NodePtr QValueListPrivate<T>::find( typename QValueListPrivate<T>::NodePtr start, const T& x ) const
{
ConstIterator first( start );
ConstIterator last( node );
while( first != last) {
if ( *first == x )
return first.node;
++first;
}
return last.node;
}
template <class T>
int QValueListPrivate<T>::findIndex( typename QValueListPrivate<T>::NodePtr start, const T& x ) const
{
ConstIterator first( start );
ConstIterator last( node );
int pos = 0;
while( first != last) {
if ( *first == x )
return pos;
++first;
++pos;
}
return -1;
}
template <class T>
uint QValueListPrivate<T>::contains( const T& x ) const
{
uint result = 0;
Iterator first = Iterator( node->next );
Iterator last = Iterator( node );
while( first != last) {
if ( *first == x )
++result;
++first;
}
return result;
}
template <class T>
uint QValueListPrivate<T>::remove( const T& x )
{
uint result = 0;
Iterator first = Iterator( node->next );
Iterator last = Iterator( node );
while( first != last) {
if ( *first == x ) {
first = remove( first );
++result;
} else
++first;
}
return result;
}
template <class T>
typename QValueListPrivate<T>::NodePtr QValueListPrivate<T>::at( size_type i ) const
{
((i <= nodes) ? (void)0 : qWarning("ASSERT: \"%s\" in %s (%d)","i <= nodes","../include/qvaluelist.h",372));
NodePtr p = node->next;
for( size_type x = 0; x < i; ++x )
p = p->next;
return p;
}
template <class T>
void QValueListPrivate<T>::clear()
{
nodes = 0;
NodePtr p = node->next;
while( p != node ) {
NodePtr next = p->next;
delete p;
p = next;
}
node->next = node->prev = node;
}
# 405 "../include/qvaluelist.h"
template <class T> class QDeepCopy;
template <class T>
class QValueList
{
public:
typedef QValueListIterator<T> iterator;
typedef QValueListConstIterator<T> const_iterator;
typedef T value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef size_t size_type;
typedef int difference_type;
QValueList() { sh = new QValueListPrivate<T>; }
QValueList( const QValueList<T>& l ) { sh = l.sh; sh->ref(); }
# 444 "../include/qvaluelist.h"
~QValueList() { sh->derefAndDelete(); }
QValueList<T>& operator= ( const QValueList<T>& l )
{
l.sh->ref();
sh->derefAndDelete();
sh = l.sh;
return *this;
}
# 479 "../include/qvaluelist.h"
bool operator== ( const QValueList<T>& l ) const;
bool operator!= ( const QValueList<T>& l ) const { return !( *this == l ); }
iterator begin() { detach(); return iterator( sh->node->next ); }
const_iterator begin() const { return const_iterator( sh->node->next ); }
iterator end() { detach(); return iterator( sh->node ); }
const_iterator end() const { return const_iterator( sh->node ); }
iterator insert( iterator it, const T& x ) { detach(); return sh->insert( it, x ); }
uint remove( const T& x ) { detach(); return sh->remove( x ); }
void clear();
QValueList<T>& operator<< ( const T& x )
{
append( x );
return *this;
}
size_type size() const { return sh->nodes; }
bool empty() const { return sh->nodes == 0; }
void push_front( const T& x ) { detach(); sh->insert( begin(), x ); }
void push_back( const T& x ) { detach(); sh->insert( end(), x ); }
iterator erase( iterator pos ) { detach(); return sh->remove( pos ); }
iterator erase( iterator first, iterator last );
reference front() { ; return *begin(); }
const_reference front() const { ; return *begin(); }
reference back() { ; return *(--end()); }
const_reference back() const { ; return *(--end()); }
void pop_front() { ; erase( begin() ); }
void pop_back() {
;
iterator tmp = end();
erase( --tmp );
}
void insert( iterator pos, size_type n, const T& x );
# 522 "../include/qvaluelist.h"
QValueList<T> operator+ ( const QValueList<T>& l ) const;
QValueList<T>& operator+= ( const QValueList<T>& l );
iterator fromLast() { detach(); return iterator( sh->node->prev ); }
const_iterator fromLast() const { return const_iterator( sh->node->prev ); }
bool isEmpty() const { return ( sh->nodes == 0 ); }
iterator append( const T& x ) { detach(); return sh->insert( end(), x ); }
iterator prepend( const T& x ) { detach(); return sh->insert( begin(), x ); }
iterator remove( iterator it ) { detach(); return sh->remove( it ); }
T& first() { ; detach(); return sh->node->next->data; }
const T& first() const { ; return sh->node->next->data; }
T& last() { ; detach(); return sh->node->prev->data; }
const T& last() const { ; return sh->node->prev->data; }
T& operator[] ( size_type i ) { ; detach(); return sh->at(i)->data; }
const T& operator[] ( size_type i ) const { ; return sh->at(i)->data; }
iterator at( size_type i ) { ; detach(); return iterator( sh->at(i) ); }
const_iterator at( size_type i ) const { ; return const_iterator( sh->at(i) ); }
iterator find ( const T& x ) { detach(); return iterator( sh->find( sh->node->next, x) ); }
const_iterator find ( const T& x ) const { return const_iterator( sh->find( sh->node->next, x) ); }
iterator find ( iterator it, const T& x ) { detach(); return iterator( sh->find( it.node, x ) ); }
const_iterator find ( const_iterator it, const T& x ) const { return const_iterator( sh->find( it.node, x ) ); }
int findIndex( const T& x ) const { return sh->findIndex( sh->node->next, x) ; }
size_type contains( const T& x ) const { return sh->contains( x ); }
size_type count() const { return sh->nodes; }
QValueList<T>& operator+= ( const T& x )
{
append( x );
return *this;
}
typedef QValueListIterator<T> Iterator;
typedef QValueListConstIterator<T> ConstIterator;
typedef T ValueType;
protected:
void detach() { if ( sh->count > 1 ) detachInternal(); }
QValueListPrivate<T>* sh;
private:
void detachInternal();
friend class QDeepCopy< QValueList<T> >;
};
template <class T>
bool QValueList<T>::operator== ( const QValueList<T>& l ) const
{
if ( size() != l.size() )
return FALSE;
const_iterator it2 = begin();
const_iterator it = l.begin();
for( ; it != l.end(); ++it, ++it2 )
if ( !( *it == *it2 ) )
return FALSE;
return TRUE;
}
template <class T>
void QValueList<T>::clear()
{
if ( sh->count == 1 ) sh->clear(); else { sh->deref(); sh = new QValueListPrivate<T>; }
}
template <class T>
typename QValueList<T>::iterator QValueList<T>::erase( typename QValueList<T>::iterator first, typename QValueList<T>::iterator last )
{
while ( first != last )
erase( first++ );
return last;
}
template <class T>
void QValueList<T>::insert( typename QValueList<T>::iterator pos, size_type n, const T& x )
{
for ( ; n > 0; --n )
insert( pos, x );
}
template <class T>
QValueList<T> QValueList<T>::operator+ ( const QValueList<T>& l ) const
{
QValueList<T> l2( *this );
for( const_iterator it = l.begin(); it != l.end(); ++it )
l2.append( *it );
return l2;
}
template <class T>
QValueList<T>& QValueList<T>::operator+= ( const QValueList<T>& l )
{
for( const_iterator it = l.begin(); it != l.end(); ++it )
append( *it );
return *this;
}
template <class T>
void QValueList<T>::detachInternal()
{
sh->deref(); sh = new QValueListPrivate<T>( *sh );
}
template <class T>
QDataStream& operator>>( QDataStream& s, QValueList<T>& l )
{
l.clear();
Q_UINT32 c;
s >> c;
for( Q_UINT32 i = 0; i < c; ++i )
{
T t;
s >> t;
l.append( t );
if ( s.atEnd() )
break;
}
return s;
}
template <class T>
QDataStream& operator<<( QDataStream& s, const QValueList<T>& l )
{
s << (Q_UINT32)l.size();
QValueListConstIterator<T> it = l.begin();
for( ; it != l.end(); ++it )
s << *it;
return s;
}
# 306 "kernel/qvariant.h" 2
# 1 "../include/qstringlist.h" 1
# 44 "../include/qstringlist.h"
# 1 "../include/qstrlist.h" 1
# 43 "../include/qstrlist.h"
# 1 "../include/qptrlist.h" 1
# 42 "../include/qptrlist.h"
# 1 "../include/qglist.h" 1
# 42 "../include/qglist.h"
# 1 "../include/qptrcollection.h" 1
# 40 "../include/qptrcollection.h"
# 1 "../include/qglobal.h" 1
# 41 "../include/qptrcollection.h" 2
class QGVector;
class QGList;
class QGDict;
class QPtrCollection
{
public:
bool autoDelete() const { return del_item; }
void setAutoDelete( bool enable ) { del_item = enable; }
virtual uint count() const = 0;
virtual void clear() = 0;
typedef void *Item;
protected:
QPtrCollection() { del_item = FALSE; }
QPtrCollection(const QPtrCollection &) { del_item = FALSE; }
virtual ~QPtrCollection() {}
bool del_item;
virtual Item newItem( Item );
virtual void deleteItem( Item ) = 0;
};
# 43 "../include/qglist.h" 2
class QLNode
{
friend class QGList;
friend class QGListIterator;
public:
QPtrCollection::Item getData() { return data; }
private:
QPtrCollection::Item data;
QLNode *prev;
QLNode *next;
QLNode( QPtrCollection::Item d ) { data = d; }
};
class QGListIteratorList;
class QGList : public QPtrCollection
{
friend class QGListIterator;
friend class QGListIteratorList;
friend class QGVector;
public:
uint count() const;
QDataStream &read( QDataStream & );
QDataStream &write( QDataStream & ) const;
protected:
QGList();
QGList( const QGList & );
virtual ~QGList();
QGList &operator=( const QGList & );
bool operator==( const QGList& ) const;
void inSort( QPtrCollection::Item );
void append( QPtrCollection::Item );
bool insertAt( uint index, QPtrCollection::Item );
void relinkNode( QLNode * );
bool removeNode( QLNode * );
bool remove( QPtrCollection::Item = 0 );
bool removeRef( QPtrCollection::Item = 0 );
bool removeFirst();
bool removeLast();
bool removeAt( uint );
bool replaceAt( uint, QPtrCollection::Item );
QPtrCollection::Item takeNode( QLNode * );
QPtrCollection::Item take();
QPtrCollection::Item takeAt( uint index );
QPtrCollection::Item takeFirst();
QPtrCollection::Item takeLast();
void sort();
void clear();
int findRef( QPtrCollection::Item, bool = TRUE );
int find( QPtrCollection::Item, bool = TRUE );
uint containsRef( QPtrCollection::Item ) const;
uint contains( QPtrCollection::Item ) const;
QPtrCollection::Item at( uint index );
int at() const;
QLNode *currentNode() const;
QPtrCollection::Item get() const;
QPtrCollection::Item cfirst() const;
QPtrCollection::Item clast() const;
QPtrCollection::Item first();
QPtrCollection::Item last();
QPtrCollection::Item next();
QPtrCollection::Item prev();
void toVector( QGVector * ) const;
virtual int compareItems( QPtrCollection::Item, QPtrCollection::Item );
virtual QDataStream &read( QDataStream &, QPtrCollection::Item & );
virtual QDataStream &write( QDataStream &, QPtrCollection::Item ) const;
private:
void prepend( QPtrCollection::Item );
void heapSortPushDown( QPtrCollection::Item* heap, int first, int last );
QLNode *firstNode;
QLNode *lastNode;
QLNode *curNode;
int curIndex;
uint numNodes;
QGListIteratorList *iterators;
QLNode *locate( uint );
QLNode *unlink();
};
inline uint QGList::count() const
{
return numNodes;
}
inline bool QGList::removeFirst()
{
first();
return remove();
}
inline bool QGList::removeLast()
{
last();
return remove();
}
inline int QGList::at() const
{
return curIndex;
}
inline QPtrCollection::Item QGList::at( uint index )
{
QLNode *n = locate( index );
return n ? n->data : 0;
}
inline QLNode *QGList::currentNode() const
{
return curNode;
}
inline QPtrCollection::Item QGList::get() const
{
return curNode ? curNode->data : 0;
}
inline QPtrCollection::Item QGList::cfirst() const
{
return firstNode ? firstNode->data : 0;
}
inline QPtrCollection::Item QGList::clast() const
{
return lastNode ? lastNode->data : 0;
}
QDataStream &operator>>( QDataStream &, QGList & );
QDataStream &operator<<( QDataStream &, const QGList & );
class QGListIterator
{
friend class QGList;
friend class QGListIteratorList;
protected:
QGListIterator( const QGList & );
QGListIterator( const QGListIterator & );
QGListIterator &operator=( const QGListIterator & );
~QGListIterator();
bool atFirst() const;
bool atLast() const;
QPtrCollection::Item toFirst();
QPtrCollection::Item toLast();
QPtrCollection::Item get() const;
QPtrCollection::Item operator()();
QPtrCollection::Item operator++();
QPtrCollection::Item operator+=(uint);
QPtrCollection::Item operator--();
QPtrCollection::Item operator-=(uint);
protected:
QGList *list;
private:
QLNode *curNode;
};
inline bool QGListIterator::atFirst() const
{
return curNode == list->firstNode;
}
inline bool QGListIterator::atLast() const
{
return curNode == list->lastNode;
}
inline QPtrCollection::Item QGListIterator::get() const
{
return curNode ? curNode->data : 0;
}
# 43 "../include/qptrlist.h" 2
template<class type>
class QPtrList
: public QGList
{
public:
QPtrList() {}
QPtrList( const QPtrList<type> &l ) : QGList(l) {}
~QPtrList() { clear(); }
QPtrList<type> &operator=(const QPtrList<type> &l)
{ return (QPtrList<type>&)QGList::operator=(l); }
bool operator==( const QPtrList<type> &list ) const
{ return QGList::operator==( list ); }
bool operator!=( const QPtrList<type> &list ) const
{ return !QGList::operator==( list ); }
uint count() const { return QGList::count(); }
bool isEmpty() const { return QGList::count() == 0; }
bool insert( uint i, const type *d){ return QGList::insertAt(i,(QPtrCollection::Item)d); }
void inSort( const type *d ) { QGList::inSort((QPtrCollection::Item)d); }
void prepend( const type *d ) { QGList::insertAt(0,(QPtrCollection::Item)d); }
void append( const type *d ) { QGList::append((QPtrCollection::Item)d); }
bool remove( uint i ) { return QGList::removeAt(i); }
bool remove() { return QGList::remove((QPtrCollection::Item)0); }
bool remove( const type *d ) { return QGList::remove((QPtrCollection::Item)d); }
bool removeRef( const type *d ) { return QGList::removeRef((QPtrCollection::Item)d); }
void removeNode( QLNode *n ) { QGList::removeNode(n); }
bool removeFirst() { return QGList::removeFirst(); }
bool removeLast() { return QGList::removeLast(); }
type *take( uint i ) { return (type *)QGList::takeAt(i); }
type *take() { return (type *)QGList::take(); }
type *takeNode( QLNode *n ) { return (type *)QGList::takeNode(n); }
void clear() { QGList::clear(); }
void sort() { QGList::sort(); }
int find( const type *d ) { return QGList::find((QPtrCollection::Item)d); }
int findNext( const type *d ) { return QGList::find((QPtrCollection::Item)d,FALSE); }
int findRef( const type *d ) { return QGList::findRef((QPtrCollection::Item)d); }
int findNextRef( const type *d ){ return QGList::findRef((QPtrCollection::Item)d,FALSE);}
uint contains( const type *d ) const { return QGList::contains((QPtrCollection::Item)d); }
uint containsRef( const type *d ) const
{ return QGList::containsRef((QPtrCollection::Item)d); }
bool replace( uint i, const type *d ) { return QGList::replaceAt( i, (QPtrCollection::Item)d ); }
type *at( uint i ) { return (type *)QGList::at(i); }
int at() const { return QGList::at(); }
type *current() const { return (type *)QGList::get(); }
QLNode *currentNode() const { return QGList::currentNode(); }
type *getFirst() const { return (type *)QGList::cfirst(); }
type *getLast() const { return (type *)QGList::clast(); }
type *first() { return (type *)QGList::first(); }
type *last() { return (type *)QGList::last(); }
type *next() { return (type *)QGList::next(); }
type *prev() { return (type *)QGList::prev(); }
void toVector( QGVector *vec )const{ QGList::toVector(vec); }
# 109 "../include/qptrlist.h"
private:
void deleteItem( Item d );
};
template<> inline void QPtrList<void>::deleteItem( QPtrCollection::Item )
{
}
template<class type> inline void QPtrList<type>::deleteItem( QPtrCollection::Item d )
{
if ( del_item ) delete (type *)d;
}
template<class type>
class QPtrListIterator : public QGListIterator
{
public:
QPtrListIterator(const QPtrList<type> &l) :QGListIterator((QGList &)l) {}
~QPtrListIterator() {}
uint count() const { return list->count(); }
bool isEmpty() const { return list->count() == 0; }
bool atFirst() const { return QGListIterator::atFirst(); }
bool atLast() const { return QGListIterator::atLast(); }
type *toFirst() { return (type *)QGListIterator::toFirst(); }
type *toLast() { return (type *)QGListIterator::toLast(); }
operator type *() const { return (type *)QGListIterator::get(); }
type *operator*() { return (type *)QGListIterator::get(); }
type *current() const { return (type *)QGListIterator::get(); }
type *operator()() { return (type *)QGListIterator::operator()();}
type *operator++() { return (type *)QGListIterator::operator++(); }
type *operator+=(uint j) { return (type *)QGListIterator::operator+=(j);}
type *operator--() { return (type *)QGListIterator::operator--(); }
type *operator-=(uint j) { return (type *)QGListIterator::operator-=(j);}
QPtrListIterator<type>& operator=(const QPtrListIterator<type>&it)
{ QGListIterator::operator=(it); return *this; }
};
# 44 "../include/qstrlist.h" 2
# 58 "../include/qstrlist.h"
typedef QPtrListIterator<char> QStrListIterator;
class QStrList : public QPtrList<char>
{
public:
QStrList( bool deepCopies=TRUE ) { dc = deepCopies; del_item = deepCopies; }
QStrList( const QStrList & );
~QStrList() { clear(); }
QStrList& operator=( const QStrList & );
private:
QPtrCollection::Item newItem( QPtrCollection::Item d ) { return dc ? qstrdup( (const char*)d ) : d; }
void deleteItem( QPtrCollection::Item d ) { if ( del_item ) delete[] (char*)d; }
int compareItems( QPtrCollection::Item s1, QPtrCollection::Item s2 ) { return qstrcmp((const char*)s1,
(const char*)s2); }
QDataStream &read( QDataStream &s, QPtrCollection::Item &d )
{ s >> (char *&)d; return s; }
QDataStream &write( QDataStream &s, QPtrCollection::Item d ) const
{ return s << (const char *)d; }
bool dc;
};
class QStrIList : public QStrList
{
public:
QStrIList( bool deepCopies=TRUE ) : QStrList( deepCopies ) {}
~QStrIList() { clear(); }
private:
int compareItems( QPtrCollection::Item s1, QPtrCollection::Item s2 )
{ return qstricmp((const char*)s1,
(const char*)s2); }
};
inline QStrList & QStrList::operator=( const QStrList &strList )
{
clear();
dc = strList.dc;
del_item = dc;
QPtrList<char>::operator=( strList );
return *this;
}
inline QStrList::QStrList( const QStrList &strList )
: QPtrList<char>( strList )
{
dc = FALSE;
operator=( strList );
}
# 45 "../include/qstringlist.h" 2
class QRegExp;
class QStringList : public QValueList<QString>
{
public:
QStringList() { }
QStringList( const QStringList& l ) : QValueList<QString>(l) { }
QStringList( const QValueList<QString>& l ) : QValueList<QString>(l) { }
QStringList( const QString& i ) { append(i); }
QStringList( const char* i ) { append(i); }
static QStringList fromStrList(const QStrList&);
void sort();
static QStringList split( const QString &sep, const QString &str, bool allowEmptyEntries = FALSE );
static QStringList split( const QChar &sep, const QString &str, bool allowEmptyEntries = FALSE );
static QStringList split( const QRegExp &sep, const QString &str, bool allowEmptyEntries = FALSE );
QString join( const QString &sep ) const;
QStringList grep( const QString &str, bool cs = TRUE ) const;
QStringList grep( const QRegExp &expr ) const;
};
class QDataStream;
extern QDataStream &operator>>( QDataStream &, QStringList& );
extern QDataStream &operator<<( QDataStream &, const QStringList& );
# 307 "kernel/qvariant.h" 2
# 1 "../include/qmap.h" 1
# 42 "../include/qmap.h"
# 1 "../include/qglobal.h" 1
# 43 "../include/qmap.h" 2
# 1 "../include/qpair.h" 1
# 40 "../include/qpair.h"
# 1 "../include/qglobal.h" 1
# 41 "../include/qpair.h" 2
template <class T1, class T2>
struct QPair
{
typedef T1 first_type;
typedef T2 second_type;
QPair()
: first( T1() ), second( T2() )
{}
QPair( const T1& t1, const T2& t2 )
: first( t1 ), second( t2 )
{}
T1 first;
T2 second;
};
template <class T1, class T2>
bool operator==( const QPair<T1, T2>& x, const QPair<T1, T2>& y )
{
return x.first == y.first && x.second == y.second;
}
template <class T1, class T2>
bool operator<( const QPair<T1, T2>& x, const QPair<T1, T2>& y )
{
return x.first < y.first ||
( !( y.first < x.first ) && x.second < y.second );
}
template <class T1, class T2>
QPair<T1, T2> qMakePair( const T1& x, const T2& y )
{
return QPair<T1, T2>( x, y );
}
template <class T1, class T2>
inline QDataStream& operator>>( QDataStream& s, QPair<T1, T2>& p )
{
s >> p.first >> p.second;
return s;
}
template <class T1, class T2>
inline QDataStream& operator<<( QDataStream& s, const QPair<T1, T2>& p )
{
s << p.first << p.second;
return s;
}
# 46 "../include/qmap.h" 2
# 56 "../include/qmap.h"
struct QMapNodeBase
{
enum Color { Red, Black };
QMapNodeBase* left;
QMapNodeBase* right;
QMapNodeBase* parent;
Color color;
QMapNodeBase* minimum() {
QMapNodeBase* x = this;
while ( x->left )
x = x->left;
return x;
}
QMapNodeBase* maximum() {
QMapNodeBase* x = this;
while ( x->right )
x = x->right;
return x;
}
};
template <class K, class T>
struct QMapNode : public QMapNodeBase
{
QMapNode( const K& _key, const T& _data ) { data = _data; key = _key; }
QMapNode( const K& _key ) { key = _key; }
QMapNode( const QMapNode<K,T>& _n ) { key = _n.key; data = _n.data; }
QMapNode() { }
T data;
K key;
};
template<class K, class T>
class QMapIterator
{
public:
typedef QMapNode< K, T >* NodePtr;
typedef T value_type;
typedef int difference_type;
typedef T* pointer;
typedef T& reference;
QMapNode<K,T>* node;
QMapIterator() : node( 0 ) {}
QMapIterator( QMapNode<K,T>* p ) : node( p ) {}
QMapIterator( const QMapIterator<K,T>& it ) : node( it.node ) {}
bool operator==( const QMapIterator<K,T>& it ) const { return node == it.node; }
bool operator!=( const QMapIterator<K,T>& it ) const { return node != it.node; }
T& operator*() { return node->data; }
const T& operator*() const { return node->data; }
const K& key() const { return node->key; }
T& data() { return node->data; }
const T& data() const { return node->data; }
private:
int inc();
int dec();
public:
QMapIterator<K,T>& operator++() {
inc();
return *this;
}
QMapIterator<K,T> operator++(int) {
QMapIterator<K,T> tmp = *this;
inc();
return tmp;
}
QMapIterator<K,T>& operator--() {
dec();
return *this;
}
QMapIterator<K,T> operator--(int) {
QMapIterator<K,T> tmp = *this;
dec();
return tmp;
}
};
template <class K, class T>
int QMapIterator<K,T>::inc()
{
QMapNodeBase* tmp = node;
if ( tmp->right ) {
tmp = tmp->right;
while ( tmp->left )
tmp = tmp->left;
} else {
QMapNodeBase* y = tmp->parent;
while (tmp == y->right) {
tmp = y;
y = y->parent;
}
if (tmp->right != y)
tmp = y;
}
node = (NodePtr)tmp;
return 0;
}
template <class K, class T>
int QMapIterator<K,T>::dec()
{
QMapNodeBase* tmp = node;
if (tmp->color == QMapNodeBase::Red &&
tmp->parent->parent == tmp ) {
tmp = tmp->right;
} else if (tmp->left != 0) {
QMapNodeBase* y = tmp->left;
while ( y->right )
y = y->right;
tmp = y;
} else {
QMapNodeBase* y = tmp->parent;
while (tmp == y->left) {
tmp = y;
y = y->parent;
}
tmp = y;
}
node = (NodePtr)tmp;
return 0;
}
template<class K, class T>
class QMapConstIterator
{
public:
typedef QMapNode< K, T >* NodePtr;
typedef T value_type;
typedef int difference_type;
typedef const T* pointer;
typedef const T& reference;
QMapNode<K,T>* node;
QMapConstIterator() : node( 0 ) {}
QMapConstIterator( QMapNode<K,T>* p ) : node( p ) {}
QMapConstIterator( const QMapConstIterator<K,T>& it ) : node( it.node ) {}
QMapConstIterator( const QMapIterator<K,T>& it ) : node( it.node ) {}
bool operator==( const QMapConstIterator<K,T>& it ) const { return node == it.node; }
bool operator!=( const QMapConstIterator<K,T>& it ) const { return node != it.node; }
const T& operator*() const { return node->data; }
const K& key() const { return node->key; }
const T& data() const { return node->data; }
private:
int inc();
int dec();
public:
QMapConstIterator<K,T>& operator++() {
inc();
return *this;
}
QMapConstIterator<K,T> operator++(int) {
QMapConstIterator<K,T> tmp = *this;
inc();
return tmp;
}
QMapConstIterator<K,T>& operator--() {
dec();
return *this;
}
QMapConstIterator<K,T> operator--(int) {
QMapConstIterator<K,T> tmp = *this;
dec();
return tmp;
}
};
template <class K, class T>
int QMapConstIterator<K,T>::inc()
{
QMapNodeBase* tmp = node;
if ( tmp->right ) {
tmp = tmp->right;
while ( tmp->left )
tmp = tmp->left;
} else {
QMapNodeBase* y = tmp->parent;
while (tmp == y->right) {
tmp = y;
y = y->parent;
}
if (tmp->right != y)
tmp = y;
}
node = (NodePtr)tmp;
return 0;
}
template <class K, class T>
int QMapConstIterator<K,T>::dec()
{
QMapNodeBase* tmp = node;
if (tmp->color == QMapNodeBase::Red &&
tmp->parent->parent == tmp ) {
tmp = tmp->right;
} else if (tmp->left != 0) {
QMapNodeBase* y = tmp->left;
while ( y->right )
y = y->right;
tmp = y;
} else {
QMapNodeBase* y = tmp->parent;
while (tmp == y->left) {
tmp = y;
y = y->parent;
}
tmp = y;
}
node = (NodePtr)tmp;
return 0;
}
class QMapPrivateBase : public QShared
{
public:
QMapPrivateBase() {
node_count = 0;
}
QMapPrivateBase( const QMapPrivateBase* _map) {
node_count = _map->node_count;
}
void rotateLeft( QMapNodeBase* x, QMapNodeBase*& root);
void rotateRight( QMapNodeBase* x, QMapNodeBase*& root );
void rebalance( QMapNodeBase* x, QMapNodeBase*& root );
QMapNodeBase* removeAndRebalance( QMapNodeBase* z, QMapNodeBase*& root,
QMapNodeBase*& leftmost,
QMapNodeBase*& rightmost );
int node_count;
};
template <class Key, class T>
class QMapPrivate : public QMapPrivateBase
{
public:
typedef QMapIterator< Key, T > Iterator;
typedef QMapConstIterator< Key, T > ConstIterator;
typedef QMapNode< Key, T > Node;
typedef QMapNode< Key, T >* NodePtr;
QMapPrivate();
QMapPrivate( const QMapPrivate< Key, T >* _map );
~QMapPrivate() { clear(); delete header; }
NodePtr copy( NodePtr p );
void clear();
void clear( NodePtr p );
Iterator begin() { return Iterator( (NodePtr)(header->left ) ); }
Iterator end() { return Iterator( header ); }
ConstIterator begin() const { return ConstIterator( (NodePtr)(header->left ) ); }
ConstIterator end() const { return ConstIterator( header ); }
ConstIterator find(const Key& k) const;
void remove( Iterator it ) {
NodePtr del = (NodePtr) removeAndRebalance( it.node, header->parent, header->left, header->right );
delete del;
--node_count;
}
# 413 "../include/qmap.h"
Iterator insertSingle( const Key& k );
Iterator insert( QMapNodeBase* x, QMapNodeBase* y, const Key& k );
protected:
const Key& key( QMapNodeBase* b ) const { return ((NodePtr)b)->key; }
NodePtr header;
};
template <class Key, class T>
QMapPrivate<Key,T>::QMapPrivate() {
header = new Node;
header->color = QMapNodeBase::Red;
header->parent = 0;
header->left = header->right = header;
}
template <class Key, class T>
QMapPrivate<Key,T>::QMapPrivate( const QMapPrivate< Key, T >* _map ) : QMapPrivateBase( _map ) {
header = new Node;
header->color = QMapNodeBase::Red;
if ( _map->header->parent == 0 ) {
header->parent = 0;
header->left = header->right = header;
} else {
header->parent = copy( (NodePtr)(_map->header->parent) );
header->parent->parent = header;
header->left = header->parent->minimum();
header->right = header->parent->maximum();
}
}
template <class Key, class T>
typename QMapPrivate<Key,T>::NodePtr QMapPrivate<Key,T>::copy( typename QMapPrivate<Key,T>::NodePtr p )
{
if ( !p )
return 0;
NodePtr n = new Node( *p );
n->color = p->color;
if ( p->left ) {
n->left = copy( (NodePtr)(p->left) );
n->left->parent = n;
} else {
n->left = 0;
}
if ( p->right ) {
n->right = copy( (NodePtr)(p->right) );
n->right->parent = n;
} else {
n->right = 0;
}
return n;
}
template <class Key, class T>
void QMapPrivate<Key,T>::clear()
{
clear( (NodePtr)(header->parent) );
header->color = QMapNodeBase::Red;
header->parent = 0;
header->left = header->right = header;
node_count = 0;
}
template <class Key, class T>
void QMapPrivate<Key,T>::clear( typename QMapPrivate<Key,T>::NodePtr p )
{
while ( p != 0 ) {
clear( (NodePtr)p->right );
NodePtr y = (NodePtr)p->left;
delete p;
p = y;
}
}
template <class Key, class T>
typename QMapPrivate<Key,T>::ConstIterator QMapPrivate<Key,T>::find(const Key& k) const
{
QMapNodeBase* y = header;
QMapNodeBase* x = header->parent;
while ( x != 0 ) {
if ( !( key(x) < k ) ) {
y = x;
x = x->left;
} else {
x = x->right;
}
}
if ( y == header || k < key(y) )
return ConstIterator( header );
return ConstIterator( (NodePtr)y );
}
template <class Key, class T>
typename QMapPrivate<Key,T>::Iterator QMapPrivate<Key,T>::insertSingle( const Key& k )
{
QMapNodeBase* y = header;
QMapNodeBase* x = header->parent;
bool result = TRUE;
while ( x != 0 ) {
result = ( k < key(x) );
y = x;
x = result ? x->left : x->right;
}
Iterator j( (NodePtr)y );
if ( result ) {
if ( j == begin() ) {
return insert(x, y, k );
} else {
--j;
}
}
if ( (j.node->key) < k )
return insert(x, y, k );
return j;
}
template <class Key, class T>
typename QMapPrivate<Key,T>::Iterator QMapPrivate<Key,T>::insert( QMapNodeBase* x, QMapNodeBase* y, const Key& k )
{
NodePtr z = new Node( k );
if (y == header || x != 0 || k < key(y) ) {
y->left = z;
if ( y == header ) {
header->parent = z;
header->right = z;
} else if ( y == header->left )
header->left = z;
} else {
y->right = z;
if ( y == header->right )
header->right = z;
}
z->parent = y;
z->left = 0;
z->right = 0;
rebalance( z, header->parent );
++node_count;
return Iterator(z);
}
# 586 "../include/qmap.h"
template <class T> class QDeepCopy;
template<class Key, class T>
class QMap
{
public:
typedef Key key_type;
typedef T mapped_type;
typedef QPair<const key_type, mapped_type> value_type;
typedef value_type* pointer;
typedef const value_type* const_pointer;
typedef value_type& reference;
typedef const value_type& const_reference;
typedef int difference_type;
typedef size_t size_type;
typedef QMapIterator<Key,T> iterator;
typedef QMapConstIterator<Key,T> const_iterator;
typedef QPair<iterator,bool> insert_pair;
typedef QMapIterator< Key, T > Iterator;
typedef QMapConstIterator< Key, T > ConstIterator;
typedef T ValueType;
typedef QMapPrivate< Key, T > Priv;
QMap()
{
sh = new QMapPrivate< Key, T >;
}
QMap( const QMap<Key,T>& m )
{
sh = m.sh; sh->ref();
}
# 648 "../include/qmap.h"
~QMap()
{
if ( sh->deref() )
delete sh;
}
QMap<Key,T>& operator= ( const QMap<Key,T>& m );
# 675 "../include/qmap.h"
iterator begin() { detach(); return sh->begin(); }
iterator end() { detach(); return sh->end(); }
const_iterator begin() const { return ((const Priv*)sh)->begin(); }
const_iterator end() const { return ((const Priv*)sh)->end(); }
iterator replace( const Key& k, const T& v )
{
remove( k );
return insert( k, v );
}
size_type size() const
{
return sh->node_count;
}
bool empty() const
{
return sh->node_count == 0;
}
QPair<iterator,bool> insert( const value_type& x );
void erase( iterator it )
{
detach();
sh->remove( it );
}
void erase( const key_type& k );
size_type count( const key_type& k ) const;
T& operator[] ( const Key& k );
void clear();
iterator find ( const Key& k )
{
detach();
return iterator( sh->find( k ).node );
}
const_iterator find ( const Key& k ) const { return sh->find( k ); }
const T& operator[] ( const Key& k ) const
{ ; return sh->find( k ).data(); }
bool contains ( const Key& k ) const
{ return find( k ) != end(); }
size_type count() const { return sh->node_count; }
QValueList<Key> keys() const {
QValueList<Key> r;
for (const_iterator i=begin(); i!=end(); ++i)
r.append(i.key());
return r;
}
QValueList<T> values() const {
QValueList<T> r;
for (const_iterator i=begin(); i!=end(); ++i)
r.append(*i);
return r;
}
bool isEmpty() const { return sh->node_count == 0; }
iterator insert( const Key& key, const T& value, bool overwrite = TRUE );
void remove( iterator it ) { detach(); sh->remove( it ); }
void remove( const Key& k );
# 747 "../include/qmap.h"
protected:
void detach() { if ( sh->count > 1 ) detachInternal(); }
Priv* sh;
private:
void detachInternal();
friend class QDeepCopy< QMap<Key,T> >;
};
template<class Key, class T>
QMap<Key,T>& QMap<Key,T>::operator= ( const QMap<Key,T>& m )
{
m.sh->ref();
if ( sh->deref() )
delete sh;
sh = m.sh;
return *this;
}
template<class Key, class T>
typename QMap<Key,T>::insert_pair QMap<Key,T>::insert( const typename QMap<Key,T>::value_type& x )
{
detach();
size_type n = size();
iterator it = sh->insertSingle( x.first );
bool inserted = FALSE;
if ( n < size() ) {
inserted = TRUE;
it.data() = x.second;
}
return QPair<iterator,bool>( it, inserted );
}
template<class Key, class T>
void QMap<Key,T>::erase( const Key& k )
{
detach();
iterator it( sh->find( k ).node );
if ( it != end() )
sh->remove( it );
}
template<class Key, class T>
typename QMap<Key,T>::size_type QMap<Key,T>::count( const Key& k ) const
{
const_iterator it( sh->find( k ).node );
if ( it != end() ) {
size_type c = 0;
while ( it != end() ) {
++it;
++c;
}
return c;
}
return 0;
}
template<class Key, class T>
T& QMap<Key,T>::operator[] ( const Key& k )
{
detach();
QMapNode<Key,T>* p = sh->find( k ).node;
if ( p != sh->end().node )
return p->data;
return insert( k, T() ).data();
}
template<class Key, class T>
void QMap<Key,T>::clear()
{
if ( sh->count == 1 )
sh->clear();
else {
sh->deref();
sh = new QMapPrivate<Key,T>;
}
}
template<class Key, class T>
typename QMap<Key,T>::iterator QMap<Key,T>::insert( const Key& key, const T& value, bool overwrite )
{
detach();
size_type n = size();
iterator it = sh->insertSingle( key );
if ( overwrite || n < size() )
it.data() = value;
return it;
}
template<class Key, class T>
void QMap<Key,T>::remove( const Key& k )
{
detach();
iterator it( sh->find( k ).node );
if ( it != end() )
sh->remove( it );
}
template<class Key, class T>
void QMap<Key,T>::detachInternal()
{
sh->deref(); sh = new QMapPrivate<Key,T>( sh );
}
template<class Key, class T>
QDataStream& operator>>( QDataStream& s, QMap<Key,T>& m ) {
m.clear();
Q_UINT32 c;
s >> c;
for( Q_UINT32 i = 0; i < c; ++i ) {
Key k; T t;
s >> k >> t;
m.insert( k, t );
if ( s.atEnd() )
break;
}
return s;
}
template<class Key, class T>
QDataStream& operator<<( QDataStream& s, const QMap<Key,T>& m ) {
s << (Q_UINT32)m.size();
QMapConstIterator<Key,T> it = m.begin();
for( ; it != m.end(); ++it )
s << it.key() << it.data();
return s;
}
# 308 "kernel/qvariant.h" 2
inline QVariant::Type QVariant::type() const
{
return d->typ;
}
inline bool QVariant::isValid() const
{
return (d->typ != Invalid);
}
inline QValueListConstIterator<QString> QVariant::stringListBegin() const
{
if ( d->typ != StringList )
return QValueListConstIterator<QString>();
return ((const QStringList*)d->value.ptr)->begin();
}
inline QValueListConstIterator<QString> QVariant::stringListEnd() const
{
if ( d->typ != StringList )
return QValueListConstIterator<QString>();
return ((const QStringList*)d->value.ptr)->end();
}
inline QValueListConstIterator<QVariant> QVariant::listBegin() const
{
if ( d->typ != List )
return QValueListConstIterator<QVariant>();
return ((const QValueList<QVariant>*)d->value.ptr)->begin();
}
inline QValueListConstIterator<QVariant> QVariant::listEnd() const
{
if ( d->typ != List )
return QValueListConstIterator<QVariant>();
return ((const QValueList<QVariant>*)d->value.ptr)->end();
}
inline QMapConstIterator<QString,QVariant> QVariant::mapBegin() const
{
if ( d->typ != Map )
return QMapConstIterator<QString,QVariant>();
return ((const QMap<QString,QVariant>*)d->value.ptr)->begin();
}
inline QMapConstIterator<QString,QVariant> QVariant::mapEnd() const
{
if ( d->typ != Map )
return QMapConstIterator<QString,QVariant>();
return ((const QMap<QString,QVariant>*)d->value.ptr)->end();
}
inline QMapConstIterator<QString,QVariant> QVariant::mapFind( const QString& key ) const
{
if ( d->typ != Map )
return QMapConstIterator<QString,QVariant>();
return ((const QMap<QString,QVariant>*)d->value.ptr)->find( key );
}
QDataStream& operator>> ( QDataStream& s, QVariant& p );
QDataStream& operator<< ( QDataStream& s, const QVariant& p );
QDataStream& operator>> ( QDataStream& s, QVariant::Type& p );
QDataStream& operator<< ( QDataStream& s, const QVariant::Type p );
# 39 "kernel/qobject.cpp" 2
# 1 "kernel/qapplication.h" 1
# 42 "kernel/qapplication.h"
# 1 "kernel/qdesktopwidget.h" 1
# 42 "kernel/qdesktopwidget.h"
# 1 "kernel/qwidget.h" 1
# 42 "kernel/qwidget.h"
# 1 "kernel/qwindowdefs.h" 1
# 43 "kernel/qwindowdefs.h"
# 1 "kernel/qobjectdefs.h" 1
# 42 "kernel/qobjectdefs.h"
# 1 "../include/qglobal.h" 1
# 43 "kernel/qobjectdefs.h" 2
# 72 "kernel/qobjectdefs.h"
struct QUObject;
# 152 "kernel/qobjectdefs.h"
class QObject;
class QMetaObject;
class QSignal;
class QConnection;
class QEvent;
struct QMetaData;
class QConnectionList;
class QConnectionListIt;
class QSignalVec;
class QObjectList;
class QObjectListIt;
class QMemberDict;
void *qt_find_obj_child( QObject *, const char *, const char * );
# 44 "kernel/qwindowdefs.h" 2
# 1 "kernel/qnamespace.h" 1
# 42 "kernel/qnamespace.h"
# 1 "../include/qglobal.h" 1
# 43 "kernel/qnamespace.h" 2
class QColor;
class QCursor;
class Qt {
public:
static const QColor & color0;
static const QColor & color1;
static const QColor & black;
static const QColor & white;
static const QColor & darkGray;
static const QColor & gray;
static const QColor & lightGray;
static const QColor & red;
static const QColor & green;
static const QColor & blue;
static const QColor & cyan;
static const QColor & magenta;
static const QColor & yellow;
static const QColor & darkRed;
static const QColor & darkGreen;
static const QColor & darkBlue;
static const QColor & darkCyan;
static const QColor & darkMagenta;
static const QColor & darkYellow;
enum ButtonState {
NoButton = 0x0000,
LeftButton = 0x0001,
RightButton = 0x0002,
MidButton = 0x0004,
MouseButtonMask = 0x0007,
ShiftButton = 0x0100,
ControlButton = 0x0200,
AltButton = 0x0400,
MetaButton = 0x0800,
KeyButtonMask = 0x0f00,
Keypad = 0x4000
};
enum Orientation {
Horizontal = 0,
Vertical
};
enum AlignmentFlags {
AlignAuto = 0x0000,
AlignLeft = 0x0001,
AlignRight = 0x0002,
AlignHCenter = 0x0004,
AlignJustify = 0x0008,
AlignHorizontal_Mask = AlignLeft | AlignRight | AlignHCenter | AlignJustify,
AlignTop = 0x0010,
AlignBottom = 0x0020,
AlignVCenter = 0x0040,
AlignVertical_Mask = AlignTop | AlignBottom | AlignVCenter,
AlignCenter = AlignVCenter | AlignHCenter
};
enum TextFlags {
SingleLine = 0x0080,
DontClip = 0x0100,
ExpandTabs = 0x0200,
ShowPrefix = 0x0400,
WordBreak = 0x0800,
BreakAnywhere = 0x1000,
DontPrint = 0x2000,
NoAccel = 0x4000
};
typedef uint WState;
enum WidgetState {
WState_Created = 0x00000001,
WState_Disabled = 0x00000002,
WState_Visible = 0x00000004,
WState_ForceHide = 0x00000008,
WState_OwnCursor = 0x00000010,
WState_MouseTracking = 0x00000020,
WState_CompressKeys = 0x00000040,
WState_BlockUpdates = 0x00000080,
WState_InPaintEvent = 0x00000100,
WState_Reparented = 0x00000200,
WState_ConfigPending = 0x00000400,
WState_Resized = 0x00000800,
WState_AutoMask = 0x00001000,
WState_Polished = 0x00002000,
WState_DND = 0x00004000,
WState_Reserved0 = 0x00008000,
WState_Reserved1 = 0x00010000,
WState_Reserved2 = 0x00020000,
WState_CreatedHidden = 0x00040000,
WState_Maximized = 0x00080000,
WState_Minimized = 0x00100000,
WState_ForceDisabled = 0x00200000,
WState_Exposed = 0x00400000,
WState_HasMouse = 0x00800000
};
typedef uint WFlags;
enum WidgetFlags {
WType_TopLevel = 0x00000001,
WType_Dialog = 0x00000002,
WType_Popup = 0x00000004,
WType_Desktop = 0x00000008,
WType_Mask = 0x0000000f,
WStyle_Customize = 0x00000010,
WStyle_NormalBorder = 0x00000020,
WStyle_DialogBorder = 0x00000040,
WStyle_NoBorder = 0x00002000,
WStyle_Title = 0x00000080,
WStyle_SysMenu = 0x00000100,
WStyle_Minimize = 0x00000200,
WStyle_Maximize = 0x00000400,
WStyle_MinMax = WStyle_Minimize | WStyle_Maximize,
WStyle_Tool = 0x00000800,
WStyle_StaysOnTop = 0x00001000,
WStyle_ContextHelp = 0x00004000,
WStyle_Reserved = 0x00008000,
WStyle_Mask = 0x0000fff0,
WDestructiveClose = 0x00010000,
WPaintDesktop = 0x00020000,
WPaintUnclipped = 0x00040000,
WPaintClever = 0x00080000,
WResizeNoErase = 0x00100000,
WMouseNoMask = 0x00200000,
WStaticContents = 0x00400000,
WRepaintNoErase = 0x00800000,
WX11BypassWM = 0x01000000,
WWinOwnDC = 0x00000000,
WGroupLeader = 0x02000000,
WShowModal = 0x04000000,
WNoMousePropagation = 0x08000000,
WSubWindow = 0x10000000
,
WNorthWestGravity = WStaticContents,
WType_Modal = WType_Dialog | WShowModal,
WStyle_Dialog = WType_Dialog,
WStyle_NoBorderEx = WStyle_NoBorder
};
enum ImageConversionFlags {
ColorMode_Mask = 0x00000003,
AutoColor = 0x00000000,
ColorOnly = 0x00000003,
MonoOnly = 0x00000002,
AlphaDither_Mask = 0x0000000c,
ThresholdAlphaDither = 0x00000000,
OrderedAlphaDither = 0x00000004,
DiffuseAlphaDither = 0x00000008,
NoAlpha = 0x0000000c,
Dither_Mask = 0x00000030,
DiffuseDither = 0x00000000,
OrderedDither = 0x00000010,
ThresholdDither = 0x00000020,
DitherMode_Mask = 0x000000c0,
AutoDither = 0x00000000,
PreferDither = 0x00000040,
AvoidDither = 0x00000080
};
enum BGMode {
TransparentMode,
OpaqueMode
};
enum PaintUnit {
PixelUnit,
LoMetricUnit,
HiMetricUnit,
LoEnglishUnit,
HiEnglishUnit,
TwipsUnit
};
# 264 "kernel/qnamespace.h"
enum GUIStyle {
MacStyle,
WindowsStyle,
Win3Style,
PMStyle,
MotifStyle
};
enum SequenceMatch {
NoMatch,
PartialMatch,
Identical
};
enum Modifier {
META = 0x00100000,
SHIFT = 0x00200000,
CTRL = 0x00400000,
ALT = 0x00800000,
MODIFIER_MASK = 0x00f00000,
UNICODE_ACCEL = 0x10000000,
ASCII_ACCEL = UNICODE_ACCEL
};
enum Key {
Key_Escape = 0x1000,
Key_Tab = 0x1001,
Key_Backtab = 0x1002, Key_BackTab = Key_Backtab,
Key_Backspace = 0x1003, Key_BackSpace = Key_Backspace,
Key_Return = 0x1004,
Key_Enter = 0x1005,
Key_Insert = 0x1006,
Key_Delete = 0x1007,
Key_Pause = 0x1008,
Key_Print = 0x1009,
Key_SysReq = 0x100a,
Key_Clear = 0x100b,
Key_Home = 0x1010,
Key_End = 0x1011,
Key_Left = 0x1012,
Key_Up = 0x1013,
Key_Right = 0x1014,
Key_Down = 0x1015,
Key_Prior = 0x1016, Key_PageUp = Key_Prior,
Key_Next = 0x1017, Key_PageDown = Key_Next,
Key_Shift = 0x1020,
Key_Control = 0x1021,
Key_Meta = 0x1022,
Key_Alt = 0x1023,
Key_CapsLock = 0x1024,
Key_NumLock = 0x1025,
Key_ScrollLock = 0x1026,
Key_F1 = 0x1030,
Key_F2 = 0x1031,
Key_F3 = 0x1032,
Key_F4 = 0x1033,
Key_F5 = 0x1034,
Key_F6 = 0x1035,
Key_F7 = 0x1036,
Key_F8 = 0x1037,
Key_F9 = 0x1038,
Key_F10 = 0x1039,
Key_F11 = 0x103a,
Key_F12 = 0x103b,
Key_F13 = 0x103c,
Key_F14 = 0x103d,
Key_F15 = 0x103e,
Key_F16 = 0x103f,
Key_F17 = 0x1040,
Key_F18 = 0x1041,
Key_F19 = 0x1042,
Key_F20 = 0x1043,
Key_F21 = 0x1044,
Key_F22 = 0x1045,
Key_F23 = 0x1046,
Key_F24 = 0x1047,
Key_F25 = 0x1048,
Key_F26 = 0x1049,
Key_F27 = 0x104a,
Key_F28 = 0x104b,
Key_F29 = 0x104c,
Key_F30 = 0x104d,
Key_F31 = 0x104e,
Key_F32 = 0x104f,
Key_F33 = 0x1050,
Key_F34 = 0x1051,
Key_F35 = 0x1052,
Key_Super_L = 0x1053,
Key_Super_R = 0x1054,
Key_Menu = 0x1055,
Key_Hyper_L = 0x1056,
Key_Hyper_R = 0x1057,
Key_Help = 0x1058,
Key_Direction_L = 0x1059,
Key_Direction_R = 0x1060,
Key_Space = 0x20,
Key_Any = Key_Space,
Key_Exclam = 0x21,
Key_QuoteDbl = 0x22,
Key_NumberSign = 0x23,
Key_Dollar = 0x24,
Key_Percent = 0x25,
Key_Ampersand = 0x26,
Key_Apostrophe = 0x27,
Key_ParenLeft = 0x28,
Key_ParenRight = 0x29,
Key_Asterisk = 0x2a,
Key_Plus = 0x2b,
Key_Comma = 0x2c,
Key_Minus = 0x2d,
Key_Period = 0x2e,
Key_Slash = 0x2f,
Key_0 = 0x30,
Key_1 = 0x31,
Key_2 = 0x32,
Key_3 = 0x33,
Key_4 = 0x34,
Key_5 = 0x35,
Key_6 = 0x36,
Key_7 = 0x37,
Key_8 = 0x38,
Key_9 = 0x39,
Key_Colon = 0x3a,
Key_Semicolon = 0x3b,
Key_Less = 0x3c,
Key_Equal = 0x3d,
Key_Greater = 0x3e,
Key_Question = 0x3f,
Key_At = 0x40,
Key_A = 0x41,
Key_B = 0x42,
Key_C = 0x43,
Key_D = 0x44,
Key_E = 0x45,
Key_F = 0x46,
Key_G = 0x47,
Key_H = 0x48,
Key_I = 0x49,
Key_J = 0x4a,
Key_K = 0x4b,
Key_L = 0x4c,
Key_M = 0x4d,
Key_N = 0x4e,
Key_O = 0x4f,
Key_P = 0x50,
Key_Q = 0x51,
Key_R = 0x52,
Key_S = 0x53,
Key_T = 0x54,
Key_U = 0x55,
Key_V = 0x56,
Key_W = 0x57,
Key_X = 0x58,
Key_Y = 0x59,
Key_Z = 0x5a,
Key_BracketLeft = 0x5b,
Key_Backslash = 0x5c,
Key_BracketRight = 0x5d,
Key_AsciiCircum = 0x5e,
Key_Underscore = 0x5f,
Key_QuoteLeft = 0x60,
Key_BraceLeft = 0x7b,
Key_Bar = 0x7c,
Key_BraceRight = 0x7d,
Key_AsciiTilde = 0x7e,
Key_nobreakspace = 0x0a0,
Key_exclamdown = 0x0a1,
Key_cent = 0x0a2,
Key_sterling = 0x0a3,
Key_currency = 0x0a4,
Key_yen = 0x0a5,
Key_brokenbar = 0x0a6,
Key_section = 0x0a7,
Key_diaeresis = 0x0a8,
Key_copyright = 0x0a9,
Key_ordfeminine = 0x0aa,
Key_guillemotleft = 0x0ab,
Key_notsign = 0x0ac,
Key_hyphen = 0x0ad,
Key_registered = 0x0ae,
Key_macron = 0x0af,
Key_degree = 0x0b0,
Key_plusminus = 0x0b1,
Key_twosuperior = 0x0b2,
Key_threesuperior = 0x0b3,
Key_acute = 0x0b4,
Key_mu = 0x0b5,
Key_paragraph = 0x0b6,
Key_periodcentered = 0x0b7,
Key_cedilla = 0x0b8,
Key_onesuperior = 0x0b9,
Key_masculine = 0x0ba,
Key_guillemotright = 0x0bb,
Key_onequarter = 0x0bc,
Key_onehalf = 0x0bd,
Key_threequarters = 0x0be,
Key_questiondown = 0x0bf,
Key_Agrave = 0x0c0,
Key_Aacute = 0x0c1,
Key_Acircumflex = 0x0c2,
Key_Atilde = 0x0c3,
Key_Adiaeresis = 0x0c4,
Key_Aring = 0x0c5,
Key_AE = 0x0c6,
Key_Ccedilla = 0x0c7,
Key_Egrave = 0x0c8,
Key_Eacute = 0x0c9,
Key_Ecircumflex = 0x0ca,
Key_Ediaeresis = 0x0cb,
Key_Igrave = 0x0cc,
Key_Iacute = 0x0cd,
Key_Icircumflex = 0x0ce,
Key_Idiaeresis = 0x0cf,
Key_ETH = 0x0d0,
Key_Ntilde = 0x0d1,
Key_Ograve = 0x0d2,
Key_Oacute = 0x0d3,
Key_Ocircumflex = 0x0d4,
Key_Otilde = 0x0d5,
Key_Odiaeresis = 0x0d6,
Key_multiply = 0x0d7,
Key_Ooblique = 0x0d8,
Key_Ugrave = 0x0d9,
Key_Uacute = 0x0da,
Key_Ucircumflex = 0x0db,
Key_Udiaeresis = 0x0dc,
Key_Yacute = 0x0dd,
Key_THORN = 0x0de,
Key_ssharp = 0x0df,
Key_agrave = 0x0e0,
Key_aacute = 0x0e1,
Key_acircumflex = 0x0e2,
Key_atilde = 0x0e3,
Key_adiaeresis = 0x0e4,
Key_aring = 0x0e5,
Key_ae = 0x0e6,
Key_ccedilla = 0x0e7,
Key_egrave = 0x0e8,
Key_eacute = 0x0e9,
Key_ecircumflex = 0x0ea,
Key_ediaeresis = 0x0eb,
Key_igrave = 0x0ec,
Key_iacute = 0x0ed,
Key_icircumflex = 0x0ee,
Key_idiaeresis = 0x0ef,
Key_eth = 0x0f0,
Key_ntilde = 0x0f1,
Key_ograve = 0x0f2,
Key_oacute = 0x0f3,
Key_ocircumflex = 0x0f4,
Key_otilde = 0x0f5,
Key_odiaeresis = 0x0f6,
Key_division = 0x0f7,
Key_oslash = 0x0f8,
Key_ugrave = 0x0f9,
Key_uacute = 0x0fa,
Key_ucircumflex = 0x0fb,
Key_udiaeresis = 0x0fc,
Key_yacute = 0x0fd,
Key_thorn = 0x0fe,
Key_ydiaeresis = 0x0ff,
Key_Back = 0x1061,
Key_Forward = 0x1062,
Key_Stop = 0x1063,
Key_Refresh = 0x1064,
Key_VolumeDown = 0x1070,
Key_VolumeMute = 0x1071,
Key_VolumeUp = 0x1072,
Key_BassBoost = 0x1073,
Key_BassUp = 0x1074,
Key_BassDown = 0x1075,
Key_TrebleUp = 0x1076,
Key_TrebleDown = 0x1077,
Key_MediaPlay = 0x1080,
Key_MediaStop = 0x1081,
Key_MediaPrev = 0x1082,
Key_MediaNext = 0x1083,
Key_MediaRecord = 0x1084,
Key_HomePage = 0x1090,
Key_Favorites = 0x1091,
Key_Search = 0x1092,
Key_Standby = 0x1093,
Key_OpenUrl = 0x1094,
Key_LaunchMail = 0x10a0,
Key_LaunchMedia = 0x10a1,
Key_Launch0 = 0x10a2,
Key_Launch1 = 0x10a3,
Key_Launch2 = 0x10a4,
Key_Launch3 = 0x10a5,
Key_Launch4 = 0x10a6,
Key_Launch5 = 0x10a7,
Key_Launch6 = 0x10a8,
Key_Launch7 = 0x10a9,
Key_Launch8 = 0x10aa,
Key_Launch9 = 0x10ab,
Key_LaunchA = 0x10ac,
Key_LaunchB = 0x10ad,
Key_LaunchC = 0x10ae,
Key_LaunchD = 0x10af,
Key_LaunchE = 0x10b0,
Key_LaunchF = 0x10b1,
Key_MediaLast = 0x1fff,
Key_unknown = 0xffff
};
enum ArrowType {
UpArrow,
DownArrow,
LeftArrow,
RightArrow
};
enum RasterOp {
CopyROP,
OrROP,
XorROP,
NotAndROP, EraseROP=NotAndROP,
NotCopyROP,
NotOrROP,
NotXorROP,
AndROP, NotEraseROP=AndROP,
NotROP,
ClearROP,
SetROP,
NopROP,
AndNotROP,
OrNotROP,
NandROP,
NorROP, LastROP=NorROP
};
enum PenStyle {
NoPen,
SolidLine,
DashLine,
DotLine,
DashDotLine,
DashDotDotLine,
MPenStyle = 0x0f
};
enum PenCapStyle {
FlatCap = 0x00,
SquareCap = 0x10,
RoundCap = 0x20,
MPenCapStyle = 0x30
};
enum PenJoinStyle {
MiterJoin = 0x00,
BevelJoin = 0x40,
RoundJoin = 0x80,
MPenJoinStyle = 0xc0
};
enum BrushStyle {
NoBrush,
SolidPattern,
Dense1Pattern,
Dense2Pattern,
Dense3Pattern,
Dense4Pattern,
Dense5Pattern,
Dense6Pattern,
Dense7Pattern,
HorPattern,
VerPattern,
CrossPattern,
BDiagPattern,
FDiagPattern,
DiagCrossPattern,
CustomPattern=24
};
enum WindowsVersion {
WV_32s = 0x0001,
WV_95 = 0x0002,
WV_98 = 0x0003,
WV_Me = 0x0004,
WV_DOS_based = 0x000f,
WV_NT = 0x0010,
WV_2000 = 0x0020,
WV_XP = 0x0030,
WV_NT_based = 0x00f0
};
enum UIEffect {
UI_General,
UI_AnimateMenu,
UI_FadeMenu,
UI_AnimateCombo,
UI_AnimateTooltip,
UI_FadeTooltip
};
enum CursorShape {
ArrowCursor,
UpArrowCursor,
CrossCursor,
WaitCursor,
IbeamCursor,
SizeVerCursor,
SizeHorCursor,
SizeBDiagCursor,
SizeFDiagCursor,
SizeAllCursor,
BlankCursor,
SplitVCursor,
SplitHCursor,
PointingHandCursor,
ForbiddenCursor,
WhatsThisCursor,
LastCursor = WhatsThisCursor,
BitmapCursor = 24
};
static const QCursor & arrowCursor;
static const QCursor & upArrowCursor;
static const QCursor & crossCursor;
static const QCursor & waitCursor;
static const QCursor & ibeamCursor;
static const QCursor & sizeVerCursor;
static const QCursor & sizeHorCursor;
static const QCursor & sizeBDiagCursor;
static const QCursor & sizeFDiagCursor;
static const QCursor & sizeAllCursor;
static const QCursor & blankCursor;
static const QCursor & splitVCursor;
static const QCursor & splitHCursor;
static const QCursor & pointingHandCursor;
static const QCursor & forbiddenCursor;
static const QCursor & whatsThisCursor;
enum TextFormat {
PlainText,
RichText,
AutoText,
LogText
};
enum AnchorAttribute {
AnchorName,
AnchorHref
};
enum Dock {
DockUnmanaged,
DockTornOff,
DockTop,
DockBottom,
DockRight,
DockLeft,
DockMinimized
,
Unmanaged = DockUnmanaged,
TornOff = DockTornOff,
Top = DockTop,
Bottom = DockBottom,
Right = DockRight,
Left = DockLeft,
Minimized = DockMinimized
};
typedef Dock ToolBarDock;
enum DateFormat {
TextDate,
ISODate,
LocalDate
};
enum TimeSpec {
LocalTime,
UTC
};
enum BackgroundMode {
FixedColor,
FixedPixmap,
NoBackground,
PaletteForeground,
PaletteButton,
PaletteLight,
PaletteMidlight,
PaletteDark,
PaletteMid,
PaletteText,
PaletteBrightText,
PaletteBase,
PaletteBackground,
PaletteShadow,
PaletteHighlight,
PaletteHighlightedText,
PaletteButtonText,
PaletteLink,
PaletteLinkVisited,
X11ParentRelative
};
typedef uint ComparisonFlags;
enum StringComparisonMode {
CaseSensitive = 0x00001,
BeginsWith = 0x00002,
EndsWith = 0x00004,
Contains = 0x00008,
ExactMatch = 0x00010
};
# 820 "kernel/qnamespace.h"
typedef unsigned long HANDLE;
};
class QInternal {
public:
enum PaintDeviceFlags {
UndefinedDevice = 0x00,
Widget = 0x01,
Pixmap = 0x02,
Printer = 0x03,
Picture = 0x04,
System = 0x05,
DeviceTypeMask = 0x0f,
ExternalDevice = 0x10,
CompatibilityMode = 0x20
};
};
# 46 "kernel/qwindowdefs.h" 2
class QPaintDevice;
class QPaintDeviceMetrics;
class QWidget;
class QWidgetMapper;
class QDialog;
class QColor;
class QColorGroup;
class QPalette;
class QCursor;
class QPoint;
class QSize;
class QRect;
class QPointArray;
class QPainter;
class QRegion;
class QFont;
class QFontMetrics;
class QFontInfo;
class QPen;
class QBrush;
class QWMatrix;
class QPixmap;
class QBitmap;
class QMovie;
class QImage;
class QImageIO;
class QPicture;
class QPrinter;
class QAccel;
class QTimer;
class QTime;
class QClipboard;
class QWidgetList;
class QWidgetListIt;
# 141 "kernel/qwindowdefs.h"
typedef struct _XDisplay Display;
typedef union _XEvent XEvent;
typedef struct _XGC *GC;
typedef struct _XRegion *Region;
typedef unsigned long WId;
Display *qt_xdisplay();
int qt_xscreen();
WId qt_xrootwin();
WId qt_xrootwin( int scrn );
GC qt_xget_readonly_gc( int scrn, bool monochrome );
GC qt_xget_temp_gc( int scrn, bool monochrome );
# 164 "kernel/qwindowdefs.h"
class QApplication;
typedef Q_INT32 QCOORD;
const QCOORD QCOORD_MAX = 2147483647;
const QCOORD QCOORD_MIN = -QCOORD_MAX - 1;
typedef unsigned int QRgb;
const char *qAppName();
typedef void (*QtCleanUpFunction)();
void qAddPostRoutine( QtCleanUpFunction );
void qRemovePostRoutine( QtCleanUpFunction );
typedef QtCleanUpFunction Q_CleanUpFunction;
# 43 "kernel/qwidget.h" 2
# 1 "kernel/qobject.h" 1
# 45 "kernel/qobject.h"
# 1 "kernel/qevent.h" 1
# 43 "kernel/qevent.h"
# 1 "kernel/qregion.h" 1
# 43 "kernel/qregion.h"
# 1 "kernel/qrect.h" 1
# 42 "kernel/qrect.h"
# 1 "kernel/qsize.h" 1
# 42 "kernel/qsize.h"
# 1 "kernel/qpoint.h" 1
# 46 "kernel/qpoint.h"
class QPoint
{
public:
QPoint();
QPoint( int xpos, int ypos );
bool isNull() const;
int x() const;
int y() const;
void setX( int x );
void setY( int y );
int manhattanLength() const;
QCOORD &rx();
QCOORD &ry();
QPoint &operator+=( const QPoint &p );
QPoint &operator-=( const QPoint &p );
QPoint &operator*=( int c );
QPoint &operator*=( double c );
QPoint &operator/=( int c );
QPoint &operator/=( double c );
friend inline bool operator==( const QPoint &, const QPoint & );
friend inline bool operator!=( const QPoint &, const QPoint & );
friend inline const QPoint operator+( const QPoint &, const QPoint & );
friend inline const QPoint operator-( const QPoint &, const QPoint & );
friend inline const QPoint operator*( const QPoint &, int );
friend inline const QPoint operator*( int, const QPoint & );
friend inline const QPoint operator*( const QPoint &, double );
friend inline const QPoint operator*( double, const QPoint & );
friend inline const QPoint operator-( const QPoint & );
friend inline const QPoint operator/( const QPoint &, int );
friend inline const QPoint operator/( const QPoint &, double );
private:
static void warningDivByZero();
QCOORD xp;
QCOORD yp;
};
QDataStream &operator<<( QDataStream &, const QPoint & );
QDataStream &operator>>( QDataStream &, QPoint & );
inline QPoint::QPoint()
{ xp=0; yp=0; }
inline QPoint::QPoint( int xpos, int ypos )
{ xp=(QCOORD)xpos; yp=(QCOORD)ypos; }
inline bool QPoint::isNull() const
{ return xp == 0 && yp == 0; }
inline int QPoint::x() const
{ return xp; }
inline int QPoint::y() const
{ return yp; }
inline void QPoint::setX( int x )
{ xp = (QCOORD)x; }
inline void QPoint::setY( int y )
{ yp = (QCOORD)y; }
inline QCOORD &QPoint::rx()
{ return xp; }
inline QCOORD &QPoint::ry()
{ return yp; }
inline QPoint &QPoint::operator+=( const QPoint &p )
{ xp+=p.xp; yp+=p.yp; return *this; }
inline QPoint &QPoint::operator-=( const QPoint &p )
{ xp-=p.xp; yp-=p.yp; return *this; }
inline QPoint &QPoint::operator*=( int c )
{ xp*=(QCOORD)c; yp*=(QCOORD)c; return *this; }
inline QPoint &QPoint::operator*=( double c )
{ xp=(QCOORD)(xp*c); yp=(QCOORD)(yp*c); return *this; }
inline bool operator==( const QPoint &p1, const QPoint &p2 )
{ return p1.xp == p2.xp && p1.yp == p2.yp; }
inline bool operator!=( const QPoint &p1, const QPoint &p2 )
{ return p1.xp != p2.xp || p1.yp != p2.yp; }
inline const QPoint operator+( const QPoint &p1, const QPoint &p2 )
{ return QPoint(p1.xp+p2.xp, p1.yp+p2.yp); }
inline const QPoint operator-( const QPoint &p1, const QPoint &p2 )
{ return QPoint(p1.xp-p2.xp, p1.yp-p2.yp); }
inline const QPoint operator*( const QPoint &p, int c )
{ return QPoint(p.xp*c, p.yp*c); }
inline const QPoint operator*( int c, const QPoint &p )
{ return QPoint(p.xp*c, p.yp*c); }
inline const QPoint operator*( const QPoint &p, double c )
{ return QPoint((QCOORD)(p.xp*c), (QCOORD)(p.yp*c)); }
inline const QPoint operator*( double c, const QPoint &p )
{ return QPoint((QCOORD)(p.xp*c), (QCOORD)(p.yp*c)); }
inline const QPoint operator-( const QPoint &p )
{ return QPoint(-p.xp, -p.yp); }
inline QPoint &QPoint::operator/=( int c )
{
if ( c == 0 )
warningDivByZero();
xp/=(QCOORD)c;
yp/=(QCOORD)c;
return *this;
}
inline QPoint &QPoint::operator/=( double c )
{
if ( c == 0.0 )
warningDivByZero();
xp=(QCOORD)(xp/c);
yp=(QCOORD)(yp/c);
return *this;
}
inline const QPoint operator/( const QPoint &p, int c )
{
if ( c == 0 )
QPoint::warningDivByZero();
return QPoint(p.xp/c, p.yp/c);
}
inline const QPoint operator/( const QPoint &p, double c )
{
if ( c == 0.0 )
QPoint::warningDivByZero();
return QPoint((QCOORD)(p.xp/c), (QCOORD)(p.yp/c));
}
# 43 "kernel/qsize.h" 2
class QSize
{
public:
enum ScaleMode {
ScaleFree,
ScaleMin,
ScaleMax
};
QSize();
QSize( int w, int h );
bool isNull() const;
bool isEmpty() const;
bool isValid() const;
int width() const;
int height() const;
void setWidth( int w );
void setHeight( int h );
void transpose();
void scale( int w, int h, ScaleMode mode );
void scale( const QSize &s, ScaleMode mode );
QSize expandedTo( const QSize & ) const;
QSize boundedTo( const QSize & ) const;
QCOORD &rwidth();
QCOORD &rheight();
QSize &operator+=( const QSize & );
QSize &operator-=( const QSize & );
QSize &operator*=( int c );
QSize &operator*=( double c );
QSize &operator/=( int c );
QSize &operator/=( double c );
friend inline bool operator==( const QSize &, const QSize & );
friend inline bool operator!=( const QSize &, const QSize & );
friend inline const QSize operator+( const QSize &, const QSize & );
friend inline const QSize operator-( const QSize &, const QSize & );
friend inline const QSize operator*( const QSize &, int );
friend inline const QSize operator*( int, const QSize & );
friend inline const QSize operator*( const QSize &, double );
friend inline const QSize operator*( double, const QSize & );
friend inline const QSize operator/( const QSize &, int );
friend inline const QSize operator/( const QSize &, double );
private:
static void warningDivByZero();
QCOORD wd;
QCOORD ht;
};
QDataStream &operator<<( QDataStream &, const QSize & );
QDataStream &operator>>( QDataStream &, QSize & );
inline QSize::QSize()
{ wd = ht = -1; }
inline QSize::QSize( int w, int h )
{ wd=(QCOORD)w; ht=(QCOORD)h; }
inline bool QSize::isNull() const
{ return wd==0 && ht==0; }
inline bool QSize::isEmpty() const
{ return wd<1 || ht<1; }
inline bool QSize::isValid() const
{ return wd>=0 && ht>=0; }
inline int QSize::width() const
{ return wd; }
inline int QSize::height() const
{ return ht; }
inline void QSize::setWidth( int w )
{ wd=(QCOORD)w; }
inline void QSize::setHeight( int h )
{ ht=(QCOORD)h; }
inline QCOORD &QSize::rwidth()
{ return wd; }
inline QCOORD &QSize::rheight()
{ return ht; }
inline QSize &QSize::operator+=( const QSize &s )
{ wd+=s.wd; ht+=s.ht; return *this; }
inline QSize &QSize::operator-=( const QSize &s )
{ wd-=s.wd; ht-=s.ht; return *this; }
inline QSize &QSize::operator*=( int c )
{ wd*=(QCOORD)c; ht*=(QCOORD)c; return *this; }
inline QSize &QSize::operator*=( double c )
{ wd=(QCOORD)(wd*c); ht=(QCOORD)(ht*c); return *this; }
inline bool operator==( const QSize &s1, const QSize &s2 )
{ return s1.wd == s2.wd && s1.ht == s2.ht; }
inline bool operator!=( const QSize &s1, const QSize &s2 )
{ return s1.wd != s2.wd || s1.ht != s2.ht; }
inline const QSize operator+( const QSize & s1, const QSize & s2 )
{ return QSize(s1.wd+s2.wd, s1.ht+s2.ht); }
inline const QSize operator-( const QSize &s1, const QSize &s2 )
{ return QSize(s1.wd-s2.wd, s1.ht-s2.ht); }
inline const QSize operator*( const QSize &s, int c )
{ return QSize(s.wd*c, s.ht*c); }
inline const QSize operator*( int c, const QSize &s )
{ return QSize(s.wd*c, s.ht*c); }
inline const QSize operator*( const QSize &s, double c )
{ return QSize((QCOORD)(s.wd*c), (QCOORD)(s.ht*c)); }
inline const QSize operator*( double c, const QSize &s )
{ return QSize((QCOORD)(s.wd*c), (QCOORD)(s.ht*c)); }
inline QSize &QSize::operator/=( int c )
{
if ( c == 0 )
warningDivByZero();
wd/=(QCOORD)c; ht/=(QCOORD)c;
return *this;
}
inline QSize &QSize::operator/=( double c )
{
if ( c == 0.0 )
warningDivByZero();
wd=(QCOORD)(wd/c); ht=(QCOORD)(ht/c);
return *this;
}
inline const QSize operator/( const QSize &s, int c )
{
if ( c == 0 )
QSize::warningDivByZero();
return QSize(s.wd/c, s.ht/c);
}
inline const QSize operator/( const QSize &s, double c )
{
if ( c == 0.0 )
QSize::warningDivByZero();
return QSize((QCOORD)(s.wd/c), (QCOORD)(s.ht/c));
}
inline QSize QSize::expandedTo( const QSize & otherSize ) const
{
return QSize( ((otherSize.wd) < (wd) ? (wd) : (otherSize.wd)), ((otherSize.ht) < (ht) ? (ht) : (otherSize.ht)) );
}
inline QSize QSize::boundedTo( const QSize & otherSize ) const
{
return QSize( ((wd) < (otherSize.wd) ? (wd) : (otherSize.wd)), ((ht) < (otherSize.ht) ? (ht) : (otherSize.ht)) );
}
# 43 "kernel/qrect.h" 2
class QRect
{
public:
QRect() { x1 = y1 = 0; x2 = y2 = -1; }
QRect( const QPoint &topleft, const QPoint &bottomright );
QRect( const QPoint &topleft, const QSize &size );
QRect( int left, int top, int width, int height );
bool isNull() const;
bool isEmpty() const;
bool isValid() const;
QRect normalize() const;
int left() const;
int top() const;
int right() const;
int bottom() const;
QCOORD &rLeft();
QCOORD &rTop();
QCOORD &rRight();
QCOORD &rBottom();
int x() const;
int y() const;
void setLeft( int pos );
void setTop( int pos );
void setRight( int pos );
void setBottom( int pos );
void setX( int x );
void setY( int y );
void setTopLeft( const QPoint &p );
void setBottomRight( const QPoint &p );
void setTopRight( const QPoint &p );
void setBottomLeft( const QPoint &p );
QPoint topLeft() const;
QPoint bottomRight() const;
QPoint topRight() const;
QPoint bottomLeft() const;
QPoint center() const;
void rect( int *x, int *y, int *w, int *h ) const;
void coords( int *x1, int *y1, int *x2, int *y2 ) const;
void moveLeft( int pos );
void moveTop( int pos );
void moveRight( int pos );
void moveBottom( int pos );
void moveTopLeft( const QPoint &p );
void moveBottomRight( const QPoint &p );
void moveTopRight( const QPoint &p );
void moveBottomLeft( const QPoint &p );
void moveCenter( const QPoint &p );
void moveBy( int dx, int dy );
void setRect( int x, int y, int w, int h );
void setCoords( int x1, int y1, int x2, int y2 );
void addCoords( int x1, int y1, int x2, int y2 );
QSize size() const;
int width() const;
int height() const;
void setWidth( int w );
void setHeight( int h );
void setSize( const QSize &s );
QRect operator|(const QRect &r) const;
QRect operator&(const QRect &r) const;
QRect& operator|=(const QRect &r);
QRect& operator&=(const QRect &r);
bool contains( const QPoint &p, bool proper=FALSE ) const;
bool contains( int x, int y ) const;
bool contains( int x, int y, bool proper ) const;
bool contains( const QRect &r, bool proper=FALSE ) const;
QRect unite( const QRect &r ) const;
QRect intersect( const QRect &r ) const;
bool intersects( const QRect &r ) const;
friend bool operator==( const QRect &, const QRect & );
friend bool operator!=( const QRect &, const QRect & );
private:
QCOORD x1;
QCOORD y1;
QCOORD x2;
QCOORD y2;
};
bool operator==( const QRect &, const QRect & );
bool operator!=( const QRect &, const QRect & );
QDataStream &operator<<( QDataStream &, const QRect & );
QDataStream &operator>>( QDataStream &, QRect & );
inline QRect::QRect( int left, int top, int width, int height )
{
x1 = (QCOORD)left;
y1 = (QCOORD)top;
x2 = (QCOORD)(left+width-1);
y2 = (QCOORD)(top+height-1);
}
inline bool QRect::isNull() const
{ return x2 == x1-1 && y2 == y1-1; }
inline bool QRect::isEmpty() const
{ return x1 > x2 || y1 > y2; }
inline bool QRect::isValid() const
{ return x1 <= x2 && y1 <= y2; }
inline int QRect::left() const
{ return x1; }
inline int QRect::top() const
{ return y1; }
inline int QRect::right() const
{ return x2; }
inline int QRect::bottom() const
{ return y2; }
inline QCOORD &QRect::rLeft()
{ return x1; }
inline QCOORD & QRect::rTop()
{ return y1; }
inline QCOORD & QRect::rRight()
{ return x2; }
inline QCOORD & QRect::rBottom()
{ return y2; }
inline int QRect::x() const
{ return x1; }
inline int QRect::y() const
{ return y1; }
inline void QRect::setLeft( int pos )
{ x1 = (QCOORD)pos; }
inline void QRect::setTop( int pos )
{ y1 = (QCOORD)pos; }
inline void QRect::setRight( int pos )
{ x2 = (QCOORD)pos; }
inline void QRect::setBottom( int pos )
{ y2 = (QCOORD)pos; }
inline void QRect::setX( int x )
{ x1 = (QCOORD)x; }
inline void QRect::setY( int y )
{ y1 = (QCOORD)y; }
inline QPoint QRect::topLeft() const
{ return QPoint(x1, y1); }
inline QPoint QRect::bottomRight() const
{ return QPoint(x2, y2); }
inline QPoint QRect::topRight() const
{ return QPoint(x2, y1); }
inline QPoint QRect::bottomLeft() const
{ return QPoint(x1, y2); }
inline QPoint QRect::center() const
{ return QPoint((x1+x2)/2, (y1+y2)/2); }
inline int QRect::width() const
{ return x2 - x1 + 1; }
inline int QRect::height() const
{ return y2 - y1 + 1; }
inline QSize QRect::size() const
{ return QSize(x2-x1+1, y2-y1+1); }
inline bool QRect::contains( int x, int y, bool proper ) const
{
if ( proper )
return x > x1 && x < x2 &&
y > y1 && y < y2;
else
return x >= x1 && x <= x2 &&
y >= y1 && y <= y2;
}
inline bool QRect::contains( int x, int y ) const
{
return x >= x1 && x <= x2 &&
y >= y1 && y <= y2;
}
# 44 "kernel/qregion.h" 2
struct QRegionPrivate;
class QRegion
{
public:
enum RegionType { Rectangle, Ellipse };
QRegion();
QRegion( int x, int y, int w, int h, RegionType = Rectangle );
QRegion( const QRect &, RegionType = Rectangle );
QRegion( const QPointArray &, bool winding=FALSE );
QRegion( const QRegion & );
QRegion( const QBitmap & );
~QRegion();
QRegion &operator=( const QRegion & );
bool isNull() const;
bool isEmpty() const;
bool contains( const QPoint &p ) const;
bool contains( const QRect &r ) const;
void translate( int dx, int dy );
QRegion unite( const QRegion & ) const;
QRegion intersect( const QRegion &) const;
QRegion subtract( const QRegion & ) const;
QRegion eor( const QRegion & ) const;
QRect boundingRect() const;
QMemArray<QRect> rects() const;
void setRects( const QRect *, int );
const QRegion operator|( const QRegion & ) const;
const QRegion operator+( const QRegion & ) const;
const QRegion operator&( const QRegion & ) const;
const QRegion operator-( const QRegion & ) const;
const QRegion operator^( const QRegion & ) const;
QRegion& operator|=( const QRegion & );
QRegion& operator+=( const QRegion & );
QRegion& operator&=( const QRegion & );
QRegion& operator-=( const QRegion & );
QRegion& operator^=( const QRegion & );
bool operator==( const QRegion & ) const;
bool operator!=( const QRegion &r ) const
{ return !(operator==(r)); }
Region handle() const { if(!data->rgn) updateX11Region(); return data->rgn; }
# 108 "kernel/qregion.h"
friend QDataStream &operator<<( QDataStream &, const QRegion & );
friend QDataStream &operator>>( QDataStream &, QRegion & );
private:
QRegion( bool );
QRegion copy() const;
void detach();
void updateX11Region() const;
void *clipRectangles( int &num ) const;
friend void *qt_getClipRects( const QRegion &, int & );
void exec( const QByteArray &, int ver = 0 );
struct QRegionData : public QShared {
Region rgn;
void *xrectangles;
QRegionPrivate *region;
bool is_null;
} *data;
};
# 167 "kernel/qregion.h"
QDataStream &operator<<( QDataStream &, const QRegion & );
QDataStream &operator>>( QDataStream &, QRegion & );
# 44 "kernel/qevent.h" 2
# 1 "kernel/qmime.h" 1
# 48 "kernel/qmime.h"
class QImageDrag;
class QTextDrag;
class QMimeSource
{
friend class QClipboardData;
public:
QMimeSource();
virtual ~QMimeSource();
virtual const char* format( int n = 0 ) const = 0;
virtual bool provides( const char* ) const;
virtual QByteArray encodedData( const char* ) const = 0;
int serialNumber() const;
private:
int ser_no;
enum { NoCache, Text, Graphics } cacheType;
union
{
struct
{
QString *str;
QCString *subtype;
} txt;
struct
{
QImage *img;
QPixmap *pix;
} gfx;
} cache;
void clearCache();
friend class QImageDrag;
friend class QTextDrag;
};
inline int QMimeSource::serialNumber() const
{ return ser_no; }
class QStringList;
class QMimeSourceFactoryData;
class QMimeSourceFactory {
public:
QMimeSourceFactory();
virtual ~QMimeSourceFactory();
static QMimeSourceFactory* defaultFactory();
static void setDefaultFactory( QMimeSourceFactory* );
static QMimeSourceFactory* takeDefaultFactory();
static void addFactory( QMimeSourceFactory *f );
static void removeFactory( QMimeSourceFactory *f );
virtual const QMimeSource* data(const QString& abs_name) const;
virtual QString makeAbsolute(const QString& abs_or_rel_name, const QString& context) const;
const QMimeSource* data(const QString& abs_or_rel_name, const QString& context) const;
virtual void setText( const QString& abs_name, const QString& text );
virtual void setImage( const QString& abs_name, const QImage& im );
virtual void setPixmap( const QString& abs_name, const QPixmap& pm );
virtual void setData( const QString& abs_name, QMimeSource* data );
virtual void setFilePath( const QStringList& );
virtual QStringList filePath() const;
void addFilePath( const QString& );
virtual void setExtensionType( const QString& ext, const char* mimetype );
private:
QMimeSource *dataInternal(const QString& abs_name, const QMap<QString, QString> &extensions ) const;
QMimeSourceFactoryData* d;
};
# 46 "kernel/qevent.h" 2
class QEvent: public Qt
{
public:
enum Type {
# 61 "kernel/qevent.h"
None = 0,
Timer = 1,
MouseButtonPress = 2,
MouseButtonRelease = 3,
MouseButtonDblClick = 4,
MouseMove = 5,
KeyPress = 6,
KeyRelease = 7,
FocusIn = 8,
FocusOut = 9,
Enter = 10,
Leave = 11,
Paint = 12,
Move = 13,
Resize = 14,
Create = 15,
Destroy = 16,
Show = 17,
Hide = 18,
Close = 19,
Quit = 20,
Reparent = 21,
ShowMinimized = 22,
ShowNormal = 23,
WindowActivate = 24,
WindowDeactivate = 25,
ShowToParent = 26,
HideToParent = 27,
ShowMaximized = 28,
ShowFullScreen = 29,
Accel = 30,
Wheel = 31,
AccelAvailable = 32,
CaptionChange = 33,
IconChange = 34,
ParentFontChange = 35,
ApplicationFontChange = 36,
ParentPaletteChange = 37,
ApplicationPaletteChange = 38,
PaletteChange = 39,
Clipboard = 40,
Speech = 42,
SockAct = 50,
AccelOverride = 51,
DeferredDelete = 52,
DragEnter = 60,
DragMove = 61,
DragLeave = 62,
Drop = 63,
DragResponse = 64,
ChildInserted = 70,
ChildRemoved = 71,
LayoutHint = 72,
ShowWindowRequest = 73,
ActivateControl = 80,
DeactivateControl = 81,
ContextMenu = 82,
IMStart = 83,
IMCompose = 84,
IMEnd = 85,
Accessibility = 86,
TabletMove = 87,
LocaleChange = 88,
LanguageChange = 89,
LayoutDirectionChange = 90,
Style = 91,
TabletPress = 92,
TabletRelease = 93,
User = 1000,
MaxUser = 65535
};
QEvent( Type type ) : t(type), posted(FALSE), spont(FALSE) {}
virtual ~QEvent();
Type type() const { return t; }
bool spontaneous() const { return spont; }
protected:
Type t;
private:
uint posted : 1;
uint spont : 1;
friend class QApplication;
friend class QAccelManager;
friend class QBaseApplication;
friend class QETWidget;
};
class QTimerEvent : public QEvent
{
public:
QTimerEvent( int timerId )
: QEvent(Timer), id(timerId) {}
int timerId() const { return id; }
protected:
int id;
};
class QMouseEvent : public QEvent
{
public:
QMouseEvent( Type type, const QPoint &pos, int button, int state );
QMouseEvent( Type type, const QPoint &pos, const QPoint&globalPos,
int button, int state )
: QEvent(type), p(pos), g(globalPos), b((ushort)button),s((ushort)state),accpt(TRUE) {};
const QPoint &pos() const { return p; }
const QPoint &globalPos() const { return g; }
int x() const { return p.x(); }
int y() const { return p.y(); }
int globalX() const { return g.x(); }
int globalY() const { return g.y(); }
ButtonState button() const { return (ButtonState) b; }
ButtonState state() const { return (ButtonState) s; }
ButtonState stateAfter() const;
bool isAccepted() const { return accpt; }
void accept() { accpt = TRUE; }
void ignore() { accpt = FALSE; }
protected:
QPoint p;
QPoint g;
ushort b;
ushort s;
uint accpt:1;
};
class QWheelEvent : public QEvent
{
public:
QWheelEvent( const QPoint &pos, int delta, int state, Orientation orient = Vertical );
QWheelEvent( const QPoint &pos, const QPoint& globalPos, int delta, int state, Orientation orient = Vertical )
: QEvent(Wheel), p(pos), g(globalPos), d(delta), s((ushort)state),
accpt(TRUE), o(orient) {}
int delta() const { return d; }
const QPoint &pos() const { return p; }
const QPoint &globalPos() const { return g; }
int x() const { return p.x(); }
int y() const { return p.y(); }
int globalX() const { return g.x(); }
int globalY() const { return g.y(); }
ButtonState state() const { return ButtonState(s); }
Orientation orientation() const { return o; }
bool isAccepted() const { return accpt; }
void accept() { accpt = TRUE; }
void ignore() { accpt = FALSE; }
protected:
QPoint p;
QPoint g;
int d;
ushort s;
bool accpt;
Orientation o;
};
class QTabletEvent : public QEvent
{
public:
enum TabletDevice { NoDevice = -1, Puck, Stylus, Eraser };
QTabletEvent( Type t, const QPoint &pos, const QPoint &globalPos, int device,
int pressure, int xTilt, int yTilt, const QPair<int,int> &uId );
QTabletEvent( const QPoint &pos, const QPoint &globalPos, int device,
int pressure, int xTilt, int yTilt, const QPair<int,int> &uId )
: QEvent( TabletMove ), mPos( pos ), mGPos( globalPos ), mDev( device ),
mPress( pressure ), mXT( xTilt ), mYT( yTilt ), mType( uId.first ),
mPhy( uId.second )
{}
int pressure() const { return mPress; }
int xTilt() const { return mXT; }
int yTilt() const { return mYT; }
const QPoint &pos() const { return mPos; }
const QPoint &globalPos() const { return mGPos; }
int x() const { return mPos.x(); }
int y() const { return mPos.y(); }
int globalX() const { return mGPos.x(); }
int globalY() const { return mGPos.y(); }
TabletDevice device() const { return TabletDevice(mDev); }
int isAccepted() const { return mbAcc; }
void accept() { mbAcc = TRUE; }
void ignore() { mbAcc = FALSE; }
QPair<int,int> uniqueId() { return QPair<int,int>( mType, mPhy); }
protected:
QPoint mPos;
QPoint mGPos;
int mDev,
mPress,
mXT,
mYT,
mType,
mPhy;
bool mbAcc;
};
class QKeyEvent : public QEvent
{
public:
QKeyEvent( Type type, int key, int ascii, int state,
const QString& text=QString::null, bool autorep=FALSE, ushort count=1 )
: QEvent(type), txt(text), k((ushort)key), s((ushort)state),
a((uchar)ascii), accpt(TRUE), autor(autorep), c(count)
{
if ( key >= Key_Back && key <= Key_MediaLast )
accpt = FALSE;
}
int key() const { return k; }
int ascii() const { return a; }
ButtonState state() const { return ButtonState(s); }
ButtonState stateAfter() const;
bool isAccepted() const { return accpt; }
QString text() const { return txt; }
bool isAutoRepeat() const { return autor; }
int count() const { return int(c); }
void accept() { accpt = TRUE; }
void ignore() { accpt = FALSE; }
protected:
QString txt;
ushort k, s;
uchar a;
uint accpt:1;
uint autor:1;
ushort c;
};
class QFocusEvent : public QEvent
{
public:
QFocusEvent( Type type )
: QEvent(type) {}
bool gotFocus() const { return type() == FocusIn; }
bool lostFocus() const { return type() == FocusOut; }
enum Reason { Mouse, Tab, Backtab, ActiveWindow, Popup, Shortcut, Other };
static Reason reason();
static void setReason( Reason reason );
static void resetReason();
private:
static Reason m_reason;
static Reason prev_reason;
};
class QPaintEvent : public QEvent
{
public:
QPaintEvent( const QRegion& paintRegion, bool erased = TRUE)
: QEvent(Paint),
rec(paintRegion.boundingRect()),
reg(paintRegion),
erase(erased){}
QPaintEvent( const QRect &paintRect, bool erased = TRUE )
: QEvent(Paint),
rec(paintRect),
reg(paintRect),
erase(erased){}
const QRect &rect() const { return rec; }
const QRegion ®ion() const { return reg; }
bool erased() const { return erase; }
protected:
friend class QApplication;
friend class QBaseApplication;
QRect rec;
QRegion reg;
bool erase;
};
class QMoveEvent : public QEvent
{
public:
QMoveEvent( const QPoint &pos, const QPoint &oldPos )
: QEvent(Move), p(pos), oldp(oldPos) {}
const QPoint &pos() const { return p; }
const QPoint &oldPos()const { return oldp;}
protected:
QPoint p, oldp;
friend class QApplication;
friend class QBaseApplication;
};
class QResizeEvent : public QEvent
{
public:
QResizeEvent( const QSize &size, const QSize &oldSize )
: QEvent(Resize), s(size), olds(oldSize) {}
const QSize &size() const { return s; }
const QSize &oldSize()const { return olds;}
protected:
QSize s, olds;
friend class QApplication;
friend class QBaseApplication;
};
class QCloseEvent : public QEvent
{
public:
QCloseEvent()
: QEvent(Close), accpt(FALSE) {}
bool isAccepted() const { return accpt; }
void accept() { accpt = TRUE; }
void ignore() { accpt = FALSE; }
protected:
bool accpt;
};
class QShowEvent : public QEvent
{
public:
QShowEvent()
: QEvent(Show) {}
};
class QHideEvent : public QEvent
{
public:
QHideEvent()
: QEvent(Hide) {}
};
class QContextMenuEvent : public QEvent
{
public:
enum Reason { Mouse, Keyboard, Other };
QContextMenuEvent( Reason reason, const QPoint &pos, const QPoint &globalPos, int state )
: QEvent( ContextMenu ), p( pos ), gp( globalPos ), accpt( FALSE ), consum(FALSE),
reas( reason ), s((ushort)state) {}
QContextMenuEvent( Reason reason, const QPoint &pos, int state );
int x() const { return p.x(); }
int y() const { return p.y(); }
int globalX() const { return gp.x(); }
int globalY() const { return gp.y(); }
const QPoint& pos() const { return p; }
const QPoint& globalPos() const { return gp; }
ButtonState state() const { return (ButtonState) s; }
bool isAccepted() const { return accpt; }
bool isConsumed() const { return consum; }
void consume() { consum = TRUE; }
void accept() { accpt = TRUE; consum = TRUE; }
void ignore() { accpt = FALSE; consum = FALSE; }
Reason reason() const { return Reason( reas ); }
protected:
QPoint p;
QPoint gp;
bool accpt;
bool consum;
uint reas:8;
ushort s;
};
class QIMEvent : public QEvent
{
public:
QIMEvent( Type type, const QString &text, int cursorPosition )
: QEvent(type), txt(text), cpos(cursorPosition), a(FALSE) {}
const QString &text() const { return txt; }
int cursorPos() const { return cpos; }
bool isAccepted() const { return a; }
void accept() { a = TRUE; }
void ignore() { a = FALSE; }
int selectionLength() const;
private:
QString txt;
int cpos;
bool a;
};
class QIMComposeEvent : public QIMEvent
{
public:
QIMComposeEvent( Type type, const QString &text, int cursorPosition,
int selLength )
: QIMEvent( type, text, cursorPosition ), selLen( selLength ) { }
private:
int selLen;
friend class QIMEvent;
};
inline int QIMEvent::selectionLength() const
{
if ( type() != IMCompose ) return 0;
QIMComposeEvent *that = (QIMComposeEvent *) this;
return that->selLen;
}
# 479 "kernel/qevent.h"
class QDropEvent : public QEvent, public QMimeSource
{
public:
QDropEvent( const QPoint& pos, Type typ=Drop )
: QEvent(typ), p(pos),
act(0), accpt(0), accptact(0), resv(0),
d(0)
{}
const QPoint &pos() const { return p; }
bool isAccepted() const { return accpt || accptact; }
void accept(bool y=TRUE) { accpt = y; }
void ignore() { accpt = FALSE; }
bool isActionAccepted() const { return accptact; }
void acceptAction(bool y=TRUE) { accptact = y; }
enum Action { Copy, Link, Move, Private, UserAction=100 };
void setAction( Action a ) { act = (uint)a; }
Action action() const { return Action(act); }
QWidget* source() const;
const char* format( int n = 0 ) const;
QByteArray encodedData( const char* ) const;
bool provides( const char* ) const;
QByteArray data(const char* f) const { return encodedData(f); }
void setPoint( const QPoint& np ) { p = np; }
protected:
QPoint p;
uint act:8;
uint accpt:1;
uint accptact:1;
uint resv:5;
void * d;
};
class QDragMoveEvent : public QDropEvent
{
public:
QDragMoveEvent( const QPoint& pos, Type typ=DragMove )
: QDropEvent(pos,typ),
rect( pos, QSize( 1, 1 ) ) {}
QRect answerRect() const { return rect; }
void accept( bool y=TRUE ) { QDropEvent::accept(y); }
void accept( const QRect & r) { accpt = TRUE; rect = r; }
void ignore( const QRect & r) { accpt =FALSE; rect = r; }
void ignore() { QDropEvent::ignore(); }
protected:
QRect rect;
};
class QDragEnterEvent : public QDragMoveEvent
{
public:
QDragEnterEvent( const QPoint& pos ) :
QDragMoveEvent(pos, DragEnter) { }
};
class QDragResponseEvent : public QEvent
{
public:
QDragResponseEvent( bool accepted )
: QEvent(DragResponse), a(accepted) {}
bool dragAccepted() const { return a; }
protected:
bool a;
};
class QDragLeaveEvent : public QEvent
{
public:
QDragLeaveEvent()
: QEvent(DragLeave) {}
};
class QChildEvent : public QEvent
{
public:
QChildEvent( Type type, QObject *child )
: QEvent(type), c(child) {}
QObject *child() const { return c; }
bool inserted() const { return t == ChildInserted; }
bool removed() const { return t == ChildRemoved; }
protected:
QObject *c;
};
class QCustomEvent : public QEvent
{
public:
QCustomEvent( int type );
QCustomEvent( Type type, void *data )
: QEvent(type), d(data) {};
void *data() const { return d; }
void setData( void* data ) { d = data; }
private:
void *d;
};
# 46 "kernel/qobject.h" 2
class QMetaObject;
class QVariant;
class QMetaProperty;
class QPostEventList;
class QSenderObjectList;
class QObjectPrivate;
class QObjectUserData;
struct QUObject;
class QObject: public Qt
{
public: virtual QMetaObject *metaObject() const { return staticMetaObject(); } virtual const char *className() const; virtual void* qt_cast( const char* ); virtual bool qt_invoke( int, QUObject* ); virtual bool qt_emit( int, QUObject* ); virtual bool qt_property( int id, int f, QVariant* v); static bool qt_static_property( QObject* , int, int, QVariant* ); static QMetaObject* staticMetaObject(); QObject* qObject() { return (QObject*)this; } static QString tr( const char *, const char * = 0 ); static QString trUtf8( const char *, const char * = 0 ); private: static QMetaObject *metaObj;
public:
QObject( QObject *parent=0, const char *name=0 );
virtual ~QObject();
# 79 "kernel/qobject.h"
virtual bool event( QEvent * );
virtual bool eventFilter( QObject *, QEvent * );
bool isA( const char * ) const;
bool inherits( const char * ) const;
const char *name() const;
const char *name( const char * defaultName ) const;
virtual void setName( const char *name );
bool isWidgetType() const { return isWidget; }
bool highPriority() const { return FALSE; }
bool signalsBlocked() const { return blockSig; }
void blockSignals( bool b );
int startTimer( int interval );
void killTimer( int id );
void killTimers();
QObject *child( const char *objName, const char *inheritsClass = 0, bool recursiveSearch = TRUE );
const QObjectList *children() const { return childObjects; }
static const QObjectList *objectTrees();
QObjectList *queryList( const char *inheritsClass = 0,
const char *objName = 0,
bool regexpMatch = TRUE,
bool recursiveSearch = TRUE ) const;
virtual void insertChild( QObject * );
virtual void removeChild( QObject * );
void installEventFilter( const QObject * );
void removeEventFilter( const QObject * );
static bool connect( const QObject *sender, const char *signal,
const QObject *receiver, const char *member );
bool connect( const QObject *sender, const char *signal,
const char *member ) const;
static bool disconnect( const QObject *sender, const char *signal,
const QObject *receiver, const char *member );
bool disconnect( const char *signal=0,
const QObject *receiver=0, const char *member=0 );
bool disconnect( const QObject *receiver, const char *member=0 );
static void connectInternal( const QObject *sender, int signal_index, const QObject *receiver,
int membcode, int member_index );
static bool disconnectInternal( const QObject *sender, int signal_index,
const QObject *receiver, int member_index );
void dumpObjectTree();
void dumpObjectInfo();
virtual bool setProperty( const char *name, const QVariant& value );
virtual QVariant property( const char *name ) const;
# 144 "kernel/qobject.h"
static uint registerUserData();
void setUserData( uint id, QObjectUserData* data);
QObjectUserData* userData( uint id ) const;
protected:
void destroyed();
void destroyed( QObject* obj );
public:
QObject *parent() const { return parentObj; }
public :
void deleteLater();
private :
void cleanupEventFilter( QObject* );
protected:
bool activate_filters( QEvent * );
QConnectionList *receivers( const char* signal ) const;
QConnectionList *receivers( int signal ) const;
void activate_signal( int signal );
void activate_signal( int signal, int );
void activate_signal( int signal, double );
void activate_signal( int signal, QString );
void activate_signal_bool( int signal, bool );
void activate_signal( QConnectionList *clist, QUObject *o );
const QObject *sender();
virtual void timerEvent( QTimerEvent * );
virtual void childEvent( QChildEvent * );
virtual void customEvent( QCustomEvent * );
virtual void connectNotify( const char *signal );
virtual void disconnectNotify( const char *signal );
virtual bool checkConnectArgs( const char *signal, const QObject *receiver,
const char *member );
static QCString normalizeSignalSlot( const char *signalSlot );
private:
uint isSignal : 1;
uint isWidget : 1;
uint pendTimer : 1;
uint blockSig : 1;
uint wasDeleted : 1;
uint isTree : 1;
const char *objname;
QObject *parentObj;
QObjectList *childObjects;
QSignalVec *connections;
QSenderObjectList *senderObjects;
QObjectList *eventFilters;
QPostEventList *postedEvents;
QObjectPrivate* d;
static QMetaObject* staticQtMetaObject();
friend class QApplication;
friend class QBaseApplication;
friend class QWidget;
friend class QSignal;
private:
QObject( const QObject & );
QObject &operator=( const QObject & );
};
class QObjectUserData {
public:
virtual ~QObjectUserData();
};
inline bool QObject::connect( const QObject *sender, const char *signal,
const char *member ) const
{
return connect( sender, signal, this, member );
}
inline bool QObject::disconnect( const char *signal,
const QObject *receiver, const char *member )
{
return disconnect( this, signal, receiver, member );
}
inline bool QObject::disconnect( const QObject *receiver, const char *member )
{
return disconnect( this, 0, receiver, member );
}
# 44 "kernel/qwidget.h" 2
# 1 "kernel/qpaintdevice.h" 1
# 51 "kernel/qpaintdevice.h"
class QIODevice;
class QString;
struct QPaintDeviceX11Data;
union QPDevCmdParam {
int ival;
int *ivec;
QString *str;
const QPoint *point;
const QRect *rect;
const QPointArray *ptarr;
const QPixmap *pixmap;
const QImage *image;
const QColor *color;
const QFont *font;
const QPen *pen;
const QBrush *brush;
const QRegion *rgn;
const QWMatrix *matrix;
QIODevice *device;
};
class QPaintDevice
{
public:
virtual ~QPaintDevice();
int devType() const;
bool isExtDev() const;
bool paintingActive() const;
virtual void setResolution( int );
virtual int resolution() const;
virtual Qt::HANDLE handle() const;
virtual Qt::HANDLE x11RenderHandle() const;
Display *x11Display() const;
int x11Screen() const;
int x11Depth() const;
int x11Cells() const;
Qt::HANDLE x11Colormap() const;
bool x11DefaultColormap() const;
void *x11Visual() const;
bool x11DefaultVisual() const;
static Display *x11AppDisplay();
static int x11AppScreen();
static int x11AppDpiX();
static int x11AppDpiY();
static void x11SetAppDpiX(int);
static void x11SetAppDpiY(int);
static int x11AppDepth();
static int x11AppCells();
static Qt::HANDLE x11AppRootWindow();
static Qt::HANDLE x11AppColormap();
static bool x11AppDefaultColormap();
static void *x11AppVisual();
static bool x11AppDefaultVisual();
static int x11AppDepth( int screen );
static int x11AppCells( int screen );
static Qt::HANDLE x11AppRootWindow( int screen );
static Qt::HANDLE x11AppColormap( int screen );
static void *x11AppVisual( int screen );
static bool x11AppDefaultColormap( int screen );
static bool x11AppDefaultVisual( int screen );
static int x11AppDpiX( int );
static int x11AppDpiY( int );
static void x11SetAppDpiX( int, int );
static void x11SetAppDpiY( int, int );
# 151 "kernel/qpaintdevice.h"
enum PDevCmd {
PdcNOP = 0,
PdcDrawPoint = 1,
PdcDrawFirst = PdcDrawPoint,
PdcMoveTo = 2,
PdcLineTo = 3,
PdcDrawLine = 4,
PdcDrawRect = 5,
PdcDrawRoundRect = 6,
PdcDrawEllipse = 7,
PdcDrawArc = 8,
PdcDrawPie = 9,
PdcDrawChord = 10,
PdcDrawLineSegments = 11,
PdcDrawPolyline = 12,
PdcDrawPolygon = 13,
PdcDrawCubicBezier = 14,
PdcDrawText = 15,
PdcDrawTextFormatted = 16,
PdcDrawPixmap = 17,
PdcDrawImage = 18,
PdcDrawText2 = 19,
PdcDrawText2Formatted = 20,
PdcDrawLast = PdcDrawText2Formatted,
PdcBegin = 30,
PdcEnd = 31,
PdcSave = 32,
PdcRestore = 33,
PdcSetdev = 34,
PdcSetBkColor = 40,
PdcSetBkMode = 41,
PdcSetROP = 42,
PdcSetBrushOrigin = 43,
PdcSetFont = 45,
PdcSetPen = 46,
PdcSetBrush = 47,
PdcSetTabStops = 48,
PdcSetTabArray = 49,
PdcSetUnit = 50,
PdcSetVXform = 51,
PdcSetWindow = 52,
PdcSetViewport = 53,
PdcSetWXform = 54,
PdcSetWMatrix = 55,
PdcSaveWMatrix = 56,
PdcRestoreWMatrix = 57,
PdcSetClip = 60,
PdcSetClipRegion = 61,
PdcReservedStart = 0,
PdcReservedStop = 199
};
protected:
QPaintDevice( uint devflags );
Qt::HANDLE hd;
Qt::HANDLE rendhd;
void copyX11Data( const QPaintDevice * );
void cloneX11Data( const QPaintDevice * );
virtual void setX11Data( const QPaintDeviceX11Data* );
QPaintDeviceX11Data* getX11Data( bool def=FALSE ) const;
# 229 "kernel/qpaintdevice.h"
virtual bool cmd( int, QPainter *, QPDevCmdParam * );
virtual int metric( int ) const;
virtual int fontMet( QFont *, int, const char * = 0, int = 0 ) const;
virtual int fontInf( QFont *, int ) const;
ushort devFlags;
ushort painters;
friend class QPainter;
friend class QPaintDeviceMetrics;
friend void bitBlt( QPaintDevice *, int, int,
const QPaintDevice *,
int, int, int, int, Qt::RasterOp, bool );
friend void qt_init_internal( int *, char **, Display *, Qt::HANDLE, Qt::HANDLE );
friend void qt_cleanup();
private:
static Display *x_appdisplay;
static int x_appscreen;
static int x_appdepth;
static int x_appcells;
static Qt::HANDLE x_approotwindow;
static Qt::HANDLE x_appcolormap;
static bool x_appdefcolormap;
static void *x_appvisual;
static bool x_appdefvisual;
static int *x_appdepth_arr;
static int *x_appcells_arr;
static Qt::HANDLE *x_approotwindow_arr;
static Qt::HANDLE *x_appcolormap_arr;
static bool *x_appdefcolormap_arr;
static void **x_appvisual_arr;
static bool *x_appdefvisual_arr;
QPaintDeviceX11Data* x11Data;
private:
QPaintDevice( const QPaintDevice & );
QPaintDevice &operator=( const QPaintDevice & );
};
void bitBlt( QPaintDevice *dst, int dx, int dy,
const QPaintDevice *src, int sx=0, int sy=0, int sw=-1, int sh=-1,
Qt::RasterOp = Qt::CopyROP, bool ignoreMask=FALSE );
void bitBlt( QPaintDevice *dst, int dx, int dy,
const QImage *src, int sx=0, int sy=0, int sw=-1, int sh=-1,
int conversion_flags=0 );
struct QPaintDeviceX11Data : public QShared {
Display* x_display;
int x_screen;
int x_depth;
int x_cells;
Qt::HANDLE x_colormap;
bool x_defcolormap;
void* x_visual;
bool x_defvisual;
};
inline int QPaintDevice::devType() const
{ return devFlags & QInternal::DeviceTypeMask; }
inline bool QPaintDevice::isExtDev() const
{ return (devFlags & QInternal::ExternalDevice) != 0; }
inline bool QPaintDevice::paintingActive() const
{ return painters != 0; }
inline Display *QPaintDevice::x11Display() const
{ return x11Data ? x11Data->x_display : x_appdisplay; }
inline int QPaintDevice::x11Screen() const
{ return x11Data ? x11Data->x_screen : x_appscreen; }
inline int QPaintDevice::x11Depth() const
{ return x11Data ? x11Data->x_depth : x_appdepth; }
inline int QPaintDevice::x11Cells() const
{ return x11Data ? x11Data->x_cells : x_appcells; }
inline Qt::HANDLE QPaintDevice::x11Colormap() const
{ return x11Data ? x11Data->x_colormap : x_appcolormap; }
inline bool QPaintDevice::x11DefaultColormap() const
{ return x11Data ? x11Data->x_defcolormap : x_appdefcolormap; }
inline void *QPaintDevice::x11Visual() const
{ return x11Data ? x11Data->x_visual : x_appvisual; }
inline bool QPaintDevice::x11DefaultVisual() const
{ return x11Data ? x11Data->x_defvisual : x_appdefvisual; }
inline Display *QPaintDevice::x11AppDisplay()
{ return x_appdisplay; }
inline int QPaintDevice::x11AppScreen()
{ return x_appscreen; }
inline int QPaintDevice::x11AppDepth( int screen )
{ return x_appdepth_arr[ screen == -1 ? x_appscreen : screen ]; }
inline int QPaintDevice::x11AppCells( int screen )
{ return x_appcells_arr[ screen == -1 ? x_appscreen : screen ]; }
inline Qt::HANDLE QPaintDevice::x11AppRootWindow( int screen )
{ return x_approotwindow_arr[ screen == -1 ? x_appscreen : screen ]; }
inline Qt::HANDLE QPaintDevice::x11AppColormap( int screen )
{ return x_appcolormap_arr[ screen == -1 ? x_appscreen : screen ]; }
inline bool QPaintDevice::x11AppDefaultColormap( int screen )
{ return x_appdefcolormap_arr[ screen == -1 ? x_appscreen : screen ]; }
inline void *QPaintDevice::x11AppVisual( int screen )
{ return x_appvisual_arr[ screen == -1 ? x_appscreen : screen ]; }
inline bool QPaintDevice::x11AppDefaultVisual( int screen )
{ return x_appdefvisual_arr[ screen == -1 ? x_appscreen : screen ]; }
inline int QPaintDevice::x11AppDepth()
{ return x_appdepth; }
inline int QPaintDevice::x11AppCells()
{ return x_appcells; }
inline Qt::HANDLE QPaintDevice::x11AppRootWindow()
{ return x_approotwindow; }
inline Qt::HANDLE QPaintDevice::x11AppColormap()
{ return x_appcolormap; }
inline bool QPaintDevice::x11AppDefaultColormap()
{ return x_appdefcolormap; }
inline void *QPaintDevice::x11AppVisual()
{ return x_appvisual; }
inline bool QPaintDevice::x11AppDefaultVisual()
{ return x_appdefvisual; }
inline void bitBlt( QPaintDevice *dst, const QPoint &dp,
const QPaintDevice *src, const QRect &sr =QRect(0,0,-1,-1),
Qt::RasterOp rop=Qt::CopyROP, bool ignoreMask=FALSE )
{
bitBlt( dst, dp.x(), dp.y(), src, sr.x(), sr.y(), sr.width(), sr.height(),
rop, ignoreMask );
}
# 45 "kernel/qwidget.h" 2
# 1 "kernel/qpalette.h" 1
# 43 "kernel/qpalette.h"
# 1 "kernel/qcolor.h" 1
# 45 "kernel/qcolor.h"
const QRgb RGB_MASK = 0x00ffffff;
inline int qRed( QRgb rgb )
{ return (int)((rgb >> 16) & 0xff); }
inline int qGreen( QRgb rgb )
{ return (int)((rgb >> 8) & 0xff); }
inline int qBlue( QRgb rgb )
{ return (int)(rgb & 0xff); }
inline int qAlpha( QRgb rgb )
{ return (int)((rgb >> 24) & 0xff); }
inline QRgb qRgb( int r, int g, int b )
{ return (0xff << 24) | ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff); }
inline QRgb qRgba( int r, int g, int b, int a )
{ return ((a & 0xff) << 24) | ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff); }
inline int qGray( int r, int g, int b )
{ return (r*11+g*16+b*5)/32; }
inline int qGray( QRgb rgb )
{ return qGray( qRed(rgb), qGreen(rgb), qBlue(rgb) ); }
class QColor
{
public:
enum Spec { Rgb, Hsv };
QColor();
QColor( int r, int g, int b );
QColor( int x, int y, int z, Spec );
QColor( QRgb rgb, uint pixel=0xffffffff);
QColor( const QString& name );
QColor( const char *name );
QColor( const QColor & );
QColor &operator=( const QColor & );
bool isValid() const;
bool isDirty() const;
QString name() const;
void setNamedColor( const QString& name );
void rgb( int *r, int *g, int *b ) const;
QRgb rgb() const;
void setRgb( int r, int g, int b );
void setRgb( QRgb rgb );
int red() const;
int green() const;
int blue() const;
void hsv( int *h, int *s, int *v ) const;
void getHsv( int &h, int &s, int &v ) const { hsv( &h, &s, &v ); }
void setHsv( int h, int s, int v );
QColor light( int f = 150 ) const;
QColor dark( int f = 200 ) const;
bool operator==( const QColor &c ) const;
bool operator!=( const QColor &c ) const;
uint alloc();
uint pixel() const;
uint alloc( int screen );
uint pixel( int screen ) const;
static int maxColors();
static int numBitPlanes();
static int enterAllocContext();
static void leaveAllocContext();
static int currentAllocContext();
static void destroyAllocContext( int );
# 135 "kernel/qcolor.h"
static void initialize();
static void cleanup();
enum { Dirt = 0x44495254, Invalid = 0x49000000 };
private:
void setSystemNamedColor( const QString& name );
void setPixel( uint pixel );
static void initGlobalColors();
static uint argbToPix32(QRgb);
static QColor* globalColors();
static bool color_init;
static bool globals_init;
static enum ColorModel { d8, d32 } colormodel;
union {
QRgb argb;
struct D8 {
QRgb argb;
uchar pix;
uchar invalid;
uchar dirty;
uchar direct;
} d8;
struct D32 {
QRgb argb;
uint pix;
bool invalid() const { return argb == QColor::Invalid && pix == QColor::Dirt; }
bool probablyDirty() const { return pix == QColor::Dirt; }
} d32;
} d;
};
inline QColor::QColor()
{ d.d32.argb = Invalid; d.d32.pix = Dirt; }
inline QColor::QColor( int r, int g, int b )
{ setRgb( r, g, b ); }
inline QRgb QColor::rgb() const
{ return d.argb; }
inline int QColor::red() const
{ return qRed(d.argb); }
inline int QColor::green() const
{ return qGreen(d.argb); }
inline int QColor::blue() const
{ return qBlue(d.argb); }
inline bool QColor::isValid() const
{
if ( colormodel == d8 )
return !d.d8.invalid;
else
return !d.d32.invalid();
}
inline bool QColor::operator==( const QColor &c ) const
{
return d.argb == c.d.argb && isValid() == c.isValid();
}
inline bool QColor::operator!=( const QColor &c ) const
{
return !operator==(c);
}
QDataStream &operator<<( QDataStream &, const QColor & );
QDataStream &operator>>( QDataStream &, QColor & );
# 44 "kernel/qpalette.h" 2
# 1 "kernel/qbrush.h" 1
# 47 "kernel/qbrush.h"
class QBrush: public Qt
{
friend class QPainter;
public:
QBrush();
QBrush( BrushStyle );
QBrush( const QColor &, BrushStyle=SolidPattern );
QBrush( const QColor &, const QPixmap & );
QBrush( const QBrush & );
~QBrush();
QBrush &operator=( const QBrush & );
BrushStyle style() const { return data->style; }
void setStyle( BrushStyle );
const QColor &color()const { return data->color; }
void setColor( const QColor & );
QPixmap *pixmap() const { return data->pixmap; }
void setPixmap( const QPixmap & );
bool operator==( const QBrush &p ) const;
bool operator!=( const QBrush &b ) const
{ return !(operator==(b)); }
private:
QBrush copy() const;
void detach();
void init( const QColor &, BrushStyle );
struct QBrushData : public QShared {
BrushStyle style;
QColor color;
QPixmap *pixmap;
} *data;
};
QDataStream &operator<<( QDataStream &, const QBrush & );
QDataStream &operator>>( QDataStream &, QBrush & );
# 46 "kernel/qpalette.h" 2
class QColorGroupPrivate;
class QColorGroup
{
public:
QColorGroup();
QColorGroup( const QColor &foreground, const QColor &button,
const QColor &light, const QColor &dark, const QColor &mid,
const QColor &text, const QColor &base );
QColorGroup( const QBrush &foreground, const QBrush &button,
const QBrush &light, const QBrush &dark, const QBrush &mid,
const QBrush &text, const QBrush &bright_text,
const QBrush &base, const QBrush &background);
QColorGroup( const QColorGroup & );
~QColorGroup();
QColorGroup& operator =(const QColorGroup&);
enum ColorRole { Foreground, Button, Light, Midlight, Dark, Mid,
Text, BrightText, ButtonText, Base, Background, Shadow,
Highlight, HighlightedText, Link, LinkVisited,
NColorRoles };
const QColor &color( ColorRole ) const;
const QBrush &brush( ColorRole ) const;
void setColor( ColorRole, const QColor & );
void setBrush( ColorRole, const QBrush & );
const QColor &foreground() const { return br[Foreground].color(); }
const QColor &button() const { return br[Button].color(); }
const QColor &light() const { return br[Light].color(); }
const QColor &dark() const { return br[Dark].color(); }
const QColor &mid() const { return br[Mid].color(); }
const QColor &text() const { return br[Text].color(); }
const QColor &base() const { return br[Base].color(); }
const QColor &background() const { return br[Background].color(); }
const QColor &midlight() const { return br[Midlight].color(); }
const QColor &brightText() const { return br[BrightText].color(); }
const QColor &buttonText() const { return br[ButtonText].color(); }
const QColor &shadow() const { return br[Shadow].color(); }
const QColor &highlight() const { return br[Highlight].color(); }
const QColor &highlightedText() const{return br[HighlightedText].color(); }
const QColor &link() const { return br[Link].color(); }
const QColor &linkVisited() const { return br[LinkVisited].color(); }
bool operator==( const QColorGroup &g ) const;
bool operator!=( const QColorGroup &g ) const
{ return !(operator==(g)); }
private:
QBrush *br;
QColorGroupPrivate * d;
friend class QPalette;
};
class QPalette
{
public:
QPalette();
QPalette( const QColor &button );
QPalette( const QColor &button, const QColor &background );
QPalette( const QColorGroup &active, const QColorGroup &disabled,
const QColorGroup &inactive );
QPalette( const QPalette & );
~QPalette();
QPalette &operator=( const QPalette & );
enum ColorGroup { Disabled, Active, Inactive, NColorGroups, Normal=Active };
const QColor &color( ColorGroup, QColorGroup::ColorRole ) const;
const QBrush &brush( ColorGroup, QColorGroup::ColorRole ) const;
void setColor( ColorGroup, QColorGroup::ColorRole, const QColor & );
void setBrush( ColorGroup, QColorGroup::ColorRole, const QBrush & );
void setColor( QColorGroup::ColorRole, const QColor & );
void setBrush( QColorGroup::ColorRole, const QBrush & );
QPalette copy() const;
const QColorGroup &active() const { return data->active; }
const QColorGroup &disabled() const { return data->disabled; }
const QColorGroup &inactive() const { return data->inactive; }
const QColorGroup &normal() const { return active(); }
void setActive( const QColorGroup & );
void setDisabled( const QColorGroup & );
void setInactive( const QColorGroup & );
void setNormal( const QColorGroup & cg ) { setActive(cg); }
bool operator==( const QPalette &p ) const;
bool operator!=( const QPalette &p ) const
{ return !(operator==(p)); }
bool isCopyOf( const QPalette & );
int serialNumber() const { return data->ser_no; }
static QColorGroup::ColorRole foregroundRoleFromMode( Qt::BackgroundMode mode );
static QColorGroup::ColorRole backgroundRoleFromMode( Qt::BackgroundMode mode);
private:
void detach();
const QBrush &directBrush( ColorGroup, QColorGroup::ColorRole ) const;
void directSetBrush( ColorGroup, QColorGroup::ColorRole, const QBrush& );
struct QPalData : public QShared {
QColorGroup disabled;
QColorGroup active;
int ser_no;
QColorGroup inactive;
} *data;
};
QDataStream &operator<<( QDataStream &, const QColorGroup & );
QDataStream &operator>>( QDataStream &, QColorGroup & );
QDataStream &operator<<( QDataStream &, const QPalette & );
QDataStream &operator>>( QDataStream &, QPalette & );
# 46 "kernel/qwidget.h" 2
# 1 "kernel/qfont.h" 1
# 47 "kernel/qfont.h"
class QFontPrivate;
class QStringList;
class QTextFormatCollection;
class QFont
{
public:
enum StyleHint {
Helvetica, SansSerif = Helvetica,
Times, Serif = Times,
Courier, TypeWriter = Courier,
OldEnglish, Decorative = OldEnglish,
System,
AnyStyle
};
enum StyleStrategy {
PreferDefault = 0x0001,
PreferBitmap = 0x0002,
PreferDevice = 0x0004,
PreferOutline = 0x0008,
ForceOutline = 0x0010,
PreferMatch = 0x0020,
PreferQuality = 0x0040,
PreferAntialias = 0x0080,
NoAntialias = 0x0100
};
enum Weight {
Light = 25,
Normal = 50,
DemiBold = 63,
Bold = 75,
Black = 87
};
QFont();
QFont( const QString &family, int pointSize = 12, int weight = Normal,
bool italic = FALSE );
QFont( const QFont & );
~QFont();
QString family() const;
void setFamily( const QString &);
int pointSize() const;
float pointSizeFloat() const;
void setPointSize( int );
void setPointSizeFloat( float );
int pixelSize() const;
void setPixelSize( int );
void setPixelSizeFloat( float );
int weight() const;
void setWeight( int );
bool bold() const;
void setBold( bool );
bool italic() const;
void setItalic( bool );
bool underline() const;
void setUnderline( bool );
bool strikeOut() const;
void setStrikeOut( bool );
bool fixedPitch() const;
void setFixedPitch( bool );
StyleHint styleHint() const;
StyleStrategy styleStrategy() const;
void setStyleHint( StyleHint, StyleStrategy = PreferDefault );
void setStyleStrategy( StyleStrategy s );
bool rawMode() const;
void setRawMode( bool );
bool exactMatch() const;
QFont &operator=( const QFont & );
bool operator==( const QFont & ) const;
bool operator!=( const QFont & ) const;
bool isCopyOf( const QFont & ) const;
Qt::HANDLE handle() const;
void setRawName( const QString & );
QString rawName() const;
QString key() const;
QString toString() const;
bool fromString(const QString &);
static QString substitute(const QString &);
static QStringList substitutes(const QString &);
static QStringList substitutions();
static void insertSubstitution(const QString&, const QString &);
static void insertSubstitutions(const QString&, const QStringList &);
static void removeSubstitution(const QString &);
static void initialize();
static void cleanup();
static void cacheStatistics();
enum Script {
Latin,
Greek,
Cyrillic,
Armenian,
Georgian,
Runic,
Ogham,
SpacingModifiers,
CombiningMarks,
Hebrew,
Arabic,
Syriac,
Thaana,
Devanagari,
Bengali,
Gurmukhi,
Gujarati,
Oriya,
Tamil,
Telugu,
Kannada,
Malayalam,
Sinhala,
Thai,
Lao,
Tibetan,
Myanmar,
Khmer,
Han,
Hiragana,
Katakana,
Hangul,
Bopomofo,
Yi,
Ethiopic,
Cherokee,
CanadianAboriginal,
Mongolian,
CurrencySymbols,
LetterlikeSymbols,
NumberForms,
MathematicalOperators,
TechnicalSymbols,
GeometricSymbols,
MiscellaneousSymbols,
EnclosedAndSquare,
Braille,
Unicode,
NScripts,
UnknownScript = NScripts,
NoScript,
HanX11,
LatinBasic = Latin,
LatinExtendedA_2 = HanX11 + 1,
LatinExtendedA_3,
LatinExtendedA_4,
LatinExtendedA_14,
LatinExtendedA_15,
KatakanaHalfWidth,
LastPrivateScript
};
QString defaultFamily() const;
QString lastResortFamily() const;
QString lastResortFont() const;
static QFont defaultFont();
static void setDefaultFont( const QFont & );
protected:
bool dirty() const;
int deciPointSize() const;
private:
QFont( QFontPrivate *, bool deep = TRUE );
QFont( QFontPrivate *, QPaintDevice *pd );
void detach();
# 296 "kernel/qfont.h"
void x11SetScreen( int screen = -1 );
int x11Screen() const;
friend class QFontMetrics;
friend class QFontInfo;
friend class QPainter;
friend class QPSPrinterFont;
friend class QWidget;
friend class QTextFormatCollection;
friend QDataStream &operator<<( QDataStream &, const QFont & );
friend QDataStream &operator>>( QDataStream &, QFont & );
QFontPrivate *d;
};
inline bool QFont::bold() const
{ return weight() > Normal; }
inline void QFont::setBold( bool enable )
{ setWeight( enable ? Bold : Normal ); }
# 331 "kernel/qfont.h"
QDataStream &operator<<( QDataStream &, const QFont & );
QDataStream &operator>>( QDataStream &, QFont & );
# 47 "kernel/qwidget.h" 2
# 1 "kernel/qfontmetrics.h" 1
# 46 "kernel/qfontmetrics.h"
class QFontStruct;
class QTextCodec;
class QTextParag;
class QFontMetrics
{
public:
QFontMetrics( const QFont & );
QFontMetrics( const QFontMetrics & );
~QFontMetrics();
QFontMetrics &operator=( const QFontMetrics & );
int ascent() const;
int descent() const;
int height() const;
int leading() const;
int lineSpacing() const;
int minLeftBearing() const;
int minRightBearing() const;
int maxWidth() const;
bool inFont(QChar) const;
int leftBearing(QChar) const;
int rightBearing(QChar) const;
int width( const QString &, int len = -1 ) const;
int width( QChar ) const;
int width( char c ) const { return width( (QChar) c ); }
int charWidth( const QString &str, int pos ) const;
QRect boundingRect( const QString &, int len = -1 ) const;
QRect boundingRect( QChar ) const;
QRect boundingRect( int x, int y, int w, int h, int flags,
const QString& str, int len=-1, int tabstops=0,
int *tabarray=0, QTextParag **intern=0 ) const;
QSize size( int flags,
const QString& str, int len=-1, int tabstops=0,
int *tabarray=0, QTextParag **intern=0 ) const;
int underlinePos() const;
int strikeOutPos() const;
int lineWidth() const;
private:
QFontMetrics( const QPainter * );
static void reset( const QPainter * );
# 104 "kernel/qfontmetrics.h"
friend class QWidget;
friend class QPainter;
friend class QTextFormat;
QFontPrivate *d;
QPainter *painter;
int flags;
bool underlineFlag() const { return (flags & 0x1) != 0; }
bool strikeOutFlag() const { return (flags & 0x2) != 0; }
void setUnderlineFlag() { flags |= 0x1; }
void setStrikeOutFlag() { flags |= 0x2; }
};
# 48 "kernel/qwidget.h" 2
# 1 "kernel/qfontinfo.h" 1
# 46 "kernel/qfontinfo.h"
class QFontInfo
{
public:
QFontInfo( const QFont & );
QFontInfo( const QFontInfo & );
~QFontInfo();
QFontInfo &operator=( const QFontInfo & );
QString family() const;
int pixelSize() const;
int pointSize() const;
bool italic() const;
int weight() const;
bool bold() const;
bool underline() const;
bool strikeOut() const;
bool fixedPitch() const;
QFont::StyleHint styleHint() const;
bool rawMode() const;
bool exactMatch() const;
private:
QFontInfo( const QPainter * );
static void reset( const QPainter * );
QFontPrivate *d;
QPainter *painter;
int flags;
bool underlineFlag() const { return (flags & 0x1) != 0; }
bool strikeOutFlag() const { return (flags & 0x2) != 0; }
bool exactMatchFlag() const { return (flags & 0x4) != 0; }
void setUnderlineFlag() { flags |= 0x1; }
void setStrikeOutFlag() { flags |= 0x2; }
void setExactMatchFlag() { flags |= 0x4; }
friend class QWidget;
friend class QPainter;
};
inline bool QFontInfo::bold() const
{ return weight() > QFont::Normal; }
# 49 "kernel/qwidget.h" 2
# 1 "kernel/qsizepolicy.h" 1
# 42 "kernel/qsizepolicy.h"
# 1 "../include/qglobal.h" 1
# 43 "kernel/qsizepolicy.h" 2
class QSizePolicy
{
private:
enum { HSize = 6, HMask = 0x3f, VMask = HMask << HSize,
MayGrow = 1, ExpMask = 2, MayShrink = 4 };
public:
enum SizeType { Fixed = 0,
Minimum = MayGrow,
Maximum = MayShrink,
Preferred = MayGrow | MayShrink,
MinimumExpanding = MayGrow | ExpMask,
Expanding = MayGrow | MayShrink | ExpMask,
Ignored = ExpMask };
enum ExpandData { NoDirection = 0,
Horizontally = 1,
Vertically = 2,
Horizontal = Horizontally,
Vertical = Vertically,
BothDirections = Horizontally | Vertically };
QSizePolicy() : data( 0 ) { }
QSizePolicy( SizeType hor, SizeType ver, bool hfw = FALSE )
: data( hor | (ver<<HSize) | (hfw ? (Q_UINT32)(1<<2*HSize) : 0) ) { }
QSizePolicy( SizeType hor, SizeType ver, uchar hors, uchar vers, bool hfw = FALSE );
SizeType horData() const { return (SizeType)( data & HMask ); }
SizeType verData() const { return (SizeType)( (data & VMask) >> HSize ); }
bool mayShrinkHorizontally() const { return horData() & MayShrink || horData() == Ignored; }
bool mayShrinkVertically() const { return verData() & MayShrink || verData() == Ignored; }
bool mayGrowHorizontally() const { return horData() & MayGrow || horData() == Ignored; }
bool mayGrowVertically() const { return verData() & MayGrow || verData() == Ignored; }
ExpandData expanding() const
{
return (ExpandData)( (int)(verData() & ExpMask ? Vertically : 0) |
(int)(horData() & ExpMask ? Horizontally : 0) );
}
void setHorData( SizeType d ) { data = (Q_UINT32)(data & ~HMask) | d; }
void setVerData( SizeType d ) { data = (Q_UINT32)(data & ~(HMask << HSize)) |
(d << HSize); }
void setHeightForWidth( bool b ) { data = b ? (Q_UINT32)( data | ( 1 << 2*HSize ) )
: (Q_UINT32)( data & ~( 1 << 2*HSize ) ); }
bool hasHeightForWidth() const { return data & ( 1 << 2*HSize ); }
bool operator==( const QSizePolicy& s ) const { return data == s.data; }
bool operator!=( const QSizePolicy& s ) const { return data != s.data; }
uint horStretch() const { return data >> 24; }
uint verStretch() const { return (data >> 16) & 0xff; }
void setHorStretch( uchar sf ) { data = (data&0x00ffffff) | (uint(sf)<<24); }
void setVerStretch( uchar sf ) { data = (data&0xff00ffff) | (uint(sf)<<16); }
inline void transpose();
private:
QSizePolicy( int i ) : data( (Q_UINT32)i ) { }
Q_UINT32 data;
};
inline QSizePolicy::QSizePolicy( SizeType hor, SizeType ver, uchar hors, uchar vers, bool hfw )
: data( hor | (ver<<HSize) | (hfw ? (Q_UINT32)(1<<2*HSize) : 0) ) {
setHorStretch( hors );
setVerStretch( vers );
}
inline void QSizePolicy::transpose() {
*this = QSizePolicy( verData(), horData(), verStretch(), horStretch(),
hasHeightForWidth() );
}
# 50 "kernel/qwidget.h" 2
class QLayout;
struct QWExtra;
struct QTLWExtra;
class QFocusData;
class QCursor;
class QWSRegionManager;
class QStyle;
class QWidget : public QObject, public QPaintDevice
{
public: virtual QMetaObject *metaObject() const { return staticMetaObject(); } virtual const char *className() const; virtual void* qt_cast( const char* ); virtual bool qt_invoke( int, QUObject* ); virtual bool qt_emit( int, QUObject* ); virtual bool qt_property( int id, int f, QVariant* v); static bool qt_static_property( QObject* , int, int, QVariant* ); static QMetaObject* staticMetaObject(); QObject* qObject() { return (QObject*)this; } static QString tr( const char *, const char * = 0 ); static QString trUtf8( const char *, const char * = 0 ); private: static QMetaObject *metaObj;
public:
explicit QWidget( QWidget* parent=0, const char* name=0, WFlags f=0 );
~QWidget();
WId winId() const;
void setName( const char *name );
QStyle &style() const;
void setStyle( QStyle * );
QStyle* setStyle( const QString& );
bool isTopLevel() const;
bool isDialog() const;
bool isPopup() const;
bool isDesktop() const;
bool isModal() const;
bool isEnabled() const;
bool isEnabledTo(QWidget*) const;
bool isEnabledToTLW() const;
public :
virtual void setEnabled( bool );
void setDisabled( bool );
public:
QRect frameGeometry() const;
const QRect &geometry() const;
int x() const;
int y() const;
QPoint pos() const;
QSize frameSize() const;
QSize size() const;
int width() const;
int height() const;
QRect rect() const;
QRect childrenRect() const;
QRegion childrenRegion() const;
QSize minimumSize() const;
QSize maximumSize() const;
int minimumWidth() const;
int minimumHeight() const;
int maximumWidth() const;
int maximumHeight() const;
void setMinimumSize( const QSize & );
virtual void setMinimumSize( int minw, int minh );
void setMaximumSize( const QSize & );
virtual void setMaximumSize( int maxw, int maxh );
void setMinimumWidth( int minw );
void setMinimumHeight( int minh );
void setMaximumWidth( int maxw );
void setMaximumHeight( int maxh );
QSize sizeIncrement() const;
void setSizeIncrement( const QSize & );
virtual void setSizeIncrement( int w, int h );
QSize baseSize() const;
void setBaseSize( const QSize & );
void setBaseSize( int basew, int baseh );
void setFixedSize( const QSize & );
void setFixedSize( int w, int h );
void setFixedWidth( int w );
void setFixedHeight( int h );
QPoint mapToGlobal( const QPoint & ) const;
QPoint mapFromGlobal( const QPoint & ) const;
QPoint mapToParent( const QPoint & ) const;
QPoint mapFromParent( const QPoint & ) const;
QPoint mapTo( QWidget *, const QPoint & ) const;
QPoint mapFrom( QWidget *, const QPoint & ) const;
QWidget *topLevelWidget() const;
BackgroundMode backgroundMode() const;
virtual void setBackgroundMode( BackgroundMode );
void setBackgroundMode( BackgroundMode, BackgroundMode );
const QColor & foregroundColor() const;
const QColor & eraseColor() const;
virtual void setEraseColor( const QColor & );
const QPixmap * erasePixmap() const;
virtual void setErasePixmap( const QPixmap & );
const QColorGroup & colorGroup() const;
const QPalette & palette() const;
bool ownPalette() const;
virtual void setPalette( const QPalette & );
void unsetPalette();
const QColor & paletteForegroundColor() const;
void setPaletteForegroundColor( const QColor & );
const QColor & paletteBackgroundColor() const;
virtual void setPaletteBackgroundColor( const QColor & );
const QPixmap * paletteBackgroundPixmap() const;
virtual void setPaletteBackgroundPixmap( const QPixmap & );
const QBrush& backgroundBrush() const;
QFont font() const;
bool ownFont() const;
virtual void setFont( const QFont & );
void unsetFont();
QFontMetrics fontMetrics() const;
QFontInfo fontInfo() const;
const QCursor &cursor() const;
bool ownCursor() const;
virtual void setCursor( const QCursor & );
virtual void unsetCursor();
QString caption() const;
const QPixmap *icon() const;
QString iconText() const;
bool hasMouseTracking() const;
bool hasMouse() const;
virtual void setMask( const QBitmap & );
virtual void setMask( const QRegion & );
void clearMask();
const QColor & backgroundColor() const;
virtual void setBackgroundColor( const QColor & );
const QPixmap * backgroundPixmap() const;
virtual void setBackgroundPixmap( const QPixmap & );
public :
virtual void setCaption( const QString &);
virtual void setIcon( const QPixmap & );
virtual void setIconText( const QString &);
virtual void setMouseTracking( bool enable );
virtual void setFocus();
void clearFocus();
public:
enum FocusPolicy {
NoFocus = 0,
TabFocus = 0x1,
ClickFocus = 0x2,
StrongFocus = 0x3,
WheelFocus = 0x7
};
bool isActiveWindow() const;
virtual void setActiveWindow();
bool isFocusEnabled() const;
FocusPolicy focusPolicy() const;
virtual void setFocusPolicy( FocusPolicy );
bool hasFocus() const;
static void setTabOrder( QWidget *, QWidget * );
virtual void setFocusProxy( QWidget * );
QWidget * focusProxy() const;
void grabMouse();
void grabMouse( const QCursor & );
void releaseMouse();
void grabKeyboard();
void releaseKeyboard();
static QWidget * mouseGrabber();
static QWidget * keyboardGrabber();
bool isUpdatesEnabled() const;
public :
virtual void setUpdatesEnabled( bool enable );
void update();
void update( int x, int y, int w, int h );
void update( const QRect& );
void repaint();
void repaint( bool erase );
void repaint( int x, int y, int w, int h, bool erase=TRUE );
void repaint( const QRect &, bool erase = TRUE );
void repaint( const QRegion &, bool erase = TRUE );
virtual void show();
virtual void hide();
void setShown( bool show );
void setHidden( bool hide );
void iconify() { showMinimized(); }
virtual void showMinimized();
virtual void showMaximized();
void showFullScreen();
virtual void showNormal();
virtual void polish();
void constPolish() const;
bool close();
void raise();
void lower();
void stackUnder( QWidget* );
virtual void move( int x, int y );
void move( const QPoint & );
virtual void resize( int w, int h );
void resize( const QSize & );
virtual void setGeometry( int x, int y, int w, int h );
virtual void setGeometry( const QRect & );
public:
virtual bool close( bool alsoDelete );
bool isVisible() const;
bool isVisibleTo(QWidget*) const;
bool isVisibleToTLW() const;
QRect visibleRect() const;
bool isHidden() const;
bool isShown() const;
bool isMinimized() const;
bool isMaximized() const;
bool isFullScreen() const;
virtual QSize sizeHint() const;
virtual QSize minimumSizeHint() const;
virtual QSizePolicy sizePolicy() const;
virtual void setSizePolicy( QSizePolicy );
void setSizePolicy( QSizePolicy::SizeType hor, QSizePolicy::SizeType ver, bool hfw = FALSE );
virtual int heightForWidth(int) const;
virtual void adjustSize();
QLayout * layout() const { return lay_out; }
void updateGeometry();
virtual void reparent( QWidget *parent, WFlags, const QPoint &,
bool showIt=FALSE );
void reparent( QWidget *parent, const QPoint &,
bool showIt=FALSE );
void recreate( QWidget *parent, WFlags f, const QPoint & p,
bool showIt=FALSE ) { reparent(parent,f,p,showIt); }
void erase();
void erase( int x, int y, int w, int h );
void erase( const QRect & );
void erase( const QRegion & );
void scroll( int dx, int dy );
void scroll( int dx, int dy, const QRect& );
void drawText( int x, int y, const QString &);
void drawText( const QPoint &, const QString &);
QWidget * focusWidget() const;
QRect microFocusHint() const;
bool acceptDrops() const;
virtual void setAcceptDrops( bool on );
virtual void setAutoMask(bool);
bool autoMask() const;
enum BackgroundOrigin { WidgetOrigin, ParentOrigin, WindowOrigin, AncestorOrigin };
virtual void setBackgroundOrigin( BackgroundOrigin );
BackgroundOrigin backgroundOrigin() const;
QPoint backgroundOffset() const;
virtual bool customWhatsThis() const;
QWidget * parentWidget( bool sameWindow = FALSE ) const;
WState testWState( WState s ) const;
WFlags testWFlags( WFlags f ) const;
static QWidget * find( WId );
static QWidgetMapper *wmapper();
QWidget *childAt( int x, int y, bool includeThis = FALSE ) const;
QWidget *childAt( const QPoint &, bool includeThis = FALSE ) const;
# 455 "kernel/qwidget.h"
protected:
bool event( QEvent * );
virtual void mousePressEvent( QMouseEvent * );
virtual void mouseReleaseEvent( QMouseEvent * );
virtual void mouseDoubleClickEvent( QMouseEvent * );
virtual void mouseMoveEvent( QMouseEvent * );
virtual void wheelEvent( QWheelEvent * );
virtual void keyPressEvent( QKeyEvent * );
virtual void keyReleaseEvent( QKeyEvent * );
virtual void focusInEvent( QFocusEvent * );
virtual void focusOutEvent( QFocusEvent * );
virtual void enterEvent( QEvent * );
virtual void leaveEvent( QEvent * );
virtual void paintEvent( QPaintEvent * );
virtual void moveEvent( QMoveEvent * );
virtual void resizeEvent( QResizeEvent * );
virtual void closeEvent( QCloseEvent * );
virtual void contextMenuEvent( QContextMenuEvent * );
virtual void imStartEvent( QIMEvent * );
virtual void imComposeEvent( QIMEvent * );
virtual void imEndEvent( QIMEvent * );
virtual void tabletEvent( QTabletEvent * );
virtual void dragEnterEvent( QDragEnterEvent * );
virtual void dragMoveEvent( QDragMoveEvent * );
virtual void dragLeaveEvent( QDragLeaveEvent * );
virtual void dropEvent( QDropEvent * );
virtual void showEvent( QShowEvent * );
virtual void hideEvent( QHideEvent * );
# 498 "kernel/qwidget.h"
virtual bool x11Event( XEvent * );
virtual void updateMask();
virtual void styleChange( QStyle& );
virtual void enabledChange( bool oldEnabled );
virtual void paletteChange( const QPalette & );
virtual void fontChange( const QFont & );
virtual void windowActivationChange( bool oldActive );
int metric( int ) const;
void resetInputContext();
virtual void create( WId = 0, bool initializeWindow = TRUE,
bool destroyOldWindow = TRUE );
virtual void destroy( bool destroyWindow = TRUE,
bool destroySubWindows = TRUE );
uint getWState() const;
virtual void setWState( uint );
void clearWState( uint n );
WFlags getWFlags() const;
virtual void setWFlags( WFlags );
void clearWFlags( WFlags n );
virtual bool focusNextPrevChild( bool next );
QWExtra *extraData();
QTLWExtra *topData();
QFocusData *focusData();
virtual void setKeyCompression(bool);
virtual void setMicroFocusHint(int x, int y, int w, int h, bool text=TRUE, QFont *f = 0);
# 551 "kernel/qwidget.h"
private :
void focusProxyDestroyed();
private:
void setFontSys( QFont *f = 0 );
void createInputContext();
void destroyInputContext();
void focusInputContext();
void checkChildrenDnd();
# 580 "kernel/qwidget.h"
void setLayout( QLayout *l );
void setWinId( WId );
void showWindow();
void hideWindow();
void showChildren( bool spontaneous );
void hideChildren( bool spontaneous );
void reparentSys( QWidget *parent, WFlags, const QPoint &, bool showIt);
void createTLExtra();
void createExtra();
void deleteExtra();
void createSysExtra();
void deleteSysExtra();
void createTLSysExtra();
void deleteTLSysExtra();
void deactivateWidgetCleanup();
void internalSetGeometry( int, int, int, int, bool );
void reparentFocusWidgets( QWidget * );
QFocusData *focusData( bool create );
void setBackgroundFromMode();
void setBackgroundColorDirect( const QColor & );
void setBackgroundPixmapDirect( const QPixmap & );
void setBackgroundModeDirect( BackgroundMode );
void setBackgroundEmpty();
void updateFrameStrut() const;
void setBackgroundX11Relative();
WId winid;
uint widget_state;
uint widget_flags;
uint focus_policy : 4;
uint own_font :1;
uint own_palette :1;
uint sizehint_forced :1;
uint is_closing :1;
uint in_show : 1;
uint in_show_maximized : 1;
uint fstrut_dirty : 1;
QRect crect;
QColor bg_col;
QPalette pal;
QFont fnt;
QLayout *lay_out;
QWExtra *extra;
# 660 "kernel/qwidget.h"
static int instanceCounter;
static int maxInstances;
static void createMapper();
static void destroyMapper();
static QWidgetList *wList();
static QWidgetList *tlwList();
static QWidgetMapper *mapper;
friend class QApplication;
friend class QBaseApplication;
friend class QPainter;
friend class QFontMetrics;
friend class QFontInfo;
friend class QETWidget;
friend class QLayout;
private:
QWidget( const QWidget & );
QWidget &operator=( const QWidget & );
public:
void setPalette( const QPalette &p, bool ) { setPalette( p ); }
void setFont( const QFont &f, bool ) { setFont( f ); }
};
inline Qt::WState QWidget::testWState( WState s ) const
{ return (widget_state & s); }
inline Qt::WFlags QWidget::testWFlags( WFlags f ) const
{ return (widget_flags & f); }
inline WId QWidget::winId() const
{ return winid; }
inline bool QWidget::isTopLevel() const
{ return testWFlags(WType_TopLevel); }
inline bool QWidget::isDialog() const
{ return testWFlags(WType_Dialog); }
inline bool QWidget::isPopup() const
{ return testWFlags(WType_Popup); }
inline bool QWidget::isDesktop() const
{ return testWFlags(WType_Desktop); }
inline bool QWidget::isEnabled() const
{ return !testWState(WState_Disabled); }
inline bool QWidget::isModal() const
{ return testWFlags(WShowModal); }
inline bool QWidget::isEnabledToTLW() const
{ return isEnabled(); }
inline const QRect &QWidget::geometry() const
{ return crect; }
inline QSize QWidget::size() const
{ return crect.size(); }
inline int QWidget::width() const
{ return crect.width(); }
inline int QWidget::height() const
{ return crect.height(); }
inline QRect QWidget::rect() const
{ return QRect(0,0,crect.width(),crect.height()); }
inline int QWidget::minimumWidth() const
{ return minimumSize().width(); }
inline int QWidget::minimumHeight() const
{ return minimumSize().height(); }
inline int QWidget::maximumWidth() const
{ return maximumSize().width(); }
inline int QWidget::maximumHeight() const
{ return maximumSize().height(); }
inline void QWidget::setMinimumSize( const QSize &s )
{ setMinimumSize(s.width(),s.height()); }
inline void QWidget::setMaximumSize( const QSize &s )
{ setMaximumSize(s.width(),s.height()); }
inline void QWidget::setSizeIncrement( const QSize &s )
{ setSizeIncrement(s.width(),s.height()); }
inline void QWidget::setBaseSize( const QSize &s )
{ setBaseSize(s.width(),s.height()); }
inline const QColor &QWidget::eraseColor() const
{ return bg_col; }
inline const QPalette &QWidget::palette() const
{ return pal; }
inline QFont QWidget::font() const
{ return fnt; }
inline QFontMetrics QWidget::fontMetrics() const
{ return QFontMetrics(font()); }
inline QFontInfo QWidget::fontInfo() const
{ return QFontInfo(font()); }
inline bool QWidget::hasMouseTracking() const
{ return testWState(WState_MouseTracking); }
inline bool QWidget::hasMouse() const
{ return testWState(WState_HasMouse); }
inline bool QWidget::isFocusEnabled() const
{ return (FocusPolicy)focus_policy != NoFocus; }
inline QWidget::FocusPolicy QWidget::focusPolicy() const
{ return (FocusPolicy)focus_policy; }
inline bool QWidget::isUpdatesEnabled() const
{ return !testWState(WState_BlockUpdates); }
inline void QWidget::update( const QRect &r )
{ update( r.x(), r.y(), r.width(), r.height() ); }
inline void QWidget::repaint()
{ repaint( 0, 0, crect.width(), crect.height(), TRUE ); }
inline void QWidget::repaint( bool erase )
{ repaint( 0, 0, crect.width(), crect.height(), erase ); }
inline void QWidget::repaint( const QRect &r, bool erase )
{ repaint( r.x(), r.y(), r.width(), r.height(), erase ); }
inline void QWidget::erase()
{ erase( 0, 0, crect.width(), crect.height() ); }
inline void QWidget::erase( const QRect &r )
{ erase( r.x(), r.y(), r.width(), r.height() ); }
inline bool QWidget::close()
{ return close( FALSE ); }
inline bool QWidget::isVisible() const
{ return testWState(WState_Visible); }
inline bool QWidget::isVisibleToTLW() const
{ return isVisible(); }
inline bool QWidget::isHidden() const
{ return testWState(WState_ForceHide); }
inline bool QWidget::isShown() const
{ return !testWState(WState_ForceHide); }
inline void QWidget::move( const QPoint &p )
{ move( p.x(), p.y() ); }
inline void QWidget::resize( const QSize &s )
{ resize( s.width(), s.height()); }
inline void QWidget::setGeometry( const QRect &r )
{ setGeometry( r.left(), r.top(), r.width(), r.height() ); }
inline void QWidget::drawText( const QPoint &p, const QString &s )
{ drawText( p.x(), p.y(), s ); }
inline QWidget *QWidget::parentWidget( bool sameWindow ) const
{
if ( sameWindow )
return isTopLevel() ? 0 : (QWidget *)QObject::parent();
return (QWidget *)QObject::parent();
}
inline QWidgetMapper *QWidget::wmapper()
{ return mapper; }
inline uint QWidget::getWState() const
{ return widget_state; }
inline void QWidget::setWState( uint f )
{ widget_state |= f; }
inline void QWidget::clearWState( uint f )
{ widget_state &= ~f; }
inline Qt::WFlags QWidget::getWFlags() const
{ return widget_flags; }
inline void QWidget::setWFlags( WFlags f )
{ widget_flags |= f; }
inline void QWidget::clearWFlags( WFlags f )
{ widget_flags &= ~f; }
inline void QWidget::constPolish() const
{
if ( !testWState(WState_Polished) ) {
QWidget* that = (QWidget*) this;
that->polish();
that->setWState(WState_Polished);
}
}
inline bool QWidget::ownCursor() const
{
return testWState( WState_OwnCursor );
}
inline bool QWidget::ownFont() const
{
return own_font;
}
inline bool QWidget::ownPalette() const
{
return own_palette;
}
inline void QWidget::setSizePolicy( QSizePolicy::SizeType hor, QSizePolicy::SizeType ver, bool hfw )
{
setSizePolicy( QSizePolicy( hor, ver, hfw) );
}
class QFocusData;
class QWSManager;
struct QTLWExtra {
QString caption;
QString iconText;
QPixmap *icon;
QFocusData *focusData;
short incw, inch;
ulong fleft, fright, ftop, fbottom;
uint iconic: 1;
uint fullscreen : 1;
uint showMode: 2;
uint savedFlags;
short basew, baseh;
WId parentWinId;
uint embedded : 1;
uint reserved: 2;
uint dnd : 1;
uint uspos : 1;
uint ussize : 1;
void *xic;
# 942 "kernel/qwidget.h"
QRect normalGeometry;
};
struct QWExtra {
Q_INT16 minw, minh;
Q_INT16 maxw, maxh;
QPixmap *bg_pix;
QWidget *focus_proxy;
QCursor *curs;
QTLWExtra *topextra;
WId xDndProxy;
# 976 "kernel/qwidget.h"
uint bg_origin : 2;
uint children_use_dnd : 1;
char bg_mode;
char bg_mode_visual;
QStyle* style;
QRect micro_focus_hint;
QSizePolicy size_policy;
};
# 43 "kernel/qdesktopwidget.h" 2
class QDesktopWidgetPrivate;
class QDesktopWidget : public QWidget
{
public: virtual QMetaObject *metaObject() const { return staticMetaObject(); } virtual const char *className() const; virtual void* qt_cast( const char* ); virtual bool qt_invoke( int, QUObject* ); virtual bool qt_emit( int, QUObject* ); virtual bool qt_property( int id, int f, QVariant* v); static bool qt_static_property( QObject* , int, int, QVariant* ); static QMetaObject* staticMetaObject(); QObject* qObject() { return (QObject*)this; } static QString tr( const char *, const char * = 0 ); static QString trUtf8( const char *, const char * = 0 ); private: static QMetaObject *metaObj;
public:
QDesktopWidget();
~QDesktopWidget();
bool isVirtualDesktop() const;
int numScreens() const;
int primaryScreen() const;
int screenNumber( QWidget *widget = 0 ) const;
int screenNumber( const QPoint & ) const;
QWidget *screen( int screen = -1 );
const QRect& screenGeometry( int screen = -1 ) const;
const QRect& screenGeometry( QWidget *widget ) const
{ return screenGeometry( screenNumber( widget ) ); }
const QRect& screenGeometry( const QPoint &point ) const
{ return screenGeometry( screenNumber( point ) ); }
const QRect& availableGeometry( int screen = -1 ) const;
const QRect& availableGeometry( QWidget *widget ) const
{ return availableGeometry( screenNumber( widget ) ); }
const QRect& availableGeometry( const QPoint &point ) const
{ return availableGeometry( screenNumber( point ) ); }
void insertChild( QObject * );
protected:
void resizeEvent( QResizeEvent *e );
private:
QDesktopWidgetPrivate *d;
QDesktopWidget( const QDesktopWidget & );
QDesktopWidget &operator=( const QDesktopWidget & );
};
# 43 "kernel/qapplication.h" 2
# 1 "../include/qasciidict.h" 1
# 42 "../include/qasciidict.h"
# 1 "../include/qgdict.h" 1
# 46 "../include/qgdict.h"
class QGDictIterator;
class QGDItList;
class QBaseBucket
{
public:
QPtrCollection::Item getData() { return data; }
QPtrCollection::Item setData( QPtrCollection::Item d ) { return data = d; }
QBaseBucket *getNext() { return next; }
void setNext( QBaseBucket *n) { next = n; }
protected:
QBaseBucket( QPtrCollection::Item d, QBaseBucket *n ) : data(d), next(n) {}
QPtrCollection::Item data;
QBaseBucket *next;
};
class QStringBucket : public QBaseBucket
{
public:
QStringBucket( const QString &k, QPtrCollection::Item d, QBaseBucket *n )
: QBaseBucket(d,n), key(k) {}
const QString &getKey() const { return key; }
private:
QString key;
};
class QAsciiBucket : public QBaseBucket
{
public:
QAsciiBucket( const char *k, QPtrCollection::Item d, QBaseBucket *n )
: QBaseBucket(d,n), key(k) {}
const char *getKey() const { return key; }
private:
const char *key;
};
class QIntBucket : public QBaseBucket
{
public:
QIntBucket( long k, QPtrCollection::Item d, QBaseBucket *n )
: QBaseBucket(d,n), key(k) {}
long getKey() const { return key; }
private:
long key;
};
class QPtrBucket : public QBaseBucket
{
public:
QPtrBucket( void *k, QPtrCollection::Item d, QBaseBucket *n )
: QBaseBucket(d,n), key(k) {}
void *getKey() const { return key; }
private:
void *key;
};
class QGDict : public QPtrCollection
{
public:
uint count() const { return numItems; }
uint size() const { return vlen; }
QPtrCollection::Item look_string( const QString& key, QPtrCollection::Item,
int );
QPtrCollection::Item look_ascii( const char *key, QPtrCollection::Item, int );
QPtrCollection::Item look_int( long key, QPtrCollection::Item, int );
QPtrCollection::Item look_ptr( void *key, QPtrCollection::Item, int );
QDataStream &read( QDataStream & );
QDataStream &write( QDataStream & ) const;
protected:
enum KeyType { StringKey, AsciiKey, IntKey, PtrKey };
QGDict( uint len, KeyType kt, bool cs, bool ck );
QGDict( const QGDict & );
~QGDict();
QGDict &operator=( const QGDict & );
bool remove_string( const QString &key, QPtrCollection::Item item=0 );
bool remove_ascii( const char *key, QPtrCollection::Item item=0 );
bool remove_int( long key, QPtrCollection::Item item=0 );
bool remove_ptr( void *key, QPtrCollection::Item item=0 );
QPtrCollection::Item take_string( const QString &key );
QPtrCollection::Item take_ascii( const char *key );
QPtrCollection::Item take_int( long key );
QPtrCollection::Item take_ptr( void *key );
void clear();
void resize( uint );
int hashKeyString( const QString & );
int hashKeyAscii( const char * );
void statistics() const;
virtual QDataStream &read( QDataStream &, QPtrCollection::Item & );
virtual QDataStream &write( QDataStream &, QPtrCollection::Item ) const;
private:
QBaseBucket **vec;
uint vlen;
uint numItems;
uint keytype : 2;
uint cases : 1;
uint copyk : 1;
QGDItList *iterators;
void unlink_common( int, QBaseBucket *, QBaseBucket * );
QStringBucket *unlink_string( const QString &,
QPtrCollection::Item item = 0 );
QAsciiBucket *unlink_ascii( const char *, QPtrCollection::Item item = 0 );
QIntBucket *unlink_int( long, QPtrCollection::Item item = 0 );
QPtrBucket *unlink_ptr( void *, QPtrCollection::Item item = 0 );
void init( uint, KeyType, bool, bool );
friend class QGDictIterator;
};
class QGDictIterator
{
friend class QGDict;
public:
QGDictIterator( const QGDict & );
QGDictIterator( const QGDictIterator & );
QGDictIterator &operator=( const QGDictIterator & );
~QGDictIterator();
QPtrCollection::Item toFirst();
QPtrCollection::Item get() const;
QString getKeyString() const;
const char *getKeyAscii() const;
long getKeyInt() const;
void *getKeyPtr() const;
QPtrCollection::Item operator()();
QPtrCollection::Item operator++();
QPtrCollection::Item operator+=(uint);
protected:
QGDict *dict;
private:
QBaseBucket *curNode;
uint curIndex;
};
inline QPtrCollection::Item QGDictIterator::get() const
{
return curNode ? curNode->getData() : 0;
}
inline QString QGDictIterator::getKeyString() const
{
return curNode ? ((QStringBucket*)curNode)->getKey() : QString::null;
}
inline const char *QGDictIterator::getKeyAscii() const
{
return curNode ? ((QAsciiBucket*)curNode)->getKey() : 0;
}
inline long QGDictIterator::getKeyInt() const
{
return curNode ? ((QIntBucket*)curNode)->getKey() : 0;
}
inline void *QGDictIterator::getKeyPtr() const
{
return curNode ? ((QPtrBucket*)curNode)->getKey() : 0;
}
# 43 "../include/qasciidict.h" 2
template<class type>
class QAsciiDict
: public QGDict
{
public:
QAsciiDict(int size=17, bool caseSensitive=TRUE, bool copyKeys=TRUE )
: QGDict(size,AsciiKey,caseSensitive,copyKeys) {}
QAsciiDict( const QAsciiDict<type> &d ) : QGDict(d) {}
~QAsciiDict() { clear(); }
QAsciiDict<type> &operator=(const QAsciiDict<type> &d)
{ return (QAsciiDict<type>&)QGDict::operator=(d); }
uint count() const { return QGDict::count(); }
uint size() const { return QGDict::size(); }
bool isEmpty() const { return QGDict::count() == 0; }
void insert( const char *k, const type *d )
{ QGDict::look_ascii(k,(Item)d,1); }
void replace( const char *k, const type *d )
{ QGDict::look_ascii(k,(Item)d,2); }
bool remove( const char *k ) { return QGDict::remove_ascii(k); }
type *take( const char *k ) { return (type *)QGDict::take_ascii(k); }
type *find( const char *k ) const
{ return (type *)((QGDict*)this)->QGDict::look_ascii(k,0,0); }
type *operator[]( const char *k ) const
{ return (type *)((QGDict*)this)->QGDict::look_ascii(k,0,0); }
void clear() { QGDict::clear(); }
void resize( uint n ) { QGDict::resize(n); }
void statistics() const { QGDict::statistics(); }
private:
void deleteItem( Item d );
};
template<> inline void QAsciiDict<void>::deleteItem( QPtrCollection::Item )
{
}
template<class type> inline void QAsciiDict<type>::deleteItem( QPtrCollection::Item d )
{
if ( del_item ) delete (type *)d;
}
template<class type>
class QAsciiDictIterator : public QGDictIterator
{
public:
QAsciiDictIterator(const QAsciiDict<type> &d)
: QGDictIterator((QGDict &)d) {}
~QAsciiDictIterator() {}
uint count() const { return dict->count(); }
bool isEmpty() const { return dict->count() == 0; }
type *toFirst() { return (type *)QGDictIterator::toFirst(); }
operator type *() const { return (type *)QGDictIterator::get(); }
type *current() const { return (type *)QGDictIterator::get(); }
const char *currentKey() const { return QGDictIterator::getKeyAscii(); }
type *operator()() { return (type *)QGDictIterator::operator()(); }
type *operator++() { return (type *)QGDictIterator::operator++(); }
type *operator+=(uint j) { return (type *)QGDictIterator::operator+=(j);}
};
# 44 "kernel/qapplication.h" 2
# 1 "kernel/qtranslator.h" 1
# 49 "kernel/qtranslator.h"
class QTranslatorPrivate;
class QTranslatorMessage
{
public:
QTranslatorMessage();
QTranslatorMessage( const char * context,
const char * sourceText,
const char * comment,
const QString& translation = QString::null );
QTranslatorMessage( QDataStream & );
QTranslatorMessage( const QTranslatorMessage & m );
QTranslatorMessage & operator=( const QTranslatorMessage & m );
uint hash() const { return h; }
const char *context() const { return cx; }
const char *sourceText() const { return st; }
const char *comment() const { return cm; }
void setTranslation( const QString & translation ) { tn = translation; }
QString translation() const { return tn; }
enum Prefix { NoPrefix, Hash, HashContext, HashContextSourceText,
HashContextSourceTextComment };
void write( QDataStream & s, bool strip = FALSE,
Prefix prefix = HashContextSourceTextComment ) const;
Prefix commonPrefix( const QTranslatorMessage& ) const;
bool operator==( const QTranslatorMessage& m ) const;
bool operator!=( const QTranslatorMessage& m ) const
{ return !operator==( m ); }
bool operator<( const QTranslatorMessage& m ) const;
bool operator<=( const QTranslatorMessage& m ) const
{ return !m.operator<( *this ); }
bool operator>( const QTranslatorMessage& m ) const
{ return m.operator<( *this ); }
bool operator>=( const QTranslatorMessage& m ) const
{ return !operator<( m ); }
private:
uint h;
QCString cx;
QCString st;
QCString cm;
QString tn;
enum Tag { Tag_End = 1, Tag_SourceText16, Tag_Translation, Tag_Context16,
Tag_Hash, Tag_SourceText, Tag_Context, Tag_Comment,
Tag_Obsolete1 };
};
class QTranslator: public QObject
{
public: virtual QMetaObject *metaObject() const { return staticMetaObject(); } virtual const char *className() const; virtual void* qt_cast( const char* ); virtual bool qt_invoke( int, QUObject* ); virtual bool qt_emit( int, QUObject* ); virtual bool qt_property( int id, int f, QVariant* v); static bool qt_static_property( QObject* , int, int, QVariant* ); static QMetaObject* staticMetaObject(); QObject* qObject() { return (QObject*)this; } static QString tr( const char *, const char * = 0 ); static QString trUtf8( const char *, const char * = 0 ); private: static QMetaObject *metaObj;
public:
QTranslator( QObject * parent, const char * name = 0 );
~QTranslator();
QString find( const char *context, const char *sourceText, const char * comment = 0 ) const {
return findMessage( context, sourceText, comment ).translation();
}
virtual QTranslatorMessage findMessage( const char *, const char *,
const char * ) const;
bool load( const QString & filename,
const QString & directory = QString::null,
const QString & search_delimiters = QString::null,
const QString & suffix = QString::null );
bool load( const uchar *data, int len ) {
clear();
return do_load( data, len );
}
void clear();
enum SaveMode { Everything, Stripped };
bool save( const QString & filename, SaveMode mode = Everything );
void insert( const QTranslatorMessage& );
void insert( const char *context, const char *sourceText, const QString &translation ) {
insert( QTranslatorMessage(context, sourceText, "", translation) );
}
void remove( const QTranslatorMessage& );
void remove( const char *context, const char *sourceText ) {
remove( QTranslatorMessage(context, sourceText, "") );
}
bool contains( const char *, const char *, const char * comment = 0 ) const;
void squeeze( SaveMode = Everything );
void unsqueeze();
QValueList<QTranslatorMessage> messages() const;
bool isEmpty() const;
private:
QTranslator( const QTranslator & );
QTranslator &operator=( const QTranslator & );
bool do_load( const uchar *data, int len );
QTranslatorPrivate * d;
};
# 46 "kernel/qapplication.h" 2
class QSessionManager;
class QStyle;
class QTranslator;
class QEventLoop;
class QMutex;
class QApplication;
extern QApplication *qApp;
class QApplication : public QObject
{
public: virtual QMetaObject *metaObject() const { return staticMetaObject(); } virtual const char *className() const; virtual void* qt_cast( const char* ); virtual bool qt_invoke( int, QUObject* ); virtual bool qt_emit( int, QUObject* ); virtual bool qt_property( int id, int f, QVariant* v); static bool qt_static_property( QObject* , int, int, QVariant* ); static QMetaObject* staticMetaObject(); QObject* qObject() { return (QObject*)this; } static QString tr( const char *, const char * = 0 ); static QString trUtf8( const char *, const char * = 0 ); private: static QMetaObject *metaObj;
public:
QApplication( int &argc, char **argv);
QApplication( int &argc, char **argv, bool GUIenabled );
enum Type { Tty, GuiClient, GuiServer };
QApplication( int &argc, char **argv, Type );
QApplication( Display* dpy, HANDLE visual = 0, HANDLE cmap = 0 );
QApplication( Display *dpy, int argc, char **argv,
HANDLE visual = 0, HANDLE cmap= 0 );
virtual ~QApplication();
int argc() const;
char **argv() const;
Type type() const;
static QStyle &style();
static void setStyle( QStyle* );
static QStyle* setStyle( const QString& );
enum ColorMode { NormalColors, CustomColors };
static ColorMode colorMode();
static void setColorMode( QApplication::ColorMode );
enum ColorSpec { NormalColor=0, CustomColor=1, ManyColor=2 };
static int colorSpec();
static void setColorSpec( int );
static QCursor *overrideCursor();
static void setOverrideCursor( const QCursor &, bool replace=FALSE );
static void restoreOverrideCursor();
static bool hasGlobalMouseTracking();
static void setGlobalMouseTracking( bool enable );
static QPalette palette( const QWidget* = 0 );
static void setPalette( const QPalette &, bool informWidgets=FALSE,
const char* className = 0 );
static QFont font( const QWidget* = 0 );
static void setFont( const QFont &, bool informWidgets=FALSE,
const char* className = 0 );
static QFontMetrics fontMetrics();
QWidget *mainWidget() const;
virtual void setMainWidget( QWidget * );
virtual void polish( QWidget * );
static QWidgetList *allWidgets();
static QWidgetList *topLevelWidgets();
static QDesktopWidget *desktop();
static QWidget *activePopupWidget();
static QWidget *activeModalWidget();
static QClipboard *clipboard();
QWidget *focusWidget() const;
QWidget *activeWindow() const;
static QWidget *widgetAt( int x, int y, bool child=FALSE );
static QWidget *widgetAt( const QPoint &, bool child=FALSE );
static QEventLoop *eventLoop();
int exec();
void processEvents();
void processEvents( int maxtime );
void processOneEvent();
bool hasPendingEvents();
int enter_loop();
void exit_loop();
int loopLevel() const;
static void exit( int retcode=0 );
static bool sendEvent( QObject *receiver, QEvent *event );
static void postEvent( QObject *receiver, QEvent *event );
static void sendPostedEvents( QObject *receiver, int event_type );
static void sendPostedEvents();
static void removePostedEvents( QObject *receiver );
virtual bool notify( QObject *, QEvent * );
static bool startingUp();
static bool closingDown();
static void flushX();
static void flush();
static void syncX();
static void beep();
void setDefaultCodec( QTextCodec * );
QTextCodec* defaultCodec() const;
void installTranslator( QTranslator * );
void removeTranslator( QTranslator * );
enum Encoding { DefaultCodec, UnicodeUTF8 };
QString translate( const char * context,
const char * key,
const char * comment = 0,
Encoding encoding = DefaultCodec ) const;
static void setWinStyleHighlightColor( const QColor &c ) {
QPalette p( palette() );
p.setColor( QColorGroup::Highlight, c );
setPalette( p, TRUE);
}
static const QColor &winStyleHighlightColor() {
return palette().active().highlight();
}
static void setDesktopSettingsAware( bool );
static bool desktopSettingsAware();
static void setCursorFlashTime( int );
static int cursorFlashTime();
static void setDoubleClickInterval( int );
static int doubleClickInterval();
static void setWheelScrollLines( int );
static int wheelScrollLines();
static void setGlobalStrut( const QSize & );
static QSize globalStrut();
static void setLibraryPaths(const QStringList &);
static QStringList libraryPaths();
static void addLibraryPath(const QString &);
static void removeLibraryPath(const QString &);
static void setStartDragTime( int ms );
static int startDragTime();
static void setStartDragDistance( int l );
static int startDragDistance();
static void setReverseLayout( bool b );
static bool reverseLayout();
static int horizontalAlignment( int align );
static bool isEffectEnabled( Qt::UIEffect );
static void setEffectEnabled( Qt::UIEffect, bool enable = TRUE );
# 231 "kernel/qapplication.h"
virtual bool x11EventFilter( XEvent * );
virtual int x11ClientMessage( QWidget*, XEvent*, bool passive_only);
int x11ProcessEvent( XEvent* );
# 255 "kernel/qapplication.h"
bool isSessionRestored() const;
QString sessionId() const;
QString sessionKey() const;
virtual void commitData( QSessionManager& sm );
virtual void saveState( QSessionManager& sm );
static void create_xim();
static void close_xim();
static bool x11_apply_settings();
void wakeUpGuiThread();
void lock();
void unlock(bool wakeUpGui = TRUE);
bool locked();
bool tryLock();
protected:
void lastWindowClosed();
void aboutToQuit();
void guiThreadAwake();
public :
void quit();
void closeAllWindows();
protected:
bool event(QEvent *);
private:
void construct( int &argc, char **argv, Type );
void initialize( int, char ** );
void init_precmdline();
void process_cmdline( int* argcptr, char ** argv );
bool internalNotify( QObject *, QEvent * );
# 315 "kernel/qapplication.h"
static QMutex *qt_mutex;
int app_argc;
char **app_argv;
bool quit_now;
int quit_code;
static QStyle *app_style;
static int app_cspec;
static QPalette *app_pal;
static QFont *app_font;
static QCursor *app_cursor;
static QEventLoop* eventloop;
static int app_tracking;
static bool is_app_running;
static bool is_app_closing;
static bool app_exit_loop;
static int loop_level;
static QWidget *main_widget;
static QWidget *focus_widget;
static QWidget *active_window;
static bool obey_desktop_settings;
static int cursor_flash_time;
static int mouse_double_click_time;
static int wheel_scroll_lines;
static bool animate_ui;
static bool animate_menu;
static bool animate_tooltip;
static bool animate_combo;
static bool fade_menu;
static bool fade_tooltip;
static bool widgetCount;
QValueList<QTranslator*> *translators;
QSessionManager *session_manager;
QString session_id;
static QString* session_key;
bool is_session_restored;
static void x11_initialize_style();
static QSize app_strut;
static QStringList *app_libpaths;
static QAsciiDict<QPalette> *app_palettes;
static QAsciiDict<QFont> *app_fonts;
static QWidgetList *popupWidgets;
bool inPopupMode() const;
void closePopup( QWidget *popup );
void openPopup( QWidget *popup );
void setActiveWindow( QWidget* act );
static bool sendSpontaneousEvent( QObject *receiver, QEvent *event );
static void removePostedEvent( QEvent * );
friend class QWidget;
friend class QETWidget;
friend class QAccelManager;
friend class QEvent;
friend class QTranslator;
friend class QEventLoop;
friend void qt_ucm_initialize( QApplication * );
private:
QApplication( const QApplication & );
QApplication &operator=( const QApplication & );
};
inline int QApplication::argc() const
{
return app_argc;
}
inline char **QApplication::argv() const
{
return app_argv;
}
# 419 "kernel/qapplication.h"
inline QCursor *QApplication::overrideCursor()
{
return app_cursor;
}
inline bool QApplication::hasGlobalMouseTracking()
{
return app_tracking > 0;
}
inline QWidget *QApplication::mainWidget() const
{
return main_widget;
}
inline QWidget *QApplication::focusWidget() const
{
return focus_widget;
}
inline QWidget *QApplication::activeWindow() const
{
return active_window;
}
inline QWidget *QApplication::widgetAt( const QPoint &p, bool child )
{
return widgetAt( p.x(), p.y(), child );
}
inline bool QApplication::inPopupMode() const
{
return popupWidgets != 0;
}
inline bool QApplication::isSessionRestored() const
{
return is_session_restored;
}
inline QString QApplication::sessionId() const
{
return session_id;
}
inline QString QApplication::sessionKey() const
{
return session_key ? *session_key : QString::null;
}
inline QSize QApplication::globalStrut()
{
return app_strut;
}
inline bool QApplication::sendEvent( QObject *receiver, QEvent *event )
{ if ( event ) event->spont = FALSE; return qApp ? qApp->notify( receiver, event ) : FALSE; }
inline bool QApplication::sendSpontaneousEvent( QObject *receiver, QEvent *event )
{ if ( event ) event->spont = TRUE; return qApp ? qApp->notify( receiver, event ) : FALSE; }
# 494 "kernel/qapplication.h"
inline int QApplication::horizontalAlignment( int align )
{
align &= AlignHorizontal_Mask;
if ( align == AlignAuto ) {
if ( reverseLayout() )
align = AlignRight;
else
align = AlignLeft;
}
return align;
}
# 40 "kernel/qobject.cpp" 2
# 1 "kernel/qobjectlist.h" 1
# 53 "kernel/qobjectlist.h"
class QObjectList : public QPtrList<QObject>
{
public:
QObjectList() : QPtrList<QObject>() {}
QObjectList( const QObjectList &list ) : QPtrList<QObject>(list) {}
~QObjectList() { clear(); }
QObjectList &operator=(const QObjectList &list)
{ return (QObjectList&)QPtrList<QObject>::operator=(list); }
};
class QObjectListIterator : public QPtrListIterator<QObject>
{
public:
QObjectListIterator( const QObjectList &l )
: QPtrListIterator<QObject>( l ) { }
QObjectListIterator &operator=( const QObjectListIterator &i )
{ return (QObjectListIterator&)
QPtrListIterator<QObject>::operator=( i ); }
};
# 80 "kernel/qobjectlist.h"
class QObjectListIt : public QPtrListIterator<QObject>
{
public:
QObjectListIt( const QObjectList &l ) : QPtrListIterator<QObject>(l) {}
QObjectListIt &operator=(const QObjectListIt &i)
{ return (QObjectListIt&)QPtrListIterator<QObject>::operator=(i); }
};
# 42 "kernel/qobject.cpp" 2
# 1 "kernel/qsignalslotimp.h" 1
# 42 "kernel/qsignalslotimp.h"
# 1 "kernel/qconnection.h" 1
# 45 "kernel/qconnection.h"
class QConnection
{
public:
QConnection( const QObject *, int, const char *memberName, int memberType );
~QConnection() {}
bool isConnected() const { return obj != 0; }
QObject *object() const { return obj; }
int member() const { return mbr; }
const char *memberName() const { return mbr_name; }
int memberType() const { return mbr_type; }
int numArgs() const { return nargs; }
private:
QObject *obj;
int mbr;
const char *mbr_name;
int mbr_type;
int nargs;
private:
QConnection( const QConnection & );
QConnection &operator=( const QConnection & );
};
# 43 "kernel/qsignalslotimp.h" 2
# 1 "../include/qptrvector.h" 1
# 42 "../include/qptrvector.h"
# 1 "../include/qgvector.h" 1
# 46 "../include/qgvector.h"
class QGVector : public QPtrCollection
{
friend class QGList;
public:
QDataStream &read( QDataStream & );
QDataStream &write( QDataStream & ) const;
virtual int compareItems( Item, Item );
protected:
QGVector();
QGVector( uint size );
QGVector( const QGVector &v );
~QGVector();
QGVector &operator=( const QGVector &v );
bool operator==( const QGVector &v ) const;
Item *data() const { return vec; }
uint size() const { return len; }
uint count() const { return numItems; }
bool insert( uint index, Item );
bool remove( uint index );
Item take( uint index );
void clear();
bool resize( uint newsize );
bool fill( Item, int flen );
void sort();
int bsearch( Item ) const;
int findRef( Item, uint index ) const;
int find( Item, uint index ) const;
uint containsRef( Item ) const;
uint contains( Item ) const;
Item at( uint index ) const
{
if ( index >= len )
warningIndexRange( index );
return vec[index];
}
bool insertExpand( uint index, Item );
void toList( QGList * ) const;
virtual QDataStream &read( QDataStream &, Item & );
virtual QDataStream &write( QDataStream &, Item ) const;
private:
Item *vec;
uint len;
uint numItems;
static void warningIndexRange( uint );
};
QDataStream &operator>>( QDataStream &, QGVector & );
QDataStream &operator<<( QDataStream &, const QGVector & );
# 43 "../include/qptrvector.h" 2
template<class type>
class QPtrVector
: public QGVector
{
public:
QPtrVector() { }
QPtrVector( uint size ) : QGVector(size) { }
QPtrVector( const QPtrVector<type> &v ) : QGVector( v ) { }
~QPtrVector() { clear(); }
QPtrVector<type> &operator=(const QPtrVector<type> &v)
{ return (QPtrVector<type>&)QGVector::operator=(v); }
bool operator==( const QPtrVector<type> &v ) const { return QGVector::operator==(v); }
type **data() const { return (type **)QGVector::data(); }
uint size() const { return QGVector::size(); }
uint count() const { return QGVector::count(); }
bool isEmpty() const { return QGVector::count() == 0; }
bool isNull() const { return QGVector::size() == 0; }
bool resize( uint size ) { return QGVector::resize(size); }
bool insert( uint i, const type *d){ return QGVector::insert(i,(Item)d); }
bool remove( uint i ) { return QGVector::remove(i); }
type *take( uint i ) { return (type *)QGVector::take(i); }
void clear() { QGVector::clear(); }
bool fill( const type *d, int size=-1 )
{ return QGVector::fill((Item)d,size);}
void sort() { QGVector::sort(); }
int bsearch( const type *d ) const{ return QGVector::bsearch((Item)d); }
int findRef( const type *d, uint i=0 ) const
{ return QGVector::findRef((Item)d,i);}
int find( const type *d, uint i= 0 ) const
{ return QGVector::find((Item)d,i); }
uint containsRef( const type *d ) const
{ return QGVector::containsRef((Item)d); }
uint contains( const type *d ) const
{ return QGVector::contains((Item)d); }
type *operator[]( int i ) const { return (type *)QGVector::at(i); }
type *at( uint i ) const { return (type *)QGVector::at(i); }
void toList( QGList *list ) const { QGVector::toList(list); }
# 94 "../include/qptrvector.h"
private:
void deleteItem( Item d );
};
template<> inline void QPtrVector<void>::deleteItem( QPtrCollection::Item )
{
}
template<class type> inline void QPtrVector<type>::deleteItem( QPtrCollection::Item d )
{
if ( del_item ) delete (type *)d;
}
# 45 "kernel/qsignalslotimp.h" 2
# 54 "kernel/qsignalslotimp.h"
class QConnectionList : public QPtrList<QConnection>
{
public:
QConnectionList() : QPtrList<QConnection>() {}
QConnectionList( const QConnectionList &list ) : QPtrList<QConnection>(list) {}
~QConnectionList() { clear(); }
QConnectionList &operator=(const QConnectionList &list)
{ return (QConnectionList&)QPtrList<QConnection>::operator=(list); }
};
class QConnectionListIt : public QPtrListIterator<QConnection>
{
public:
QConnectionListIt( const QConnectionList &l ) : QPtrListIterator<QConnection>(l) {}
QConnectionListIt &operator=(const QConnectionListIt &i)
{ return (QConnectionListIt&)QPtrListIterator<QConnection>::operator=(i); }
};
# 79 "kernel/qsignalslotimp.h"
class QSignalVec : public QPtrVector<QConnectionList>
{
public:
QSignalVec(int size=17 )
: QPtrVector<QConnectionList>(size) {}
QSignalVec( const QSignalVec &dict )
: QPtrVector<QConnectionList>(dict) {}
~QSignalVec() { clear(); }
QSignalVec &operator=(const QSignalVec &dict)
{ return (QSignalVec&)QPtrVector<QConnectionList>::operator=(dict); }
QConnectionList* at( uint index ) const {
return index >= size()? 0 : QPtrVector<QConnectionList>::at(index);
}
bool insert( uint index, const QConnectionList* d ) {
if (index >= size() )
resize( 2*index + 1);
return QPtrVector<QConnectionList>::insert(index, d);
}
};
# 43 "kernel/qobject.cpp" 2
# 1 "../include/qregexp.h" 1
# 46 "../include/qregexp.h"
class QRegExpEngine;
struct QRegExpPrivate;
class QRegExp
{
public:
enum CaretMode { CaretAtZero, CaretAtOffset, CaretWontMatch };
QRegExp();
QRegExp( const QString& pattern, bool caseSensitive = TRUE,
bool wildcard = FALSE );
QRegExp( const QRegExp& rx );
~QRegExp();
QRegExp& operator=( const QRegExp& rx );
bool operator==( const QRegExp& rx ) const;
bool operator!=( const QRegExp& rx ) const { return !operator==( rx ); }
bool isEmpty() const;
bool isValid() const;
QString pattern() const;
void setPattern( const QString& pattern );
bool caseSensitive() const;
void setCaseSensitive( bool sensitive );
bool wildcard() const;
void setWildcard( bool wildcard );
bool minimal() const;
void setMinimal( bool minimal );
bool exactMatch( const QString& str ) const;
int match( const QString& str, int index = 0, int *len = 0,
bool indexIsStart = TRUE ) const;
# 90 "../include/qregexp.h"
int search( const QString& str, int offset = 0 ) const;
int search( const QString& str, int offset, CaretMode caretMode ) const;
int searchRev( const QString& str, int offset = -1 ) const;
int searchRev( const QString& str, int offset, CaretMode caretMode ) const;
int matchedLength() const;
int numCaptures() const;
QStringList capturedTexts();
QString cap( int nth = 0 );
int pos( int nth = 0 );
QString errorString();
static QString escape( const QString& str );
private:
void compile( bool caseSensitive );
static int caretIndex( int offset, CaretMode caretMode );
QRegExpEngine *eng;
QRegExpPrivate *priv;
};
# 44 "kernel/qobject.cpp" 2
# 1 "kernel/qmetaobject.h" 1
# 50 "kernel/qmetaobject.h"
class QObject;
struct QUMethod;
class QMetaObjectPrivate;
struct QMetaData
{
const char *name;
const QUMethod* method;
enum Access { Private, Protected, Public };
Access access;
};
struct QMetaEnum
{
const char *name;
uint count;
struct Item
{
const char *key;
int value;
};
const Item *items;
bool set;
};
class QMetaProperty
{
public:
const char* type() const { return t; }
const char* name() const { return n; }
bool writable() const;
bool isValid() const;
bool isSetType() const;
bool isEnumType() const;
QStrList enumKeys() const;
int keyToValue( const char* key ) const;
const char* valueToKey( int value ) const;
int keysToValue( const QStrList& keys ) const;
QStrList valueToKeys( int value ) const;
bool designable( QObject* = 0 ) const;
bool scriptable( QObject* = 0 ) const;
bool stored( QObject* = 0 ) const;
bool reset( QObject* ) const;
const char* t;
const char* n;
enum Flags {
Invalid = 0x00000000,
Readable = 0x00000001,
Writable = 0x00000002,
EnumOrSet = 0x00000004,
UnresolvedEnum = 0x00000008,
StdSet = 0x00000100,
Override = 0x00000200
};
uint flags;
bool testFlags( uint f ) const;
bool stdSet() const;
int id() const;
QMetaObject** meta;
const QMetaEnum* enumData;
int _id;
void clear();
};
inline bool QMetaProperty::testFlags( uint f ) const
{ return (flags & (uint)f) != (uint)0; }
struct QClassInfo
{
const char* name;
const char* value;
};
class QMetaObject
{
public:
QMetaObject( const char * const class_name, QMetaObject *superclass,
const QMetaData * const slot_data, int n_slots,
const QMetaData * const signal_data, int n_signals,
const QMetaProperty *const prop_data, int n_props,
const QMetaEnum *const enum_data, int n_enums,
const QClassInfo *const class_info, int n_info );
QMetaObject( const char * const class_name, QMetaObject *superclass,
const QMetaData * const slot_data, int n_slots,
const QMetaData * const signal_data, int n_signals,
const QMetaProperty *const prop_data, int n_props,
const QMetaEnum *const enum_data, int n_enums,
bool (*qt_static_property)(QObject*, int, int, QVariant*),
const QClassInfo *const class_info, int n_info );
virtual ~QMetaObject();
const char *className() const { return classname; }
const char *superClassName() const { return superclassname; }
QMetaObject *superClass() const { return superclass; }
bool inherits( const char* clname ) const;
int numSlots( bool super = FALSE ) const;
int numSignals( bool super = FALSE ) const;
int findSlot( const char *, bool super = FALSE ) const;
int findSignal( const char *, bool super = FALSE ) const;
const QMetaData *slot( int index, bool super = FALSE ) const;
const QMetaData *signal( int index, bool super = FALSE ) const;
QStrList slotNames( bool super = FALSE ) const;
QStrList signalNames( bool super = FALSE ) const;
int slotOffset() const;
int signalOffset() const;
int propertyOffset() const;
int numClassInfo( bool super = FALSE ) const;
const QClassInfo *classInfo( int index, bool super = FALSE ) const;
const char *classInfo( const char* name, bool super = FALSE ) const;
const QMetaProperty *property( int index, bool super = FALSE ) const;
int findProperty( const char *name, bool super = FALSE ) const;
int indexOfProperty( const QMetaProperty*, bool super = FALSE ) const;
const QMetaProperty* resolveProperty( const QMetaProperty* ) const;
int resolveProperty( int ) const;
QStrList propertyNames( bool super = FALSE ) const;
int numProperties( bool super = FALSE ) const;
static QMetaObject *new_metaobject( const char *, QMetaObject *,
const QMetaData *const, int,
const QMetaData *const, int,
const QMetaProperty *const prop_data, int n_props,
const QMetaEnum *const enum_data, int n_enums,
const QClassInfo *const class_info, int n_info );
static QMetaObject *new_metaobject( const char *, QMetaObject *,
const QMetaData *const, int,
const QMetaData *const, int,
const QMetaProperty *const prop_data, int n_props,
const QMetaEnum *const enum_data, int n_enums,
bool (*qt_static_property)(QObject*, int, int, QVariant*),
const QClassInfo *const class_info, int n_info );
QStrList enumeratorNames( bool super = FALSE ) const;
int numEnumerators( bool super = FALSE ) const;
const QMetaEnum *enumerator( const char* name, bool super = FALSE ) const;
static QMetaObject *metaObject( const char *class_name );
static bool hasMetaObject( const char *class_name );
private:
QMemberDict *init( const QMetaData *, int );
const char *classname;
const char *superclassname;
QMetaObject *superclass;
QMetaObjectPrivate *d;
void *reserved;
const QMetaData *slotData;
QMemberDict *slotDict;
const QMetaData *signalData;
QMemberDict *signalDict;
int signaloffset;
int slotoffset;
int propertyoffset;
public:
bool qt_static_property( QObject* o, int id, int f, QVariant* v);
private:
friend class QMetaProperty;
private:
QMetaObject( const QMetaObject & );
QMetaObject &operator=( const QMetaObject & );
};
inline int QMetaObject::slotOffset() const
{ return slotoffset; }
inline int QMetaObject::signalOffset() const
{ return signaloffset; }
inline int QMetaObject::propertyOffset() const
{ return propertyoffset; }
typedef QMetaObject *(*QtStaticMetaObjectFunction)();
class QMetaObjectCleanUp
{
public:
QMetaObjectCleanUp( const char *mo_name, QtStaticMetaObjectFunction );
QMetaObjectCleanUp();
~QMetaObjectCleanUp();
void setMetaObject( QMetaObject *&mo );
private:
QMetaObject **metaObject;
};
# 45 "kernel/qobject.cpp" 2
# 1 "../include/private/qucom_p.h" 1
# 43 "../include/private/qucom_p.h"
# 1 "../include/quuid.h" 1
# 60 "../include/quuid.h"
struct QUuid
{
QUuid()
{
memset( this, 0, sizeof(QUuid) );
}
QUuid( uint l, ushort w1, ushort w2, uchar b1, uchar b2, uchar b3, uchar b4, uchar b5, uchar b6, uchar b7, uchar b8 )
{
data1 = l;
data2 = w1;
data3 = w2;
data4[0] = b1;
data4[1] = b2;
data4[2] = b3;
data4[3] = b4;
data4[4] = b5;
data4[5] = b6;
data4[6] = b7;
data4[7] = b8;
}
QUuid( const QUuid &uuid )
{
memcpy( this, &uuid, sizeof(QUuid) );
}
QUuid( const QString & );
QUuid( const char * );
QString toString() const;
operator QString() const { return toString(); }
bool isNull() const;
QUuid &operator=(const QUuid &orig )
{
memcpy( this, &orig, sizeof(QUuid) );
return *this;
}
bool operator==(const QUuid &orig ) const
{
uint i;
if ( data1 != orig.data1 || data2 != orig.data2 ||
data3 != orig.data3 )
return FALSE;
for( i = 0; i < 8; i++ )
if ( data4[i] != orig.data4[i] )
return FALSE;
return TRUE;
}
bool operator!=(const QUuid &orig ) const
{
return !( *this == orig );
}
# 157 "../include/quuid.h"
uint data1;
ushort data2;
ushort data3;
uchar data4[ 8 ];
};
QDataStream &operator<<( QDataStream &, const QUuid & );
QDataStream &operator>>( QDataStream &, QUuid & );
# 44 "../include/private/qucom_p.h" 2
# 62 "../include/private/qucom_p.h"
struct QUObject;
struct QUInterfaceDescription;
struct QUnknownInterface;
struct QDispatchInterface;
struct QUBuffer
{
virtual long read( char *data, ulong maxlen ) = 0;
virtual long write( const char *data, ulong len ) = 0;
};
struct QUType
{
virtual const QUuid *uuid() const = 0;
virtual const char *desc() const = 0;
virtual bool canConvertFrom( QUObject *, QUType * ) = 0;
virtual bool canConvertTo( QUObject *, QUType * ) = 0;
virtual bool convertFrom( QUObject *, QUType * ) = 0;
virtual bool convertTo( QUObject *, QUType * ) = 0;
virtual void clear( QUObject * ) = 0;
virtual int serializeTo( QUObject *, QUBuffer * ) = 0;
virtual int serializeFrom( QUObject *, QUBuffer * ) = 0;
static bool isEqual( const QUType *t1, const QUType *t2 );
static bool check( QUObject* o, QUType* t );
};
extern const QUuid TID_QUType_Null;
struct QUType_Null : public QUType
{
const QUuid *uuid() const;
const char *desc() const;
bool canConvertFrom( QUObject *, QUType * );
bool canConvertTo( QUObject *, QUType * );
bool convertFrom( QUObject *, QUType * );
bool convertTo( QUObject *, QUType * );
void clear( QUObject * );
int serializeTo( QUObject *, QUBuffer * );
int serializeFrom( QUObject *, QUBuffer * );
};
extern QUType_Null static_QUType_Null;
struct QUObject
{
public:
QUObject() : type( &static_QUType_Null ) {}
~QUObject() { type->clear( this ); }
QUType *type;
union
{
bool b;
char c;
short s;
int i;
long l;
unsigned char uc;
unsigned short us;
unsigned int ui;
unsigned long ul;
float f;
double d;
char byte[16];
struct {
char* data;
unsigned long size;
} bytearray;
void* ptr;
struct {
void *ptr;
bool owner;
} voidstar;
struct {
char *ptr;
bool owner;
} charstar;
struct {
char *ptr;
bool owner;
} utf8;
struct {
char *ptr;
bool owner;
} local8bit;
QUnknownInterface* iface;
QDispatchInterface* idisp;
} payload;
};
struct QUParameter
{
const char* name;
QUType *type;
const void* typeExtra;
enum { In = 1, Out = 2, InOut = In | Out };
int inOut;
};
struct QUMethod
{
const char* name;
int count;
const QUParameter* parameters;
};
struct QUProperty
{
const char* name;
QUType* type;
const void* typeExtra;
int set;
int get;
int designable;
int stored;
};
struct QUInterfaceDescription
{
int methodCount;
const QUMethod* methods;
int propertyCount;
const QUProperty* properties;
};
struct QUComponentDescription
{
const char* name;
const char* vendor;
const char* release;
const char* info;
QUuid cid;
int count;
const QUuid* interfaces;
};
struct QUComponentServerDescription
{
const char* name;
const char* vendor;
const char* release;
const char* info;
int count;
const QUComponentDescription* components;
};
struct QUEnumItem
{
const char *key;
int value;
};
struct QUEnum
{
const char *name;
unsigned int count;
const QUEnumItem *items;
bool set;
};
inline bool QUType::isEqual( const QUType *t1, const QUType *t2 ) {
return t1 == t2 || t1->uuid() == t2->uuid() ||
*(t1->uuid()) == *(t2->uuid());
}
inline bool QUType::check( QUObject* o, QUType* t ) {
return isEqual( o->type, t ) || t->convertFrom( o, o->type );
}
extern const QUuid TID_QUType_enum;
struct QUType_enum : public QUType
{
const QUuid *uuid() const;
const char *desc() const;
void set( QUObject *, int );
int &get( QUObject * o ) { return o->payload.i; }
bool canConvertFrom( QUObject *, QUType * );
bool canConvertTo( QUObject *, QUType * );
bool convertFrom( QUObject *, QUType * );
bool convertTo( QUObject *, QUType * );
void clear( QUObject * ) {}
int serializeTo( QUObject *, QUBuffer * );
int serializeFrom( QUObject *, QUBuffer * );
};
extern QUType_enum static_QUType_enum;
extern const QUuid TID_QUType_ptr;
struct QUType_ptr : public QUType
{
const QUuid *uuid() const;
const char *desc() const;
void set( QUObject *, const void* );
void* &get( QUObject * o ) { return o->payload.ptr; }
bool canConvertFrom( QUObject *, QUType * );
bool canConvertTo( QUObject *, QUType * );
bool convertFrom( QUObject *, QUType * );
bool convertTo( QUObject *, QUType * );
void clear( QUObject * ) {}
int serializeTo( QUObject *, QUBuffer * );
int serializeFrom( QUObject *, QUBuffer * );
};
extern QUType_ptr static_QUType_ptr;
extern const QUuid TID_QUType_iface;
struct QUType_iface : public QUType
{
const QUuid *uuid() const;
const char *desc() const;
void set( QUObject *, QUnknownInterface* );
QUnknownInterface* &get( QUObject *o ){ return o->payload.iface; }
bool canConvertFrom( QUObject *, QUType * );
bool canConvertTo( QUObject *, QUType * );
bool convertFrom( QUObject *, QUType * );
bool convertTo( QUObject *, QUType * );
void clear( QUObject * ) {}
int serializeTo( QUObject *, QUBuffer * );
int serializeFrom( QUObject *, QUBuffer * );
};
extern QUType_iface static_QUType_iface;
extern const QUuid TID_QUType_idisp;
struct QUType_idisp : public QUType
{
const QUuid *uuid() const;
const char *desc() const;
void set( QUObject *, QDispatchInterface* );
QDispatchInterface* &get( QUObject *o ){ return o->payload.idisp; }
bool canConvertFrom( QUObject *, QUType * );
bool canConvertTo( QUObject *, QUType * );
bool convertFrom( QUObject *, QUType * );
bool convertTo( QUObject *, QUType * );
void clear( QUObject * ) {}
int serializeTo( QUObject *, QUBuffer * );
int serializeFrom( QUObject *, QUBuffer * );
};
extern QUType_idisp static_QUType_idisp;
extern const QUuid TID_QUType_bool;
struct QUType_bool : public QUType
{
const QUuid *uuid() const;
const char *desc() const;
void set( QUObject *, bool );
bool &get( QUObject *o ) { return o->payload.b; }
bool canConvertFrom( QUObject *, QUType * );
bool canConvertTo( QUObject *, QUType * );
bool convertFrom( QUObject *, QUType * );
bool convertTo( QUObject *, QUType * );
void clear( QUObject * ) {}
int serializeTo( QUObject *, QUBuffer * );
int serializeFrom( QUObject *, QUBuffer * );
};
extern QUType_bool static_QUType_bool;
extern const QUuid TID_QUType_int;
struct QUType_int : public QUType
{
const QUuid *uuid() const;
const char *desc() const;
void set( QUObject *, int );
int &get( QUObject *o ) { return o->payload.i; }
bool canConvertFrom( QUObject *, QUType * );
bool canConvertTo( QUObject *, QUType * );
bool convertFrom( QUObject *, QUType * );
bool convertTo( QUObject *, QUType * );
void clear( QUObject * ) {}
int serializeTo( QUObject *, QUBuffer * );
int serializeFrom( QUObject *, QUBuffer * );
};
extern QUType_int static_QUType_int;
extern const QUuid TID_QUType_uint;
struct QUType_uint : public QUType
{
const QUuid *uuid() const;
const char *desc() const;
void set( QUObject *, uint );
uint &get( QUObject *o ) { return o->payload.ui; }
bool canConvertFrom( QUObject *, QUType * );
bool canConvertTo( QUObject *, QUType * );
bool convertFrom( QUObject *, QUType * );
bool convertTo( QUObject *, QUType * );
void clear( QUObject * ) {}
int serializeTo( QUObject *, QUBuffer * );
int serializeFrom( QUObject *, QUBuffer * );
};
extern QUType_uint static_QUType_uint;
extern const QUuid TID_QUType_double;
struct QUType_double : public QUType
{
const QUuid *uuid() const;
const char *desc() const;
void set( QUObject *, double );
double &get( QUObject *o ) { return o->payload.d; }
bool canConvertFrom( QUObject *, QUType * );
bool canConvertTo( QUObject *, QUType * );
bool convertFrom( QUObject *, QUType * );
bool convertTo( QUObject *, QUType * );
void clear( QUObject * ) {}
int serializeTo( QUObject *, QUBuffer * );
int serializeFrom( QUObject *, QUBuffer * );
};
extern QUType_double static_QUType_double;
extern const QUuid TID_QUType_float;
struct QUType_float : public QUType
{
const QUuid *uuid() const;
const char *desc() const;
void set( QUObject *, float );
float &get( QUObject *o ) { return o->payload.f; }
bool canConvertFrom( QUObject *, QUType * );
bool canConvertTo( QUObject *, QUType * );
bool convertFrom( QUObject *, QUType * );
bool convertTo( QUObject *, QUType * );
void clear( QUObject * ) {}
int serializeTo( QUObject *, QUBuffer * );
int serializeFrom( QUObject *, QUBuffer * );
};
extern QUType_float static_QUType_float;
extern const QUuid TID_QUType_charstar;
struct QUType_charstar : public QUType
{
const QUuid *uuid() const;
const char *desc() const;
void set( QUObject *, const char*, bool take = FALSE );
char* get( QUObject *o ){ return o->payload.charstar.ptr; }
bool canConvertFrom( QUObject *, QUType * );
bool canConvertTo( QUObject *, QUType * );
bool convertFrom( QUObject *, QUType * );
bool convertTo( QUObject *, QUType * );
void clear( QUObject * );
int serializeTo( QUObject *, QUBuffer * );
int serializeFrom( QUObject *, QUBuffer * );
};
extern QUType_charstar static_QUType_charstar;
extern const QUuid TID_QUType_QString;
struct QUType_QString : public QUType
{
const QUuid *uuid() const;
const char *desc() const;
void set( QUObject *, const QString & );
QString &get( QUObject * o ) { return *(QString*)o->payload.ptr; }
bool canConvertFrom( QUObject *, QUType * );
bool canConvertTo( QUObject *, QUType * );
bool convertFrom( QUObject *, QUType * );
bool convertTo( QUObject *, QUType * );
void clear( QUObject * );
int serializeTo( QUObject *, QUBuffer * );
int serializeFrom( QUObject *, QUBuffer * );
};
extern QUType_QString static_QUType_QString;
# 46 "kernel/qobject.cpp" 2
# 1 "kernel/qucomextra_p.h" 1
# 46 "kernel/qucomextra_p.h"
class QVariant;
extern const QUuid TID_QUType_QVariant;
struct QUType_QVariant : public QUType
{
const QUuid *uuid() const;
const char *desc() const;
void set( QUObject *, const QVariant & );
QVariant &get( QUObject * o );
bool canConvertFrom( QUObject *, QUType * );
bool canConvertTo( QUObject *, QUType * );
bool convertFrom( QUObject *, QUType * );
bool convertTo( QUObject *, QUType * );
void clear( QUObject * );
int serializeTo( QUObject *, QUBuffer * );
int serializeFrom( QUObject *, QUBuffer * );
};
extern QUType_QVariant static_QUType_QVariant;
extern const QUuid TID_QUType_varptr;
struct QUType_varptr : public QUType
{
const QUuid *uuid() const;
const char *desc() const;
void set( QUObject *, const void* );
void* &get( QUObject * o ) { return o->payload.ptr; }
bool canConvertFrom( QUObject *, QUType * );
bool canConvertTo( QUObject *, QUType * );
bool convertFrom( QUObject *, QUType * );
bool convertTo( QUObject *, QUType * );
void clear( QUObject * ) {}
int serializeTo( QUObject *, QUBuffer * );
int serializeFrom( QUObject *, QUBuffer * );
};
extern QUType_varptr static_QUType_varptr;
# 47 "kernel/qobject.cpp" 2
# 1 "../include/qmutex.h" 1
# 42 "../include/qmutex.h"
# 1 "../include/qglobal.h" 1
# 43 "../include/qmutex.h" 2
class QMutexPrivate;
const int Q_MUTEX_NORMAL = 0;
const int Q_MUTEX_RECURSIVE = 1;
class QMutex
{
friend class QWaitCondition;
friend class QWaitConditionPrivate;
public:
QMutex(bool recursive = FALSE);
virtual ~QMutex();
void lock();
void unlock();
bool locked();
bool tryLock();
private:
QMutexPrivate * d;
QMutex( const QMutex & );
QMutex &operator=( const QMutex & );
};
class QMutexLocker
{
public:
QMutexLocker( QMutex * );
~QMutexLocker();
QMutex *mutex() const;
private:
QMutex *mtx;
QMutexLocker( const QMutexLocker & );
QMutexLocker &operator=( const QMutexLocker & );
};
inline QMutexLocker::QMutexLocker( QMutex *m )
: mtx( m )
{
mtx->lock();
}
inline QMutexLocker::~QMutexLocker()
{
mtx->unlock();
}
inline QMutex *QMutexLocker::mutex() const
{
return mtx;
}
# 51 "kernel/qobject.cpp" 2
# 1 "/usr/include/ctype.h" 1 3
# 29 "/usr/include/ctype.h" 3
extern "C" {
# 40 "/usr/include/ctype.h" 3
# 1 "/usr/include/endian.h" 1 3
# 37 "/usr/include/endian.h" 3
# 1 "/usr/include/bits/endian.h" 1 3
# 38 "/usr/include/endian.h" 2 3
# 41 "/usr/include/ctype.h" 2 3
enum
{
_ISupper = ((0) < 8 ? ((1 << (0)) << 8) : ((1 << (0)) >> 8)),
_ISlower = ((1) < 8 ? ((1 << (1)) << 8) : ((1 << (1)) >> 8)),
_ISalpha = ((2) < 8 ? ((1 << (2)) << 8) : ((1 << (2)) >> 8)),
_ISdigit = ((3) < 8 ? ((1 << (3)) << 8) : ((1 << (3)) >> 8)),
_ISxdigit = ((4) < 8 ? ((1 << (4)) << 8) : ((1 << (4)) >> 8)),
_ISspace = ((5) < 8 ? ((1 << (5)) << 8) : ((1 << (5)) >> 8)),
_ISprint = ((6) < 8 ? ((1 << (6)) << 8) : ((1 << (6)) >> 8)),
_ISgraph = ((7) < 8 ? ((1 << (7)) << 8) : ((1 << (7)) >> 8)),
_ISblank = ((8) < 8 ? ((1 << (8)) << 8) : ((1 << (8)) >> 8)),
_IScntrl = ((9) < 8 ? ((1 << (9)) << 8) : ((1 << (9)) >> 8)),
_ISpunct = ((10) < 8 ? ((1 << (10)) << 8) : ((1 << (10)) >> 8)),
_ISalnum = ((11) < 8 ? ((1 << (11)) << 8) : ((1 << (11)) >> 8))
};
# 75 "/usr/include/ctype.h" 3
extern __const unsigned short int *__ctype_b;
extern __const __int32_t *__ctype_tolower;
extern __const __int32_t *__ctype_toupper;
# 91 "/usr/include/ctype.h" 3
extern int isalnum (int) throw ();
extern int isalpha (int) throw ();
extern int iscntrl (int) throw ();
extern int isdigit (int) throw ();
extern int islower (int) throw ();
extern int isgraph (int) throw ();
extern int isprint (int) throw ();
extern int ispunct (int) throw ();
extern int isspace (int) throw ();
extern int isupper (int) throw ();
extern int isxdigit (int) throw ();
extern int isblank (int) throw ();
extern int tolower (int __c) throw ();
extern int toupper (int __c) throw ();
extern int isascii (int __c) throw ();
extern int toascii (int __c) throw ();
extern int _toupper (int) throw ();
extern int _tolower (int) throw ();
# 167 "/usr/include/ctype.h" 3
extern __inline int
tolower (int __c) throw ()
{
return __c >= -128 && __c < 256 ? __ctype_tolower[__c] : __c;
}
extern __inline int
toupper (int __c) throw ()
{
return __c >= -128 && __c < 256 ? __ctype_toupper[__c] : __c;
}
# 223 "/usr/include/ctype.h" 3
extern int __isalnum_l (int, __locale_t) throw ();
extern int __isalpha_l (int, __locale_t) throw ();
extern int __iscntrl_l (int, __locale_t) throw ();
extern int __isdigit_l (int, __locale_t) throw ();
extern int __islower_l (int, __locale_t) throw ();
extern int __isgraph_l (int, __locale_t) throw ();
extern int __isprint_l (int, __locale_t) throw ();
extern int __ispunct_l (int, __locale_t) throw ();
extern int __isspace_l (int, __locale_t) throw ();
extern int __isupper_l (int, __locale_t) throw ();
extern int __isxdigit_l (int, __locale_t) throw ();
extern int __isblank_l (int, __locale_t) throw ();
extern int __tolower_l (int __c, __locale_t __l) throw ();
extern int __toupper_l (int __c, __locale_t __l) throw ();
# 276 "/usr/include/ctype.h" 3
}
# 54 "kernel/qobject.cpp" 2
class QObjectPrivate : public QPtrVector<QObjectUserData>
{
public:
QObjectPrivate( uint s ) : QPtrVector<QObjectUserData>(s){ setAutoDelete( TRUE ); }
};
class QSenderObjectList : public QObjectList, public QShared
{
public:
QSenderObjectList():currentSender(0){}
QObject *currentSender;
};
# 170 "kernel/qobject.cpp"
static inline bool isIdentChar( char x )
{
return x == '_' || (x >= '0' && x <= '9') ||
(x >= 'a' && x <= 'z') || (x >= 'A' && x <= 'Z');
}
static inline bool isSpace( char x )
{
# 186 "kernel/qobject.cpp"
return (__ctype_b[(int) (((uchar) x))] & (unsigned short int) _ISspace);
}
static QCString qt_rmWS( const char *s )
{
QCString result( qstrlen(s)+1 );
char *d = result.data();
char last = 0;
while( *s && isSpace(*s) )
s++;
while ( *s ) {
while ( *s && !isSpace(*s) )
last = *d++ = *s++;
while ( *s && isSpace(*s) )
s++;
if ( *s && isIdentChar(*s) && isIdentChar(last) )
last = *d++ = ' ';
}
*d = '\0';
result.truncate( (int)(d - result.data()) );
int void_pos = result.find("(void)");
if ( void_pos >= 0 )
result.remove( void_pos+1, (uint)strlen("void") );
return result;
}
int qStartTimer( int interval, QObject *obj );
bool qKillTimer( int id );
bool qKillTimer( QObject *obj );
static void removeObjFromList( QObjectList *objList, const QObject *obj,
bool single=FALSE )
{
if ( !objList )
return;
int index = objList->findRef( obj );
while ( index >= 0 ) {
objList->remove();
if ( single )
return;
index = objList->findNextRef( obj );
}
}
# 251 "kernel/qobject.cpp"
void *qt_find_obj_child( QObject *parent, const char *type, const char *name )
{
const QObjectList *list = parent->children();
if ( list ) {
QObjectListIt it( *list );
QObject *obj;
while ( (obj = it.current()) ) {
++it;
if ( qstrcmp(name,obj->name()) == 0 &&
obj->inherits(type) )
return obj;
}
}
return 0;
}
static QObjectList* object_trees = 0;
static QMutex *obj_trees_mutex = 0;
static void cleanup_object_trees()
{
delete object_trees;
object_trees = 0;
delete obj_trees_mutex;
obj_trees_mutex = 0;
}
static void ensure_object_trees()
{
object_trees = new QObjectList;
qAddPostRoutine( cleanup_object_trees );
}
static void insert_tree( QObject* obj )
{
if ( !obj_trees_mutex )
obj_trees_mutex = new QMutex();
QMutexLocker locker( obj_trees_mutex );
if ( !object_trees )
ensure_object_trees();
object_trees->insert(0, obj );
}
static void remove_tree( QObject* obj )
{
if ( object_trees ) {
QMutexLocker locker( obj_trees_mutex );
object_trees->removeRef( obj );
}
}
# 338 "kernel/qobject.cpp"
QObject::QObject( QObject *parent, const char *name )
:
isSignal( FALSE ),
isWidget( FALSE ),
pendTimer( FALSE ),
blockSig( FALSE ),
wasDeleted( FALSE ),
isTree( FALSE ),
objname( name ? qstrdup(name) : 0 ),
parentObj( 0 ),
childObjects( 0 ),
connections( 0 ),
senderObjects( 0 ),
eventFilters( 0 ),
postedEvents( 0 ),
d( 0 )
{
if ( !metaObj )
(void) staticMetaObject();
if ( parent ) {
parent->insertChild( this );
} else {
insert_tree( this );
isTree = TRUE;
}
}
# 380 "kernel/qobject.cpp"
QObject::~QObject()
{
if ( wasDeleted ) {
return;
}
wasDeleted = 1;
destroyed( this );
destroyed();
if ( objname )
delete [] (char*)objname;
objname = 0;
if ( pendTimer )
qKillTimer( this );
if ( postedEvents && qApp )
QApplication::removePostedEvents( this );
if ( isTree ) {
remove_tree( this );
isTree = FALSE;
}
if ( parentObj )
parentObj->removeChild( this );
register QObject *obj;
if ( senderObjects ) {
QSenderObjectList *tmp = senderObjects;
senderObjects = 0;
obj = tmp->first();
while ( obj ) {
obj->disconnect( this );
obj = tmp->next();
}
if ( tmp->deref() )
delete tmp;
}
if ( connections ) {
for ( int i = 0; i < (int) connections->size(); i++ ) {
QConnectionList* clist = (*connections)[i];
if ( !clist )
continue;
register QConnection *c;
QConnectionListIt cit(*clist);
while( (c=cit.current()) ) {
++cit;
if ( (obj=c->object()) )
removeObjFromList( obj->senderObjects, this );
}
}
delete connections;
connections = 0;
}
if ( eventFilters ) {
delete eventFilters;
eventFilters = 0;
}
if ( childObjects ) {
QObjectListIt it(*childObjects);
while ( (obj=it.current()) ) {
++it;
obj->parentObj = 0;
childObjects->removeRef( obj );
delete obj;
}
delete childObjects;
}
if ( d )
delete d;
}
# 495 "kernel/qobject.cpp"
bool QObject::isA( const char *clname ) const
{
return qstrcmp( clname, className() ) == 0;
}
# 525 "kernel/qobject.cpp"
bool QObject::inherits( const char *clname ) const
{
return metaObject()->inherits( clname );
}
# 556 "kernel/qobject.cpp"
const char * QObject::name() const
{
return objname ? objname : "unnamed";
}
void QObject::setName( const char *name )
{
if ( objname )
delete [] (char*) objname;
objname = name ? qstrdup(name) : 0;
}
# 579 "kernel/qobject.cpp"
const char * QObject::name( const char * defaultName ) const
{
return objname ? objname : defaultName;
}
# 598 "kernel/qobject.cpp"
QObject* QObject::child( const char *objName, const char *inheritsClass,
bool recursiveSearch )
{
const QObjectList *list = children();
if ( !list )
return 0;
bool onlyWidgets = ( inheritsClass && qstrcmp( inheritsClass, "QWidget" ) == 0 );
QObjectListIt it( *list );
QObject *obj;
while ( ( obj = it.current() ) ) {
++it;
if ( onlyWidgets ) {
if ( obj->isWidgetType() && ( !objName || qstrcmp( objName, obj->name() ) == 0 ) )
break;
} else if ( ( !inheritsClass || obj->inherits(inheritsClass) ) && ( !objName || qstrcmp( objName, obj->name() ) == 0 ) )
break;
if ( recursiveSearch && (obj = obj->child( objName, inheritsClass, recursiveSearch ) ) )
break;
}
return obj;
}
# 653 "kernel/qobject.cpp"
bool QObject::event( QEvent *e )
{
if ( e == 0 )
qWarning( "QObject::event: Null events are not permitted" );
if ( eventFilters ) {
if ( activate_filters(e) )
return TRUE;
}
switch ( e->type() ) {
case QEvent::Timer:
timerEvent( (QTimerEvent*)e );
return TRUE;
case QEvent::ChildInserted:
case QEvent::ChildRemoved:
childEvent( (QChildEvent*)e );
return TRUE;
case QEvent::DeferredDelete:
delete this;
return TRUE;
default:
if ( e->type() >= QEvent::User ) {
customEvent( (QCustomEvent*) e );
return TRUE;
}
break;
}
return FALSE;
}
# 698 "kernel/qobject.cpp"
void QObject::timerEvent( QTimerEvent * )
{
}
# 731 "kernel/qobject.cpp"
void QObject::childEvent( QChildEvent * )
{
}
# 743 "kernel/qobject.cpp"
void QObject::customEvent( QCustomEvent * )
{
}
# 807 "kernel/qobject.cpp"
bool QObject::eventFilter( QObject * , QEvent * )
{
return FALSE;
}
# 819 "kernel/qobject.cpp"
bool QObject::activate_filters( QEvent *e )
{
if ( !eventFilters )
return FALSE;
QObjectListIt it( *eventFilters );
register QObject *obj = it.current();
while ( obj ) {
++it;
if ( obj->eventFilter(this,e) ) {
return TRUE;
}
obj = it.current();
}
return FALSE;
}
# 853 "kernel/qobject.cpp"
void QObject::blockSignals( bool block )
{
blockSig = block;
}
# 920 "kernel/qobject.cpp"
int QObject::startTimer( int interval )
{
pendTimer = TRUE;
return qStartTimer( interval, (QObject *)this );
}
# 935 "kernel/qobject.cpp"
void QObject::killTimer( int id )
{
qKillTimer( id );
}
# 951 "kernel/qobject.cpp"
void QObject::killTimers()
{
qKillTimer( this );
}
static void objSearch( QObjectList *result,
QObjectList *list,
const char *inheritsClass,
bool onlyWidgets,
const char *objName,
QRegExp *rx,
bool recurse )
{
if ( !list || list->isEmpty() )
return;
QObject *obj = list->first();
while ( obj ) {
bool ok = TRUE;
if ( onlyWidgets )
ok = obj->isWidgetType();
else if ( inheritsClass && !obj->inherits(inheritsClass) )
ok = FALSE;
if ( ok ) {
if ( objName )
ok = ( qstrcmp(objName,obj->name()) == 0 );
else if ( rx )
ok = ( rx->search(QString::fromLatin1(obj->name())) != -1 );
}
if ( ok )
result->append( obj );
if ( recurse && obj->children() )
objSearch( result, (QObjectList *)obj->children(), inheritsClass,
onlyWidgets, objName, rx, recurse );
obj = list->next();
}
}
# 1035 "kernel/qobject.cpp"
const QObjectList *QObject::objectTrees()
{
return object_trees;
}
# 1091 "kernel/qobject.cpp"
QObjectList *QObject::queryList( const char *inheritsClass,
const char *objName,
bool regexpMatch,
bool recursiveSearch ) const
{
QObjectList *list = new QObjectList;
(qt_check_pointer((list)==0,"kernel/qobject.cpp",1097));
bool onlyWidgets = ( inheritsClass && qstrcmp(inheritsClass, "QWidget") == 0 );
if ( regexpMatch && objName ) {
QRegExp rx(QString::fromLatin1(objName));
objSearch( list, (QObjectList *)children(), inheritsClass, onlyWidgets,
0, &rx, recursiveSearch );
} else
{
objSearch( list, (QObjectList *)children(), inheritsClass, onlyWidgets,
objName, 0, recursiveSearch );
}
return list;
}
QConnectionList *QObject::receivers( const char* signal ) const
{
if ( connections && signal ) {
if ( *signal == '2' ) {
QCString s = qt_rmWS( signal+1 );
return receivers( metaObject()->findSignal( (const char*)s, TRUE ) );
} else {
return receivers( metaObject()->findSignal(signal, TRUE ) );
}
}
return 0;
}
QConnectionList *QObject::receivers( int signal ) const
{
if ( connections && signal >= 0 )
return connections->at( signal );
return 0;
}
# 1157 "kernel/qobject.cpp"
void QObject::insertChild( QObject *obj )
{
if ( obj->isTree ) {
remove_tree( obj );
obj->isTree = FALSE;
}
if ( obj->parentObj && obj->parentObj != this ) {
if ( obj->parentObj != this && obj->isWidgetType() )
qWarning( "QObject::insertChild: Cannot reparent a widget, "
"use QWidget::reparent() instead" );
obj->parentObj->removeChild( obj );
}
if ( !childObjects ) {
childObjects = new QObjectList;
(qt_check_pointer((childObjects)==0,"kernel/qobject.cpp",1174));
} else if ( obj->parentObj == this ) {
qWarning( "QObject::insertChild: Object %s::%s already in list",
obj->className(), obj->name( "unnamed" ) );
return;
}
obj->parentObj = this;
childObjects->append( obj );
QChildEvent *e = new QChildEvent( QEvent::ChildInserted, obj );
QApplication::postEvent( this, e );
}
# 1199 "kernel/qobject.cpp"
void QObject::removeChild( QObject *obj )
{
if ( childObjects && childObjects->removeRef(obj) ) {
obj->parentObj = 0;
if ( !obj->wasDeleted ) {
insert_tree( obj );
obj->isTree = TRUE;
}
if ( childObjects->isEmpty() ) {
delete childObjects;
childObjects = 0;
}
QChildEvent ce( QEvent::ChildRemoved, obj );
QApplication::sendEvent( this, &ce );
}
}
# 1281 "kernel/qobject.cpp"
void QObject::installEventFilter( const QObject *obj )
{
if ( !obj )
return;
if ( eventFilters ) {
int c = eventFilters->findRef( obj );
if ( c >= 0 )
eventFilters->take( c );
disconnect( obj, "2""destroyed(QObject*)",
this, "1""cleanupEventFilter(QObject*)" );
} else {
eventFilters = new QObjectList;
(qt_check_pointer((eventFilters)==0,"kernel/qobject.cpp",1293));
}
eventFilters->insert( 0, obj );
connect( obj, "2""destroyed(QObject*)", this, "1""cleanupEventFilter(QObject*)" );
}
# 1312 "kernel/qobject.cpp"
void QObject::removeEventFilter( const QObject *obj )
{
if ( eventFilters && eventFilters->removeRef(obj) ) {
if ( eventFilters->isEmpty() ) {
delete eventFilters;
eventFilters = 0;
}
disconnect( obj, "2""destroyed(QObject*)",
this, "1""cleanupEventFilter(QObject*)" );
}
}
# 1331 "kernel/qobject.cpp"
static bool check_signal_macro( const QObject *sender, const char *signal,
const char *func, const char *op )
{
int sigcode = (int)(*signal) - '0';
if ( sigcode != 2 ) {
if ( sigcode == 1 )
qWarning( "QObject::%s: Attempt to %s non-signal %s::%s",
func, op, sender->className(), signal+1 );
else
qWarning( "QObject::%s: Use the SIGNAL macro to %s %s::%s",
func, op, sender->className(), signal );
return FALSE;
}
return TRUE;
}
static bool check_member_code( int code, const QObject *object,
const char *member, const char *func )
{
if ( code != 1 && code != 2 ) {
qWarning( "QObject::%s: Use the SLOT or SIGNAL macro to "
"%s %s::%s", func, func, object->className(), member );
return FALSE;
}
return TRUE;
}
static void err_member_notfound( int code, const QObject *object,
const char *member, const char *func )
{
const char *type = 0;
switch ( code ) {
case 1: type = "slot"; break;
case 2: type = "signal"; break;
}
if ( strchr(member,')') == 0 )
qWarning( "QObject::%s: Parentheses expected, %s %s::%s",
func, type, object->className(), member );
else
qWarning( "QObject::%s: No such %s %s::%s",
func, type, object->className(), member );
}
static void err_info_about_objects( const char * func,
const QObject * sender,
const QObject * receiver )
{
const char * a = sender->name(), * b = receiver->name();
if ( a )
qWarning( "QObject::%s: (sender name: '%s')", func, a );
if ( b )
qWarning( "QObject::%s: (receiver name: '%s')", func, b );
}
static void err_info_about_candidates( int code,
const QMetaObject* mo,
const char* member,
const char *func )
{
if ( strstr(member,"const char*") ) {
QCString newname = member;
int p;
while ( (p=newname.find("const char*")) >= 0 ) {
newname.replace(p, 11, "const QString&");
}
const QMetaData *rm = 0;
switch ( code ) {
case 1:
rm = mo->slot( mo->findSlot( newname, TRUE ), TRUE );
break;
case 2:
rm = mo->signal( mo->findSignal( newname, TRUE ), TRUE );
break;
}
if ( rm ) {
qWarning("QObject::%s: Candidate: %s", func, newname.data());
}
}
}
# 1434 "kernel/qobject.cpp"
const QObject *QObject::sender()
{
if ( senderObjects &&
senderObjects->currentSender &&
senderObjects->findRef( senderObjects->currentSender ) != -1 )
return senderObjects->currentSender;
return 0;
}
# 1463 "kernel/qobject.cpp"
void QObject::connectNotify( const char * )
{
}
# 1480 "kernel/qobject.cpp"
void QObject::disconnectNotify( const char * )
{
}
# 1506 "kernel/qobject.cpp"
bool QObject::checkConnectArgs( const char *signal,
const QObject *,
const char *member )
{
const char *s1 = signal;
const char *s2 = member;
while ( *s1++ != '(' ) { }
while ( *s2++ != '(' ) { }
if ( *s2 == ')' || qstrcmp(s1,s2) == 0 )
return TRUE;
int s1len = qstrlen(s1);
int s2len = qstrlen(s2);
if ( s2len < s1len && qstrncmp(s1,s2,s2len-1)==0 && s1[s2len-1]==',' )
return TRUE;
return FALSE;
}
QCString QObject::normalizeSignalSlot( const char *signalSlot )
{
if ( !signalSlot )
return QCString();
return qt_rmWS( signalSlot );
}
# 1611 "kernel/qobject.cpp"
bool QObject::connect( const QObject *sender, const char *signal,
const QObject *receiver, const char *member )
{
if ( sender == 0 || receiver == 0 || signal == 0 || member == 0 ) {
qWarning( "QObject::connect: Cannot connect %s::%s to %s::%s",
sender ? sender->className() : "(null)",
signal ? signal+1 : "(null)",
receiver ? receiver->className() : "(null)",
member ? member+1 : "(null)" );
return FALSE;
}
QCString signal_name = qt_rmWS( signal );
QCString member_name = qt_rmWS( member );
signal = signal_name;
member = member_name;
QMetaObject *smeta = sender->metaObject();
if ( !check_signal_macro( sender, signal, "connect", "bind" ) )
return FALSE;
signal++;
int signal_index = smeta->findSignal( signal, TRUE );
if ( signal_index < 0 ) {
err_member_notfound( 2, sender, signal, "connect" );
err_info_about_candidates( 2, smeta, signal, "connect" );
err_info_about_objects( "connect", sender, receiver );
return FALSE;
}
const QMetaData *sm = smeta->signal( signal_index, TRUE );
signal = sm->name;
int membcode = member[0] - '0';
QObject *s = (QObject *)sender;
QObject *r = (QObject *)receiver;
if ( !check_member_code( membcode, r, member, "connect" ) )
return FALSE;
member++;
QMetaObject *rmeta = r->metaObject();
int member_index = -1;
switch ( membcode ) {
case 1:
member_index = rmeta->findSlot( member, TRUE );
break;
case 2:
member_index = rmeta->findSignal( member, TRUE );
break;
}
if ( member_index < 0 ) {
err_member_notfound( membcode, r, member, "connect" );
err_info_about_candidates( membcode, rmeta, member, "connect" );
err_info_about_objects( "connect", sender, receiver );
return FALSE;
}
if ( !s->checkConnectArgs(signal,receiver,member) ) {
qWarning( "QObject::connect: Incompatible sender/receiver arguments"
"\n\t%s::%s --> %s::%s",
s->className(), signal,
r->className(), member );
return FALSE;
} else {
const QMetaData *rm = membcode == 1 ?
rmeta->slot( member_index, TRUE ) :
rmeta->signal( member_index, TRUE );
if ( rm ) {
int si = 0;
int ri = 0;
while ( si < sm->method->count && ri < rm->method->count ) {
if ( sm->method->parameters[si].inOut == QUParameter::Out )
si++;
else if ( rm->method->parameters[ri].inOut == QUParameter::Out )
ri++;
else if ( !QUType::isEqual( sm->method->parameters[si++].type,
rm->method->parameters[ri++].type ) ) {
if ( ( QUType::isEqual( sm->method->parameters[si-1].type, &static_QUType_ptr )
&& QUType::isEqual( rm->method->parameters[ri-1].type, &static_QUType_varptr ) )
|| ( QUType::isEqual( sm->method->parameters[si-1].type, &static_QUType_varptr )
&& QUType::isEqual( rm->method->parameters[ri-1].type, &static_QUType_ptr ) ) )
continue;
qWarning( "QObject::connect: Incompatible sender/receiver marshalling"
"\n\t%s::%s --> %s::%s",
s->className(), signal,
r->className(), member );
return FALSE;
}
}
}
}
connectInternal( sender, signal_index, receiver, membcode, member_index );
s->connectNotify( signal_name );
return TRUE;
}
void QObject::connectInternal( const QObject *sender, int signal_index, const QObject *receiver,
int membcode, int member_index )
{
QObject *s = (QObject*)sender;
QObject *r = (QObject*)receiver;
if ( !s->connections ) {
s->connections = new QSignalVec( signal_index+1 );
(qt_check_pointer((s->connections)==0,"kernel/qobject.cpp",1730));
s->connections->setAutoDelete( TRUE );
}
QConnectionList *clist = s->connections->at( signal_index );
if ( !clist ) {
clist = new QConnectionList;
(qt_check_pointer((clist)==0,"kernel/qobject.cpp",1737));
clist->setAutoDelete( TRUE );
s->connections->insert( signal_index, clist );
}
QMetaObject *rmeta = r->metaObject();
const QMetaData *rm = 0;
switch ( membcode ) {
case 1:
rm = rmeta->slot( member_index, TRUE );
break;
case 2:
rm = rmeta->signal( member_index, TRUE );
break;
}
QConnection *c = new QConnection( r, member_index, rm ? rm->name : "qt_invoke", membcode );
(qt_check_pointer((c)==0,"kernel/qobject.cpp",1755));
clist->append( c );
if ( !r->senderObjects )
r->senderObjects = new QSenderObjectList;
r->senderObjects->append( s );
}
# 1840 "kernel/qobject.cpp"
bool QObject::disconnect( const QObject *sender, const char *signal,
const QObject *receiver, const char *member )
{
if ( sender == 0 || (receiver == 0 && member != 0) ) {
qWarning( "QObject::disconnect: Unexpected null parameter" );
return FALSE;
}
if ( !sender->connections )
return FALSE;
QCString signal_name;
QCString member_name;
QObject *s = (QObject *)sender;
QObject *r = (QObject *)receiver;
int member_index = -1;
if ( member ) {
member_name = qt_rmWS( member );
member = member_name.data();
int membcode = member[0] - '0';
if ( !check_member_code( membcode, r, member, "disconnect" ) )
return FALSE;
member++;
QMetaObject *rmeta = r->metaObject();
switch ( membcode ) {
case 1:
member_index = rmeta->findSlot( member, TRUE );
break;
case 2:
member_index = rmeta->findSignal( member, TRUE );
break;
}
if ( member_index < 0 ) {
err_member_notfound( membcode, r, member, "disconnect" );
err_info_about_candidates( membcode, rmeta, member, "connect" );
err_info_about_objects( "disconnect", sender, receiver );
return FALSE;
}
}
if ( signal == 0 ) {
if ( disconnectInternal( s, -1, r, member_index ) )
s->disconnectNotify( 0 );
else
return FALSE;
} else {
signal_name = qt_rmWS( signal );
signal = signal_name.data();
if ( !check_signal_macro( s, signal, "disconnect", "unbind" ) )
return FALSE;
signal++;
QMetaObject *smeta = s->metaObject();
if ( !smeta )
return FALSE;
int signal_index = smeta->findSignal( signal, TRUE );
if ( signal_index < 0 ) {
qWarning( "QObject::disconnect: No such signal %s::%s",
s->className(), signal );
return FALSE;
}
if ( disconnectInternal( s, signal_index, r, member_index ) )
s->disconnectNotify( signal_name );
else
return FALSE;
}
return TRUE;
}
bool QObject::disconnectInternal( const QObject *sender, int signal_index,
const QObject *receiver, int member_index )
{
QObject *s = (QObject*)sender;
QObject *r = (QObject*)receiver;
if ( !s->connections )
return FALSE;
QConnectionList *clist;
register QConnection *c;
if ( signal_index == -1 ) {
for ( int i = 0; i < (int) s->connections->size(); i++ ) {
clist = (*s->connections)[i];
if ( !clist )
continue;
c = clist->first();
while ( c ) {
if ( r == 0 ) {
removeObjFromList( c->object()->senderObjects, s );
c = clist->next();
} else if ( r == c->object() && ( member_index == -1 || member_index == c->member() ) ) {
removeObjFromList( c->object()->senderObjects, s );
clist->remove();
c = clist->current();
} else {
c = clist->next();
}
}
if ( r == 0 )
s->connections->insert( i, 0 );
}
} else {
clist = s->connections->at( signal_index );
if ( !clist )
return FALSE;
c = clist->first();
while ( c ) {
if ( r == 0 ) {
removeObjFromList( c->object()->senderObjects, s, TRUE );
c = clist->next();
} else if ( r == c->object() && ( member_index == -1 || member_index == c->member() ) ) {
removeObjFromList( c->object()->senderObjects, s, TRUE );
clist->remove();
c = clist->current();
} else {
c = clist->next();
}
}
if ( r == 0 )
s->connections->insert( signal_index, 0 );
}
return TRUE;
}
# 2008 "kernel/qobject.cpp"
void QObject::deleteLater()
{
QApplication::postEvent( this, new QEvent( QEvent::DeferredDelete) );
}
void QObject::cleanupEventFilter(QObject* obj)
{
removeEventFilter( obj );
}
# 2065 "kernel/qobject.cpp"
static QMetaObjectCleanUp cleanUp_Qt = QMetaObjectCleanUp( "QObject", &QObject::staticMetaObject );
QMetaObject* QObject::staticQtMetaObject()
{
static QMetaObject* qtMetaObject = 0;
if ( qtMetaObject )
return qtMetaObject;
static const QMetaEnum::Item enum_0[] = {
{ "AlignLeft", (int) Qt::AlignLeft },
{ "AlignRight", (int) Qt::AlignRight },
{ "AlignHCenter", (int) Qt::AlignHCenter },
{ "AlignTop", (int) Qt::AlignTop },
{ "AlignBottom", (int) Qt::AlignBottom },
{ "AlignVCenter", (int) Qt::AlignVCenter },
{ "AlignCenter", (int) Qt::AlignCenter },
{ "AlignAuto", (int) Qt::AlignAuto },
{ "AlignJustify", (int) Qt::AlignJustify },
{ "WordBreak", (int) Qt::WordBreak }
};
static const QMetaEnum::Item enum_1[] = {
{ "Horizontal", (int) Qt::Horizontal },
{ "Vertical", (int) Qt::Vertical }
};
static const QMetaEnum::Item enum_2[] = {
{ "PlainText", (int) Qt::PlainText },
{ "RichText", (int) Qt::RichText },
{ "AutoText", (int) Qt::AutoText }
};
static const QMetaEnum::Item enum_3[] = {
{ "FixedColor", (int) Qt::FixedColor },
{ "FixedPixmap", (int) Qt::FixedPixmap },
{ "NoBackground", (int) Qt::NoBackground },
{ "PaletteForeground", (int) Qt::PaletteForeground },
{ "PaletteButton", (int) Qt::PaletteButton },
{ "PaletteLight", (int) Qt::PaletteLight },
{ "PaletteMidlight", (int) Qt::PaletteMidlight },
{ "PaletteDark", (int) Qt::PaletteDark },
{ "PaletteMid", (int) Qt::PaletteMid },
{ "PaletteText", (int) Qt::PaletteText },
{ "PaletteBrightText", (int) Qt::PaletteBrightText },
{ "PaletteBase", (int) Qt::PaletteBase },
{ "PaletteBackground", (int) Qt::PaletteBackground },
{ "PaletteShadow", (int) Qt::PaletteShadow },
{ "PaletteHighlight", (int) Qt::PaletteHighlight },
{ "PaletteHighlightedText", (int) Qt::PaletteHighlightedText },
{ "PaletteButtonText", (int) Qt::PaletteButtonText },
{ "PaletteLink", (int) Qt::PaletteLink },
{ "PaletteLinkVisited", (int) Qt::PaletteLinkVisited },
{ "X11ParentRelative", (int) Qt::X11ParentRelative }
};
static const QMetaEnum::Item enum_4[] = {
{ "TextDate", (int) Qt::TextDate },
{ "ISODate", (int) Qt::ISODate },
{ "LocalDate", (int) Qt::LocalDate }
};
static const QMetaEnum enum_tbl[] = {
{ "Alignment", 10, enum_0, TRUE },
{ "Orientation", 2, enum_1, FALSE },
{ "TextFormat", 3, enum_2, FALSE },
{ "BackgroundMode", 18, enum_3, FALSE },
{ "DateFormat", 3, enum_4, FALSE }
};
qtMetaObject = new QMetaObject( "Qt", 0,
0, 0,
0, 0,
0, 0,
enum_tbl, 5,
0, 0 );
cleanUp_Qt.setMetaObject( qtMetaObject );
return qtMetaObject;
}
# 2157 "kernel/qobject.cpp"
void QObject::activate_signal( int signal )
{
if ( !connections || signalsBlocked() || signal < 0 )
return;
QConnectionList *clist = connections->at( signal );
if ( !clist )
return;
QUObject o[1];
activate_signal( clist, o );
}
void QObject::activate_signal( QConnectionList *clist, QUObject *o )
{
if ( !clist )
return;
QObject *object;
QSenderObjectList* sol;
QObject* oldSender = 0;
QConnection *c;
if ( clist->count() == 1 ) {
c = clist->first();
object = c->object();
sol = object->senderObjects;
if ( sol ) {
oldSender = sol->currentSender;
sol->ref();
sol->currentSender = this;
}
if ( c->memberType() == 2 )
object->qt_emit( c->member(), o );
else
object->qt_invoke( c->member(), o );
if (sol ) {
sol->currentSender = oldSender;
if ( sol->deref() )
delete sol;
}
} else {
QConnectionListIt it(*clist);
while ( (c=it.current()) ) {
++it;
object = c->object();
sol = object->senderObjects;
if ( sol ) {
oldSender = sol->currentSender;
sol->ref();
sol->currentSender = this;
}
if ( c->memberType() == 2 )
object->qt_emit( c->member(), o );
else
object->qt_invoke( c->member(), o );
if (sol ) {
sol->currentSender = oldSender;
if ( sol->deref() )
delete sol;
}
}
}
}
# 2256 "kernel/qobject.cpp"
void QObject::activate_signal( int signal, int param ) { if ( !connections || signalsBlocked() || signal < 0 ) return; QConnectionList *clist = connections->at( signal ); if ( !clist ) return; QUObject o[2]; static_QUType_int.set( o+1, param ); activate_signal( clist, o ); }
void QObject::activate_signal( int signal, double param ) { if ( !connections || signalsBlocked() || signal < 0 ) return; QConnectionList *clist = connections->at( signal ); if ( !clist ) return; QUObject o[2]; static_QUType_double.set( o+1, param ); activate_signal( clist, o ); }
void QObject::activate_signal( int signal, QString param ) { if ( !connections || signalsBlocked() || signal < 0 ) return; QConnectionList *clist = connections->at( signal ); if ( !clist ) return; QUObject o[2]; static_QUType_QString.set( o+1, param ); activate_signal( clist, o ); }
void QObject::activate_signal_bool( int signal, bool param ) { if ( !connections || signalsBlocked() || signal < 0 ) return; QConnectionList *clist = connections->at( signal ); if ( !clist ) return; QUObject o[2]; static_QUType_bool.set( o+1, param ); activate_signal( clist, o ); }
static void dumpRecursive( int level, QObject *object )
{
# 2299 "kernel/qobject.cpp"
(void)level;
(void)object;
}
# 2312 "kernel/qobject.cpp"
void QObject::dumpObjectTree()
{
dumpRecursive( 0, this );
}
# 2326 "kernel/qobject.cpp"
void QObject::dumpObjectInfo()
{
# 2365 "kernel/qobject.cpp"
}
# 2380 "kernel/qobject.cpp"
bool QObject::setProperty( const char *name, const QVariant& value )
{
if ( !value.isValid() )
return FALSE;
QVariant v = value;
QMetaObject* meta = metaObject();
if ( !meta )
return FALSE;
int id = meta->findProperty( name, TRUE );
const QMetaProperty* p = meta->property( id, TRUE );
if ( !p || !p->isValid() || !p->writable() ) {
qWarning( "%s::setProperty( \"%s\", value ) failed: property invalid, read-only or does not exist",
className(), name );
return FALSE;
}
if ( p->isEnumType() ) {
if ( v.type() == QVariant::String || v.type() == QVariant::CString ) {
if ( p->isSetType() ) {
QString s = value.toString();
QStringList l = QStringList::split( '|', s );
QStrList keys;
for ( QStringList::Iterator it = l.begin(); it != l.end(); ++it )
keys.append( (*it).stripWhiteSpace().latin1() );
v = QVariant( p->keysToValue( keys ) );
} else {
v = QVariant( p->keyToValue( value.toCString().data() ) );
}
} else if ( v.type() != QVariant::Int && v.type() != QVariant::UInt ) {
return FALSE;
}
return qt_property( id, 0, &v );
}
QVariant::Type type = (QVariant::Type)(p->flags >> 24);
if ( type == QVariant::Invalid )
type = QVariant::nameToType( p->type() );
if ( type != QVariant::Invalid && !v.canCast( type ) )
return FALSE;
return qt_property( id, 0, &v );
}
# 2436 "kernel/qobject.cpp"
QVariant QObject::property( const char *name ) const
{
QVariant v;
QMetaObject* meta = metaObject();
if ( !meta )
return v;
int id = meta->findProperty( name, TRUE );
const QMetaProperty* p = meta->property( id, TRUE );
if ( !p || !p->isValid() ) {
qWarning( "%s::property( \"%s\" ) failed: property invalid or does not exist",
className(), name );
return QVariant( FALSE, 0 );
}
QObject* that = (QObject*) this;
that->qt_property( id, 1, &v );
return v;
}
uint QObject::registerUserData()
{
static int user_data_registration = 0;
return user_data_registration++;
}
QObjectUserData::~QObjectUserData()
{
}
void QObject::setUserData( uint id, QObjectUserData* data)
{
if ( !d )
d = new QObjectPrivate( id+1 );
if ( id >= d->size() )
d->resize( id+1 );
d->insert( id, data );
}
QObjectUserData* QObject::userData( uint id ) const
{
if ( d && id < d->size() )
return d->at( id );
return 0;
}
>Fix:
For a workaround: avoid optimization level 2 (-O2).
>Release-Note:
>Audit-Trail:
>Unformatted:
^ permalink raw reply [flat|nested] 2+ messages in thread
end of thread, other threads:[~2003-03-11 22:35 UTC | newest]
Thread overview: 2+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2003-03-11 22:35 optimization/8241: g++ ICE for optimization -O2 neroden
-- strict thread matches above, loose matches on Subject: below --
2002-10-16 8:26 christoph.kluge
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for read-only IMAP folder(s) and NNTP newsgroup(s).