// /usr/lib/gcc-lib/i386-pc-linux-gnu/3.3.4/cc1plus -quiet -I. -I. -I.. -I/usr/kde/3.3/include -I/usr/qt/3/include -I/usr/X11R6/include -D__GNUC__=3 -D__GNUC_MINOR__=3 -D__GNUC_PATCHLEVEL__=4 -D_GNU_SOURCE -DHAVE_CONFIG_H -DQT_THREAD_SUPPORT -D_REENTRANT -D_XOPEN_SOURCE=500 -D_BSD_SOURCE -DNDEBUG -DNO_DEBUG -DQT_CLEAN_NAMESPACE -DQT_NO_ASCII_CAST -DQT_NO_STL -DQT_NO_COMPAT -DQT_NO_TRANSLATION converterdialog.cc -D__GNUG__=3 -quiet -dumpbase converterdialog.cc -mcpu=i586 -ansi -auxbase-strip converterdialog.o -O2 -O2 -Wnon-virtual-dtor -Wno-long-long -Wundef -Wcast-align -Wconversion -Wchar-subscripts -Wall -W -Wpointer-arith -Wwrite-strings -Wformat-security -Wmissing-format-attribute -ansi -fomit-frame-pointer -fno-exceptions -fno-check-new -fno-common -o - -frandom-seed=0
# 1 "converterdialog.cc"
# 1 "<built-in>"
# 1 "<command line>"
# 1 "converterdialog.cc"
# 22 "converterdialog.cc"
# 1 "/usr/qt/3/include/qlabel.h" 1
# 42 "/usr/qt/3/include/qlabel.h"
# 1 "/usr/qt/3/include/qframe.h" 1
# 42 "/usr/qt/3/include/qframe.h"
# 1 "/usr/qt/3/include/qwidget.h" 1
# 42 "/usr/qt/3/include/qwidget.h"
# 1 "/usr/qt/3/include/qwindowdefs.h" 1
# 43 "/usr/qt/3/include/qwindowdefs.h"
# 1 "/usr/qt/3/include/qobjectdefs.h" 1
# 42 "/usr/qt/3/include/qobjectdefs.h"
# 1 "/usr/qt/3/include/qglobal.h" 1
# 609 "/usr/qt/3/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;
# 673 "/usr/qt/3/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);
}
# 693 "/usr/qt/3/include/qglobal.h"
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;
# 714 "/usr/qt/3/include/qglobal.h"
typedef long long Q_INT64;
typedef unsigned long long Q_UINT64;

typedef Q_INT64 Q_LLONG;
typedef Q_UINT64 Q_ULLONG;







    typedef Q_ULONG QtOffset;







class QDataStream;
# 758 "/usr/qt/3/include/qglobal.h"
# 1 "/usr/qt/3/include/qconfig.h" 1
# 759 "/usr/qt/3/include/qglobal.h" 2
# 768 "/usr/qt/3/include/qglobal.h"
# 1 "/usr/qt/3/include/qmodules.h" 1
# 769 "/usr/qt/3/include/qglobal.h" 2
# 824 "/usr/qt/3/include/qglobal.h"
# 1 "/usr/qt/3/include/qfeatures.h" 1
# 825 "/usr/qt/3/include/qglobal.h" 2
# 891 "/usr/qt/3/include/qglobal.h"
 const char *qVersion();
 bool qSysInfo( int *wordSize, bool *bigEndian );
 bool qSharedBuild();
# 952 "/usr/qt/3/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 );
# 1016 "/usr/qt/3/include/qglobal.h"
 bool qt_check_pointer( bool c, const char *, int );
# 1030 "/usr/qt/3/include/qglobal.h"
enum QtMsgType { QtDebugMsg, QtWarningMsg, QtFatalMsg };

typedef void (*QtMsgHandler)(QtMsgType, const char *);
 QtMsgHandler qInstallMsgHandler( QtMsgHandler );





 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();
 const char *qInstallPathTranslations();
 const char *qInstallPathSysconf();
# 43 "/usr/qt/3/include/qobjectdefs.h" 2
# 72 "/usr/qt/3/include/qobjectdefs.h"
struct QUObject;
# 152 "/usr/qt/3/include/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 * );



 void *qt_inheritedBy( QMetaObject *super, const QObject *cls );

template <typename T>
 T qt_cast(const QObject *object)
{ return (T)qt_inheritedBy( ((T)0)->staticMetaObject(), object ); }
# 44 "/usr/qt/3/include/qwindowdefs.h" 2
# 1 "/usr/qt/3/include/qstring.h" 1
# 42 "/usr/qt/3/include/qstring.h"
# 1 "/usr/qt/3/include/qcstring.h" 1
# 43 "/usr/qt/3/include/qcstring.h"
# 1 "/usr/qt/3/include/qmemarray.h" 1
# 42 "/usr/qt/3/include/qmemarray.h"
# 1 "/usr/qt/3/include/qgarray.h" 1
# 42 "/usr/qt/3/include/qgarray.h"
# 1 "/usr/qt/3/include/qshared.h" 1
# 42 "/usr/qt/3/include/qshared.h"
# 1 "/usr/qt/3/include/qglobal.h" 1
# 43 "/usr/qt/3/include/qshared.h" 2



struct QShared
{
    QShared() : count( 1 ) { }
    void ref() { count++; }
    bool deref() { return !--count; }
    uint count;
};
# 43 "/usr/qt/3/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();
    enum Optimization { MemOptim, SpeedOptim };
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, Optimization optim );
    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 "/usr/qt/3/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 resize( uint size, Optimization optim ) { return QGArray::resize(size*sizeof(type), optim); }
    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(); }
};






# 1 "/usr/qt/3/include/qwinexport.h" 1
# 118 "/usr/qt/3/include/qmemarray.h" 2
# 44 "/usr/qt/3/include/qcstring.h" 2


# 1 "/usr/include/string.h" 1 3 4
# 26 "/usr/include/string.h" 3 4
# 1 "/usr/include/features.h" 1 3 4
# 295 "/usr/include/features.h" 3 4
# 1 "/usr/include/sys/cdefs.h" 1 3 4
# 296 "/usr/include/features.h" 2 3 4
# 318 "/usr/include/features.h" 3 4
# 1 "/usr/include/gnu/stubs.h" 1 3 4
# 319 "/usr/include/features.h" 2 3 4
# 27 "/usr/include/string.h" 2 3 4

extern "C" {




# 1 "/usr/lib/gcc-lib/i386-pc-linux-gnu/3.3.4/include/stddef.h" 1 3 4
# 213 "/usr/lib/gcc-lib/i386-pc-linux-gnu/3.3.4/include/stddef.h" 3 4
typedef unsigned int size_t;
# 34 "/usr/include/string.h" 2 3 4




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 4
# 28 "/usr/include/xlocale.h" 3 4
typedef struct __locale_struct
{

  struct locale_data *__locales[13];


  const unsigned short int *__ctype_b;
  const int *__ctype_tolower;
  const int *__ctype_toupper;


  const char *__names[13];
} *__locale_t;
# 115 "/usr/include/string.h" 2 3 4


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__));
# 160 "/usr/include/string.h" 3 4


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 *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 char *strcasestr (__const char *__haystack, __const char *__needle)
     throw () __attribute__ ((__pure__));






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 ();

# 268 "/usr/include/string.h" 3 4
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 ();
# 400 "/usr/include/string.h" 3 4
}
# 47 "/usr/qt/3/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) : 0u; }

 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 );
# 98 "/usr/qt/3/include/qcstring.h"
 Q_UINT16 qChecksum( const char *s, uint len );
# 116 "/usr/qt/3/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 );
private:
    int find( const char *str, int index, bool cs, uint l ) const;
};






 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;
}
# 1 "/usr/qt/3/include/qwinexport.h" 1
# 389 "/usr/qt/3/include/qcstring.h" 2
# 43 "/usr/qt/3/include/qstring.h" 2



# 1 "/usr/lib/gcc-lib/i386-pc-linux-gnu/3.3.4/include/limits.h" 1 3 4
# 11 "/usr/lib/gcc-lib/i386-pc-linux-gnu/3.3.4/include/limits.h" 3 4
# 1 "/usr/lib/gcc-lib/i386-pc-linux-gnu/3.3.4/include/syslimits.h" 1 3 4






# 1 "/usr/lib/gcc-lib/i386-pc-linux-gnu/3.3.4/include/limits.h" 1 3 4
# 122 "/usr/lib/gcc-lib/i386-pc-linux-gnu/3.3.4/include/limits.h" 3 4
# 1 "/usr/include/limits.h" 1 3 4
# 144 "/usr/include/limits.h" 3 4
# 1 "/usr/include/bits/posix1_lim.h" 1 3 4
# 130 "/usr/include/bits/posix1_lim.h" 3 4
# 1 "/usr/include/bits/local_lim.h" 1 3 4
# 36 "/usr/include/bits/local_lim.h" 3 4
# 1 "/usr/include/linux/limits.h" 1 3 4
# 37 "/usr/include/bits/local_lim.h" 2 3 4
# 131 "/usr/include/bits/posix1_lim.h" 2 3 4
# 145 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/posix2_lim.h" 1 3 4
# 149 "/usr/include/limits.h" 2 3 4



# 1 "/usr/include/bits/xopen_lim.h" 1 3 4
# 34 "/usr/include/bits/xopen_lim.h" 3 4
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 35 "/usr/include/bits/xopen_lim.h" 2 3 4
# 153 "/usr/include/limits.h" 2 3 4
# 123 "/usr/lib/gcc-lib/i386-pc-linux-gnu/3.3.4/include/limits.h" 2 3 4
# 8 "/usr/lib/gcc-lib/i386-pc-linux-gnu/3.3.4/include/syslimits.h" 2 3 4
# 12 "/usr/lib/gcc-lib/i386-pc-linux-gnu/3.3.4/include/limits.h" 2 3 4
# 47 "/usr/qt/3/include/qstring.h" 2
# 68 "/usr/qt/3/include/qstring.h"
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), issimpletext(TRUE), maxl(0), islatin1(FALSE) { ref(); }
    QStringData(QChar *u, uint l, uint m) :
        QShared(), unicode(u), ascii(0), len(l), issimpletext(FALSE), maxl(m), islatin1(FALSE) { }
    ~QStringData() { if ( unicode ) delete[] ((char*)unicode);
                     if ( ascii ) delete[] ascii; }

    void deleteSelf();
    QChar *unicode;
    char *ascii;
    void setDirty() {
        if ( ascii ) {
            delete [] ascii;
            ascii = 0;
        }
        issimpletext = FALSE;
    }



    uint len : 30;

    uint issimpletext : 1;



    uint maxl : 30;

    uint islatin1 : 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( Q_LLONG a, int fieldwidth=0, int base=10 ) const;
    QString arg( Q_ULLONG 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( double a, int fieldWidth = 0, char fmt = 'g',
                 int prec = -1 ) 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( const QString& a1, const QString& a2 ) const;
    QString arg( const QString& a1, const QString& a2,
                 const QString& a3 ) const;
    QString arg( const QString& a1, const QString& a2, const QString& a3,
                 const QString& a4 ) 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 &reg, 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 QByteArray & );
    QString &insert( uint index, const char * );

    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( const QString & );
    QString &remove( const QString &, bool cs );

    QString &remove( QChar c );
    QString &remove( char c )
    { return remove( QChar(c) ); }

    QString &remove( const char * );


    QString &remove( const QRegExp & );

    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( QChar c, const QString &, bool );


    QString &replace( char c, const QString & after )
    { return replace( QChar(c), after, TRUE ); }
    QString &replace( char c, const QString & after, bool cs )
    { return replace( QChar(c), after, cs ); }


    QString &replace( const QString &, const QString & );
    QString &replace( const QString &, const QString &, bool );


    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;
    Q_LLONG toLongLong( bool *ok=0, int base=10 ) const;
    Q_ULLONG toULongLong( 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( Q_LLONG, int base=10 );
    QString &setNum( Q_ULLONG, 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( Q_LLONG, int base=10 );
    static QString number( Q_ULLONG, 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;
    static QString fromAscii(const char*, int len=-1);
    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;







    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 &setAscii( const char*, int len=-1 );
    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();
# 701 "/usr/qt/3/include/qstring.h"
    bool startsWith( const QString& str ) const;
    bool startsWith( const QString& str, bool cs ) const;


    bool endsWith( const QString& str ) const;
    bool endsWith( const QString& str, bool cs ) const;


    void setLength( uint newLength );

    uint capacity() const;
    void reserve( uint minCapacity );
    void squeeze();

    bool simpleText() const { if ( !d->issimpletext ) checkSimpleText(); return (bool)d->issimpletext; }
    bool isRightToLeft() const;


private:
    QString( int size, bool );

    void deref();
    void real_detach();
    void subat( uint );
    QString multiArg( int numArgs, const QString& a1, const QString& a2,
                      const QString& a3 = QString::null,
                      const QString& a4 = QString::null ) const;

    void checkSimpleText() const;
    void grow( uint newLength );

    QString &insertHelper( uint index, const char *s, uint len=(2147483647 * 2U + 1U) );
    QString &operatorPlusEqHelper( const char *s, uint len2=(2147483647 * 2U + 1U) );


    static QChar* latin1ToUnicode( const char*, uint * len, uint maxlen=(uint)-1 );
    static QChar* latin1ToUnicode( const QByteArray&, uint * len );
    static char* unicodeToLatin1( 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 & );
# 838 "/usr/qt/3/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 uint QString::capacity() const
{ return d->maxl; }

inline bool QString::isEmpty() const
{ return length() == 0; }

inline QString QString::copy() const
{ return QString( *this ); }


inline QString &QString::insert( uint index, const char *s )
{ return insertHelper( index, s ); }

inline QString &QString::insert( uint index, const QByteArray &s )
{
    int pos = s.find( 0 );
    return insertHelper( index, s, pos==-1 ? s.size() : pos );
}


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); }



inline QString &QString::operator+=( const QByteArray &s )
{
    int pos = s.find( 0 );
    return operatorPlusEqHelper( s, pos==-1 ? s.size() : pos );
}


inline QString &QString::append( const QString & s )
{ return operator+=(s); }


inline QString &QString::append( const QByteArray &s )
{ return operator+=(s); }

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); }
# 952 "/usr/qt/3/include/qstring.h"
inline QString &QString::setNum( short n, int base )
{ return setNum((Q_LLONG)n, base); }

inline QString &QString::setNum( ushort n, int base )
{ return setNum((Q_ULLONG)n, base); }

inline QString &QString::setNum( int n, int base )
{ return setNum((Q_LLONG)n, base); }

inline QString &QString::setNum( uint n, int base )
{ return setNum((Q_ULLONG)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( (Q_LLONG)a, fieldWidth, base ); }

inline QString QString::arg( uint a, int fieldWidth, int base ) const
{ return arg( (Q_ULLONG)a, fieldWidth, base ); }

inline QString QString::arg( short a, int fieldWidth, int base ) const
{ return arg( (Q_LLONG)a, fieldWidth, base ); }

inline QString QString::arg( ushort a, int fieldWidth, int base ) const
{ return arg( (Q_ULLONG)a, fieldWidth, base ); }

inline QString QString::arg( const QString& a1, const QString& a2 ) const {
    return multiArg( 2, a1, a2 );
}

inline QString QString::arg( const QString& a1, const QString& a2,
                             const QString& a3 ) const {
    return multiArg( 3, a1, a2, a3 );
}

inline QString QString::arg( const QString& a1, const QString& a2,
                             const QString& a3, const QString& a4 ) const {
    return multiArg( 4, a1, a2, a3, a4 );
}

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::fromAscii(str), index); }

inline int QString::findRev( const char* str, int index ) const
{ return findRev(QString::fromAscii(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::fromAscii(s2);
    return tmp;
}

 inline const QString operator+( const char *s1, const QString &s2 )
{
    QString tmp = QString::fromAscii( 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;
}
# 1109 "/usr/qt/3/include/qstring.h"
# 1 "/usr/qt/3/include/qwinexport.h" 1
# 1110 "/usr/qt/3/include/qstring.h" 2
# 45 "/usr/qt/3/include/qwindowdefs.h" 2
# 1 "/usr/qt/3/include/qnamespace.h" 1
# 42 "/usr/qt/3/include/qnamespace.h"
# 1 "/usr/qt/3/include/qglobal.h" 1
# 43 "/usr/qt/3/include/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 SortOrder {
        Ascending,
        Descending
    };






    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,
        Underline = 0x01000000,
        Overline = 0x02000000,
        StrikeOut = 0x04000000,
        IncludeTrailingSpaces = 0x08000000,

        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_FullScreen = 0x00010000,
        WState_OwnSizePolicy = 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,
        WMacNoSheet = 0x00000000,
        WMacDrawer = 0x00000000,
# 218 "/usr/qt/3/include/qnamespace.h"
        WGroupLeader = 0x02000000,
        WShowModal = 0x04000000,
        WNoMousePropagation = 0x08000000,
        WSubWindow = 0x10000000,

        WStyle_Splash = 0x20000000,



        WNoAutoErase = WRepaintNoErase | WResizeNoErase







    };

    enum WindowState {
        WindowNoState = 0x00000000,
        WindowMinimized = 0x00000001,
        WindowMaximized = 0x00000002,
        WindowFullScreen = 0x00000004,
        WindowActive = 0x00000008
    };






    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
    };
# 295 "/usr/qt/3/include/qnamespace.h"
    enum GUIStyle {
        WindowsStyle = 1,
        MotifStyle = 4
    };
# 310 "/usr/qt/3/include/qnamespace.h"
    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 MacintoshVersion {

        MV_Unknown = 0x0000,


        MV_9 = 0x0001,
        MV_10_DOT_0 = 0x0002,
        MV_10_DOT_1 = 0x0003,
        MV_10_DOT_2 = 0x0004,
        MV_10_DOT_3 = 0x0005,


        MV_CHEETAH = MV_10_DOT_0,
        MV_PUMA = MV_10_DOT_1,
        MV_JAGUAR = MV_10_DOT_2,
        MV_PANTHER = MV_10_DOT_3
    };


    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_2003 = 0x0040,
        WV_NT_based = 0x00f0,

        WV_CE = 0x0100,
        WV_CENET = 0x0200,
        WV_CE_based = 0x0f00
    };


    enum UIEffect {
        UI_General,
        UI_AnimateMenu,
        UI_FadeMenu,
        UI_AnimateCombo,
        UI_AnimateTooltip,
        UI_FadeTooltip,
        UI_AnimateToolBox
    };


    enum CursorShape {
        ArrowCursor,
        UpArrowCursor,
        CrossCursor,
        WaitCursor,
        IbeamCursor,
        SizeVerCursor,
        SizeHorCursor,
        SizeBDiagCursor,
        SizeFDiagCursor,
        SizeAllCursor,
        BlankCursor,
        SplitVCursor,
        SplitHCursor,
        PointingHandCursor,
        ForbiddenCursor,
        WhatsThisCursor,
        BusyCursor,
        LastCursor = BusyCursor,
        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;
    static const QCursor & busyCursor;


    enum TextFormat {
        PlainText,
        RichText,
        AutoText,
        LogText
    };


    enum AnchorAttribute {
        AnchorName,
        AnchorHref
    };


    enum Dock {
        DockUnmanaged,
        DockTornOff,
        DockTop,
        DockBottom,
        DockRight,
        DockLeft,
        DockMinimized
# 824 "/usr/qt/3/include/qnamespace.h"
    };

    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
    };


    enum Corner {
        TopLeft = 0x00000,
        TopRight = 0x00001,
        BottomLeft = 0x00002,
        BottomRight = 0x00003
    };
# 891 "/usr/qt/3/include/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 "/usr/qt/3/include/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 "/usr/qt/3/include/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 );

 const char *qAppClass();
# 166 "/usr/qt/3/include/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 );
# 43 "/usr/qt/3/include/qwidget.h" 2
# 1 "/usr/qt/3/include/qobject.h" 1
# 45 "/usr/qt/3/include/qobject.h"
# 1 "/usr/qt/3/include/qevent.h" 1
# 43 "/usr/qt/3/include/qevent.h"
# 1 "/usr/qt/3/include/qregion.h" 1
# 43 "/usr/qt/3/include/qregion.h"
# 1 "/usr/qt/3/include/qrect.h" 1
# 42 "/usr/qt/3/include/qrect.h"
# 1 "/usr/qt/3/include/qsize.h" 1
# 42 "/usr/qt/3/include/qsize.h"
# 1 "/usr/qt/3/include/qpoint.h" 1
# 46 "/usr/qt/3/include/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));
}


# 1 "/usr/qt/3/include/qwinexport.h" 1
# 216 "/usr/qt/3/include/qpoint.h" 2
# 43 "/usr/qt/3/include/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 "/usr/qt/3/include/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:

    friend void qt_setCoords( QRect *r, int xp1, int yp1, int xp2, int yp2 );







    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;
}

# 1 "/usr/qt/3/include/qwinexport.h" 1
# 273 "/usr/qt/3/include/qrect.h" 2
# 44 "/usr/qt/3/include/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 "/usr/qt/3/include/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;
# 149 "/usr/qt/3/include/qregion.h"
};
# 169 "/usr/qt/3/include/qregion.h"
 QDataStream &operator<<( QDataStream &, const QRegion & );
 QDataStream &operator>>( QDataStream &, QRegion & );
# 44 "/usr/qt/3/include/qevent.h" 2

# 1 "/usr/qt/3/include/qmime.h" 1
# 43 "/usr/qt/3/include/qmime.h"
# 1 "/usr/qt/3/include/qmap.h" 1
# 42 "/usr/qt/3/include/qmap.h"
# 1 "/usr/qt/3/include/qglobal.h" 1
# 43 "/usr/qt/3/include/qmap.h" 2

# 1 "/usr/qt/3/include/qdatastream.h" 1
# 42 "/usr/qt/3/include/qdatastream.h"
# 1 "/usr/qt/3/include/qiodevice.h" 1
# 42 "/usr/qt/3/include/qiodevice.h"
# 1 "/usr/qt/3/include/qglobal.h" 1
# 43 "/usr/qt/3/include/qiodevice.h" 2
# 88 "/usr/qt/3/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 "/usr/qt/3/include/qdatastream.h" 2




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_INT64 &i );
    QDataStream &operator>>( Q_UINT64 &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_INT64 i );
    QDataStream &operator<<( Q_UINT64 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_UINT64 &i )
{ return *this >> (Q_INT64&)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_UINT64 i )
{ return *this << (Q_INT64)i; }


inline QDataStream &QDataStream::operator<<( Q_ULONG i )
{ return *this << (Q_LONG)i; }
# 45 "/usr/qt/3/include/qmap.h" 2
# 1 "/usr/qt/3/include/qpair.h" 1
# 40 "/usr/qt/3/include/qpair.h"
# 1 "/usr/qt/3/include/qglobal.h" 1
# 41 "/usr/qt/3/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 )
    {}

    QPair<T1, T2>& operator=(const QPair<T1, T2>& other)
    {
        if (this != &other) {
            first = other.first;
            second = other.second;
        }
        return *this;
    }

    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 "/usr/qt/3/include/qmap.h" 2
# 1 "/usr/qt/3/include/qvaluelist.h" 1
# 42 "/usr/qt/3/include/qvaluelist.h"
# 1 "/usr/qt/3/include/qtl.h" 1
# 42 "/usr/qt/3/include/qtl.h"
# 1 "/usr/qt/3/include/qglobal.h" 1
# 43 "/usr/qt/3/include/qtl.h" 2
# 1 "/usr/qt/3/include/qtextstream.h" 1
# 44 "/usr/qt/3/include/qtextstream.h"
# 1 "/usr/include/stdio.h" 1 3 4
# 30 "/usr/include/stdio.h" 3 4
extern "C" {



# 1 "/usr/lib/gcc-lib/i386-pc-linux-gnu/3.3.4/include/stddef.h" 1 3 4
# 35 "/usr/include/stdio.h" 2 3 4

# 1 "/usr/include/bits/types.h" 1 3 4
# 28 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/wordsize.h" 1 3 4
# 29 "/usr/include/bits/types.h" 2 3 4


# 1 "/usr/lib/gcc-lib/i386-pc-linux-gnu/3.3.4/include/stddef.h" 1 3 4
# 32 "/usr/include/bits/types.h" 2 3 4


typedef unsigned char __u_char;
typedef unsigned short int __u_short;
typedef unsigned int __u_int;
typedef unsigned long int __u_long;


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;







__extension__ typedef long long int __quad_t;
__extension__ typedef unsigned long long int __u_quad_t;
# 129 "/usr/include/bits/types.h" 3 4
# 1 "/usr/include/bits/typesizes.h" 1 3 4
# 130 "/usr/include/bits/types.h" 2 3 4






__extension__ typedef unsigned long long int __dev_t;
__extension__ typedef unsigned int __uid_t;
__extension__ typedef unsigned int __gid_t;
__extension__ typedef unsigned long int __ino_t;
__extension__ typedef unsigned long long int __ino64_t;
__extension__ typedef unsigned int __mode_t;
__extension__ typedef unsigned int __nlink_t;
__extension__ typedef long int __off_t;
__extension__ typedef long long int __off64_t;
__extension__ typedef int __pid_t;
__extension__ typedef struct { int __val[2]; } __fsid_t;
__extension__ typedef long int __clock_t;
__extension__ typedef unsigned long int __rlim_t;
__extension__ typedef unsigned long long int __rlim64_t;
__extension__ typedef unsigned int __id_t;
__extension__ typedef long int __time_t;
__extension__ typedef unsigned int __useconds_t;
__extension__ typedef long int __suseconds_t;

__extension__ typedef int __daddr_t;
__extension__ typedef long int __swblk_t;
__extension__ typedef int __key_t;


__extension__ typedef int __clockid_t;


__extension__ typedef int __timer_t;


__extension__ typedef long int __blksize_t;




__extension__ typedef long int __blkcnt_t;
__extension__ typedef long long int __blkcnt64_t;


__extension__ typedef unsigned long int __fsblkcnt_t;
__extension__ typedef unsigned long long int __fsblkcnt64_t;


__extension__ typedef unsigned long int __fsfilcnt_t;
__extension__ typedef unsigned long long int __fsfilcnt64_t;

__extension__ typedef int __ssize_t;



typedef __off64_t __loff_t;
typedef __quad_t *__qaddr_t;
typedef char *__caddr_t;


__extension__ typedef int __intptr_t;


__extension__ typedef unsigned int __socklen_t;
# 37 "/usr/include/stdio.h" 2 3 4









typedef struct _IO_FILE FILE;





# 62 "/usr/include/stdio.h" 3 4
typedef struct _IO_FILE __FILE;
# 72 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/libio.h" 1 3 4
# 32 "/usr/include/libio.h" 3 4
# 1 "/usr/include/_G_config.h" 1 3 4
# 14 "/usr/include/_G_config.h" 3 4
# 1 "/usr/lib/gcc-lib/i386-pc-linux-gnu/3.3.4/include/stddef.h" 1 3 4
# 354 "/usr/lib/gcc-lib/i386-pc-linux-gnu/3.3.4/include/stddef.h" 3 4
typedef unsigned int wint_t;
# 15 "/usr/include/_G_config.h" 2 3 4
# 24 "/usr/include/_G_config.h" 3 4
# 1 "/usr/include/wchar.h" 1 3 4
# 48 "/usr/include/wchar.h" 3 4
# 1 "/usr/lib/gcc-lib/i386-pc-linux-gnu/3.3.4/include/stddef.h" 1 3 4
# 49 "/usr/include/wchar.h" 2 3 4

# 1 "/usr/include/bits/wchar.h" 1 3 4
# 51 "/usr/include/wchar.h" 2 3 4
# 76 "/usr/include/wchar.h" 3 4
typedef struct
{
  int __count;
  union
  {
    wint_t __wch;
    char __wchb[4];
  } __value;
} __mbstate_t;
# 25 "/usr/include/_G_config.h" 2 3 4

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 4
# 1 "/usr/include/gconv.h" 1 3 4
# 28 "/usr/include/gconv.h" 3 4
# 1 "/usr/include/wchar.h" 1 3 4
# 48 "/usr/include/wchar.h" 3 4
# 1 "/usr/lib/gcc-lib/i386-pc-linux-gnu/3.3.4/include/stddef.h" 1 3 4
# 49 "/usr/include/wchar.h" 2 3 4
# 29 "/usr/include/gconv.h" 2 3 4


# 1 "/usr/lib/gcc-lib/i386-pc-linux-gnu/3.3.4/include/stddef.h" 1 3 4
# 32 "/usr/include/gconv.h" 2 3 4





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 wint_t (*__gconv_btowc_fct) (struct __gconv_step *, unsigned char);


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_btowc_fct __btowc_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 4
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 4
# 53 "/usr/include/libio.h" 3 4
# 1 "/usr/lib/gcc-lib/i386-pc-linux-gnu/3.3.4/include/stdarg.h" 1 3 4
# 43 "/usr/lib/gcc-lib/i386-pc-linux-gnu/3.3.4/include/stdarg.h" 3 4
typedef __builtin_va_list __gnuc_va_list;
# 54 "/usr/include/libio.h" 2 3 4
# 163 "/usr/include/libio.h" 3 4
struct _IO_jump_t; struct _IO_FILE;
# 173 "/usr/include/libio.h" 3 4
typedef void _IO_lock_t;





struct _IO_marker {
  struct _IO_marker *_next;
  struct _IO_FILE *_sbuf;



  int _pos;
# 196 "/usr/include/libio.h" 3 4
};


enum __codecvt_result
{
  __codecvt_ok,
  __codecvt_partial,
  __codecvt_error,
  __codecvt_noconv
};
# 264 "/usr/include/libio.h" 3 4
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 _flags2;

  __off_t _old_offset;



  unsigned short _cur_column;
  signed char _vtable_offset;
  char _shortbuf[1];



  _IO_lock_t *_lock;
# 312 "/usr/include/libio.h" 3 4
  __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_;
# 351 "/usr/include/libio.h" 3 4
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 ();
# 441 "/usr/include/libio.h" 3 4
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 ();
# 471 "/usr/include/libio.h" 3 4
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 ();
# 529 "/usr/include/libio.h" 3 4
}
# 73 "/usr/include/stdio.h" 2 3 4




typedef __gnuc_va_list va_list;
# 86 "/usr/include/stdio.h" 3 4


typedef _G_fpos_t fpos_t;





typedef _G_fpos64_t fpos64_t;
# 138 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio_lim.h" 1 3 4
# 139 "/usr/include/stdio.h" 2 3 4



extern struct _IO_FILE *stdin;
extern struct _IO_FILE *stdout;
extern struct _IO_FILE *stderr;







extern int remove (__const char *__filename) throw ();

extern int rename (__const char *__old, __const char *__new) throw ();









extern FILE *tmpfile (void);
# 174 "/usr/include/stdio.h" 3 4
extern FILE *tmpfile64 (void);



extern char *tmpnam (char *__s) throw ();





extern char *tmpnam_r (char *__s) throw ();
# 196 "/usr/include/stdio.h" 3 4
extern char *tempnam (__const char *__dir, __const char *__pfx)
     throw () __attribute__ ((__malloc__));








extern int fclose (FILE *__stream);




extern int fflush (FILE *__stream);

# 221 "/usr/include/stdio.h" 3 4
extern int fflush_unlocked (FILE *__stream);
# 231 "/usr/include/stdio.h" 3 4
extern int fcloseall (void);









extern FILE *fopen (__const char *__restrict __filename,
                    __const char *__restrict __modes);




extern FILE *freopen (__const char *__restrict __filename,
                      __const char *__restrict __modes,
                      FILE *__restrict __stream);
# 262 "/usr/include/stdio.h" 3 4


extern FILE *fopen64 (__const char *__restrict __filename,
                      __const char *__restrict __modes);
extern FILE *freopen64 (__const char *__restrict __filename,
                        __const char *__restrict __modes,
                        FILE *__restrict __stream);




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, ...);




extern int printf (__const char *__restrict __format, ...);

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);




extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg);

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)
     __attribute__ ((__format__ (__printf__, 2, 0)));
extern int dprintf (int __fd, __const char *__restrict __fmt, ...)
     __attribute__ ((__format__ (__printf__, 2, 3)));








extern int fscanf (FILE *__restrict __stream,
                   __const char *__restrict __format, ...);




extern int scanf (__const char *__restrict __format, ...);

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)
     __attribute__ ((__format__ (__scanf__, 2, 0)));





extern int vscanf (__const char *__restrict __format, __gnuc_va_list __arg)
     __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);
extern int getc (FILE *__stream);





extern int getchar (void);

# 454 "/usr/include/stdio.h" 3 4
extern int getc_unlocked (FILE *__stream);
extern int getchar_unlocked (void);
# 465 "/usr/include/stdio.h" 3 4
extern int fgetc_unlocked (FILE *__stream);











extern int fputc (int __c, FILE *__stream);
extern int putc (int __c, FILE *__stream);





extern int putchar (int __c);

# 498 "/usr/include/stdio.h" 3 4
extern int fputc_unlocked (int __c, FILE *__stream);







extern int putc_unlocked (int __c, FILE *__stream);
extern int putchar_unlocked (int __c);






extern int getw (FILE *__stream);


extern int putw (int __w, FILE *__stream);








extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream);






extern char *gets (char *__s);

# 543 "/usr/include/stdio.h" 3 4
extern char *fgets_unlocked (char *__restrict __s, int __n,
                             FILE *__restrict __stream);
# 559 "/usr/include/stdio.h" 3 4
extern __ssize_t __getdelim (char **__restrict __lineptr,
                               size_t *__restrict __n, int __delimiter,
                               FILE *__restrict __stream);
extern __ssize_t getdelim (char **__restrict __lineptr,
                             size_t *__restrict __n, int __delimiter,
                             FILE *__restrict __stream);







extern __ssize_t getline (char **__restrict __lineptr,
                            size_t *__restrict __n,
                            FILE *__restrict __stream);








extern int fputs (__const char *__restrict __s, FILE *__restrict __stream);





extern int puts (__const char *__s);






extern int ungetc (int __c, FILE *__stream);






extern size_t fread (void *__restrict __ptr, size_t __size,
                     size_t __n, FILE *__restrict __stream);




extern size_t fwrite (__const void *__restrict __ptr, size_t __size,
                      size_t __n, FILE *__restrict __s);

# 620 "/usr/include/stdio.h" 3 4
extern int fputs_unlocked (__const char *__restrict __s,
                           FILE *__restrict __stream);
# 631 "/usr/include/stdio.h" 3 4
extern size_t fread_unlocked (void *__restrict __ptr, size_t __size,
                              size_t __n, FILE *__restrict __stream);
extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size,
                               size_t __n, FILE *__restrict __stream);








extern int fseek (FILE *__stream, long int __off, int __whence);




extern long int ftell (FILE *__stream);




extern void rewind (FILE *__stream);

# 667 "/usr/include/stdio.h" 3 4
extern int fseeko (FILE *__stream, __off_t __off, int __whence);




extern __off_t ftello (FILE *__stream);
# 686 "/usr/include/stdio.h" 3 4






extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos);




extern int fsetpos (FILE *__stream, __const fpos_t *__pos);
# 709 "/usr/include/stdio.h" 3 4



extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence);
extern __off64_t ftello64 (FILE *__stream);
extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos);
extern int fsetpos64 (FILE *__stream, __const fpos64_t *__pos);




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);






# 1 "/usr/include/bits/sys_errlist.h" 1 3 4
# 27 "/usr/include/bits/sys_errlist.h" 3 4
extern int sys_nerr;
extern __const char *__const sys_errlist[];


extern int _sys_nerr;
extern __const char *__const _sys_errlist[];
# 748 "/usr/include/stdio.h" 2 3 4




extern int fileno (FILE *__stream) throw ();




extern int fileno_unlocked (FILE *__stream) throw ();
# 767 "/usr/include/stdio.h" 3 4
extern FILE *popen (__const char *__command, __const char *__modes);





extern int pclose (FILE *__stream);





extern char *ctermid (char *__s) throw ();





extern char *cuserid (char *__s);




struct obstack;


extern int obstack_printf (struct obstack *__restrict __obstack,
                           __const char *__restrict __format, ...)
     throw () __attribute__ ((__format__ (__printf__, 2, 3)));
extern int obstack_vprintf (struct obstack *__restrict __obstack,
                            __const char *__restrict __format,
                            __gnuc_va_list __args)
     throw () __attribute__ ((__format__ (__printf__, 2, 0)));







extern void flockfile (FILE *__stream) throw ();



extern int ftrylockfile (FILE *__stream) throw ();


extern void funlockfile (FILE *__stream) throw ();
# 828 "/usr/include/stdio.h" 3 4
# 1 "/usr/include/bits/stdio.h" 1 3 4
# 33 "/usr/include/bits/stdio.h" 3 4
inline int
vprintf (__const char *__restrict __fmt, __gnuc_va_list __arg)
{
  return vfprintf (stdout, __fmt, __arg);
}


inline int
getchar (void)
{
  return _IO_getc (stdin);
}




inline int
getc_unlocked (FILE *__fp)
{
  return (__builtin_expect ((__fp)->_IO_read_ptr >= (__fp)->_IO_read_end, 0) ? __uflow (__fp) : *(unsigned char *) (__fp)->_IO_read_ptr++);
}


inline int
getchar_unlocked (void)
{
  return (__builtin_expect ((stdin)->_IO_read_ptr >= (stdin)->_IO_read_end, 0) ? __uflow (stdin) : *(unsigned char *) (stdin)->_IO_read_ptr++);
}




inline int
putchar (int __c)
{
  return _IO_putc (__c, stdout);
}




inline int
fputc_unlocked (int __c, FILE *__stream)
{
  return (__builtin_expect ((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end, 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}





inline int
putc_unlocked (int __c, FILE *__stream)
{
  return (__builtin_expect ((__stream)->_IO_write_ptr >= (__stream)->_IO_write_end, 0) ? __overflow (__stream, (unsigned char) (__c)) : (unsigned char) (*(__stream)->_IO_write_ptr++ = (__c)));
}


inline int
putchar_unlocked (int __c)
{
  return (__builtin_expect ((stdout)->_IO_write_ptr >= (stdout)->_IO_write_end, 0) ? __overflow (stdout, (unsigned char) (__c)) : (unsigned char) (*(stdout)->_IO_write_ptr++ = (__c)));
}





inline __ssize_t
getline (char **__lineptr, size_t *__n, FILE *__stream)
{
  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);
}
# 829 "/usr/include/stdio.h" 2 3 4


}
# 45 "/usr/qt/3/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 "/usr/qt/3/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;
}
# 121 "/usr/qt/3/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 "/usr/qt/3/include/qvaluelist.h" 2
# 58 "/usr/qt/3/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","/usr/qt/3/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","/usr/qt/3/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 "/usr/qt/3/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(); }







    ~QValueList() { sh->derefAndDelete(); }

    QValueList<T>& operator= ( const QValueList<T>& l )
    {
        l.sh->ref();
        sh->derefAndDelete();
        sh = l.sh;
        return *this;
    }
# 471 "/usr/qt/3/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 ); }
    const_iterator constBegin() const { return const_iterator( sh->node->next ); }
    iterator end() { detach(); return iterator( sh->node ); }
    const_iterator end() const { return const_iterator( sh->node ); }
    const_iterator constEnd() 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 );
# 517 "/usr/qt/3/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;
}




# 1 "/usr/qt/3/include/qwinexport.h" 1
# 664 "/usr/qt/3/include/qvaluelist.h" 2
# 47 "/usr/qt/3/include/qmap.h" 2
# 56 "/usr/qt/3/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;
    }
# 414 "/usr/qt/3/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);
}
# 587 "/usr/qt/3/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();
    }
# 641 "/usr/qt/3/include/qmap.h"
    ~QMap()
    {
        if ( sh->deref() )
            delete sh;
    }
    QMap<Key,T>& operator= ( const QMap<Key,T>& m );
# 660 "/usr/qt/3/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(); }
    const_iterator constBegin() const { return begin(); }
    const_iterator constEnd() const { return 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 );
# 735 "/usr/qt/3/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;
}



# 1 "/usr/qt/3/include/qwinexport.h" 1
# 873 "/usr/qt/3/include/qmap.h" 2
# 44 "/usr/qt/3/include/qmime.h" 2




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 "/usr/qt/3/include/qevent.h" 2



class QEvent: public Qt
{
public:
    enum Type {
# 61 "/usr/qt/3/include/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,
        WindowBlocked = 74,
        WindowUnblocked = 75,
        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,
        OkRequest = 94,
        HelpRequest = 95,
        WindowStateChange = 96,
        IconDrag = 97,
        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 ), mbAcc(TRUE)
    {}
    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){}
    QPaintEvent( const QRegion &paintRegion, const QRect &paintRect, bool erased = TRUE )
        : QEvent(Paint),
          rec(paintRect),
          reg(paintRegion),
          erase(erased){}

    const QRect &rect() const { return rec; }
    const QRegion &region() 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 QIconDragEvent : public QEvent
{
public:
    QIconDragEvent()
        : QEvent(IconDrag), 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( TRUE ), consum( TRUE ),
        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() { accpt = FALSE; 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(TRUE) {}
    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;
}
# 504 "/usr/qt/3/include/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 "/usr/qt/3/include/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; } private: static QMetaObject *metaObj;
   

public:
    QObject( QObject *parent=0, const char *name=0 );
    virtual ~QObject();
# 79 "/usr/qt/3/include/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 membcode, int member_index );

    void dumpObjectTree();
    void dumpObjectInfo();


    virtual bool setProperty( const char *name, const QVariant& value );
    virtual QVariant property( const char *name ) const;


    static QString tr( const char *sourceText, const char * = 0);

    static QString trUtf8( const char *sourceText, const char * = 0);




    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 );
}



inline QString QObject::tr( const char *sourceText, const char * ) {
    return QString::fromLatin1( sourceText );
}

inline QString QObject::trUtf8( const char *sourceText, const char * ) {
    return QString::fromUtf8( sourceText );
}





# 1 "/usr/qt/3/include/qwinexport.h" 1
# 259 "/usr/qt/3/include/qobject.h" 2
# 44 "/usr/qt/3/include/qwidget.h" 2
# 1 "/usr/qt/3/include/qpaintdevice.h" 1
# 51 "/usr/qt/3/include/qpaintdevice.h"
class QIODevice;
class QString;
class QTextItem;



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;
    const QTextItem *textItem;
    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 );
# 153 "/usr/qt/3/include/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,
        PdcDrawTextItem = 21,
        PdcDrawLast = PdcDrawTextItem,



        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;
# 232 "/usr/qt/3/include/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 "/usr/qt/3/include/qwidget.h" 2
# 1 "/usr/qt/3/include/qpalette.h" 1
# 43 "/usr/qt/3/include/qpalette.h"
# 1 "/usr/qt/3/include/qcolor.h" 1
# 43 "/usr/qt/3/include/qcolor.h"
# 1 "/usr/qt/3/include/qstringlist.h" 1
# 44 "/usr/qt/3/include/qstringlist.h"
# 1 "/usr/qt/3/include/qstrlist.h" 1
# 43 "/usr/qt/3/include/qstrlist.h"
# 1 "/usr/qt/3/include/qptrlist.h" 1
# 40 "/usr/qt/3/include/qptrlist.h"
# 1 "/usr/qt/3/include/qglist.h" 1
# 42 "/usr/qt/3/include/qglist.h"
# 1 "/usr/qt/3/include/qptrcollection.h" 1
# 40 "/usr/qt/3/include/qptrcollection.h"
# 1 "/usr/qt/3/include/qglobal.h" 1
# 41 "/usr/qt/3/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 "/usr/qt/3/include/qglist.h" 2


class QLNode
{
friend class QGList;
friend class QGListIterator;
friend class QGListStdIterator;
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;


    QLNode* begin() const { return firstNode; }
    QLNode* end() const { return 0; }
    QLNode* erase( QLNode* it );

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;
}

class QGListStdIterator
{
public:
    inline QGListStdIterator( QLNode* n ) : node( n ){}
    inline operator QLNode* () { return node; }
protected:
    inline QLNode *next() { return node->next; }
    QLNode *node;
};
# 41 "/usr/qt/3/include/qptrlist.h" 2


template<class type>
class QPtrListStdIterator : public QGListStdIterator
{
public:
    inline QPtrListStdIterator( QLNode* n ): QGListStdIterator(n) {}
    type *operator*() { return node ? (type *)node->getData() : 0; }
    inline QPtrListStdIterator<type> operator++()
    { node = next(); return *this; }
    inline QPtrListStdIterator<type> operator++(int)
    { QLNode* n = node; node = next(); return QPtrListStdIterator<type>( n ); }
    inline bool operator==( const QPtrListStdIterator<type>& it ) const { return node == it.node; }
    inline bool operator!=( const QPtrListStdIterator<type>& it ) const { return node != it.node; }
};


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); }



    typedef QPtrListStdIterator<type> Iterator;
    typedef QPtrListStdIterator<type> ConstIterator;
    inline Iterator begin() { return QGList::begin(); }
    inline ConstIterator begin() const { return QGList::begin(); }
    inline ConstIterator constBegin() const { return QGList::begin(); }
    inline Iterator end() { return QGList::end(); }
    inline ConstIterator end() const { return QGList::end(); }
    inline ConstIterator constEnd() const { return QGList::end(); }
    inline Iterator erase( Iterator it ) { return QGList::erase( it ); }

    typedef Iterator iterator;
    typedef ConstIterator const_iterator;
# 138 "/usr/qt/3/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; }
};







# 1 "/usr/qt/3/include/qwinexport.h" 1
# 191 "/usr/qt/3/include/qptrlist.h" 2
# 44 "/usr/qt/3/include/qstrlist.h" 2
# 52 "/usr/qt/3/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 "/usr/qt/3/include/qstringlist.h" 2




class QRegExp;
template <class T> class QDeepCopy;







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;


    QStringList& gres( const QString &before, const QString &after,
                       bool cs = TRUE );

    QStringList& gres( const QRegExp &expr, const QString &after );


protected:
    void detach() { QValueList<QString>::detach(); }
    friend class QDeepCopy< QStringList >;
};


class QDataStream;
extern QDataStream &operator>>( QDataStream &, QStringList& );
extern QDataStream &operator<<( QDataStream &, const QStringList& );
# 44 "/usr/qt/3/include/qcolor.h" 2


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 );

    QRgb rgb() const;
    void setRgb( int r, int g, int b );
    void setRgb( QRgb rgb );
    void getRgb( int *r, int *g, int *b ) const { rgb( r, g, b ); }
    void rgb( int *r, int *g, int *b ) const;

    int red() const;
    int green() const;
    int blue() const;

    void setHsv( int h, int s, int v );
    void getHsv( int *h, int *s, int *v ) const { hsv( h, s, v ); }
    void hsv( int *h, int *s, int *v ) const;
    void getHsv( int &h, int &s, int &v ) const { hsv( &h, &s, &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 );
# 138 "/usr/qt/3/include/qcolor.h"
    static void initialize();
    static void cleanup();

    static QStringList colorNames();

    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 )
{
    d.d32.argb = Invalid;
    d.d32.pix = Dirt;
    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 "/usr/qt/3/include/qpalette.h" 2

# 1 "/usr/qt/3/include/qbrush.h" 1
# 47 "/usr/qt/3/include/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 "/usr/qt/3/include/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; }




    void setActive( const QColorGroup & );
    void setDisabled( const QColorGroup & );
    void setInactive( const QColorGroup & );




    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 "/usr/qt/3/include/qwidget.h" 2
# 1 "/usr/qt/3/include/qfont.h" 1
# 47 "/usr/qt/3/include/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,
        OpenGLCompatible = 0x0200
    };

    enum Weight {
        Light = 25,
        Normal = 50,
        DemiBold = 63,
        Bold = 75,
        Black = 87
    };

    enum Stretch {
        UltraCondensed = 50,
        ExtraCondensed = 62,
        Condensed = 75,
        SemiCondensed = 87,
        Unstretched = 100,
        SemiExpanded = 112,
        Expanded = 125,
        ExtraExpanded = 150,
        UltraExpanded = 200
    };


    QFont();





    QFont( const QString &family, int pointSize = -1, int weight = -1,
           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 overline() const;
    void setOverline( 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 );

    int stretch() const;
    void setStretch( int );


    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();
# 203 "/usr/qt/3/include/qfont.h"
    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,


        Tagalog,
        Hanunoo,
        Buhid,
        Tagbanwa,

        KatakanaHalfWidth,


        Limbu,
        TaiLe,



        NScripts,
        UnknownScript = NScripts,

        NoScript,





        Han_Japanese,
        Han_SimplifiedChinese,
        Han_TraditionalChinese,
        Han_Korean,

        LastPrivateScript

    };

    QString defaultFamily() const;
    QString lastResortFamily() const;
    QString lastResortFont() const;
# 308 "/usr/qt/3/include/qfont.h"
    QFont resolve( const QFont & ) const;

protected:

    bool dirty() const;
    int deciPointSize() const;

private:
    QFont( QFontPrivate *, QPaintDevice *pd );

    void detach();




    void x11SetScreen( int screen = -1 );
    int x11Screen() const;


    friend class QFontMetrics;
    friend class QFontInfo;
    friend class QPainter;
    friend class QPSPrinterFont;
    friend class QApplication;
    friend class QWidget;
    friend class QTextFormatCollection;
    friend class QTextLayout;
    friend class QTextItem;
    friend class QGLContext;


    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 ); }
# 362 "/usr/qt/3/include/qfont.h"
 QDataStream &operator<<( QDataStream &, const QFont & );
 QDataStream &operator>>( QDataStream &, QFont & );
# 47 "/usr/qt/3/include/qwidget.h" 2
# 1 "/usr/qt/3/include/qfontmetrics.h" 1
# 50 "/usr/qt/3/include/qfontmetrics.h"
class QTextCodec;
class QTextParag;

class QFontMetrics
{
public:
    QFontMetrics( const QFont & );
    QFontMetrics( const QFont &, QFont::Script );
    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 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 overlinePos() const;
    int strikeOutPos() const;
    int lineWidth() const;

private:
    QFontMetrics( const QPainter * );

    friend class QWidget;
    friend class QPainter;
    friend class QTextFormat;




    QFontPrivate *d;
    QPainter *painter;
    int fscript;
};
# 48 "/usr/qt/3/include/qwidget.h" 2
# 1 "/usr/qt/3/include/qfontinfo.h" 1
# 46 "/usr/qt/3/include/qfontinfo.h"
class QFontInfo
{
public:
    QFontInfo( const QFont & );
    QFontInfo( const QFont &, QFont::Script );
    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 overline() const;
    bool strikeOut() const;
    bool fixedPitch() const;
    QFont::StyleHint styleHint() const;
    bool rawMode() const;

    bool exactMatch() const;


private:
    QFontInfo( const QPainter * );

    QFontPrivate *d;
    QPainter *painter;
    int fscript;

    friend class QWidget;
    friend class QPainter;
};


inline bool QFontInfo::bold() const
{ return weight() > QFont::Normal; }
# 49 "/usr/qt/3/include/qwidget.h" 2
# 1 "/usr/qt/3/include/qsizepolicy.h" 1
# 42 "/usr/qt/3/include/qsizepolicy.h"
# 1 "/usr/qt/3/include/qglobal.h" 1
# 43 "/usr/qt/3/include/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,




                      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 "/usr/qt/3/include/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; } 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 = TabFocus | ClickFocus | 0x8,
        WheelFocus = StrongFocus | 0x4
    };

    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 setInputMethodEnabled( bool b );
    bool isInputMethodEnabled() 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 );



    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;

    uint windowState() const;
    void setWindowState(uint windowState);

    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;

    QRegion clipRegion() const;


public :
    virtual void adjustSize();

public:

    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 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;
# 468 "/usr/qt/3/include/qwidget.h"
    void setWindowOpacity(double level);
    double windowOpacity() const;

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 * );
# 514 "/usr/qt/3/include/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);
# 567 "/usr/qt/3/include/qwidget.h"
private :
    void focusProxyDestroyed();

private:
    void setFontSys( QFont *f = 0 );

    void createInputContext();
    void destroyInputContext();
    void focusInputContext();
    void checkChildrenDnd();
# 597 "/usr/qt/3/include/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;
    uint im_enabled : 1;
    QRect crect;
    QColor bg_col;

    QPalette pal;

    QFont fnt;

    QLayout *lay_out;

    QWExtra *extra;
# 678 "/usr/qt/3/include/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( TRUE ); }

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) );
}

inline bool QWidget::isInputMethodEnabled() const
{
    return (bool)im_enabled;
}





class QFocusData;
class QWSManager;







struct QTLWExtra {

    QString caption;
    QString iconText;
    QPixmap *icon;

    QFocusData *focusData;
    short incw, inch;

    ulong fleft, fright, ftop, fbottom;
    uint unused : 8;



    uint savedFlags;
    short basew, baseh;

    WId parentWinId;
    uint embedded : 1;
    uint spont_unmapped: 1;
    uint reserved: 1;
    uint dnd : 1;
    uint uspos : 1;
    uint ussize : 1;
    void *xic;
# 966 "/usr/qt/3/include/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;
# 1000 "/usr/qt/3/include/qwidget.h"
    uint bg_origin : 2;

    uint children_use_dnd : 1;
    uint compress_events : 1;




    char bg_mode;
    char bg_mode_visual;

    QStyle* style;

    QRect micro_focus_hint;
    QSizePolicy size_policy;
};


# 1 "/usr/qt/3/include/qwinexport.h" 1
# 1019 "/usr/qt/3/include/qwidget.h" 2
# 43 "/usr/qt/3/include/qframe.h" 2




class QFrame : 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; } private: static QMetaObject *metaObj;
   
   
   
   
   
   
   
   
   

public:
    QFrame( QWidget* parent=0, const char* name=0, WFlags f=0 );

    int frameStyle() const;
    virtual void setFrameStyle( int );

    int frameWidth() const;
    QRect contentsRect() const;


    bool lineShapesOk() const { return TRUE; }


    QSize sizeHint() const;

    enum Shape { NoFrame = 0,
                 Box = 0x0001,
                 Panel = 0x0002,
                 WinPanel = 0x0003,
                 HLine = 0x0004,
                 VLine = 0x0005,
                 StyledPanel = 0x0006,
                 PopupPanel = 0x0007,
                 MenuBarPanel = 0x0008,
                 ToolBarPanel = 0x0009,
                 LineEditPanel = 0x000a,
                 TabWidgetPanel = 0x000b,
                 GroupBoxPanel = 0x000c,
                 MShape = 0x000f
    };
    enum Shadow { Plain = 0x0010,
                  Raised = 0x0020,
                  Sunken = 0x0030,
                  MShadow = 0x00f0 };

    Shape frameShape() const;
    void setFrameShape( Shape );
    Shadow frameShadow() const;
    void setFrameShadow( Shadow );

    int lineWidth() const;
    virtual void setLineWidth( int );

    int margin() const;
    virtual void setMargin( int );

    int midLineWidth() const;
    virtual void setMidLineWidth( int );

    QRect frameRect() const;
    virtual void setFrameRect( const QRect & );

protected:
    void paintEvent( QPaintEvent * );
    void resizeEvent( QResizeEvent * );
    virtual void drawFrame( QPainter * );
    virtual void drawContents( QPainter * );
    virtual void frameChanged();
    void styleChange( QStyle& );

private:
    void updateFrameWidth(bool=FALSE);
    QRect frect;
    int fstyle;
    short lwidth;
    short mwidth;
    short mlwidth;
    short fwidth;

    void * d;
private:

    QFrame( const QFrame & );
    QFrame &operator=( const QFrame & );

};


inline int QFrame::frameStyle() const
{ return fstyle; }

inline QFrame::Shape QFrame::frameShape() const
{ return (Shape) ( fstyle & MShape ); }

inline QFrame::Shadow QFrame::frameShadow() const
{ return (Shadow) ( fstyle & MShadow ); }

inline void QFrame::setFrameShape( QFrame::Shape s )
{ setFrameStyle( ( fstyle & MShadow ) | s ); }

inline void QFrame::setFrameShadow( QFrame::Shadow s )
{ setFrameStyle( ( fstyle & MShape ) | s ); }

inline int QFrame::lineWidth() const
{ return lwidth; }

inline int QFrame::midLineWidth() const
{ return mlwidth; }

inline int QFrame::margin() const
{ return mwidth; }

inline int QFrame::frameWidth() const
{ return fwidth; }
# 43 "/usr/qt/3/include/qlabel.h" 2




class QSimpleRichText;
class QLabelPrivate;

class QLabel : public QFrame
{
    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; } private: static QMetaObject *metaObj;
   
   
   
   
   
   
   

public:
    QLabel( QWidget *parent, const char* name=0, WFlags f=0 );
    QLabel( const QString &text, QWidget *parent, const char* name=0,
            WFlags f=0 );
    QLabel( QWidget *buddy, const QString &,
            QWidget *parent, const char* name=0, WFlags f=0 );
    ~QLabel();

    QString text() const { return ltext; }
    QPixmap *pixmap() const { return lpixmap; }

    QPicture *picture() const { return lpicture; }


    QMovie *movie() const;


    TextFormat textFormat() const;
    void setTextFormat( TextFormat );

    int alignment() const { return align; }
    virtual void setAlignment( int );
    int indent() const { return extraMargin; }
    void setIndent( int );

    bool autoResize() const { return autoresize; }
    virtual void setAutoResize( bool );

    bool hasScaledContents() const;
    void setScaledContents( bool );

    QSize sizeHint() const;
    QSize minimumSizeHint() const;

    virtual void setBuddy( QWidget * );
    QWidget *buddy() const;

    int heightForWidth(int) const;

    void setFont( const QFont &f );

public :
    virtual void setText( const QString &);
    virtual void setPixmap( const QPixmap & );

    virtual void setPicture( const QPicture & );


    virtual void setMovie( const QMovie & );

    virtual void setNum( int );
    virtual void setNum( double );
    void clear();

protected:
    void drawContents( QPainter * );
    void fontChange( const QFont & );
    void resizeEvent( QResizeEvent* );

private :

    void acceleratorSlot();
    void buddyDied();


    void movieUpdated(const QRect&);
    void movieResized(const QSize&);


private:
    void init();
    void clearContents();
    void updateLabel( QSize oldSizeHint );
    QSize sizeForWidth( int w ) const;
    QString ltext;
    QPixmap *lpixmap;

    QPicture *lpicture;


    QMovie * lmovie;


    QWidget * lbuddy;

    ushort align;
    short extraMargin;
    uint autoresize:1;
    uint scaledcontents :1;
    TextFormat textformat;

    QSimpleRichText* doc;


    QAccel * accel;

    QLabelPrivate* d;

    friend class QTipLabel;

private:

    QLabel( const QLabel & );
    QLabel &operator=( const QLabel & );

};
# 23 "converterdialog.cc" 2
# 1 "/usr/qt/3/include/qlayout.h" 1
# 47 "/usr/qt/3/include/qlayout.h"
# 1 "/usr/lib/gcc-lib/i386-pc-linux-gnu/3.3.4/include/limits.h" 1 3 4
# 48 "/usr/qt/3/include/qlayout.h" 2







static const int QLAYOUTSIZE_MAX = 2147483647/256/16;

class QGridLayoutBox;
class QGridLayoutData;
class QLayout;
class QLayoutItem;
struct QLayoutData;
class QMenuBar;
class QSpacerItem;
class QWidget;

class QGLayoutIterator : public QShared
{
public:
    virtual ~QGLayoutIterator();
    virtual QLayoutItem *next() = 0;
    virtual QLayoutItem *current() = 0;
    virtual QLayoutItem *takeCurrent() = 0;
};

class QLayoutIterator
{
public:
    QLayoutIterator( QGLayoutIterator *i ) : it( i ) { }
    QLayoutIterator( const QLayoutIterator &i ) : it( i.it ) {
        if ( it )
            it->ref();
    }
    ~QLayoutIterator() { if ( it && it->deref() ) delete it; }
    QLayoutIterator &operator=( const QLayoutIterator &i ) {
        if ( i.it )
            i.it->ref();
        if ( it && it->deref() )
            delete it;
        it = i.it;
        return *this;
    }
    QLayoutItem *operator++() { return it ? it->next() : 0; }
    QLayoutItem *current() { return it ? it->current() : 0; }
    QLayoutItem *takeCurrent() { return it ? it->takeCurrent() : 0; }
    void deleteCurrent();

private:
    QGLayoutIterator *it;
};

class QLayoutItem
{
public:
    QLayoutItem( int alignment = 0 ) : align( alignment ) { }
    virtual ~QLayoutItem();
    virtual QSize sizeHint() const = 0;
    virtual QSize minimumSize() const = 0;
    virtual QSize maximumSize() const = 0;
    virtual QSizePolicy::ExpandData expanding() const = 0;
    virtual void setGeometry( const QRect& ) = 0;
    virtual QRect geometry() const = 0;
    virtual bool isEmpty() const = 0;
    virtual bool hasHeightForWidth() const;
    virtual int heightForWidth( int ) const;

    virtual void invalidate();

    virtual QWidget *widget();
    virtual QLayoutIterator iterator();
    virtual QLayout *layout();
    virtual QSpacerItem *spacerItem();

    int alignment() const { return align; }
    virtual void setAlignment( int a );

protected:
    int align;
};

class QSpacerItem : public QLayoutItem
{
public:
    QSpacerItem( int w, int h,
                 QSizePolicy::SizeType hData = QSizePolicy::Minimum,
                 QSizePolicy::SizeType vData = QSizePolicy::Minimum )
        : width( w ), height( h ), sizeP( hData, vData ) { }
    void changeSize( int w, int h,
                     QSizePolicy::SizeType hData = QSizePolicy::Minimum,
                     QSizePolicy::SizeType vData = QSizePolicy::Minimum );
    QSize sizeHint() const;
    QSize minimumSize() const;
    QSize maximumSize() const;
    QSizePolicy::ExpandData expanding() const;
    bool isEmpty() const;
    void setGeometry( const QRect& );
    QRect geometry() const;
    QSpacerItem *spacerItem();

private:
    int width;
    int height;
    QSizePolicy sizeP;
    QRect rect;
};

class QWidgetItem : public QLayoutItem
{
public:
    QWidgetItem( QWidget *w ) : wid( w ) { }
    QSize sizeHint() const;
    QSize minimumSize() const;
    QSize maximumSize() const;
    QSizePolicy::ExpandData expanding() const;
    bool isEmpty() const;
    void setGeometry( const QRect& );
    QRect geometry() const;
    virtual QWidget *widget();

    bool hasHeightForWidth() const;
    int heightForWidth( int ) const;

private:
    QWidget *wid;
};

class QLayout : public QObject, public QLayoutItem
{
    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; } private: static QMetaObject *metaObj;
   
   
   
   

public:

    enum ResizeMode { FreeResize, Minimum, Fixed, Auto };

    QLayout( QWidget *parent, int margin = 0, int spacing = -1,
             const char *name = 0 );
    QLayout( QLayout *parentLayout, int spacing = -1, const char *name = 0 );
    QLayout( int spacing = -1, const char *name = 0 );
    ~QLayout();

    int margin() const { return outsideBorder; }
    int spacing() const { return insideSpacing; }

    virtual void setMargin( int );
    virtual void setSpacing( int );

    int defaultBorder() const { return insideSpacing; }
    void freeze( int w, int h );
    void freeze() { setResizeMode( Fixed ); }

    void setResizeMode( ResizeMode );
    ResizeMode resizeMode() const;


    virtual void setMenuBar( QMenuBar *w );
    QMenuBar *menuBar() const { return menubar; }


    QWidget *mainWidget();
    bool isTopLevel() const { return topLevel; }

    virtual void setAutoAdd( bool );
    bool autoAdd() const { return autoNewChild; }

    void invalidate();
    QRect geometry() const;
    bool activate();

    void add( QWidget *w ) { addItem( new QWidgetItem(w) ); }
    virtual void addItem( QLayoutItem * ) = 0;

    void remove( QWidget *w );
    void removeItem( QLayoutItem * );

    QSizePolicy::ExpandData expanding() const;
    QSize minimumSize() const;
    QSize maximumSize() const;
    void setGeometry( const QRect& ) = 0;
    QLayoutIterator iterator() = 0;
    bool isEmpty() const;

    int totalHeightForWidth( int w ) const;
    QSize totalMinimumSize() const;
    QSize totalMaximumSize() const;
    QSize totalSizeHint() const;
    QLayout *layout();

    bool supportsMargin() const { return marginImpl; }

    void setEnabled( bool );
    bool isEnabled() const;

protected:
    bool eventFilter( QObject *, QEvent * );
    void childEvent( QChildEvent *e );
    void addChildLayout( QLayout *l );
    void deleteAllItems();

    void setSupportsMargin( bool );
    QRect alignmentRect( const QRect& ) const;

private:
    void setWidgetLayout( QWidget *, QLayout * );
    void init();
    int insideSpacing;
    int outsideBorder;
    uint topLevel : 1;
    uint enabled : 1;
    uint autoNewChild : 1;
    uint frozen : 1;
    uint activated : 1;
    uint marginImpl : 1;
    uint autoMinimum : 1;
    uint autoResizeMode : 1;
    QRect rect;
    QLayoutData *extraData;

    QMenuBar *menubar;


private:

    QLayout( const QLayout & );
    QLayout &operator=( const QLayout & );


    static void propagateSpacing( QLayout *layout );
};

inline void QLayoutIterator::deleteCurrent()
{
    delete takeCurrent();
}

class QGridLayout : public QLayout
{
    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; } private: static QMetaObject *metaObj;
public:
    QGridLayout( QWidget *parent, int nRows = 1, int nCols = 1, int border = 0,
                 int spacing = -1, const char *name = 0 );
    QGridLayout( int nRows = 1, int nCols = 1, int spacing = -1,
                 const char *name = 0 );
    QGridLayout( QLayout *parentLayout, int nRows = 1, int nCols = 1,
                 int spacing = -1, const char *name = 0 );
    ~QGridLayout();

    QSize sizeHint() const;
    QSize minimumSize() const;
    QSize maximumSize() const;


    virtual void setRowStretch( int row, int stretch );
    virtual void setColStretch( int col, int stretch );
    int rowStretch( int row ) const;
    int colStretch( int col ) const;

    void setRowSpacing( int row, int minSize );
    void setColSpacing( int col, int minSize );
    int rowSpacing( int row ) const;
    int colSpacing( int col ) const;

    int numRows() const;
    int numCols() const;
    QRect cellGeometry( int row, int col ) const;

    bool hasHeightForWidth() const;
    int heightForWidth( int ) const;
    int minimumHeightForWidth( int ) const;

    QSizePolicy::ExpandData expanding() const;
    void invalidate();

    void addItem( QLayoutItem * );
    void addItem( QLayoutItem *item, int row, int col );
    void addMultiCell( QLayoutItem *, int fromRow, int toRow,
                               int fromCol, int toCol, int align = 0 );

    void addWidget( QWidget *, int row, int col, int align = 0 );
    void addMultiCellWidget( QWidget *, int fromRow, int toRow,
                             int fromCol, int toCol, int align = 0 );
    void addLayout( QLayout *layout, int row, int col);
    void addMultiCellLayout( QLayout *layout, int fromRow, int toRow,
                             int fromCol, int toCol, int align = 0 );
    void addRowSpacing( int row, int minsize );
    void addColSpacing( int col, int minsize );

    void expand( int rows, int cols );

    enum Corner { TopLeft, TopRight, BottomLeft, BottomRight };
    void setOrigin( Corner );
    Corner origin() const;
    QLayoutIterator iterator();
    void setGeometry( const QRect& );

protected:
    bool findWidget( QWidget* w, int *r, int *c );
    void add( QLayoutItem*, int row, int col );

private:

    QGridLayout( const QGridLayout & );
    QGridLayout &operator=( const QGridLayout & );


    void init( int rows, int cols );
    QGridLayoutData *data;
};

class QBoxLayoutData;
class QDockWindow;

class QBoxLayout : public QLayout
{
    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; } private: static QMetaObject *metaObj;
public:
    enum Direction { LeftToRight, RightToLeft, TopToBottom, BottomToTop,
                     Down = TopToBottom, Up = BottomToTop };

    QBoxLayout( QWidget *parent, Direction, int border = 0, int spacing = -1,
                const char *name = 0 );
    QBoxLayout( QLayout *parentLayout, Direction, int spacing = -1,
                const char *name = 0 );
    QBoxLayout( Direction, int spacing = -1, const char *name = 0 );
    ~QBoxLayout();

    void addItem( QLayoutItem * );

    Direction direction() const { return dir; }
    void setDirection( Direction );

    void addSpacing( int size );
    void addStretch( int stretch = 0 );
    void addWidget( QWidget *, int stretch = 0, int alignment = 0 );
    void addLayout( QLayout *layout, int stretch = 0 );
    void addStrut( int );

    void insertSpacing( int index, int size );
    void insertStretch( int index, int stretch = 0 );
    void insertWidget( int index, QWidget *widget, int stretch = 0,
                       int alignment = 0 );
    void insertLayout( int index, QLayout *layout, int stretch = 0 );

    bool setStretchFactor( QWidget*, int stretch );
    bool setStretchFactor( QLayout *l, int stretch );

    QSize sizeHint() const;
    QSize minimumSize() const;
    QSize maximumSize() const;

    bool hasHeightForWidth() const;
    int heightForWidth( int ) const;
    int minimumHeightForWidth( int ) const;

    QSizePolicy::ExpandData expanding() const;
    void invalidate();
    QLayoutIterator iterator();
    void setGeometry( const QRect& );

    int findWidget( QWidget* w );

protected:
    void insertItem( int index, QLayoutItem * );

private:
    friend class QDockWindow;

    QBoxLayout( const QBoxLayout & );
    QBoxLayout &operator=( const QBoxLayout & );


    void setupGeom();
    void calcHfw( int );
    QBoxLayoutData *data;
    Direction dir;
    QBoxLayout *createTmpCopy();
};

class QHBoxLayout : public QBoxLayout
{
    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; } private: static QMetaObject *metaObj;
public:
    QHBoxLayout( QWidget *parent, int border = 0,
                 int spacing = -1, const char *name = 0 );
    QHBoxLayout( QLayout *parentLayout,
                 int spacing = -1, const char *name = 0 );
    QHBoxLayout( int spacing = -1, const char *name = 0 );

    ~QHBoxLayout();

private:

    QHBoxLayout( const QHBoxLayout & );
    QHBoxLayout &operator=( const QHBoxLayout & );

};

class QVBoxLayout : public QBoxLayout
{
    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; } private: static QMetaObject *metaObj;
public:
    QVBoxLayout( QWidget *parent, int border = 0,
                 int spacing = -1, const char *name = 0 );
    QVBoxLayout( QLayout *parentLayout,
                 int spacing = -1, const char *name = 0 );
    QVBoxLayout( int spacing = -1, const char *name = 0 );

    ~QVBoxLayout();

private:

    QVBoxLayout( const QVBoxLayout & );
    QVBoxLayout &operator=( const QVBoxLayout & );

};
# 24 "converterdialog.cc" 2

# 1 "/usr/kde/3.3/include/klocale.h" 1
# 26 "/usr/kde/3.3/include/klocale.h"
# 1 "/usr/kde/3.3/include/kdemacros.h" 1
# 27 "/usr/kde/3.3/include/klocale.h" 2

class QStringList;
class QTextCodec;
class QDate;
class QTime;
class QDateTime;

class KGlobal;
class KConfig;
class KConfigBase;
class KLocalePrivate;
class KCatalogue;
class KCalendarSystem;
# 73 "/usr/kde/3.3/include/klocale.h"
QString i18n(const char *text);
# 82 "/usr/kde/3.3/include/klocale.h"
QString i18n(const char *comment, const char *text);







QString i18n(const char *singular, const char *plural, unsigned long n);







inline QString tr2i18n(const char* message, const char* =0) {
  return i18n(message);
}
# 114 "/usr/kde/3.3/include/klocale.h"
class KLocale
{
  friend class KGlobal;
public:
# 134 "/usr/kde/3.3/include/klocale.h"
  KLocale( const QString& catalog, KConfig *config = 0 );




  KLocale( const KLocale & rhs );




  KLocale& operator= ( const KLocale & rhs );




  ~KLocale();
# 169 "/usr/kde/3.3/include/klocale.h"
  QString translate( const char *index ) const;
# 196 "/usr/kde/3.3/include/klocale.h"
  QString translate( const char *comment, const char *fallback) const;
# 208 "/usr/kde/3.3/include/klocale.h"
  QString translate( const char *singular, const char *plural,
                     unsigned long n) const;
# 218 "/usr/kde/3.3/include/klocale.h"
  bool setEncoding(int mibEnum);
# 229 "/usr/kde/3.3/include/klocale.h"
  bool setLanguage(const QString & language);
# 240 "/usr/kde/3.3/include/klocale.h"
  bool setLanguage(const QStringList & languages);
# 251 "/usr/kde/3.3/include/klocale.h"
  bool setCountry(const QString & country);





  enum SignPosition { ParensAround = 0, BeforeQuantityMoney = 1,
                      AfterQuantityMoney = 2,
                      BeforeMoney = 3, AfterMoney = 4 };







  QString decimalSymbol() const;
# 276 "/usr/kde/3.3/include/klocale.h"
  QString thousandsSeparator() const;







  QString currencySymbol() const;
# 293 "/usr/kde/3.3/include/klocale.h"
  QString monetaryDecimalSymbol() const;
# 302 "/usr/kde/3.3/include/klocale.h"
  QString monetaryThousandsSeparator() const;







  QString positiveSign() const;







  QString negativeSign() const;







  int fracDigits() const;







  bool positivePrefixCurrencySymbol() const;







  bool negativePrefixCurrencySymbol() const;
# 351 "/usr/kde/3.3/include/klocale.h"
  SignPosition positiveMonetarySignPosition() const;
# 360 "/usr/kde/3.3/include/klocale.h"
  SignPosition negativeMonetarySignPosition() const;
# 376 "/usr/kde/3.3/include/klocale.h"
  QString formatMoney(double num,
                      const QString & currency = QString::null,
                      int digits = -1) const;
# 392 "/usr/kde/3.3/include/klocale.h"
  QString formatNumber(double num, int precision = -1) const;
# 405 "/usr/kde/3.3/include/klocale.h"
  QString formatLong(long num) const;
# 415 "/usr/kde/3.3/include/klocale.h"
   bool nounDeclension() const;
# 426 "/usr/kde/3.3/include/klocale.h"
  QString formatDate(const QDate &pDate, bool shortFormat = false) const;
# 435 "/usr/kde/3.3/include/klocale.h"
  bool dateMonthNamePossessive() const;
# 449 "/usr/kde/3.3/include/klocale.h"
  QString formatTime(const QTime &pTime, bool includeSecs, bool isDuration ) const;
# 461 "/usr/kde/3.3/include/klocale.h"
  QString formatTime(const QTime &pTime, bool includeSecs = false) const;






  bool use12Clock() const;
# 479 "/usr/kde/3.3/include/klocale.h"
  bool weekStartsMonday() const __attribute__ ((deprecated));







  int weekStartDay() const;
# 509 "/usr/kde/3.3/include/klocale.h"
  QString monthName(int i, bool shortName = false) const __attribute__ ((deprecated));
# 534 "/usr/kde/3.3/include/klocale.h"
  QString monthNamePossessive(int i, bool shortName = false) const __attribute__ ((deprecated));
# 546 "/usr/kde/3.3/include/klocale.h"
  QString weekDayName(int i, bool shortName = false) const __attribute__ ((deprecated));







  const KCalendarSystem * calendar() const;
# 563 "/usr/kde/3.3/include/klocale.h"
  QString calendarType() const;
# 573 "/usr/kde/3.3/include/klocale.h"
  void setCalendar(const QString & calendarType);
# 585 "/usr/kde/3.3/include/klocale.h"
  QString formatDateTime(const QDateTime &pDateTime,
                         bool shortFormat = true,
                         bool includeSecs = false) const;
# 598 "/usr/kde/3.3/include/klocale.h"
  double readMoney(const QString &numStr, bool * ok = 0) const;
# 609 "/usr/kde/3.3/include/klocale.h"
  double readNumber(const QString &numStr, bool * ok = 0) const;
# 621 "/usr/kde/3.3/include/klocale.h"
  QDate readDate(const QString &str, bool* ok = 0) const;





  QDate readDate( const QString &intstr, const QString &fmt, bool* ok = 0) const;

  enum ReadDateFlags {
      NormalFormat = 1,
      ShortFormat = 2
  };
# 647 "/usr/kde/3.3/include/klocale.h"
  QDate readDate(const QString &str, ReadDateFlags flags, bool *ok = 0) const;
# 661 "/usr/kde/3.3/include/klocale.h"
  QTime readTime(const QString &str, bool* ok = 0) const;

  enum ReadTimeFlags {
      WithSeconds = 0,
      WithoutSeconds = 1
  };
# 681 "/usr/kde/3.3/include/klocale.h"
  QTime readTime(const QString &str, ReadTimeFlags flags, bool *ok = 0) const;
# 690 "/usr/kde/3.3/include/klocale.h"
  QString language() const;







  QString country() const;
# 713 "/usr/kde/3.3/include/klocale.h"
  QStringList languagesTwoAlpha() const;
# 723 "/usr/kde/3.3/include/klocale.h"
  QStringList languageList() const;
# 733 "/usr/kde/3.3/include/klocale.h"
  const char * encoding() const;
# 743 "/usr/kde/3.3/include/klocale.h"
  int encodingMib() const;
# 752 "/usr/kde/3.3/include/klocale.h"
  QTextCodec * codecForEncoding() const;
# 762 "/usr/kde/3.3/include/klocale.h"
  int fileEncodingMib() const;
# 785 "/usr/kde/3.3/include/klocale.h"
  void setDateFormat(const QString & format);
# 807 "/usr/kde/3.3/include/klocale.h"
  void setDateFormatShort(const QString & format);






  void setDateMonthNamePossessive(bool possessive);
# 833 "/usr/kde/3.3/include/klocale.h"
  void setTimeFormat(const QString & format);
# 844 "/usr/kde/3.3/include/klocale.h"
  void setWeekStartsMonday(bool start) __attribute__ ((deprecated));







  void setWeekStartDay(int day);






  QString dateFormat() const;






  QString dateFormatShort() const;






  QString timeFormat() const;






  void setDecimalSymbol(const QString & symbol);





  void setThousandsSeparator(const QString & separator);






  void setPositiveSign(const QString & sign);





  void setNegativeSign(const QString & sign);





  void setPositiveMonetarySignPosition(SignPosition signpos);





  void setNegativeMonetarySignPosition(SignPosition signpos);







  void setPositivePrefixCurrencySymbol(bool prefix);







  void setNegativePrefixCurrencySymbol(bool prefix);





  void setFracDigits(int digits);





  void setMonetaryThousandsSeparator(const QString & separator);






  void setMonetaryDecimalSymbol(const QString & symbol);





  void setCurrencySymbol(const QString & symbol);






  int pageSize() const;






  void setPageSize(int paperFormat);





  enum MeasureSystem { Metric, Imperial };






  MeasureSystem measureSystem() const;






  void setMeasureSystem(MeasureSystem value);
# 998 "/usr/kde/3.3/include/klocale.h"
  void insertCatalogue(const QString& catalog);






  void removeCatalogue(const QString &catalog);





  void setActiveCatalogue(const QString &catalog);







  QString translateQt(const char *context,
                      const char *sourceText,
                      const char *message) const;






  QStringList allLanguagesTwoAlpha() const;







  QString twoAlphaToLanguageName(const QString &code) const;






  QStringList allCountriesTwoAlpha() const;







  QString twoAlphaToCountryName(const QString &code) const;
# 1062 "/usr/kde/3.3/include/klocale.h"
  static void splitLocale(const QString & str,
                          QString & language,
                          QString & country,
                          QString & charset);
# 1075 "/usr/kde/3.3/include/klocale.h"
  static void setMainCatalogue(const char *catalog);







  static QString langLookup(const QString &fname, const char *rtype = "html");






  static QString defaultLanguage();






  static QString defaultCountry();





  static QString _initLanguage(KConfigBase *config);
# 1112 "/usr/kde/3.3/include/klocale.h"
  QString formatMoney(const QString &numStr) const __attribute__ ((deprecated));





  QString formatNumber(const QString &numStr) const __attribute__ ((deprecated));







  QString languages() const __attribute__ ((deprecated));





  bool setCharset(const QString & charset) __attribute__ ((deprecated));





  QString charset() const __attribute__ ((deprecated));

protected:




  static void initInstance();

private:






  void initFormat(KConfig *config);







  void initMainCatalogues(const QString & catalog);
# 1172 "/usr/kde/3.3/include/klocale.h"
  void initLanguageList(KConfig * config, bool useEnv);






  void initEncoding(KConfig * config);





  void initFileNameEncoding(KConfig *config);




  static QCString encodeFileNameUTF8( const QString & fileName );




  static QString decodeFileNameUTF8( const QCString & localFileName );





  void initCatalogue( KCatalogue & catalog );




  void doFormatInit() const;




  void initFormat();




  QString translate_priv(const char *index,
                         const char *text,
                         const char ** original = 0,
                         int* pluralType = 0) const;




  bool useDefaultLanguage() const;




  bool isLanguageInstalled(const QString & language) const;





  void updateCatalogues( );




  void initPluralTypes( );





  int pluralType( const QString & language );







  int pluralType( const KCatalogue& catalog );
# 1268 "/usr/kde/3.3/include/klocale.h"
  static QString catalogueFileName(const QString & language,
                                   const KCatalogue & catalog);






   bool isApplicationTranslatedInto( const QString & language);

private:

  QString m_decimalSymbol;
  QString m_thousandsSeparator;
  QString m_currencySymbol;
  QString m_monetaryDecimalSymbol;
  QString m_monetaryThousandsSeparator;
  QString m_positiveSign;
  QString m_negativeSign;
  int m_fracDigits;
  SignPosition m_positiveMonetarySignPosition;
  SignPosition m_negativeMonetarySignPosition;


  QString m_timeFormat;
  QString m_dateFormat;
  QString m_dateFormatShort;

  QString m_language;
  QString m_country;

  bool m_weekStartsMonday;
  bool m_positivePrefixCurrencySymbol;
  bool m_negativePrefixCurrencySymbol;

  KLocalePrivate *d;
};
# 26 "converterdialog.cc" 2

# 1 "converterdialog.h" 1
# 24 "converterdialog.h"
# 1 "/usr/qt/3/include/qlineedit.h" 1
# 41 "/usr/qt/3/include/qlineedit.h"
struct QLineEditPrivate;

class QValidator;
class QPopupMenu;
# 53 "/usr/qt/3/include/qlineedit.h"
class QTextParagraph;
class QTextCursor;

class QLineEdit : public QFrame
{
    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; } private: static QMetaObject *metaObj;
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   
   

public:
    QLineEdit( QWidget* parent, const char* name=0 );
    QLineEdit( const QString &, QWidget* parent, const char* name=0 );
    QLineEdit( const QString &, const QString &, QWidget* parent, const char* name=0 );
    ~QLineEdit();

    QString text() const;

    QString displayText() const;

    int maxLength() const;

    bool frame() const;

    enum EchoMode { Normal, NoEcho, Password };
    EchoMode echoMode() const;

    bool isReadOnly() const;

    const QValidator * validator() const;

    QSize sizeHint() const;
    QSize minimumSizeHint() const;

    int cursorPosition() const;
    bool validateAndSet( const QString &, int, int, int );

    int alignment() const;





    void cursorForward( bool mark, int steps = 1 );
    void cursorBackward( bool mark, int steps = 1 );
    void cursorWordForward( bool mark );
    void cursorWordBackward( bool mark );
    void backspace();
    void del();
    void home( bool mark );
    void end( bool mark );

    bool isModified() const;
    void clearModified();

    bool edited() const;
    void setEdited( bool );

    bool hasSelectedText() const;
    QString selectedText() const;
    int selectionStart() const;

    bool isUndoAvailable() const;
    bool isRedoAvailable() const;






    bool dragEnabled() const;

    QString inputMask() const;
    void setInputMask( const QString &inputMask );
    bool hasAcceptableInput() const;

public :
    virtual void setText( const QString &);
    virtual void selectAll();
    virtual void deselect();
    virtual void clearValidator();
    virtual void insert( const QString &);
    virtual void clear();
    virtual void undo();
    virtual void redo();
    virtual void setMaxLength( int );
    virtual void setFrame( bool );
    virtual void setEchoMode( EchoMode );
    virtual void setReadOnly( bool );
    virtual void setValidator( const QValidator * );
    virtual void setFont( const QFont & );
    virtual void setPalette( const QPalette & );
    virtual void setSelection( int, int );
    virtual void setCursorPosition( int );
    virtual void setAlignment( int flag );

    virtual void cut();
    virtual void copy() const;
    virtual void paste();

    virtual void setDragEnabled( bool b );

protected:
    void textChanged( const QString &);
    void returnPressed();
    void lostFocus();
    void selectionChanged();

protected:
    bool event( QEvent * );
    void mousePressEvent( QMouseEvent * );
    void mouseMoveEvent( QMouseEvent * );
    void mouseReleaseEvent( QMouseEvent * );
    void mouseDoubleClickEvent( QMouseEvent * );
    void keyPressEvent( QKeyEvent * );
    void imStartEvent( QIMEvent * );
    void imComposeEvent( QIMEvent * );
    void imEndEvent( QIMEvent * );
    void focusInEvent( QFocusEvent * );
    void focusOutEvent( QFocusEvent * );
    void resizeEvent( QResizeEvent * );
    void drawContents( QPainter * );

    void dragEnterEvent( QDragEnterEvent * );
    void dragMoveEvent( QDragMoveEvent *e );
    void dragLeaveEvent( QDragLeaveEvent *e );
    void dropEvent( QDropEvent * );

    void contextMenuEvent( QContextMenuEvent * );
    virtual QPopupMenu *createPopupMenu();
    void windowActivationChange( bool );




private :
    void clipboardChanged();

public:
    void setPasswordChar( QChar c );
    QChar passwordChar() const;
    int characterAt( int, QChar* ) const;
    bool getSelection( int *, int * );

private:
    friend struct QLineEditPrivate;
    QLineEditPrivate * d;

private:

    QLineEdit( const QLineEdit & );
    QLineEdit &operator=( const QLineEdit & );

};
# 25 "converterdialog.h" 2
# 1 "/usr/kde/3.3/include/kdialogbase.h" 1
# 26 "/usr/kde/3.3/include/kdialogbase.h"
# 1 "/usr/kde/3.3/include/kdialog.h" 1
# 24 "/usr/kde/3.3/include/kdialog.h"
class QLayoutItem;

# 1 "/usr/qt/3/include/qdialog.h" 1
# 49 "/usr/qt/3/include/qdialog.h"
class QPushButton;
class QDialogPrivate;

class QDialog : public QWidget
{
friend class QPushButton;
    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; } private: static QMetaObject *metaObj;
   
   

public:
    explicit QDialog( QWidget* parent=0, const char* name=0, bool modal=FALSE,
             WFlags f=0 );
    ~QDialog();

    enum DialogCode { Rejected, Accepted };

    int result() const { return rescode; }

    void show();
    void hide();
    void move( int x, int y );
    void move( const QPoint &p );
    void resize( int w, int h );
    void resize( const QSize & );
    void setGeometry( int x, int y, int w, int h );
    void setGeometry( const QRect & );

    void setOrientation( Orientation orientation );
    Orientation orientation() const;

    void setExtension( QWidget* extension );
    QWidget* extension() const;

    QSize sizeHint() const;
    QSize minimumSizeHint() const;

    void setSizeGripEnabled( bool );
    bool isSizeGripEnabled() const;

    void setModal( bool modal );
    bool isModal() const;




public :
    int exec();

protected :
    virtual void done( int );
    virtual void accept();
    virtual void reject();

    void showExtension( bool );

protected:
    void setResult( int r ) { rescode = r; }
    void keyPressEvent( QKeyEvent * );
    void closeEvent( QCloseEvent * );
    void resizeEvent( QResizeEvent * );
    void contextMenuEvent( QContextMenuEvent * );
    bool eventFilter( QObject *, QEvent * );
    void adjustPosition( QWidget*);

private:
    void setDefault( QPushButton * );
    void setMainDefault( QPushButton * );
    void hideDefault();




    int rescode;
    uint did_move : 1;
    uint has_relpos : 1;
    uint did_resize : 1;
    uint in_loop: 1;
    void adjustPositionInternal( QWidget*, bool useRelPos = FALSE );
    QDialogPrivate* d;

private:

    QDialog( const QDialog & );
    QDialog &operator=( const QDialog & );

};
# 27 "/usr/kde/3.3/include/kdialog.h" 2
# 51 "/usr/kde/3.3/include/kdialog.h"
class KDialog : public QDialog
{
  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; } private: static QMetaObject *metaObj;

  public:






    KDialog(QWidget *parent = 0, const char *name = 0,
            bool modal = false, WFlags f = 0);





    static int marginHint();





    static int spacingHint();
# 84 "/usr/kde/3.3/include/kdialog.h"
    static void resizeLayout( QWidget *widget, int margin, int spacing );
# 93 "/usr/kde/3.3/include/kdialog.h"
    static void resizeLayout( QLayoutItem *lay, int margin, int spacing );
# 105 "/usr/kde/3.3/include/kdialog.h"
    static void centerOnScreen( QWidget *widget, int screen = -1 );
# 116 "/usr/kde/3.3/include/kdialog.h"
    static bool avoidArea( QWidget *widget, const QRect& area, int screen = -1 );

  public :




    virtual void polish();
# 132 "/usr/kde/3.3/include/kdialog.h"
    virtual void setCaption( const QString &caption );







    virtual void setPlainCaption( const QString &caption );


  protected:



    virtual void keyPressEvent(QKeyEvent*);


   protected:







    void layoutHintChanged();

  private:
    static int mMarginSize;
    static int mSpacingSize;

  protected:
    virtual void virtual_hook( int id, void* data );
  private:
    class KDialogPrivate;
    KDialogPrivate *d;

};
# 188 "/usr/kde/3.3/include/kdialog.h"
class KDialogQueuePrivate;
class KDialogQueue : 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; } private: static QMetaObject *metaObj;

public:

      static void queueDialog(QDialog *);

      ~KDialogQueue();

protected:
      KDialogQueue();
      static KDialogQueue *self();

private :
      void slotShowQueuedDialog();

protected:
      KDialogQueuePrivate *d;
      static KDialogQueue *_self;
};
# 27 "/usr/kde/3.3/include/kdialogbase.h" 2
# 1 "/usr/kde/3.3/include/kjanuswidget.h" 1
# 24 "/usr/kde/3.3/include/kjanuswidget.h"
# 1 "/usr/qt/3/include/qpixmap.h" 1
# 48 "/usr/qt/3/include/qpixmap.h"
class QGfx;
class QPixmapPrivate;







class QPixmap : public QPaintDevice, public Qt
{
public:
    enum ColorMode { Auto, Color, Mono };
    enum Optimization { DefaultOptim, NoOptim, MemoryOptim=NoOptim,
                        NormalOptim, BestOptim };

    QPixmap();
    QPixmap( const QImage& image );
    QPixmap( int w, int h, int depth = -1, Optimization = DefaultOptim );
    QPixmap( const QSize &, int depth = -1, Optimization = DefaultOptim );

    QPixmap( const QString& fileName, const char *format=0,
             ColorMode mode=Auto );
    QPixmap( const QString& fileName, const char *format,
             int conversion_flags );
    QPixmap( const char *xpm[] );
    QPixmap( const QByteArray &data );

    QPixmap( const QPixmap & );
   ~QPixmap();

    QPixmap &operator=( const QPixmap & );
    QPixmap &operator=( const QImage & );

    bool isNull() const;

    int width() const { return data->w; }
    int height() const { return data->h; }
    QSize size() const { return QSize(data->w,data->h); }
    QRect rect() const { return QRect(0,0,data->w,data->h); }
    int depth() const { return data->d; }
    static int defaultDepth();

    void fill( const QColor &fillColor = Qt::white );
    void fill( const QWidget *, int xofs, int yofs );
    void fill( const QWidget *, const QPoint &ofs );
    void resize( int width, int height );
    void resize( const QSize & );

    const QBitmap *mask() const;
    void setMask( const QBitmap & );
    bool selfMask() const;
    bool hasAlpha() const;
    bool hasAlphaChannel() const;

    QBitmap createHeuristicMask( bool clipTight = TRUE ) const;


    static QPixmap fromMimeSource( const QString& abs_name );

    static QPixmap grabWindow( WId, int x=0, int y=0, int w=-1, int h=-1 );
    static QPixmap grabWidget( QWidget * widget,
                                int x=0, int y=0, int w=-1, int h=-1 );


    QPixmap xForm( const QWMatrix & ) const;
    static QWMatrix trueMatrix( const QWMatrix &, int w, int h );


    QImage convertToImage() const;
    bool convertFromImage( const QImage &, ColorMode mode=Auto );
    bool convertFromImage( const QImage &, int conversion_flags );

    static const char* imageFormat( const QString &fileName );
    bool load( const QString& fileName, const char *format=0,
                      ColorMode mode=Auto );
    bool load( const QString& fileName, const char *format,
                      int conversion_flags );
    bool loadFromData( const uchar *buf, uint len,
                              const char* format=0,
                              ColorMode mode=Auto );
    bool loadFromData( const uchar *buf, uint len,
                              const char* format,
                              int conversion_flags );
    bool loadFromData( const QByteArray &data,
                              const char* format=0,
                              int conversion_flags=0 );
    bool save( const QString& fileName, const char* format, int quality = -1 ) const;
    bool save( QIODevice* device, const char* format, int quality = -1 ) const;






    int serialNumber() const;

    Optimization optimization() const;
    void setOptimization( Optimization );
    static Optimization defaultOptimization();
    static void setDefaultOptimization( Optimization );

    virtual void detach();

    bool isQBitmap() const;
# 171 "/usr/qt/3/include/qpixmap.h"
    static int x11SetDefaultScreen( int screen );
    void x11SetScreen( int screen );



   


protected:
    QPixmap( int w, int h, const uchar *data, bool isXbitmap );
    int metric( int ) const;
# 190 "/usr/qt/3/include/qpixmap.h"
    struct QPixmapData : public QShared {
        QCOORD w, h;
        short d;
        uint uninit : 1;
        uint bitmap : 1;
        uint selfmask : 1;



        int ser_no;
        QBitmap *mask;
# 212 "/usr/qt/3/include/qpixmap.h"
        void *ximage;
        void *maskgc;
        QPixmap *alphapm;
# 226 "/usr/qt/3/include/qpixmap.h"
        Optimization optim;



    } *data;
private:

    bool doImageIO( QImageIO* io, int quality ) const;

    QPixmap( int w, int h, int depth, bool, Optimization );
    void init( int, int, int, bool, Optimization );
    void deref();
    QPixmap copy( bool ignoreMask = FALSE ) const;







    static Optimization defOptim;
    friend void bitBlt( QPaintDevice *, int, int,
                                 const QPaintDevice *,
                                 int, int, int, int, RasterOp, bool );
    friend void bitBlt( QPaintDevice *, int, int,
                                 const QImage* src,
                                 int, int, int, int, int conversion_flags );
    friend void copyBlt( QPixmap *dst, int dx, int dy,
                                  const QPixmap *src, int sx, int sy,
                                  int sw, int sh );







    friend class QBitmap;
    friend class QPaintDevice;
    friend class QPainter;
    friend class QGLWidget;
};


inline bool QPixmap::isNull() const
{
    return data->w == 0;
}

inline void QPixmap::fill( const QWidget *w, const QPoint &ofs )
{
    fill( w, ofs.x(), ofs.y() );
}

inline void QPixmap::resize( const QSize &s )
{
    resize( s.width(), s.height() );
}

inline const QBitmap *QPixmap::mask() const
{
    return data->mask;
}

inline bool QPixmap::selfMask() const
{
    return data->selfmask;
}
# 302 "/usr/qt/3/include/qpixmap.h"
inline int QPixmap::serialNumber() const
{
    return data->ser_no;
}

inline QPixmap::Optimization QPixmap::optimization() const
{
    return data->optim;
}

inline bool QPixmap::isQBitmap() const
{
    return data->bitmap;
}
# 330 "/usr/qt/3/include/qpixmap.h"
 QDataStream &operator<<( QDataStream &, const QPixmap & );
 QDataStream &operator>>( QDataStream &, QPixmap & );
# 344 "/usr/qt/3/include/qpixmap.h"
bool qt_xForm_helper( const QWMatrix&, int, int, int, uchar*, int, int, int, uchar*, int, int, int );


 void copyBlt( QPixmap *dst, int dx, int dy,
                       const QPixmap *src, int sx = 0, int sy = 0,
                       int sw = -1, int sh = -1 );
# 25 "/usr/kde/3.3/include/kjanuswidget.h" 2
# 1 "/usr/qt/3/include/qsplitter.h" 1
# 48 "/usr/qt/3/include/qsplitter.h"
class QSplitterHandle;
class QSplitterPrivate;
class QSplitterLayoutStruct;
class QTextStream;

class QSplitter : public QFrame
{
    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; } private: static QMetaObject *metaObj;
   
   
   
   

public:

    enum ResizeMode { Stretch, KeepSize, FollowSizeHint, Auto };

    QSplitter( QWidget* parent = 0, const char* name = 0 );
    QSplitter( Orientation, QWidget* parent = 0, const char* name = 0 );
    ~QSplitter();

    virtual void setOrientation( Orientation );
    Orientation orientation() const { return orient; }



    void setChildrenCollapsible( bool );
    bool childrenCollapsible() const;

    void setCollapsible( QWidget *w, bool );
    virtual void setResizeMode( QWidget *w, ResizeMode );
    virtual void setOpaqueResize( bool = TRUE );
    bool opaqueResize() const;

    void moveToFirst( QWidget * );
    void moveToLast( QWidget * );

    void refresh() { recalc( TRUE ); }
    QSize sizeHint() const;
    QSize minimumSizeHint() const;

    QValueList<int> sizes() const;
    void setSizes( QValueList<int> );

    int handleWidth() const;
    void setHandleWidth( int );

protected:
    void childEvent( QChildEvent * );

    bool event( QEvent * );
    void resizeEvent( QResizeEvent * );

    int idAfter( QWidget* ) const;

    void moveSplitter( QCOORD pos, int id );
    virtual void drawSplitter( QPainter*, QCOORD x, QCOORD y,
                               QCOORD w, QCOORD h );
    void styleChange( QStyle& );
    int adjustPos( int, int );
    virtual void setRubberband( int );
    void getRange( int id, int *, int * );

private:
    enum { DefaultResizeMode = 3 };

    void init();
    void recalc( bool update = FALSE );
    void doResize();
    void storeSizes();
    void getRange( int id, int *, int *, int *, int * );
    void addContribution( int, int *, int *, bool );
    int adjustPos( int, int, int *, int *, int *, int * );
    bool collapsible( QSplitterLayoutStruct * );
    void processChildEvents();
    QSplitterLayoutStruct *findWidget( QWidget * );
    QSplitterLayoutStruct *addWidget( QWidget *, bool prepend = FALSE );
    void recalcId();
    void doMove( bool backwards, int pos, int id, int delta, bool upLeft,
                 bool mayCollapse );
    void setGeo( QWidget *w, int pos, int size, bool splitterMoved );
    int findWidgetJustBeforeOrJustAfter( int id, int delta, int &collapsibleSize );
    void updateHandles();

    inline QCOORD pick( const QPoint &p ) const
    { return orient == Horizontal ? p.x() : p.y(); }
    inline QCOORD pick( const QSize &s ) const
    { return orient == Horizontal ? s.width() : s.height(); }

    inline QCOORD trans( const QPoint &p ) const
    { return orient == Vertical ? p.x() : p.y(); }
    inline QCOORD trans( const QSize &s ) const
    { return orient == Vertical ? s.width() : s.height(); }

    QSplitterPrivate *d;

    Orientation orient;
    friend class QSplitterHandle;


    friend QTextStream& operator<<( QTextStream&, const QSplitter& );
    friend QTextStream& operator>>( QTextStream&, QSplitter& );


private:

    QSplitter( const QSplitter & );
    QSplitter& operator=( const QSplitter & );

};


 QTextStream& operator<<( QTextStream&, const QSplitter& );
 QTextStream& operator>>( QTextStream&, QSplitter& );
# 26 "/usr/kde/3.3/include/kjanuswidget.h" 2

# 1 "/usr/kde/3.3/include/klistbox.h" 1
# 21 "/usr/kde/3.3/include/klistbox.h"
# 1 "/usr/qt/3/include/qlistbox.h" 1
# 42 "/usr/qt/3/include/qlistbox.h"
# 1 "/usr/qt/3/include/qscrollview.h" 1
# 42 "/usr/qt/3/include/qscrollview.h"
# 1 "/usr/qt/3/include/qscrollbar.h" 1
# 41 "/usr/qt/3/include/qscrollbar.h"
class QTimer;



# 1 "/usr/qt/3/include/qrangecontrol.h" 1
# 42 "/usr/qt/3/include/qrangecontrol.h"
# 1 "/usr/qt/3/include/qglobal.h" 1
# 43 "/usr/qt/3/include/qrangecontrol.h" 2






class QRangeControlPrivate;


class QRangeControl
{
public:
    QRangeControl();
    QRangeControl( int minValue, int maxValue,
                   int lineStep, int pageStep, int value );
    virtual ~QRangeControl();
    int value() const;
    void setValue( int );
    void addPage();
    void subtractPage();
    void addLine();
    void subtractLine();

    int minValue() const;
    int maxValue() const;
    void setRange( int minValue, int maxValue );
    void setMinValue( int minVal );
    void setMaxValue( int minVal );

    int lineStep() const;
    int pageStep() const;
    void setSteps( int line, int page );

    int bound( int ) const;

protected:
    int positionFromValue( int val, int space ) const;
    int valueFromPosition( int pos, int space ) const;
    void directSetValue( int val );
    int prevValue() const;

    virtual void valueChange();
    virtual void rangeChange();
    virtual void stepChange();

private:
    int minVal, maxVal;
    int line, page;
    int val, prevVal;

    QRangeControlPrivate * d;

private:

    QRangeControl( const QRangeControl & );
    QRangeControl &operator=( const QRangeControl & );

};


inline int QRangeControl::value() const
{ return val; }

inline int QRangeControl::prevValue() const
{ return prevVal; }

inline int QRangeControl::minValue() const
{ return minVal; }

inline int QRangeControl::maxValue() const
{ return maxVal; }

inline int QRangeControl::lineStep() const
{ return line; }

inline int QRangeControl::pageStep() const
{ return page; }






class QSpinWidgetPrivate;
class QSpinWidget : 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; } private: static QMetaObject *metaObj;
public:
    QSpinWidget( QWidget* parent=0, const char* name=0 );
    ~QSpinWidget();

    void setEditWidget( QWidget * widget );
    QWidget * editWidget();

    QRect upRect() const;
    QRect downRect() const;

    void setUpEnabled( bool on );
    void setDownEnabled( bool on );

    bool isUpEnabled() const;
    bool isDownEnabled() const;

    enum ButtonSymbols { UpDownArrows, PlusMinus };
    virtual void setButtonSymbols( ButtonSymbols bs );
    ButtonSymbols buttonSymbols() const;

    void arrange();

protected:
    void stepUpPressed();
    void stepDownPressed();

public :
    void stepUp();
    void stepDown();

protected:
    void mousePressEvent( QMouseEvent *e );
    void resizeEvent( QResizeEvent* ev );
    void mouseReleaseEvent( QMouseEvent *e );
    void mouseMoveEvent( QMouseEvent *e );

    void wheelEvent( QWheelEvent * );

    void styleChange( QStyle& );
    void paintEvent( QPaintEvent * );
    void enableChanged( bool old );
    void windowActivationChange( bool );

private :
    void timerDone();
    void timerDoneEx();

private:
    QSpinWidgetPrivate * d;

    void updateDisplay();

private:

    QSpinWidget( const QSpinWidget& );
    QSpinWidget& operator=( const QSpinWidget& );

};
# 46 "/usr/qt/3/include/qscrollbar.h" 2




class QScrollBar : public QWidget, public QRangeControl
{
    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; } private: static QMetaObject *metaObj;
   
   
   
   
   
   
   
   

public:
    QScrollBar( QWidget *parent, const char* name = 0 );
    QScrollBar( Orientation, QWidget *parent, const char* name = 0 );
    QScrollBar( int minValue, int maxValue, int lineStep, int pageStep,
                int value, Orientation, QWidget *parent, const char* name = 0 );
    ~QScrollBar();

    virtual void setOrientation( Orientation );
    Orientation orientation() const;
    virtual void setTracking( bool enable );
    bool tracking() const;
    bool draggingSlider() const;

    virtual void setPalette( const QPalette & );
    virtual QSize sizeHint() const;
    virtual void setSizePolicy( QSizePolicy sp );
    void setSizePolicy( QSizePolicy::SizeType hor, QSizePolicy::SizeType ver, bool hfw = FALSE );

    int minValue() const;
    int maxValue() const;
    void setMinValue( int );
    void setMaxValue( int );
    int lineStep() const;
    int pageStep() const;
    void setLineStep( int );
    void setPageStep( int );
    int value() const;

    int sliderStart() const;
    QRect sliderRect() const;

public :
    void setValue( int );

protected:
    void valueChanged( int value );
    void sliderPressed();
    void sliderMoved( int value );
    void sliderReleased();
    void nextLine();
    void prevLine();
    void nextPage();
    void prevPage();

protected:

    void wheelEvent( QWheelEvent * );

    void keyPressEvent( QKeyEvent * );
    void resizeEvent( QResizeEvent * );
    void paintEvent( QPaintEvent * );

    void mousePressEvent( QMouseEvent * );
    void mouseReleaseEvent( QMouseEvent * );
    void mouseMoveEvent( QMouseEvent * );
    void contextMenuEvent( QContextMenuEvent * );
    void hideEvent( QHideEvent* );

    void valueChange();
    void stepChange();
    void rangeChange();

    void styleChange( QStyle& );

private :
    void doAutoRepeat();

private:
    void init();
    void positionSliderFromValue();
    int calculateValueFromSlider() const;

    void startAutoRepeat();
    void stopAutoRepeat();

    int rangeValueToSliderPos( int val ) const;
    int sliderPosToRangeValue( int val ) const;

    void action( int control );

    void drawControls( uint controls, uint activeControl ) const;
    void drawControls( uint controls, uint activeControl,
                       QPainter *p ) const;

    uint pressedControl;
    bool track;
    bool clickedAt;
    Orientation orient;

    int slidePrevVal;
    QCOORD sliderPos;
    QCOORD clickOffset;

    QTimer * repeater;
    void * d;

private:

    QScrollBar( const QScrollBar & );
    QScrollBar &operator=( const QScrollBar & );

};


inline void QScrollBar::setTracking( bool t )
{
    track = t;
}

inline bool QScrollBar::tracking() const
{
    return track;
}

inline QScrollBar::Orientation QScrollBar::orientation() const
{
    return orient;
}

inline int QScrollBar::sliderStart() const
{
    return sliderPos;
}

inline void QScrollBar::setSizePolicy( QSizePolicy::SizeType hor, QSizePolicy::SizeType ver, bool hfw )
{
    QWidget::setSizePolicy( hor, ver, hfw );
}
# 43 "/usr/qt/3/include/qscrollview.h" 2




class QScrollViewData;

class QScrollView : public QFrame
{
    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; } private: static QMetaObject *metaObj;
   
   
   
   
   
   
   
   
   
   

   


public:
    QScrollView(QWidget* parent=0, const char* name=0, WFlags f=0);
    ~QScrollView();

    enum ResizePolicy { Default, Manual, AutoOne, AutoOneFit };
    virtual void setResizePolicy( ResizePolicy );
    ResizePolicy resizePolicy() const;

    void styleChange( QStyle & );
    void removeChild(QWidget* child);
    virtual void addChild( QWidget* child, int x=0, int y=0 );
    virtual void moveChild( QWidget* child, int x, int y );
    int childX(QWidget* child);
    int childY(QWidget* child);
    bool childIsVisible(QWidget* child) { return child->isVisible(); }
    void showChild(QWidget* child, bool yes=TRUE) {
        if ( yes )
            child->show();
        else
            child->hide();
    }

    enum ScrollBarMode { Auto, AlwaysOff, AlwaysOn };

    ScrollBarMode vScrollBarMode() const;
    virtual void setVScrollBarMode( ScrollBarMode );

    ScrollBarMode hScrollBarMode() const;
    virtual void setHScrollBarMode( ScrollBarMode );

    QWidget* cornerWidget() const;
    virtual void setCornerWidget(QWidget*);



    QScrollBar* horizontalScrollBar() const;
    QScrollBar* verticalScrollBar() const;
    QWidget* viewport() const;
    QWidget* clipper() const;

    int visibleWidth() const;
    int visibleHeight() const;

    int contentsWidth() const;
    int contentsHeight() const;
    int contentsX() const;
    int contentsY() const;

    void resize( int w, int h );
    void resize( const QSize& );
    void show();

    void updateContents( int x, int y, int w, int h );
    void updateContents( const QRect& r );
    void updateContents();
    void repaintContents( int x, int y, int w, int h, bool erase=TRUE );
    void repaintContents( const QRect& r, bool erase=TRUE );
    void repaintContents( bool erase=TRUE );
    void contentsToViewport( int x, int y, int& vx, int& vy ) const;
    void viewportToContents( int vx, int vy, int& x, int& y ) const;
    QPoint contentsToViewport( const QPoint& ) const;
    QPoint viewportToContents( const QPoint& ) const;
    void enableClipper( bool y );

    void setStaticBackground( bool y );
    bool hasStaticBackground() const;

    QSize viewportSize( int, int ) const;
    QSize sizeHint() const;
    QSize minimumSizeHint() const;

    void removeChild(QObject* child);

    bool isHorizontalSliderPressed();
    bool isVerticalSliderPressed();


    virtual void setDragAutoScroll( bool b );
    bool dragAutoScroll() const;


protected:
    void contentsMoving(int x, int y);
    void horizontalSliderPressed();
    void horizontalSliderReleased();
    void verticalSliderPressed();
    void verticalSliderReleased();

public :
    virtual void resizeContents( int w, int h );
    void scrollBy( int dx, int dy );
    virtual void setContentsPos( int x, int y );
    void ensureVisible(int x, int y);
    void ensureVisible(int x, int y, int xmargin, int ymargin);
    void center(int x, int y);
    void center(int x, int y, float xmargin, float ymargin);

    void updateScrollBars();
    void setEnabled( bool enable );

protected:
    virtual void drawContents(QPainter*, int cx, int cy, int cw, int ch);
    virtual void drawContentsOffset(QPainter*, int ox, int oy,
                    int cx, int cy, int cw, int ch);


    virtual void contentsMousePressEvent( QMouseEvent* );
    virtual void contentsMouseReleaseEvent( QMouseEvent* );
    virtual void contentsMouseDoubleClickEvent( QMouseEvent* );
    virtual void contentsMouseMoveEvent( QMouseEvent* );

    virtual void contentsDragEnterEvent( QDragEnterEvent * );
    virtual void contentsDragMoveEvent( QDragMoveEvent * );
    virtual void contentsDragLeaveEvent( QDragLeaveEvent * );
    virtual void contentsDropEvent( QDropEvent * );


    virtual void contentsWheelEvent( QWheelEvent * );

    virtual void contentsContextMenuEvent( QContextMenuEvent * );


    virtual void viewportPaintEvent( QPaintEvent* );
    virtual void viewportResizeEvent( QResizeEvent* );
    virtual void viewportMousePressEvent( QMouseEvent* );
    virtual void viewportMouseReleaseEvent( QMouseEvent* );
    virtual void viewportMouseDoubleClickEvent( QMouseEvent* );
    virtual void viewportMouseMoveEvent( QMouseEvent* );

    virtual void viewportDragEnterEvent( QDragEnterEvent * );
    virtual void viewportDragMoveEvent( QDragMoveEvent * );
    virtual void viewportDragLeaveEvent( QDragLeaveEvent * );
    virtual void viewportDropEvent( QDropEvent * );


    virtual void viewportWheelEvent( QWheelEvent * );

    virtual void viewportContextMenuEvent( QContextMenuEvent * );

    void frameChanged();

    virtual void setMargins(int left, int top, int right, int bottom);
    int leftMargin() const;
    int topMargin() const;
    int rightMargin() const;
    int bottomMargin() const;

    bool focusNextPrevChild( bool next );

    virtual void setHBarGeometry(QScrollBar& hbar, int x, int y, int w, int h);
    virtual void setVBarGeometry(QScrollBar& vbar, int x, int y, int w, int h);

    void resizeEvent(QResizeEvent*);
    void mousePressEvent( QMouseEvent * );
    void mouseReleaseEvent( QMouseEvent * );
    void mouseDoubleClickEvent( QMouseEvent * );
    void mouseMoveEvent( QMouseEvent * );

    void wheelEvent( QWheelEvent * );

    void contextMenuEvent( QContextMenuEvent * );
    bool eventFilter( QObject *, QEvent *e );

    void setCachedSizeHint( const QSize &sh ) const;
    QSize cachedSizeHint() const;
    void fontChange( const QFont & );

private:
    void drawContents( QPainter* );
    void moveContents(int x, int y);

    QScrollViewData* d;

private :
    void hslide(int);
    void vslide(int);
    void hbarIsPressed();
    void hbarIsReleased();
    void vbarIsPressed();
    void vbarIsReleased();

    void doDragAutoScroll();
    void startDragAutoScroll();
    void stopDragAutoScroll();


private:

    QScrollView( const QScrollView & );
    QScrollView &operator=( const QScrollView & );

    void changeFrameRect(const QRect&);

public:
    void disableSizeHintCaching();

};
# 43 "/usr/qt/3/include/qlistbox.h" 2






class QListBoxPrivate;
class QListBoxItem;
class QString;
class QStrList;
class QStringList;


class QListBox : public QScrollView
{
    friend class QListBoxItem;
    friend class QListBoxPrivate;

    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; } private: static QMetaObject *metaObj;
   
   
   
   
   
   
   
   
   
   
   
   
   
   

public:
    QListBox( QWidget* parent=0, const char* name=0, WFlags f=0 );
    ~QListBox();

    virtual void setFont( const QFont & );

    uint count() const;

    void insertStringList( const QStringList&, int index=-1 );
    void insertStrList( const QStrList *, int index=-1 );
    void insertStrList( const QStrList &, int index=-1 );
    void insertStrList( const char **,
                        int numStrings=-1, int index=-1 );

    void insertItem( const QListBoxItem *, int index=-1 );
    void insertItem( const QListBoxItem *, const QListBoxItem *after );
    void insertItem( const QString &text, int index=-1 );
    void insertItem( const QPixmap &pixmap, int index=-1 );
    void insertItem( const QPixmap &pixmap, const QString &text, int index=-1 );

    void removeItem( int index );

    QString text( int index ) const;
    const QPixmap *pixmap( int index ) const;

    void changeItem( const QListBoxItem *, int index );
    void changeItem( const QString &text, int index );
    void changeItem( const QPixmap &pixmap, int index );
    void changeItem( const QPixmap &pixmap, const QString &text, int index );

    void takeItem( const QListBoxItem * );

    int numItemsVisible() const;

    int currentItem() const;
    QString currentText() const { return text(currentItem()); }
    virtual void setCurrentItem( int index );
    virtual void setCurrentItem( QListBoxItem * );
    void centerCurrentItem() { ensureCurrentVisible(); }
    int topItem() const;
    virtual void setTopItem( int index );
    virtual void setBottomItem( int index );

    long maxItemWidth() const;

    enum SelectionMode { Single, Multi, Extended, NoSelection };
    virtual void setSelectionMode( SelectionMode );
    SelectionMode selectionMode() const;

    void setMultiSelection( bool multi );
    bool isMultiSelection() const;

    virtual void setSelected( QListBoxItem *, bool );
    void setSelected( int, bool );
    bool isSelected( int ) const;
    bool isSelected( const QListBoxItem * ) const;
    QListBoxItem* selectedItem() const;

    QSize sizeHint() const;
    QSize minimumSizeHint() const;

    QListBoxItem *item( int index ) const;
    int index( const QListBoxItem * ) const;
    QListBoxItem *findItem( const QString &text, ComparisonFlags compare = BeginsWith ) const;

    void triggerUpdate( bool doLayout );

    bool itemVisible( int index );
    bool itemVisible( const QListBoxItem * );

    enum LayoutMode { FixedNumber,
                      FitToWidth, FitToHeight = FitToWidth,
                      Variable };
    virtual void setColumnMode( LayoutMode );
    virtual void setColumnMode( int );
    virtual void setRowMode( LayoutMode );
    virtual void setRowMode( int );

    LayoutMode columnMode() const;
    LayoutMode rowMode() const;

    int numColumns() const;
    int numRows() const;

    bool variableWidth() const;
    virtual void setVariableWidth( bool );

    bool variableHeight() const;
    virtual void setVariableHeight( bool );

    void viewportPaintEvent( QPaintEvent * );
# 196 "/usr/qt/3/include/qlistbox.h"
    int itemHeight( int index = 0 ) const;
    QListBoxItem * itemAt( const QPoint & ) const;

    QRect itemRect( QListBoxItem *item ) const;

    QListBoxItem *firstItem() const;

    void sort( bool ascending = TRUE );

public :
    void clear();
    virtual void ensureCurrentVisible();
    virtual void clearSelection();
    virtual void selectAll( bool select );
    virtual void invertSelection();

protected:
    void highlighted( int index );
    void selected( int index );
    void highlighted( const QString &);
    void selected( const QString &);
    void highlighted( QListBoxItem * );
    void selected( QListBoxItem * );

    void selectionChanged();
    void selectionChanged( QListBoxItem * );
    void currentChanged( QListBoxItem * );
    void clicked( QListBoxItem * );
    void clicked( QListBoxItem *, const QPoint & );
    void pressed( QListBoxItem * );
    void pressed( QListBoxItem *, const QPoint & );

    void doubleClicked( QListBoxItem * );
    void returnPressed( QListBoxItem * );
    void rightButtonClicked( QListBoxItem *, const QPoint & );
    void rightButtonPressed( QListBoxItem *, const QPoint & );
    void mouseButtonPressed( int, QListBoxItem*, const QPoint& );
    void mouseButtonClicked( int, QListBoxItem*, const QPoint& );

    void contextMenuRequested( QListBoxItem *, const QPoint & );

    void onItem( QListBoxItem *item );
    void onViewport();

protected:
    void mousePressEvent( QMouseEvent * );
    void mouseReleaseEvent( QMouseEvent * );
    void mouseDoubleClickEvent( QMouseEvent * );
    void mouseMoveEvent( QMouseEvent * );
    void contentsContextMenuEvent( QContextMenuEvent * );

    void keyPressEvent( QKeyEvent *e );
    void focusInEvent( QFocusEvent *e );
    void focusOutEvent( QFocusEvent *e );
    void resizeEvent( QResizeEvent * );
    void showEvent( QShowEvent * );

    bool eventFilter( QObject *o, QEvent *e );

    void updateItem( int index );
    void updateItem( QListBoxItem * );







    virtual void paintCell( QPainter *, int row, int col );

    void toggleCurrentItem();
    bool isRubberSelecting() const;

    void doLayout() const;

    void windowActivationChange( bool );






protected :
    void clearInputString();

private :
    void refreshSlot();
    void doAutoScroll();
    void adjustItems();

private:
    void mousePressEventEx( QMouseEvent * );
    void tryGeometry( int, int ) const;
    int currentRow() const;
    int currentColumn() const;
    void updateSelection();
    void repaintSelection();
    void drawRubber();
    void doRubberSelection( const QRect &old, const QRect &rubber );
    void handleItemChange( QListBoxItem *old, bool shift, bool control );
    void selectRange( QListBoxItem *from, QListBoxItem *to, bool invert, bool includeFirst, bool clearSel = FALSE );

    void emitChangedSignal( bool );

    int columnAt( int ) const;
    int rowAt( int ) const;

    QListBoxPrivate * d;

    static QListBox * changedListBox;

private:

    QListBox( const QListBox & );
    QListBox &operator=( const QListBox & );

};


class QListBoxItem
{
public:
    QListBoxItem( QListBox* listbox = 0 );
    QListBoxItem( QListBox* listbox, QListBoxItem *after );
    virtual ~QListBoxItem();

    virtual QString text() const;
    virtual const QPixmap *pixmap() const;

    virtual int height( const QListBox * ) const;
    virtual int width( const QListBox * ) const;

    bool isSelected() const { return s; }
    bool isCurrent() const;






    QListBox *listBox() const;

    void setSelectable( bool b );
    bool isSelectable() const;

    QListBoxItem *next() const;
    QListBoxItem *prev() const;

    virtual int rtti() const;
    static int RTTI;

protected:
    virtual void paint( QPainter * ) = 0;
    virtual void setText( const QString &text ) { txt = text; }
    void setCustomHighlighting( bool );

private:
    QString txt;
    uint s:1;
    uint dirty:1;
    uint custom_highlight : 1;
    int x, y;
    QListBoxItem * p, * n;
    QListBox* lbox;
    friend class QListBox;
    friend class QListBoxPrivate;
    friend class QComboBox;
    friend class QComboBoxPopupItem;

private:

    QListBoxItem( const QListBoxItem & );
    QListBoxItem &operator=( const QListBoxItem & );

};


class QListBoxText : public QListBoxItem
{
public:
    QListBoxText( QListBox* listbox, const QString & text=QString::null );
    QListBoxText( const QString & text=QString::null );
    QListBoxText( QListBox* listbox, const QString & text, QListBoxItem *after );
   ~QListBoxText();

    int height( const QListBox * ) const;
    int width( const QListBox * ) const;

    int rtti() const;
    static int RTTI;

protected:
    void paint( QPainter * );

private:

    QListBoxText( const QListBoxText & );
    QListBoxText &operator=( const QListBoxText & );

};


class QListBoxPixmap : public QListBoxItem
{
public:
    QListBoxPixmap( QListBox* listbox, const QPixmap & );
    QListBoxPixmap( const QPixmap & );
    QListBoxPixmap( QListBox* listbox, const QPixmap & pix, QListBoxItem *after );
    QListBoxPixmap( QListBox* listbox, const QPixmap &, const QString& );
    QListBoxPixmap( const QPixmap &, const QString& );
    QListBoxPixmap( QListBox* listbox, const QPixmap & pix, const QString&, QListBoxItem *after );
   ~QListBoxPixmap();

    const QPixmap *pixmap() const { return &pm; }

    int height( const QListBox * ) const;
    int width( const QListBox * ) const;

    int rtti() const;
    static int RTTI;

protected:
    void paint( QPainter * );

private:
    QPixmap pm;
private:

    QListBoxPixmap( const QListBoxPixmap & );
    QListBoxPixmap &operator=( const QListBoxPixmap & );

};
# 22 "/usr/kde/3.3/include/klistbox.h" 2
# 38 "/usr/kde/3.3/include/klistbox.h"
class KListBox : public QListBox
{
    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; } private: static QMetaObject *metaObj;

public:
  KListBox( QWidget *parent = 0, const char *name = 0, WFlags f = 0 );

protected:
# 57 "/usr/kde/3.3/include/klistbox.h"
  void executed( QListBoxItem *item );
# 70 "/usr/kde/3.3/include/klistbox.h"
  void executed( QListBoxItem *item, const QPoint &pos );
# 86 "/usr/kde/3.3/include/klistbox.h"
  void doubleClicked( QListBoxItem *item, const QPoint &pos );

protected :
  void slotOnItem( QListBoxItem *item );
  void slotOnViewport();

  void slotSettingsChanged(int);




  void slotAutoSelect();

protected:
  void emitExecute( QListBoxItem *item, const QPoint &pos );

  virtual void keyPressEvent(QKeyEvent *e);
  virtual void focusOutEvent( QFocusEvent *fe );
  virtual void leaveEvent( QEvent *e );
  virtual void contentsMousePressEvent( QMouseEvent *e );
  virtual void contentsMouseDoubleClickEvent ( QMouseEvent *e );

  bool m_bUseSingle;
  bool m_bChangeCursorOverItem;

  QListBoxItem* m_pCurrentItem;

  QTimer* m_pAutoSelect;
  int m_autoSelectDelay;

private :
  void slotMouseButtonClicked( int btn, QListBoxItem *item, const QPoint &pos );

protected:
  virtual void virtual_hook( int id, void* data );
private:
  class KListBoxPrivate;
  KListBoxPrivate *d;
};
# 28 "/usr/kde/3.3/include/kjanuswidget.h" 2



class KListView;

class QGrid;
class QHBox;
class QLabel;
class QTabWidget;
class QVBox;
class QWidgetStack;
class KSeparator;
class QListViewItem;
class KGuiItem;
# 66 "/usr/kde/3.3/include/kjanuswidget.h"
class KJanusWidget : 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; } private: static QMetaObject *metaObj;

  private:
    class IconListBox : public KListBox
    {
      public:
        IconListBox( QWidget *parent=0, const char *name=0, WFlags f=0 );
        void updateMinimumHeight();
        void updateWidth();
        void invalidateHeight();
        void invalidateWidth();
        void setShowAll( bool showAll );

      private:
        bool mShowAll;
        bool mHeightValid;
        bool mWidthValid;
    };

  public:
    enum Face
    {






      TreeList = 0,






      Tabbed,





      Plain,







      Swallow,







      IconList
    };

  public:
# 138 "/usr/kde/3.3/include/kjanuswidget.h"
    KJanusWidget( QWidget *parent=0, const char *name=0, int face=Plain );




    ~KJanusWidget();






    virtual bool showPage( int index );







    virtual int activePageIndex() const;







    virtual bool isValid() const;






    virtual int face() const;







    virtual QSize minimumSizeHint() const;







    virtual QSize sizeHint() const;






    virtual QFrame *plainPage();
# 217 "/usr/kde/3.3/include/kjanuswidget.h"
    virtual QFrame *addPage(const QString &item,const QString &header=QString::null,
                    const QPixmap &pixmap=QPixmap() );
# 234 "/usr/kde/3.3/include/kjanuswidget.h"
     virtual QFrame *addPage(const QStringList &items, const QString &header=QString::null,
                    const QPixmap &pixmap=QPixmap() );
# 256 "/usr/kde/3.3/include/kjanuswidget.h"
    virtual QVBox *addVBoxPage( const QString &item,
                        const QString &header=QString::null,
                        const QPixmap &pixmap=QPixmap() );
# 272 "/usr/kde/3.3/include/kjanuswidget.h"
    virtual QVBox *addVBoxPage( const QStringList &items,
                        const QString &header=QString::null,
                        const QPixmap &pixmap=QPixmap() );
# 296 "/usr/kde/3.3/include/kjanuswidget.h"
    virtual QHBox *addHBoxPage( const QString &itemName,
                        const QString &header=QString::null,
                        const QPixmap &pixmap=QPixmap() );
# 312 "/usr/kde/3.3/include/kjanuswidget.h"
    virtual QHBox *addHBoxPage( const QStringList &items,
                        const QString &header=QString::null,
                        const QPixmap &pixmap=QPixmap() );
# 339 "/usr/kde/3.3/include/kjanuswidget.h"
    virtual QGrid *addGridPage( int n, Orientation dir,
                        const QString &itemName,
                        const QString &header=QString::null,
                        const QPixmap &pixmap=QPixmap() );
# 356 "/usr/kde/3.3/include/kjanuswidget.h"
    virtual QGrid *addGridPage( int n, Orientation dir,
                        const QStringList &items,
                        const QString &header=QString::null,
                        const QPixmap &pixmap=QPixmap() );
# 370 "/usr/kde/3.3/include/kjanuswidget.h"
    void removePage( QWidget *page );
# 389 "/usr/kde/3.3/include/kjanuswidget.h"
    virtual int pageIndex( QWidget *widget ) const;
# 400 "/usr/kde/3.3/include/kjanuswidget.h"
    virtual bool setSwallowedWidget( QWidget *widget );
# 412 "/usr/kde/3.3/include/kjanuswidget.h"
    virtual void setTreeListAutoResize( bool state );
# 426 "/usr/kde/3.3/include/kjanuswidget.h"
    virtual void setShowIconsInTreeList(bool state);
# 436 "/usr/kde/3.3/include/kjanuswidget.h"
    virtual void setRootIsDecorated( bool state );
# 451 "/usr/kde/3.3/include/kjanuswidget.h"
                void unfoldTreeList( bool persist = false );
# 461 "/usr/kde/3.3/include/kjanuswidget.h"
                void addWidgetBelowList( QWidget * widget );
# 473 "/usr/kde/3.3/include/kjanuswidget.h"
                void addButtonBelowList( const QString & text, QObject * recv,
                    const char * slot );
# 487 "/usr/kde/3.3/include/kjanuswidget.h"
                void addButtonBelowList( const KGuiItem & guiitem, QObject *
                    recv, const char * slot );
# 502 "/usr/kde/3.3/include/kjanuswidget.h"
    virtual void setIconListAllVisible( bool state );






    virtual void setFolderIcon(const QStringList &path, const QPixmap &pixmap);






                QString pageTitle(int index) const;







                QWidget *pageWidget(int index) const;

  protected:
    void aboutToShowPage(QWidget *page);

  public :



    virtual void setFocus();

  protected:




    virtual void showEvent( QShowEvent * );
# 550 "/usr/kde/3.3/include/kjanuswidget.h"
    virtual bool eventFilter( QObject *o, QEvent *e );

  private :
    bool slotShowPage();
    void slotFontChanged();
    void slotItemClicked(QListViewItem *it);
    void pageGone(QObject *obj);
    void slotReopen(QListViewItem *item);

  protected:
    bool showPage( QWidget *w );
    void addPageWidget( QFrame *page, const QStringList &items,
                        const QString &header, const QPixmap &pixmap );
    void InsertTreeListItem(const QStringList &items, const QPixmap &pixmap, QFrame *page);
    QWidget *FindParent();

  private:
    bool mValid;


    QPtrList<QWidget> *mPageList;
    QStringList *mTitleList;

    int mFace;
    KListView *mTreeList;
    IconListBox *mIconList;
    QWidgetStack *mPageStack;
    QLabel *mTitleLabel;
    QTabWidget *mTabControl;
    QFrame *mPlainPage;
    QWidget *mSwallowPage;
    QWidget *mActivePageWidget;
    KSeparator *mTitleSep;
    QSplitter::ResizeMode mTreeListResizeMode;
    bool mShowIconsInTreeList;
    QMap<QListViewItem *, QWidget *> mTreeListToPageStack;
    QMap<QListBoxItem *, QWidget *> mIconListToPageStack;
    QMap<QString, QPixmap> mFolderIconMap;
    QMap<QString, QStringList> mChildrenNames;
    QMap<QString, QWidget *> mChildPages;

  public:
    class IconListItem;
  protected:
    virtual void virtual_hook( int id, void* data );
  private:
    class KJanusWidgetPrivate;
    KJanusWidgetPrivate *d;
};
# 28 "/usr/kde/3.3/include/kdialogbase.h" 2
# 1 "/usr/kde/3.3/include/kguiitem.h" 1
# 26 "/usr/kde/3.3/include/kguiitem.h"
# 1 "/usr/qt/3/include/qiconset.h" 1
# 48 "/usr/qt/3/include/qiconset.h"
class QIconFactory;
class QIconSetPrivate;


class QIconSet
{
public:

    enum Size { Automatic, Small, Large };
    enum Mode { Normal, Disabled, Active };
    enum State { On, Off };

    QIconSet();
    QIconSet( const QPixmap& pixmap, Size size = Automatic );
    QIconSet( const QPixmap& smallPix, const QPixmap& largePix );
    QIconSet( const QIconSet& other );
    virtual ~QIconSet();

    void reset( const QPixmap& pixmap, Size size );

    virtual void setPixmap( const QPixmap& pixmap, Size size,
                            Mode mode = Normal, State state = Off );
    virtual void setPixmap( const QString& fileName, Size size,
                            Mode mode = Normal, State state = Off );
    QPixmap pixmap( Size size, Mode mode, State state = Off ) const;
    QPixmap pixmap( Size size, bool enabled, State state = Off ) const;
    QPixmap pixmap() const;
    bool isGenerated( Size size, Mode mode, State state = Off ) const;
    void clearGenerated();
    void installIconFactory( QIconFactory *factory );

    bool isNull() const;

    void detach();

    QIconSet& operator=( const QIconSet& other );


    static void setIconSize( Size which, const QSize& size );
    static const QSize& iconSize( Size which );


   


private:
    void normalize( Size& which, const QSize& pixSize );
    QPixmap *createScaled( Size size, const QPixmap *suppliedPix ) const;
    QPixmap *createDisabled( Size size, State state ) const;

    QIconSetPrivate *d;
};

class QIconFactory : private QShared
{
public:
    QIconFactory();
    virtual ~QIconFactory();

    virtual QPixmap *createPixmap( const QIconSet& iconSet, QIconSet::Size size,
                                   QIconSet::Mode mode, QIconSet::State state );
    void setAutoDelete( bool autoDelete ) { autoDel = autoDelete; }
    bool autoDelete() const { return autoDel; }

    static QIconFactory *defaultFactory();
    static void installDefaultFactory( QIconFactory *factory );

private:

    QIconFactory( const QIconFactory & );
    QIconFactory &operator=( const QIconFactory & );


    friend class QIconSet;
    friend class QIconSetPrivate;

    uint autoDel : 1;
    uint unused : 31;
};
# 27 "/usr/kde/3.3/include/kguiitem.h" 2


# 1 "/usr/kde/3.3/include/kicontheme.h" 1
# 22 "/usr/kde/3.3/include/kicontheme.h"
class KConfig;
class KIconThemeDir;

class KIconThemePrivate;

class KIconPrivate;
# 36 "/usr/kde/3.3/include/kicontheme.h"
class KIcon
{
public:
    KIcon() { size = 0; }




    bool isValid() const { return size != 0; }




    enum Context {
      Any,
      Action,
      Application,
      Device,
      FileSystem,
      MimeType
    };




    enum Type {
      Fixed,
      Scalable,
      Threshold
    };




    enum MatchType {
      MatchExact,
      MatchBest

    };






    enum Group { NoGroup=-1, Desktop=0, FirstGroup=0, Toolbar,
        MainToolbar, Small, Panel, LastGroup, User };




    enum StdSizes {

        SizeSmall=16,

        SizeSmallMedium=22,

        SizeMedium=32,

        SizeLarge=48,

        SizeHuge=64,

        SizeEnormous=128
         };




    enum States { DefaultState,
                  ActiveState,
                  DisabledState,
                  LastState
    };






    enum Overlays {
      LockOverlay=0x100,
      ZipOverlay=0x200,
      LinkOverlay=0x400,
      HiddenOverlay=0x800,
      ShareOverlay=0x1000,
      OverlayMask = ~0xff
    };




    int size;




    Context context;




    Type type;




    int threshold;




    QString path;

private:
    KIconPrivate *d;
};

inline KIcon::Group& operator++(KIcon::Group& group) { group = static_cast<KIcon::Group>(group+1); return group; }
inline KIcon::Group operator++(KIcon::Group& group,int) { KIcon::Group ret = group; ++group; return ret; }






class KIconTheme
{
public:






    KIconTheme(const QString& name, const QString& appName=QString::null);
    ~KIconTheme();





    QString name() const { return mName; }






    QString description() const { return mDesc; }






    QString example() const;





    QString screenshot() const;





    QString linkOverlay() const;





    QString zipOverlay() const;





    QString lockOverlay() const;






    QString shareOverlay () const;





    QString dir() const { return mDir; }





    QStringList inherits() const { return mInherits; }





    bool isValid() const;






    bool isHidden() const;






    int depth() const { return mDepth; }






    int defaultSize(KIcon::Group group) const;






    QValueList<int> querySizes(KIcon::Group group) const;







    QStringList queryIcons(int size, KIcon::Context context = KIcon::Any) const;







    QStringList queryIconsByContext(int size, KIcon::Context context = KIcon::Any) const;
# 298 "/usr/kde/3.3/include/kicontheme.h"
    KIcon iconPath(const QString& name, int size, KIcon::MatchType match) const;





    static QStringList list();





    static QString current();




    static void reconfigure();






    static QString defaultThemeName();

private:
    int mDefSize[8];
    QValueList<int> mSizes[8];

    int mDepth;
    QString mDir, mName, mDesc;
    QStringList mInherits;
    QPtrList<KIconThemeDir> mDirs;
    KIconThemePrivate *d;

    static QString *_theme;
    static QStringList *_theme_list;
};
# 30 "/usr/kde/3.3/include/kguiitem.h" 2
# 1 "/usr/kde/3.3/include/kglobal.h" 1
# 22 "/usr/kde/3.3/include/kglobal.h"
# 1 "/usr/kde/3.3/include/kinstance.h" 1
# 21 "/usr/kde/3.3/include/kinstance.h"
class KStandardDirs;
class KAboutData;
class KConfig;
class KIconLoader;
class KCharsets;
class QFont;
class KInstancePrivate;
class KMimeSourceFactory;
class KSharedConfig;
# 44 "/usr/kde/3.3/include/kinstance.h"
class KInstance
{
    friend class KStandardDirs;

 public:




    KInstance( const QCString& instanceName) ;
# 65 "/usr/kde/3.3/include/kinstance.h"
    KInstance( const KAboutData * aboutData );







    KInstance( KInstance* src );




    virtual ~KInstance();





    KStandardDirs *dirs() const;





    KConfig *config() const;





    KSharedConfig *sharedConfig() const;





    KIconLoader *iconLoader() const;




    void newIconLoader() const;







    const KAboutData *aboutData() const;






    QCString instanceName() const;






    KMimeSourceFactory* mimeSourceFactory () const;

protected:



    KInstance( const KInstance& );






    void setConfigName(const QString &name);

private:
    mutable KStandardDirs *_dirs;

    mutable KConfig *_config;
    mutable KIconLoader *_iconLoader;

    QCString _name;
    const KAboutData *_aboutData;

protected:
    virtual void virtual_hook( int id, void* data );
private:
    KInstancePrivate *d;
};
# 23 "/usr/kde/3.3/include/kglobal.h" 2

class KCharsets;
class KConfig;
class KSharedConfig;
class KIconLoader;
class KLocale;
class KStandardDirs;
class KStaticDeleterBase;
class KStaticDeleterList;
class KStringDict;
class QString;
# 45 "/usr/kde/3.3/include/kglobal.h"
class KGlobal
{
public:







    static KInstance *instance();





    static KStandardDirs *dirs();





    static KConfig *config();





    static KSharedConfig *sharedConfig();





    static KIconLoader *iconLoader();





    static KLocale *locale();





    static KCharsets *charsets();
# 110 "/usr/kde/3.3/include/kglobal.h"
    static const QString &staticQString(const char *str);
# 129 "/usr/kde/3.3/include/kglobal.h"
    static const QString &staticQString(const QString &str);







    static void registerStaticDeleter(KStaticDeleterBase *d);







    static void unregisterStaticDeleter(KStaticDeleterBase *d);







    static void deleteStaticDeleters();


    static KStringDict *_stringDict;
    static KInstance *_instance;
    static KLocale *_locale;
    static KCharsets *_charsets;
    static KStaticDeleterList *_staticDeleters;







    static void setActiveInstance(KInstance *d);
    static KInstance *activeInstance() { return _activeInstance; }

    static KInstance *_activeInstance;
};
# 197 "/usr/kde/3.3/include/kglobal.h"
template<class T>
inline const T& kMin (const T& a, const T& b) { return a < b ? a : b; }

template<class T>
inline const T& kMax (const T& a, const T& b) { return b < a ? a : b; }

template<class T>
inline T kAbs (const T& a) { return a < 0 ? -a : a; }

template<class T>
inline const T& kClamp( const T& x, const T& low, const T& high )
{
    if ( x < low ) return low;
    else if ( high < x ) return high;
    else return x;
}
# 31 "/usr/kde/3.3/include/kguiitem.h" 2






class KGuiItem
{
public:
    KGuiItem();





    KGuiItem( const QString &text,
              const QString &iconName = QString::null,
              const QString &toolTip = QString::null,
              const QString &whatsThis = QString::null );

    KGuiItem( const QString &text, const QIconSet &iconSet,
              const QString &toolTip = QString::null,
              const QString &whatsThis = QString::null );

    KGuiItem( const KGuiItem &rhs );
    KGuiItem &operator=( const KGuiItem &rhs );

    ~KGuiItem();

    QString text() const;
    QString plainText() const;
    QIconSet iconSet( KIcon::Group, int size = 0, KInstance* instance = KGlobal::instance()) const;

    QIconSet iconSet() const { return iconSet( KIcon::Small ); }


    QString iconName() const;
    QString toolTip() const;
    QString whatsThis() const;
    bool isEnabled() const;
    bool hasIcon() const;

    bool hasIconSet() const { return hasIcon(); }


    void setText( const QString &text );
    void setIconSet( const QIconSet &iconset );
    void setIconName( const QString &iconName );
    void setToolTip( const QString &tooltip );
    void setWhatsThis( const QString &whatsThis );
    void setEnabled( bool enable );

private:
    class KGuiItemPrivate;
    KGuiItemPrivate *d;
};
# 29 "/usr/kde/3.3/include/kdialogbase.h" 2
# 1 "/usr/kde/3.3/include/kstdguiitem.h" 1
# 37 "/usr/kde/3.3/include/kstdguiitem.h"
class KStdGuiItem
{
public:





    enum BidiMode { UseRTL = 0, IgnoreRTL };

    enum StdItem
    {
        Ok=1, Cancel, Yes, No, Discard, Save, DontSave, SaveAs,
        Apply, Clear, Help, Defaults, Close, Back, Forward, Print,
        Continue, Open, Quit, AdminMode, Reset, Delete, Insert
    };
    static KGuiItem guiItem ( StdItem ui_enum );
    static QString stdItem ( StdItem ui_enum );
    static KGuiItem ok();
    static KGuiItem cancel();
    static KGuiItem yes();
    static KGuiItem no();
    static KGuiItem insert();
    static KGuiItem discard();
    static KGuiItem save();
    static KGuiItem help();
    static KGuiItem dontSave();
    static KGuiItem saveAs();
    static KGuiItem apply();
    static KGuiItem clear();
    static KGuiItem defaults();
    static KGuiItem close();
    static KGuiItem print();
    static KGuiItem reset();




    static KGuiItem adminMode();





    static KGuiItem cont();






    static KGuiItem del();

    static KGuiItem open();
# 102 "/usr/kde/3.3/include/kstdguiitem.h"
    static KGuiItem back( BidiMode useBidi = IgnoreRTL );
# 114 "/usr/kde/3.3/include/kstdguiitem.h"
    static KGuiItem forward( BidiMode useBidi = IgnoreRTL );







    static QPair<KGuiItem, KGuiItem> backAndForward();

    static KGuiItem quit();
};
# 30 "/usr/kde/3.3/include/kdialogbase.h" 2



class QPushButton;
class KSeparator;
class KURLLabel;
class QBoxLayout;
class QPixmap;
class KGuiItem;




class KDialogBaseButton;





class KDialogBaseTile;
# 193 "/usr/kde/3.3/include/kdialogbase.h"
class KDialogBase : public KDialog
{
  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; } private: static QMetaObject *metaObj;

  public:
# 218 "/usr/kde/3.3/include/kdialogbase.h"
    enum ButtonCode
    {
      Help = 0x00000001,
      Default = 0x00000002,
      Ok = 0x00000004,
      Apply = 0x00000008,
      Try = 0x00000010,
      Cancel = 0x00000020,
      Close = 0x00000040,
      User1 = 0x00000080,
      User2 = 0x00000100,
      User3 = 0x00000200,
      No = 0x00000080,
      Yes = 0x00000100,
      Details = 0x00000400,
      Filler = 0x40000000,
      Stretch = 0x80000000,
      NoDefault
    };

    enum ActionButtonStyle
    {
      ActionStyle0=0,
      ActionStyle1,
      ActionStyle2,
      ActionStyle3,
      ActionStyle4,
      ActionStyleMAX
    };
# 258 "/usr/kde/3.3/include/kdialogbase.h"
    enum DialogType
    {
      TreeList = KJanusWidget::TreeList,
      Tabbed = KJanusWidget::Tabbed,
      Plain = KJanusWidget::Plain,
      Swallow = KJanusWidget::Swallow,
      IconList = KJanusWidget::IconList
    };

  public:
# 291 "/usr/kde/3.3/include/kdialogbase.h"
    KDialogBase( QWidget *parent=0, const char *name=0, bool modal=true,
                 const QString &caption=QString::null,
                 int buttonMask=Ok|Apply|Cancel, ButtonCode defaultButton=Ok,
                 bool separator=false,
                 const KGuiItem &user1=KGuiItem(),
                 const KGuiItem &user2=KGuiItem(),
                 const KGuiItem &user3=KGuiItem() );
# 326 "/usr/kde/3.3/include/kdialogbase.h"
    KDialogBase( int dialogFace, const QString &caption,
                 int buttonMask, ButtonCode defaultButton,
                 QWidget *parent=0, const char *name=0, bool modal=true,
                 bool separator=false,
                 const KGuiItem &user1=KGuiItem(),
                 const KGuiItem &user2=KGuiItem(),
                 const KGuiItem &user3=KGuiItem() );
# 362 "/usr/kde/3.3/include/kdialogbase.h"
    KDialogBase( KDialogBase::DialogType dialogFace, WFlags f,
                 QWidget *parent=0, const char *name=0, bool modal=true,
                 const QString &caption=QString::null,
                 int buttonMask=Ok|Apply|Cancel, ButtonCode defaultButton=Ok,
                 bool separator=false,
                 const KGuiItem &user1=KGuiItem(),
                 const KGuiItem &user2=KGuiItem(),
                 const KGuiItem &user3=KGuiItem() );
# 402 "/usr/kde/3.3/include/kdialogbase.h"
    KDialogBase( const QString &caption, int buttonMask=Yes|No|Cancel,
                 ButtonCode defaultButton=Yes, ButtonCode escapeButton=Cancel,
                 QWidget *parent=0, const char *name=0,
                 bool modal=true, bool separator=false,
                 const KGuiItem &yes = KStdGuiItem::yes(),
                 const KGuiItem &no = KStdGuiItem::no(),
                 const KGuiItem &cancel = KStdGuiItem::cancel()
                 );




    ~KDialogBase();
# 426 "/usr/kde/3.3/include/kdialogbase.h"
    void setButtonBoxOrientation( int orientation );
# 439 "/usr/kde/3.3/include/kdialogbase.h"
    void setEscapeButton( ButtonCode id );
# 449 "/usr/kde/3.3/include/kdialogbase.h"
    virtual void adjustSize();
    virtual QSize sizeHint() const;
    virtual QSize minimumSizeHint() const;
# 463 "/usr/kde/3.3/include/kdialogbase.h"
    QFrame *plainPage();
# 492 "/usr/kde/3.3/include/kdialogbase.h"
    QFrame *addPage( const QString &itemName,
                      const QString &header=QString::null,
                      const QPixmap &pixmap=QPixmap() );
# 507 "/usr/kde/3.3/include/kdialogbase.h"
    QFrame *addPage( const QStringList &items,
                      const QString &header=QString::null,
                      const QPixmap &pixmap=QPixmap() );
# 535 "/usr/kde/3.3/include/kdialogbase.h"
    QVBox *addVBoxPage( const QString &itemName,
                        const QString &header=QString::null,
                        const QPixmap &pixmap=QPixmap() );
# 550 "/usr/kde/3.3/include/kdialogbase.h"
    QVBox *addVBoxPage( const QStringList &items,
                        const QString &header=QString::null,
                        const QPixmap &pixmap=QPixmap() );
# 572 "/usr/kde/3.3/include/kdialogbase.h"
    QHBox *addHBoxPage( const QString &itemName,
                        const QString &header=QString::null,
                        const QPixmap &pixmap=QPixmap() );
# 587 "/usr/kde/3.3/include/kdialogbase.h"
    QHBox *addHBoxPage( const QStringList &items,
                        const QString &header=QString::null,
                        const QPixmap &pixmap=QPixmap() );
# 611 "/usr/kde/3.3/include/kdialogbase.h"
    QGrid *addGridPage( int n, Orientation dir,
                        const QString &itemName,
                        const QString &header=QString::null,
                        const QPixmap &pixmap=QPixmap() );
# 628 "/usr/kde/3.3/include/kdialogbase.h"
    QGrid *addGridPage( int n, Orientation dir,
                        const QStringList &items,
                        const QString &header=QString::null,
                        const QPixmap &pixmap=QPixmap() );
# 640 "/usr/kde/3.3/include/kdialogbase.h"
    void setFolderIcon(const QStringList &path,const QPixmap &pixmap);
# 655 "/usr/kde/3.3/include/kdialogbase.h"
    QFrame *makeMainWidget();
# 670 "/usr/kde/3.3/include/kdialogbase.h"
    QVBox *makeVBoxMainWidget();
# 685 "/usr/kde/3.3/include/kdialogbase.h"
    QHBox *makeHBoxMainWidget();
# 704 "/usr/kde/3.3/include/kdialogbase.h"
    QGrid *makeGridMainWidget( int n, Orientation dir );






    void enableButtonSeparator( bool state );
# 723 "/usr/kde/3.3/include/kdialogbase.h"
    void showButton( ButtonCode id, bool state );
# 733 "/usr/kde/3.3/include/kdialogbase.h"
    void showButtonOK( bool state );
# 743 "/usr/kde/3.3/include/kdialogbase.h"
    void showButtonApply( bool state );







    void showButtonCancel( bool state );
# 763 "/usr/kde/3.3/include/kdialogbase.h"
    bool showPage( int index );
# 773 "/usr/kde/3.3/include/kdialogbase.h"
    int activePageIndex() const;
# 792 "/usr/kde/3.3/include/kdialogbase.h"
    int pageIndex( QWidget *widget ) const;
# 807 "/usr/kde/3.3/include/kdialogbase.h"
    void setMainWidget( QWidget *widget );






    QWidget *mainWidget();
# 823 "/usr/kde/3.3/include/kdialogbase.h"
    void disableResize();
# 836 "/usr/kde/3.3/include/kdialogbase.h"
    void setInitialSize( const QSize &s, bool noResize=false );
# 848 "/usr/kde/3.3/include/kdialogbase.h"
    void incInitialSize( const QSize &s, bool noResize=false );
# 857 "/usr/kde/3.3/include/kdialogbase.h"
   QSize configDialogSize( const QString& groupName ) const;
# 868 "/usr/kde/3.3/include/kdialogbase.h"
   QSize configDialogSize( KConfig& config, const QString& groupName ) const;
# 879 "/usr/kde/3.3/include/kdialogbase.h"
   void saveDialogSize( const QString& groupName, bool global=false );
# 891 "/usr/kde/3.3/include/kdialogbase.h"
   void saveDialogSize( KConfig& config, const QString& groupName,
                             bool global=false ) const;
# 902 "/usr/kde/3.3/include/kdialogbase.h"
    void setButtonOK( const KGuiItem &item = KStdGuiItem::ok() );
# 919 "/usr/kde/3.3/include/kdialogbase.h"
    void setButtonOKText( const QString &text=QString::null,
                          const QString &tooltip=QString::null,
                          const QString &quickhelp=QString::null ) __attribute__ ((deprecated));
# 931 "/usr/kde/3.3/include/kdialogbase.h"
    void setButtonApply( const KGuiItem &item = KStdGuiItem::apply() );
# 948 "/usr/kde/3.3/include/kdialogbase.h"
    void setButtonApplyText( const QString &text=QString::null,
                             const QString &tooltip=QString::null,
                             const QString &quickhelp=QString::null ) __attribute__ ((deprecated));
# 960 "/usr/kde/3.3/include/kdialogbase.h"
    void setButtonCancel( const KGuiItem &item = KStdGuiItem::cancel() );
# 975 "/usr/kde/3.3/include/kdialogbase.h"
    void setButtonCancelText( const QString &text=QString::null,
                              const QString &tooltip=QString::null,
                              const QString &quickhelp=QString::null ) __attribute__ ((deprecated));







    void setButtonText( ButtonCode id, const QString &text );







    void setButtonTip( ButtonCode id, const QString &text );







    void setButtonWhatsThis( ButtonCode id, const QString &text );
# 1014 "/usr/kde/3.3/include/kdialogbase.h"
    void setButtonGuiItem( ButtonCode id, const KGuiItem &item );
# 1026 "/usr/kde/3.3/include/kdialogbase.h"
     void setTreeListAutoResize( bool state );
# 1040 "/usr/kde/3.3/include/kdialogbase.h"
    void setShowIconsInTreeList(bool state);
# 1050 "/usr/kde/3.3/include/kdialogbase.h"
    void setRootIsDecorated( bool state );
# 1065 "/usr/kde/3.3/include/kdialogbase.h"
    void unfoldTreeList( bool persist = false );
# 1075 "/usr/kde/3.3/include/kdialogbase.h"
    void addWidgetBelowList( QWidget * widget );
# 1087 "/usr/kde/3.3/include/kdialogbase.h"
    void addButtonBelowList( const QString & text, QObject * recv, const char * slot );
# 1100 "/usr/kde/3.3/include/kdialogbase.h"
    void addButtonBelowList( const KGuiItem & guiitem, QObject * recv, const char * slot );
# 1114 "/usr/kde/3.3/include/kdialogbase.h"
    void setIconListAllVisible( bool state );






    static bool haveBackgroundTile();







    static const QPixmap *backgroundTile();




    static const QPixmap *getBackgroundTile() __attribute__ ((deprecated));
# 1143 "/usr/kde/3.3/include/kdialogbase.h"
    static void setBackgroundTile( const QPixmap *pix );






    void showTile( bool state );
# 1163 "/usr/kde/3.3/include/kdialogbase.h"
    void getBorderWidths( int& ulx, int& uly, int& lrx, int& lry ) const __attribute__ ((deprecated));
# 1176 "/usr/kde/3.3/include/kdialogbase.h"
    QRect getContentsRect() const __attribute__ ((deprecated));
# 1195 "/usr/kde/3.3/include/kdialogbase.h"
    QSize calculateSize( int w, int h ) const;
# 1205 "/usr/kde/3.3/include/kdialogbase.h"
    QString helpLinkText() const;
# 1220 "/usr/kde/3.3/include/kdialogbase.h"
    QPushButton *actionButton( ButtonCode id );

  public :






    void enableButton( ButtonCode id, bool state );






    void enableButtonOK( bool state );






    void enableButtonApply( bool state );






    void enableButtonCancel( bool state );






    void enableLinkedHelp( bool state );
# 1268 "/usr/kde/3.3/include/kdialogbase.h"
    void delayedDestruct();
# 1278 "/usr/kde/3.3/include/kdialogbase.h"
    void setHelpLinkText( const QString &text );
# 1292 "/usr/kde/3.3/include/kdialogbase.h"
    void setHelp( const QString &anchor,
                  const QString &appname = QString::null );




    void helpClickedSlot( const QString & );




    void setDetails(bool showDetails);







    void setDetailsWidget(QWidget *detailsWidget);





    void updateBackground();
# 1327 "/usr/kde/3.3/include/kdialogbase.h"
    void cancel();

  protected:




    void helpClicked();





    void defaultClicked();






    void user3Clicked();





    void user2Clicked();





    void user1Clicked();





    void applyClicked();





    void tryClicked();





    void okClicked();





    void yesClicked();





    void noClicked();





    void cancelClicked();





    void closeClicked();





    void apply();




    void backgroundChanged();
# 1421 "/usr/kde/3.3/include/kdialogbase.h"
    void hidden();
# 1437 "/usr/kde/3.3/include/kdialogbase.h"
    void finished();





    void aboutToShowDetails();





    void aboutToShowPage(QWidget *page);

  protected:





    virtual void keyPressEvent( QKeyEvent *e );





    virtual void hideEvent( QHideEvent * );







    virtual void closeEvent( QCloseEvent *e );

  protected :




    virtual void slotHelp();




    virtual void slotDefault();





    virtual void slotDetails();




    virtual void slotUser3();




    virtual void slotUser2();




    virtual void slotUser1();





    virtual void slotOk();




    virtual void slotApply();




    virtual void slotTry();





    virtual void slotYes();





    virtual void slotNo();






    virtual void slotCancel();





    virtual void slotClose();






    virtual void applyPressed();




    void updateGeometry();
# 1566 "/usr/kde/3.3/include/kdialogbase.h"
    void slotDelayedDestruct();

  private:



    void setupLayout();






    void makeRelay();
# 1593 "/usr/kde/3.3/include/kdialogbase.h"
    void makeButtonBox( int mask, ButtonCode defaultButton,
                        const KGuiItem &user1 = KGuiItem(),
                        const KGuiItem &user2 = KGuiItem(),
                        const KGuiItem &user3 = KGuiItem() );
# 1605 "/usr/kde/3.3/include/kdialogbase.h"
    void setButtonFocus( QPushButton *p, bool isDefault, bool isFocus );






    void printMakeMainWidgetError();

  private :





    void setButtonStyle( int style );


  private:
    QBoxLayout *mTopLayout;
    QWidget *mMainWidget;
    KURLLabel *mUrlHelp;
    KJanusWidget *mJanus;
    KSeparator *mActionSep;

    bool mIsActivated;

    QString mAnchor;
    QString mHelpApp;
    QString mHelpLinkText;

    static KDialogBaseTile *mTile;
    bool mShowTile;

    bool mMessageBoxMode;
    int mButtonOrientation;
    ButtonCode mEscapeButton;

  protected:
    virtual void virtual_hook( int id, void* data );
  private:
    class KDialogBasePrivate;
    KDialogBasePrivate *d;
};
# 26 "converterdialog.h" 2

class CHexValidator;


class CValidateLineEdit : public QLineEdit
{
  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; } private: static QMetaObject *metaObj;

  public:
    CValidateLineEdit( QWidget *parent, int validateType, const char *name=0 );
    ~CValidateLineEdit( void );

  public :
    void setData( const QByteArray &buf );

  private :
    void convertText( const QString &text );

  protected:
    void dataChanged( const QByteArray &buf );

  private:
    bool mBusy;
    CHexValidator *mValidator;
};


class CConverterDialog : public KDialogBase
{
  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; } private: static QMetaObject *metaObj;

  public:
    CConverterDialog( QWidget *parent, const char *name=0, bool modal=true );
    ~CConverterDialog( void );

  protected:
    void showEvent( QShowEvent *e );

  protected :
    virtual void slotUser1( void );
    virtual void slotUser2( void );

  private :
    void setData( const QByteArray &data );

  protected:
    void probeCursorValue( QByteArray &buf, uint size );

  private:
    CValidateLineEdit *mHexInput;
    CValidateLineEdit *mDecInput;
    CValidateLineEdit *mOctInput;
    CValidateLineEdit *mBinInput;
    CValidateLineEdit *mTxtInput;
};
# 28 "converterdialog.cc" 2
# 1 "hexvalidator.h" 1
# 24 "hexvalidator.h"
# 1 "/usr/qt/3/include/qvalidator.h" 1
# 44 "/usr/qt/3/include/qvalidator.h"
# 1 "/usr/qt/3/include/qregexp.h" 1
# 46 "/usr/qt/3/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;
# 90 "/usr/qt/3/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 prepareEngine() const;
    void prepareEngineForMatch( const QString& str ) const;
    void invalidateEngine();

    static int caretIndex( int offset, CaretMode caretMode );

    QRegExpEngine *eng;
    QRegExpPrivate *priv;
};
# 45 "/usr/qt/3/include/qvalidator.h" 2





class QValidator : 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; } private: static QMetaObject *metaObj;
public:
    QValidator( QObject * parent, const char *name = 0 );
    ~QValidator();

    enum State { Invalid, Intermediate, Valid=Intermediate, Acceptable };

    virtual State validate( QString &, int & ) const = 0;
    virtual void fixup( QString & ) const;

private:

    QValidator( const QValidator & );
    QValidator& operator=( const QValidator & );

};


class QIntValidator : public QValidator
{
    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; } private: static QMetaObject *metaObj;
   
   

public:
    QIntValidator( QObject * parent, const char *name = 0 );
    QIntValidator( int bottom, int top,
                   QObject * parent, const char *name = 0 );
    ~QIntValidator();

    QValidator::State validate( QString &, int & ) const;

    void setBottom( int );
    void setTop( int );
    virtual void setRange( int bottom, int top );

    int bottom() const { return b; }
    int top() const { return t; }

private:

    QIntValidator( const QIntValidator & );
    QIntValidator& operator=( const QIntValidator & );


    int b, t;
};



class QDoubleValidator : public QValidator
{
    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; } private: static QMetaObject *metaObj;
   
   
   

public:
    QDoubleValidator( QObject * parent, const char *name = 0 );
    QDoubleValidator( double bottom, double top, int decimals,
                      QObject * parent, const char *name = 0 );
    ~QDoubleValidator();

    QValidator::State validate( QString &, int & ) const;

    virtual void setRange( double bottom, double top, int decimals = 0 );
    void setBottom( double );
    void setTop( double );
    void setDecimals( int );

    double bottom() const { return b; }
    double top() const { return t; }
    int decimals() const { return d; }

private:

    QDoubleValidator( const QDoubleValidator & );
    QDoubleValidator& operator=( const QDoubleValidator & );


    double b, t;
    int d;
};


class QRegExpValidator : public QValidator
{
    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; } private: static QMetaObject *metaObj;


public:
    QRegExpValidator( QObject *parent, const char *name = 0 );
    QRegExpValidator( const QRegExp& rx, QObject *parent,
                      const char *name = 0 );
    ~QRegExpValidator();

    virtual QValidator::State validate( QString& input, int& pos ) const;

    void setRegExp( const QRegExp& rx );
    const QRegExp& regExp() const { return r; }

private:

    QRegExpValidator( const QRegExpValidator& );
    QRegExpValidator& operator=( const QRegExpValidator& );


    QRegExp r;
};
# 25 "hexvalidator.h" 2

class CHexValidator: public QValidator
{
  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; } private: static QMetaObject *metaObj;

  public:
    enum EState
    {
      hexadecimal = 0,
      decimal,
      octal,
      binary,
      regularText
    };

  public:
    CHexValidator( QWidget *parent, EState state, const char *name = 0 );
    ~CHexValidator( void );
    QValidator::State validate( QString &string, int &pos ) const;
    void setState( EState state );
    void convert( QByteArray &dest, const QString &src );
    void format( QString &dest, const QByteArray &src );

  private:
    EState mState;


};
# 29 "converterdialog.cc" 2


CValidateLineEdit::CValidateLineEdit( QWidget *parent, int validateType,
                                      const char *name )
  :QLineEdit( parent, name ), mBusy(false)
{
  mValidator = new CHexValidator( this, (CHexValidator::EState)validateType );
  setValidator( mValidator );
  connect( this, "2""textChanged(const QString &)",
           this, "1""convertText(const QString &)" );
}


CValidateLineEdit::~CValidateLineEdit( void )
{
}


void CValidateLineEdit::setData( const QByteArray &buf )
{
  if( mBusy == false )
  {
    QString text;
    mValidator->format( text, buf );
    setText( text );
  }
}


void CValidateLineEdit::convertText( const QString &text )
{
  QByteArray buf;
  mValidator->convert( buf, text );
  mBusy = true;
  dataChanged( buf );
  mBusy = false;
}



CConverterDialog::CConverterDialog( QWidget *parent, const char *name,
                                    bool modal )
  :KDialogBase( parent, name, modal, i18n("Converter"), Cancel|User2|User1,
                Cancel, true, KStdGuiItem::clear(), i18n("&On Cursor") )
{
  QWidget *page = new QWidget( this );
  setMainWidget( page );

  QGridLayout *topLayout = new QGridLayout( page, 6, 2, 0, spacingHint() );
  topLayout->setRowStretch( 5, 10 );
  topLayout->setColStretch( 1, 10 );

  QLabel *label = new QLabel( i18n("Hexadecimal:"), page );
  topLayout->addWidget( label, 0, 0 );
  label = new QLabel( i18n("Decimal:"), page );
  topLayout->addWidget( label, 1, 0 );
  label = new QLabel( i18n("Octal:"), page );
  topLayout->addWidget( label, 2, 0 );
  label = new QLabel( i18n("Binary:"), page );
  topLayout->addWidget( label, 3, 0 );
  label = new QLabel( i18n("Text:"), page );
  topLayout->addWidget( label, 4, 0 );

  mHexInput = new CValidateLineEdit( page, CHexValidator::hexadecimal );
  mHexInput->setMinimumWidth( fontMetrics().maxWidth()*17 );
  topLayout->addWidget( mHexInput, 0, 1 );
  mDecInput = new CValidateLineEdit( page, CHexValidator::decimal );
  topLayout->addWidget( mDecInput, 1, 1 );
  mOctInput = new CValidateLineEdit( page, CHexValidator::octal );
  topLayout->addWidget( mOctInput, 2, 1 );
  mBinInput = new CValidateLineEdit( page, CHexValidator::binary );
  topLayout->addWidget( mBinInput, 3, 1 );
  mTxtInput = new CValidateLineEdit( page, CHexValidator::regularText );
  topLayout->addWidget( mTxtInput, 4, 1 );

  connect( mHexInput, "2""dataChanged(const QByteArray &)",
           this, "1""setData(const QByteArray &)" );
  connect( mDecInput, "2""dataChanged(const QByteArray &)",
           this, "1""setData(const QByteArray &)" );
  connect( mOctInput, "2""dataChanged(const QByteArray &)",
           this, "1""setData(const QByteArray &)" );
  connect( mBinInput, "2""dataChanged(const QByteArray &)",
           this, "1""setData(const QByteArray &)" );
  connect( mTxtInput, "2""dataChanged(const QByteArray &)",
           this, "1""setData(const QByteArray &)" );

}


CConverterDialog::~CConverterDialog( void )
{
}


void CConverterDialog::showEvent( QShowEvent *e )
{
  KDialogBase::showEvent(e);
  mHexInput->setFocus();
}


void CConverterDialog::setData( const QByteArray &data )
{
  mHexInput->blockSignals(true);
  mDecInput->blockSignals(true);
  mOctInput->blockSignals(true);
  mBinInput->blockSignals(true);
  mTxtInput->blockSignals(true);
  mHexInput->setData(data);
  mDecInput->setData(data);
  mOctInput->setData(data);
  mBinInput->setData(data);
  mTxtInput->setData(data);
  mHexInput->blockSignals(false);
  mDecInput->blockSignals(false);
  mOctInput->blockSignals(false);
  mBinInput->blockSignals(false);
  mTxtInput->blockSignals(false);
}

void CConverterDialog::slotUser1( void )
{
  QByteArray buf;
  setData( buf );
}

void CConverterDialog::slotUser2( void )
{
  QByteArray buf;
  probeCursorValue( buf, 1 );
  setData( buf );
}


# 1 "converterdialog.moc" 1
# 12 "converterdialog.moc"
# 1 "/usr/qt/3/include/qmetaobject.h" 1
# 42 "/usr/qt/3/include/qmetaobject.h"
# 1 "/usr/qt/3/include/qconnection.h" 1
# 45 "/usr/qt/3/include/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 & );

};


# 1 "/usr/qt/3/include/qwinexport.h" 1
# 75 "/usr/qt/3/include/qconnection.h" 2
# 43 "/usr/qt/3/include/qmetaobject.h" 2







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;
};
# 13 "converterdialog.moc" 2
# 1 "/usr/qt/3/include/qapplication.h" 1
# 42 "/usr/qt/3/include/qapplication.h"
# 1 "/usr/qt/3/include/qdesktopwidget.h" 1
# 43 "/usr/qt/3/include/qdesktopwidget.h"
class QApplication;
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; } 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 resized( int );
    void workAreaResized( int );

protected:
    void resizeEvent( QResizeEvent *e );

private:
    QDesktopWidgetPrivate *d;


    QDesktopWidget( const QDesktopWidget & );
    QDesktopWidget &operator=( const QDesktopWidget & );


    friend class QApplication;



};
# 43 "/usr/qt/3/include/qapplication.h" 2
# 1 "/usr/qt/3/include/qasciidict.h" 1
# 42 "/usr/qt/3/include/qasciidict.h"
# 1 "/usr/qt/3/include/qgdict.h" 1
# 46 "/usr/qt/3/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 "/usr/qt/3/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);}
};


# 1 "/usr/qt/3/include/qwinexport.h" 1
# 120 "/usr/qt/3/include/qasciidict.h" 2
# 44 "/usr/qt/3/include/qapplication.h" 2

# 1 "/usr/qt/3/include/qtranslator.h" 1
# 46 "/usr/qt/3/include/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; } 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();
# 176 "/usr/qt/3/include/qapplication.h"
    enum Encoding { DefaultCodec, UnicodeUTF8 };
    QString translate( const char * context,
                                const char * key,
                                const char * comment = 0,
                                Encoding encoding = DefaultCodec ) const;

    QString applicationDirPath();
    QString applicationFilePath();



    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 );
# 237 "/usr/qt/3/include/qapplication.h"
    virtual bool x11EventFilter( XEvent * );
    virtual int x11ClientMessage( QWidget*, XEvent*, bool passive_only);
    int x11ProcessEvent( XEvent* );
# 263 "/usr/qt/3/include/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();
    void aboutQt();






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 * );
# 327 "/usr/qt/3/include/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 int composedUnicode;

    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 animate_toolbox;
    static bool widgetCount;
    static bool metaComposeUnicode;

    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 QDialog;
    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;
}
# 435 "/usr/qt/3/include/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; }



inline QString QApplication::translate( const char *, const char *sourceText,
                                        const char *, Encoding encoding ) const
{

    if ( encoding == UnicodeUTF8 )
        return QString::fromUtf8( sourceText );
    else

        return QString::fromLatin1( sourceText );
}


inline int QApplication::horizontalAlignment( int align )
{
    align &= AlignHorizontal_Mask;
    if ( align == AlignAuto ) {
        if ( reverseLayout() )
            align = AlignRight;
        else
            align = AlignLeft;
    }
    return align;
}
# 14 "converterdialog.moc" 2

# 1 "/usr/qt/3/include/private/qucomextra_p.h" 1
# 54 "/usr/qt/3/include/private/qucomextra_p.h"
# 1 "/usr/qt/3/include/private/qucom_p.h" 1
# 55 "/usr/qt/3/include/private/qucom_p.h"
# 1 "/usr/qt/3/include/quuid.h" 1
# 61 "/usr/qt/3/include/quuid.h"
struct QUuid
{
    enum Variant {
        VarUnknown =-1,
        NCS = 0,
        DCE = 2,
        Microsoft = 6,
        Reserved = 7
    };

    enum Version {
        VerUnknown =-1,
        Time = 1,
        EmbeddedPOSIX = 2,
        Name = 3,
        Random = 4
    };

    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 );
    }

    bool operator<(const QUuid &other ) const;
    bool operator>(const QUuid &other ) const;
# 176 "/usr/qt/3/include/quuid.h"
    static QUuid createUuid();
    QUuid::Variant variant() const;
    QUuid::Version version() const;

    uint data1;
    ushort data2;
    ushort data3;
    uchar data4[ 8 ];
};


 QDataStream &operator<<( QDataStream &, const QUuid & );
 QDataStream &operator>>( QDataStream &, QUuid & );
# 56 "/usr/qt/3/include/private/qucom_p.h" 2






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_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_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;
# 55 "/usr/qt/3/include/private/qucomextra_p.h" 2



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;
# 16 "converterdialog.moc" 2






const char *CValidateLineEdit::className() const
{
    return "CValidateLineEdit";
}

QMetaObject *CValidateLineEdit::metaObj = 0;
static QMetaObjectCleanUp cleanUp_CValidateLineEdit( "CValidateLineEdit", &CValidateLineEdit::staticMetaObject );
# 50 "converterdialog.moc"
QMetaObject* CValidateLineEdit::staticMetaObject()
{
    if ( metaObj )
        return metaObj;
    QMetaObject* parentObject = QLineEdit::staticMetaObject();
    static const QUParameter param_slot_0[] = {
        { "buf", &static_QUType_varptr, "\x1d", QUParameter::In }
    };
    static const QUMethod slot_0 = {"setData", 1, param_slot_0 };
    static const QUParameter param_slot_1[] = {
        { "text", &static_QUType_QString, 0, QUParameter::In }
    };
    static const QUMethod slot_1 = {"convertText", 1, param_slot_1 };
    static const QMetaData slot_tbl[] = {
        { "setData(const QByteArray&)", &slot_0, QMetaData::Public },
        { "convertText(const QString&)", &slot_1, QMetaData::Private }
    };
    static const QUParameter param_signal_0[] = {
        { "buf", &static_QUType_varptr, "\x1d", QUParameter::In }
    };
    static const QUMethod signal_0 = {"dataChanged", 1, param_signal_0 };
    static const QMetaData signal_tbl[] = {
        { "dataChanged(const QByteArray&)", &signal_0, QMetaData::Private }
    };
    metaObj = QMetaObject::new_metaobject(
        "CValidateLineEdit", parentObject,
        slot_tbl, 2,
        signal_tbl, 1,

        0, 0,
        0, 0,

        0, 0 );
    cleanUp_CValidateLineEdit.setMetaObject( metaObj );
    return metaObj;
}

void* CValidateLineEdit::qt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "CValidateLineEdit" ) )
        return this;
    return QLineEdit::qt_cast( clname );
}


# 1 "/usr/qt/3/include/qsignalslotimp.h" 1
# 44 "/usr/qt/3/include/qsignalslotimp.h"
# 1 "/usr/qt/3/include/qptrvector.h" 1
# 42 "/usr/qt/3/include/qptrvector.h"
# 1 "/usr/qt/3/include/qgvector.h" 1
# 46 "/usr/qt/3/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 "/usr/qt/3/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 "/usr/qt/3/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;
}






# 1 "/usr/qt/3/include/qwinexport.h" 1
# 115 "/usr/qt/3/include/qptrvector.h" 2
# 45 "/usr/qt/3/include/qsignalslotimp.h" 2


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); }
};
# 72 "/usr/qt/3/include/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);
    }
};


# 1 "/usr/qt/3/include/qwinexport.h" 1
# 94 "/usr/qt/3/include/qsignalslotimp.h" 2
# 96 "converterdialog.moc" 2


void CValidateLineEdit::dataChanged( const QByteArray& t0 )
{
    if ( signalsBlocked() )
        return;
    QConnectionList *clist = receivers( staticMetaObject()->signalOffset() + 0 );
    if ( !clist )
        return;
    QUObject o[2];
    static_QUType_varptr.set(o+1,&t0);
    activate_signal( clist, o );
}

bool CValidateLineEdit::qt_invoke( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: setData((const QByteArray&)*((const QByteArray*)static_QUType_ptr.get(_o+1))); break;
    case 1: convertText((const QString&)static_QUType_QString.get(_o+1)); break;
    default:
        return QLineEdit::qt_invoke( _id, _o );
    }
    return TRUE;
}

bool CValidateLineEdit::qt_emit( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->signalOffset() ) {
    case 0: dataChanged((const QByteArray&)*((const QByteArray*)static_QUType_ptr.get(_o+1))); break;
    default:
        return QLineEdit::qt_emit(_id,_o);
    }
    return TRUE;
}


bool CValidateLineEdit::qt_property( int id, int f, QVariant* v)
{
    return QLineEdit::qt_property( id, f, v);
}

bool CValidateLineEdit::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }



const char *CConverterDialog::className() const
{
    return "CConverterDialog";
}

QMetaObject *CConverterDialog::metaObj = 0;
static QMetaObjectCleanUp cleanUp_CConverterDialog( "CConverterDialog", &CConverterDialog::staticMetaObject );
# 169 "converterdialog.moc"
QMetaObject* CConverterDialog::staticMetaObject()
{
    if ( metaObj )
        return metaObj;
    QMetaObject* parentObject = KDialogBase::staticMetaObject();
    static const QUMethod slot_0 = {"slotUser1", 0, 0 };
    static const QUMethod slot_1 = {"slotUser2", 0, 0 };
    static const QUParameter param_slot_2[] = {
        { "data", &static_QUType_varptr, "\x1d", QUParameter::In }
    };
    static const QUMethod slot_2 = {"setData", 1, param_slot_2 };
    static const QMetaData slot_tbl[] = {
        { "slotUser1()", &slot_0, QMetaData::Protected },
        { "slotUser2()", &slot_1, QMetaData::Protected },
        { "setData(const QByteArray&)", &slot_2, QMetaData::Private }
    };
    static const QUParameter param_signal_0[] = {
        { "buf", &static_QUType_varptr, "\x1d", QUParameter::InOut },
        { "size", &static_QUType_varptr, "\x11", QUParameter::In }
    };
    static const QUMethod signal_0 = {"probeCursorValue", 2, param_signal_0 };
    static const QMetaData signal_tbl[] = {
        { "probeCursorValue(QByteArray&,uint)", &signal_0, QMetaData::Private }
    };
    metaObj = QMetaObject::new_metaobject(
        "CConverterDialog", parentObject,
        slot_tbl, 3,
        signal_tbl, 1,

        0, 0,
        0, 0,

        0, 0 );
    cleanUp_CConverterDialog.setMetaObject( metaObj );
    return metaObj;
}

void* CConverterDialog::qt_cast( const char* clname )
{
    if ( !qstrcmp( clname, "CConverterDialog" ) )
        return this;
    return KDialogBase::qt_cast( clname );
}


void CConverterDialog::probeCursorValue( QByteArray& t0, uint t1 )
{
    if ( signalsBlocked() )
        return;
    QConnectionList *clist = receivers( staticMetaObject()->signalOffset() + 0 );
    if ( !clist )
        return;
    QUObject o[3];
    static_QUType_varptr.set(o+1,&t0);
    static_QUType_varptr.set(o+2,&t1);
    activate_signal( clist, o );
}

bool CConverterDialog::qt_invoke( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->slotOffset() ) {
    case 0: slotUser1(); break;
    case 1: slotUser2(); break;
    case 2: setData((const QByteArray&)*((const QByteArray*)static_QUType_ptr.get(_o+1))); break;
    default:
        return KDialogBase::qt_invoke( _id, _o );
    }
    return TRUE;
}

bool CConverterDialog::qt_emit( int _id, QUObject* _o )
{
    switch ( _id - staticMetaObject()->signalOffset() ) {
    case 0: probeCursorValue((QByteArray&)*((QByteArray*)static_QUType_ptr.get(_o+1)),(uint)(*((uint*)static_QUType_ptr.get(_o+2)))); break;
    default:
        return KDialogBase::qt_emit(_id,_o);
    }
    return TRUE;
}


bool CConverterDialog::qt_property( int id, int f, QVariant* v)
{
    return KDialogBase::qt_property( id, f, v);
}

bool CConverterDialog::qt_static_property( QObject* , int , int , QVariant* ){ return FALSE; }
# 164 "converterdialog.cc" 2