
#include <QBitmap>
#include <QPainterPath>
#include <QVariant>
#include <QObject>
/****************************************************************************
** Meta object code from reading C++ file 'qbitarray.h'
**
** Created: Thu 12. Apr 14:07:28 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qbitarray.h"
class PythonQtQBitArrayWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
QVariant new_QBitArray() { return QBitArray(); }
QVariant new_QBitArray(int arg0,bool arg1) { return QBitArray(arg0,arg1); }
QVariant new_QBitArray(int arg0) { return QBitArray(arg0); }
QVariant new_QBitArray(const QBitArray & arg0) { return QBitArray(arg0); }
int size(QBitArray* obj)  const  {return obj->size(); }
int count(QBitArray* obj)  const  {return obj->count(); }
int count(QBitArray* obj,bool arg0)  const  {return obj->count(arg0); }
bool isEmpty(QBitArray* obj)  const  {return obj->isEmpty(); }
bool isNull(QBitArray* obj)  const  {return obj->isNull(); }
void resize(QBitArray* obj,int arg0)  {obj->resize(arg0); }
void detach(QBitArray* obj)  {obj->detach(); }
bool isDetached(QBitArray* obj)  const  {return obj->isDetached(); }
void clear(QBitArray* obj)  {obj->clear(); }
bool testBit(QBitArray* obj,int arg0)  const  {return obj->testBit(arg0); }
void setBit(QBitArray* obj,int arg0)  {obj->setBit(arg0); }
void setBit(QBitArray* obj,int arg0,bool arg1)  {obj->setBit(arg0,arg1); }
void clearBit(QBitArray* obj,int arg0)  {obj->clearBit(arg0); }
bool toggleBit(QBitArray* obj,int arg0)  {return obj->toggleBit(arg0); }
bool at(QBitArray* obj,int arg0)  const  {return obj->at(arg0); }
bool fill(QBitArray* obj,bool arg0,int arg1)  {return obj->fill(arg0,arg1); }
bool fill(QBitArray* obj,bool arg0)  {return obj->fill(arg0); }
void fill(QBitArray* obj,bool arg0,int arg1,int arg2)  {obj->fill(arg0,arg1,arg2); }
void truncate(QBitArray* obj,int arg0)  {obj->truncate(arg0); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qdatetime.h'
**
** Created: Thu 12. Apr 14:07:28 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qdatetime.h"
class PythonQtQDateWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
QVariant new_QDate() { return QDate(); }
QVariant new_QDate(int arg0,int arg1,int arg2) { return QDate(arg0,arg1,arg2); }
bool isNull(QDate* obj)  const  {return obj->isNull(); }
bool isValid(QDate* obj)  const  {return obj->isValid(); }
int year(QDate* obj)  const  {return obj->year(); }
int month(QDate* obj)  const  {return obj->month(); }
int day(QDate* obj)  const  {return obj->day(); }
int dayOfWeek(QDate* obj)  const  {return obj->dayOfWeek(); }
int dayOfYear(QDate* obj)  const  {return obj->dayOfYear(); }
int daysInMonth(QDate* obj)  const  {return obj->daysInMonth(); }
int daysInYear(QDate* obj)  const  {return obj->daysInYear(); }
int weekNumber(QDate* obj,int * arg0)  const  {return obj->weekNumber(arg0); }
int weekNumber(QDate* obj)  const  {return obj->weekNumber(); }
QString static_QDate_shortMonthName(int arg0)  {return QDate::shortMonthName(arg0); }
QString static_QDate_shortDayName(int arg0)  {return QDate::shortDayName(arg0); }
QString static_QDate_longMonthName(int arg0)  {return QDate::longMonthName(arg0); }
QString static_QDate_longDayName(int arg0)  {return QDate::longDayName(arg0); }
QString toString(QDate* obj,Qt::DateFormat arg0)  const  {return obj->toString(arg0); }
QString toString(QDate* obj)  const  {return obj->toString(); }
QString toString(QDate* obj,const QString & arg0)  const  {return obj->toString(arg0); }
bool setYMD(QDate* obj,int arg0,int arg1,int arg2)  {return obj->setYMD(arg0,arg1,arg2); }
bool setDate(QDate* obj,int arg0,int arg1,int arg2)  {return obj->setDate(arg0,arg1,arg2); }
QDate addDays(QDate* obj,int arg0)  const  {return obj->addDays(arg0); }
QDate addMonths(QDate* obj,int arg0)  const  {return obj->addMonths(arg0); }
QDate addYears(QDate* obj,int arg0)  const  {return obj->addYears(arg0); }
int daysTo(QDate* obj,const QDate & arg0)  const  {return obj->daysTo(arg0); }
QDate static_QDate_currentDate()  {return QDate::currentDate(); }
QDate static_QDate_fromString(const QString & arg0,Qt::DateFormat arg1)  {return QDate::fromString(arg0,arg1); }
QDate static_QDate_fromString(const QString & arg0)  {return QDate::fromString(arg0); }
QDate static_QDate_fromString(const QString & arg0,const QString & arg1)  {return QDate::fromString(arg0,arg1); }
bool static_QDate_isValid(int arg0,int arg1,int arg2)  {return QDate::isValid(arg0,arg1,arg2); }
bool static_QDate_isLeapYear(int arg0)  {return QDate::isLeapYear(arg0); }
uint static_QDate_gregorianToJulian(int arg0,int arg1,int arg2)  {return QDate::gregorianToJulian(arg0,arg1,arg2); }
void static_QDate_julianToGregorian(uint arg0,int & arg1,int & arg2,int & arg3)  {QDate::julianToGregorian(arg0,arg1,arg2,arg3); }
QDate fromJulianDay(QDate* obj,int arg0)  {return obj->fromJulianDay(arg0); }
int toJulianDay(QDate* obj)  const  {return obj->toJulianDay(); }

};

class PythonQtQTimeWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
QVariant new_QTime() { return QTime(); }
bool isNull(QTime* obj)  const  {return obj->isNull(); }
bool isValid(QTime* obj)  const  {return obj->isValid(); }
int hour(QTime* obj)  const  {return obj->hour(); }
int minute(QTime* obj)  const  {return obj->minute(); }
int second(QTime* obj)  const  {return obj->second(); }
int msec(QTime* obj)  const  {return obj->msec(); }
QString toString(QTime* obj,Qt::DateFormat arg0)  const  {return obj->toString(arg0); }
QString toString(QTime* obj)  const  {return obj->toString(); }
QString toString(QTime* obj,const QString & arg0)  const  {return obj->toString(arg0); }
bool setHMS(QTime* obj,int arg0,int arg1,int arg2,int arg3)  {return obj->setHMS(arg0,arg1,arg2,arg3); }
bool setHMS(QTime* obj,int arg0,int arg1,int arg2)  {return obj->setHMS(arg0,arg1,arg2); }
QTime addSecs(QTime* obj,int arg0)  const  {return obj->addSecs(arg0); }
int secsTo(QTime* obj,const QTime & arg0)  const  {return obj->secsTo(arg0); }
QTime addMSecs(QTime* obj,int arg0)  const  {return obj->addMSecs(arg0); }
int msecsTo(QTime* obj,const QTime & arg0)  const  {return obj->msecsTo(arg0); }
QTime static_QTime_currentTime()  {return QTime::currentTime(); }
QTime static_QTime_fromString(const QString & arg0,Qt::DateFormat arg1)  {return QTime::fromString(arg0,arg1); }
QTime static_QTime_fromString(const QString & arg0)  {return QTime::fromString(arg0); }
QTime static_QTime_fromString(const QString & arg0,const QString & arg1)  {return QTime::fromString(arg0,arg1); }
bool static_QTime_isValid(int arg0,int arg1,int arg2,int arg3)  {return QTime::isValid(arg0,arg1,arg2,arg3); }
bool static_QTime_isValid(int arg0,int arg1,int arg2)  {return QTime::isValid(arg0,arg1,arg2); }
void start(QTime* obj)  {obj->start(); }
int restart(QTime* obj)  {return obj->restart(); }
int elapsed(QTime* obj)  const  {return obj->elapsed(); }

};

class PythonQtQDateTimeWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
QVariant new_QDateTime() { return QDateTime(); }
QVariant new_QDateTime(const QDate & arg0) { return QDateTime(arg0); }
QVariant new_QDateTime(const QDate & arg0,const QTime & arg1,Qt::TimeSpec arg2) { return QDateTime(arg0,arg1,arg2); }
QVariant new_QDateTime(const QDate & arg0,const QTime & arg1) { return QDateTime(arg0,arg1); }
QVariant new_QDateTime(const QDateTime & arg0) { return QDateTime(arg0); }
bool isNull(QDateTime* obj)  const  {return obj->isNull(); }
bool isValid(QDateTime* obj)  const  {return obj->isValid(); }
QDate date(QDateTime* obj)  const  {return obj->date(); }
QTime time(QDateTime* obj)  const  {return obj->time(); }
Qt::TimeSpec timeSpec(QDateTime* obj)  const  {return obj->timeSpec(); }
uint toTime_t(QDateTime* obj)  const  {return obj->toTime_t(); }
void setDate(QDateTime* obj,const QDate & arg0)  {obj->setDate(arg0); }
void setTime(QDateTime* obj,const QTime & arg0)  {obj->setTime(arg0); }
void setTimeSpec(QDateTime* obj,Qt::TimeSpec arg0)  {obj->setTimeSpec(arg0); }
void setTime_t(QDateTime* obj,uint arg0)  {obj->setTime_t(arg0); }
QString toString(QDateTime* obj,Qt::DateFormat arg0)  const  {return obj->toString(arg0); }
QString toString(QDateTime* obj)  const  {return obj->toString(); }
QString toString(QDateTime* obj,const QString & arg0)  const  {return obj->toString(arg0); }
QDateTime addDays(QDateTime* obj,int arg0)  const  {return obj->addDays(arg0); }
QDateTime addMonths(QDateTime* obj,int arg0)  const  {return obj->addMonths(arg0); }
QDateTime addYears(QDateTime* obj,int arg0)  const  {return obj->addYears(arg0); }
QDateTime addSecs(QDateTime* obj,int arg0)  const  {return obj->addSecs(arg0); }
QDateTime addMSecs(QDateTime* obj,qint64 arg0)  const  {return obj->addMSecs(arg0); }
QDateTime toTimeSpec(QDateTime* obj,Qt::TimeSpec arg0)  const  {return obj->toTimeSpec(arg0); }
QDateTime toLocalTime(QDateTime* obj)  const  {return obj->toLocalTime(); }
QDateTime toUTC(QDateTime* obj)  const  {return obj->toUTC(); }
int daysTo(QDateTime* obj,const QDateTime & arg0)  const  {return obj->daysTo(arg0); }
int secsTo(QDateTime* obj,const QDateTime & arg0)  const  {return obj->secsTo(arg0); }
QDateTime static_QDateTime_currentDateTime()  {return QDateTime::currentDateTime(); }
QDateTime static_QDateTime_fromString(const QString & arg0,Qt::DateFormat arg1)  {return QDateTime::fromString(arg0,arg1); }
QDateTime static_QDateTime_fromString(const QString & arg0)  {return QDateTime::fromString(arg0); }
QDateTime static_QDateTime_fromString(const QString & arg0,const QString & arg1)  {return QDateTime::fromString(arg0,arg1); }
QDateTime static_QDateTime_fromTime_t(uint arg0)  {return QDateTime::fromTime_t(arg0); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qurl.h'
**
** Created: Thu 12. Apr 14:07:28 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qurl.h"
class PythonQtQUrlWrapper : public QObject  {
  Q_OBJECT

public:
Q_ENUMS(ParsingMode FormattingOption )
enum ParsingMode {TolerantMode = QUrl::TolerantMode, 
StrictMode = QUrl::StrictMode }; 
enum FormattingOption {None = QUrl::None, 
RemoveScheme = QUrl::RemoveScheme, 
RemovePassword = QUrl::RemovePassword, 
RemoveUserInfo = QUrl::RemoveUserInfo, 
RemovePort = QUrl::RemovePort, 
RemoveAuthority = QUrl::RemoveAuthority, 
RemovePath = QUrl::RemovePath, 
RemoveQuery = QUrl::RemoveQuery, 
RemoveFragment = QUrl::RemoveFragment, 
StripTrailingSlash = QUrl::StripTrailingSlash }; 
Q_DECLARE_FLAGS(FormattingOptions, FormattingOption)
public slots:
QVariant new_QUrl(const QString & arg0) { return QUrl(arg0); }
QVariant new_QUrl(const QString & arg0,ParsingMode arg1) { return QUrl(arg0,(QUrl::ParsingMode)arg1); }
QVariant new_QUrl(const QUrl & arg0) { return QUrl(arg0); }
void setUrl(QUrl* obj,const QString & arg0)  {obj->setUrl(arg0); }
void setUrl(QUrl* obj,const QString & arg0,ParsingMode arg1)  {obj->setUrl(arg0,(QUrl::ParsingMode)arg1); }
void setEncodedUrl(QUrl* obj,const QByteArray & arg0)  {obj->setEncodedUrl(arg0); }
void setEncodedUrl(QUrl* obj,const QByteArray & arg0,ParsingMode arg1)  {obj->setEncodedUrl(arg0,(QUrl::ParsingMode)arg1); }
bool isValid(QUrl* obj)  const  {return obj->isValid(); }
bool isEmpty(QUrl* obj)  const  {return obj->isEmpty(); }
void clear(QUrl* obj)  {obj->clear(); }
void setScheme(QUrl* obj,const QString & arg0)  {obj->setScheme(arg0); }
QString scheme(QUrl* obj)  const  {return obj->scheme(); }
void setAuthority(QUrl* obj,const QString & arg0)  {obj->setAuthority(arg0); }
QString authority(QUrl* obj)  const  {return obj->authority(); }
void setUserInfo(QUrl* obj,const QString & arg0)  {obj->setUserInfo(arg0); }
QString userInfo(QUrl* obj)  const  {return obj->userInfo(); }
void setUserName(QUrl* obj,const QString & arg0)  {obj->setUserName(arg0); }
QString userName(QUrl* obj)  const  {return obj->userName(); }
void setPassword(QUrl* obj,const QString & arg0)  {obj->setPassword(arg0); }
QString password(QUrl* obj)  const  {return obj->password(); }
void setHost(QUrl* obj,const QString & arg0)  {obj->setHost(arg0); }
QString host(QUrl* obj)  const  {return obj->host(); }
void setPort(QUrl* obj,int arg0)  {obj->setPort(arg0); }
int port(QUrl* obj)  const  {return obj->port(); }
int port(QUrl* obj,int arg0)  const  {return obj->port(arg0); }
void setPath(QUrl* obj,const QString & arg0)  {obj->setPath(arg0); }
QString path(QUrl* obj)  const  {return obj->path(); }
bool hasQuery(QUrl* obj)  const  {return obj->hasQuery(); }
void setEncodedQuery(QUrl* obj,const QByteArray & arg0)  {obj->setEncodedQuery(arg0); }
QByteArray encodedQuery(QUrl* obj)  const  {return obj->encodedQuery(); }
void setQueryDelimiters(QUrl* obj,char arg0,char arg1)  {obj->setQueryDelimiters(arg0,arg1); }
char queryValueDelimiter(QUrl* obj)  const  {return obj->queryValueDelimiter(); }
char queryPairDelimiter(QUrl* obj)  const  {return obj->queryPairDelimiter(); }
void setQueryItems(QUrl* obj,const QList<QPair<QString,QString> > & arg0)  {obj->setQueryItems(arg0); }
void addQueryItem(QUrl* obj,const QString & arg0,const QString & arg1)  {obj->addQueryItem(arg0,arg1); }
QList<QPair<QString,QString> > queryItems(QUrl* obj)  const  {return obj->queryItems(); }
bool hasQueryItem(QUrl* obj,const QString & arg0)  const  {return obj->hasQueryItem(arg0); }
QString queryItemValue(QUrl* obj,const QString & arg0)  const  {return obj->queryItemValue(arg0); }
QStringList allQueryItemValues(QUrl* obj,const QString & arg0)  const  {return obj->allQueryItemValues(arg0); }
void removeQueryItem(QUrl* obj,const QString & arg0)  {obj->removeQueryItem(arg0); }
void removeAllQueryItems(QUrl* obj,const QString & arg0)  {obj->removeAllQueryItems(arg0); }
void setFragment(QUrl* obj,const QString & arg0)  {obj->setFragment(arg0); }
QString fragment(QUrl* obj)  const  {return obj->fragment(); }
bool hasFragment(QUrl* obj)  const  {return obj->hasFragment(); }
QUrl resolved(QUrl* obj,const QUrl & arg0)  const  {return obj->resolved(arg0); }
bool isRelative(QUrl* obj)  const  {return obj->isRelative(); }
bool isParentOf(QUrl* obj,const QUrl & arg0)  const  {return obj->isParentOf(arg0); }
QUrl static_QUrl_fromLocalFile(const QString & arg0)  {return QUrl::fromLocalFile(arg0); }
QString toLocalFile(QUrl* obj)  const  {return obj->toLocalFile(); }
QString toString(QUrl* obj,FormattingOptions arg0)  const  {return obj->toString((QUrl::FormattingOptions)QFlag(arg0)); }
QString toString(QUrl* obj)  const  {return obj->toString(); }
QByteArray toEncoded(QUrl* obj,FormattingOptions arg0)  const  {return obj->toEncoded((QUrl::FormattingOptions)QFlag(arg0)); }
QByteArray toEncoded(QUrl* obj)  const  {return obj->toEncoded(); }
QUrl static_QUrl_fromEncoded(const QByteArray & arg0)  {return QUrl::fromEncoded(arg0); }
QUrl static_QUrl_fromEncoded(const QByteArray & arg0,ParsingMode arg1)  {return QUrl::fromEncoded(arg0,(QUrl::ParsingMode)arg1); }
void detach(QUrl* obj)  {obj->detach(); }
bool isDetached(QUrl* obj)  const  {return obj->isDetached(); }
QString static_QUrl_fromPercentEncoding(const QByteArray & arg0)  {return QUrl::fromPercentEncoding(arg0); }
QByteArray static_QUrl_toPercentEncoding(const QString & arg0,const QByteArray & arg1,const QByteArray & arg2)  {return QUrl::toPercentEncoding(arg0,arg1,arg2); }
QByteArray static_QUrl_toPercentEncoding(const QString & arg0,const QByteArray & arg1)  {return QUrl::toPercentEncoding(arg0,arg1); }
QByteArray static_QUrl_toPercentEncoding(const QString & arg0)  {return QUrl::toPercentEncoding(arg0); }
QString static_QUrl_fromPunycode(const QByteArray & arg0)  {return QUrl::fromPunycode(arg0); }
QByteArray static_QUrl_toPunycode(const QString & arg0)  {return QUrl::toPunycode(arg0); }
QString static_QUrl_fromAce(const QByteArray & arg0)  {return QUrl::fromAce(arg0); }
QByteArray static_QUrl_toAce(const QString & arg0)  {return QUrl::toAce(arg0); }
QStringList static_QUrl_idnWhitelist()  {return QUrl::idnWhitelist(); }
void static_QUrl_setIdnWhitelist(const QStringList & arg0)  {QUrl::setIdnWhitelist(arg0); }
QString errorString(QUrl* obj)  const  {return obj->errorString(); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qlocale.h'
**
** Created: Thu 12. Apr 14:07:28 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qlocale.h"
class PythonQtQLocaleWrapper : public QObject  {
  Q_OBJECT

public:
Q_ENUMS(Language Country FormatType NumberOption )
enum Language {C = QLocale::C, 
Abkhazian = QLocale::Abkhazian, 
Afan = QLocale::Afan, 
Afar = QLocale::Afar, 
Afrikaans = QLocale::Afrikaans, 
Albanian = QLocale::Albanian, 
Amharic = QLocale::Amharic, 
Arabic = QLocale::Arabic, 
Armenian = QLocale::Armenian, 
Assamese = QLocale::Assamese, 
Aymara = QLocale::Aymara, 
Azerbaijani = QLocale::Azerbaijani, 
Bashkir = QLocale::Bashkir, 
Basque = QLocale::Basque, 
Bengali = QLocale::Bengali, 
Bhutani = QLocale::Bhutani, 
Bihari = QLocale::Bihari, 
Bislama = QLocale::Bislama, 
Breton = QLocale::Breton, 
Bulgarian = QLocale::Bulgarian, 
Burmese = QLocale::Burmese, 
Byelorussian = QLocale::Byelorussian, 
Cambodian = QLocale::Cambodian, 
Catalan = QLocale::Catalan, 
Chinese = QLocale::Chinese, 
Corsican = QLocale::Corsican, 
Croatian = QLocale::Croatian, 
Czech = QLocale::Czech, 
Danish = QLocale::Danish, 
Dutch = QLocale::Dutch, 
English = QLocale::English, 
Esperanto = QLocale::Esperanto, 
Estonian = QLocale::Estonian, 
Faroese = QLocale::Faroese, 
FijiLanguage = QLocale::FijiLanguage, 
Finnish = QLocale::Finnish, 
French = QLocale::French, 
Frisian = QLocale::Frisian, 
Gaelic = QLocale::Gaelic, 
Galician = QLocale::Galician, 
Georgian = QLocale::Georgian, 
German = QLocale::German, 
Greek = QLocale::Greek, 
Greenlandic = QLocale::Greenlandic, 
Guarani = QLocale::Guarani, 
Gujarati = QLocale::Gujarati, 
Hausa = QLocale::Hausa, 
Hebrew = QLocale::Hebrew, 
Hindi = QLocale::Hindi, 
Hungarian = QLocale::Hungarian, 
Icelandic = QLocale::Icelandic, 
Indonesian = QLocale::Indonesian, 
Interlingua = QLocale::Interlingua, 
Interlingue = QLocale::Interlingue, 
Inuktitut = QLocale::Inuktitut, 
Inupiak = QLocale::Inupiak, 
Irish = QLocale::Irish, 
Italian = QLocale::Italian, 
Japanese = QLocale::Japanese, 
Javanese = QLocale::Javanese, 
Kannada = QLocale::Kannada, 
Kashmiri = QLocale::Kashmiri, 
Kazakh = QLocale::Kazakh, 
Kinyarwanda = QLocale::Kinyarwanda, 
Kirghiz = QLocale::Kirghiz, 
Korean = QLocale::Korean, 
Kurdish = QLocale::Kurdish, 
Kurundi = QLocale::Kurundi, 
Laothian = QLocale::Laothian, 
Latin = QLocale::Latin, 
Latvian = QLocale::Latvian, 
Lingala = QLocale::Lingala, 
Lithuanian = QLocale::Lithuanian, 
Macedonian = QLocale::Macedonian, 
Malagasy = QLocale::Malagasy, 
Malay = QLocale::Malay, 
Malayalam = QLocale::Malayalam, 
Maltese = QLocale::Maltese, 
Maori = QLocale::Maori, 
Marathi = QLocale::Marathi, 
Moldavian = QLocale::Moldavian, 
Mongolian = QLocale::Mongolian, 
NauruLanguage = QLocale::NauruLanguage, 
Nepali = QLocale::Nepali, 
Norwegian = QLocale::Norwegian, 
Occitan = QLocale::Occitan, 
Oriya = QLocale::Oriya, 
Pashto = QLocale::Pashto, 
Persian = QLocale::Persian, 
Polish = QLocale::Polish, 
Portuguese = QLocale::Portuguese, 
Punjabi = QLocale::Punjabi, 
Quechua = QLocale::Quechua, 
RhaetoRomance = QLocale::RhaetoRomance, 
Romanian = QLocale::Romanian, 
Russian = QLocale::Russian, 
Samoan = QLocale::Samoan, 
Sangho = QLocale::Sangho, 
Sanskrit = QLocale::Sanskrit, 
Serbian = QLocale::Serbian, 
SerboCroatian = QLocale::SerboCroatian, 
Sesotho = QLocale::Sesotho, 
Setswana = QLocale::Setswana, 
Shona = QLocale::Shona, 
Sindhi = QLocale::Sindhi, 
Singhalese = QLocale::Singhalese, 
Siswati = QLocale::Siswati, 
Slovak = QLocale::Slovak, 
Slovenian = QLocale::Slovenian, 
Somali = QLocale::Somali, 
Spanish = QLocale::Spanish, 
Sundanese = QLocale::Sundanese, 
Swahili = QLocale::Swahili, 
Swedish = QLocale::Swedish, 
Tagalog = QLocale::Tagalog, 
Tajik = QLocale::Tajik, 
Tamil = QLocale::Tamil, 
Tatar = QLocale::Tatar, 
Telugu = QLocale::Telugu, 
Thai = QLocale::Thai, 
Tibetan = QLocale::Tibetan, 
Tigrinya = QLocale::Tigrinya, 
TongaLanguage = QLocale::TongaLanguage, 
Tsonga = QLocale::Tsonga, 
Turkish = QLocale::Turkish, 
Turkmen = QLocale::Turkmen, 
Twi = QLocale::Twi, 
Uigur = QLocale::Uigur, 
Ukrainian = QLocale::Ukrainian, 
Urdu = QLocale::Urdu, 
Uzbek = QLocale::Uzbek, 
Vietnamese = QLocale::Vietnamese, 
Volapuk = QLocale::Volapuk, 
Welsh = QLocale::Welsh, 
Wolof = QLocale::Wolof, 
Xhosa = QLocale::Xhosa, 
Yiddish = QLocale::Yiddish, 
Yoruba = QLocale::Yoruba, 
Zhuang = QLocale::Zhuang, 
Zulu = QLocale::Zulu, 
Nynorsk = QLocale::Nynorsk, 
Bosnian = QLocale::Bosnian, 
Divehi = QLocale::Divehi, 
Manx = QLocale::Manx, 
Cornish = QLocale::Cornish, 
LastLanguage = QLocale::LastLanguage }; 
enum Country {AnyCountry = QLocale::AnyCountry, 
Afghanistan = QLocale::Afghanistan, 
Albania = QLocale::Albania, 
Algeria = QLocale::Algeria, 
AmericanSamoa = QLocale::AmericanSamoa, 
Andorra = QLocale::Andorra, 
Angola = QLocale::Angola, 
Anguilla = QLocale::Anguilla, 
Antarctica = QLocale::Antarctica, 
AntiguaAndBarbuda = QLocale::AntiguaAndBarbuda, 
Argentina = QLocale::Argentina, 
Armenia = QLocale::Armenia, 
Aruba = QLocale::Aruba, 
Australia = QLocale::Australia, 
Austria = QLocale::Austria, 
Azerbaijan = QLocale::Azerbaijan, 
Bahamas = QLocale::Bahamas, 
Bahrain = QLocale::Bahrain, 
Bangladesh = QLocale::Bangladesh, 
Barbados = QLocale::Barbados, 
Belarus = QLocale::Belarus, 
Belgium = QLocale::Belgium, 
Belize = QLocale::Belize, 
Benin = QLocale::Benin, 
Bermuda = QLocale::Bermuda, 
Bhutan = QLocale::Bhutan, 
Bolivia = QLocale::Bolivia, 
BosniaAndHerzegowina = QLocale::BosniaAndHerzegowina, 
Botswana = QLocale::Botswana, 
BouvetIsland = QLocale::BouvetIsland, 
Brazil = QLocale::Brazil, 
BritishIndianOceanTerritory = QLocale::BritishIndianOceanTerritory, 
BruneiDarussalam = QLocale::BruneiDarussalam, 
Bulgaria = QLocale::Bulgaria, 
BurkinaFaso = QLocale::BurkinaFaso, 
Burundi = QLocale::Burundi, 
Cambodia = QLocale::Cambodia, 
Cameroon = QLocale::Cameroon, 
Canada = QLocale::Canada, 
CapeVerde = QLocale::CapeVerde, 
CaymanIslands = QLocale::CaymanIslands, 
CentralAfricanRepublic = QLocale::CentralAfricanRepublic, 
Chad = QLocale::Chad, 
Chile = QLocale::Chile, 
China = QLocale::China, 
ChristmasIsland = QLocale::ChristmasIsland, 
CocosIslands = QLocale::CocosIslands, 
Colombia = QLocale::Colombia, 
Comoros = QLocale::Comoros, 
DemocraticRepublicOfCongo = QLocale::DemocraticRepublicOfCongo, 
PeoplesRepublicOfCongo = QLocale::PeoplesRepublicOfCongo, 
CookIslands = QLocale::CookIslands, 
CostaRica = QLocale::CostaRica, 
IvoryCoast = QLocale::IvoryCoast, 
Croatia = QLocale::Croatia, 
Cuba = QLocale::Cuba, 
Cyprus = QLocale::Cyprus, 
CzechRepublic = QLocale::CzechRepublic, 
Denmark = QLocale::Denmark, 
Djibouti = QLocale::Djibouti, 
Dominica = QLocale::Dominica, 
DominicanRepublic = QLocale::DominicanRepublic, 
EastTimor = QLocale::EastTimor, 
Ecuador = QLocale::Ecuador, 
Egypt = QLocale::Egypt, 
ElSalvador = QLocale::ElSalvador, 
EquatorialGuinea = QLocale::EquatorialGuinea, 
Eritrea = QLocale::Eritrea, 
Estonia = QLocale::Estonia, 
Ethiopia = QLocale::Ethiopia, 
FalklandIslands = QLocale::FalklandIslands, 
FaroeIslands = QLocale::FaroeIslands, 
FijiCountry = QLocale::FijiCountry, 
Finland = QLocale::Finland, 
France = QLocale::France, 
MetropolitanFrance = QLocale::MetropolitanFrance, 
FrenchGuiana = QLocale::FrenchGuiana, 
FrenchPolynesia = QLocale::FrenchPolynesia, 
FrenchSouthernTerritories = QLocale::FrenchSouthernTerritories, 
Gabon = QLocale::Gabon, 
Gambia = QLocale::Gambia, 
Georgia = QLocale::Georgia, 
Germany = QLocale::Germany, 
Ghana = QLocale::Ghana, 
Gibraltar = QLocale::Gibraltar, 
Greece = QLocale::Greece, 
Greenland = QLocale::Greenland, 
Grenada = QLocale::Grenada, 
Guadeloupe = QLocale::Guadeloupe, 
Guam = QLocale::Guam, 
Guatemala = QLocale::Guatemala, 
Guinea = QLocale::Guinea, 
GuineaBissau = QLocale::GuineaBissau, 
Guyana = QLocale::Guyana, 
Haiti = QLocale::Haiti, 
HeardAndMcDonaldIslands = QLocale::HeardAndMcDonaldIslands, 
Honduras = QLocale::Honduras, 
HongKong = QLocale::HongKong, 
Hungary = QLocale::Hungary, 
Iceland = QLocale::Iceland, 
India = QLocale::India, 
Indonesia = QLocale::Indonesia, 
Iran = QLocale::Iran, 
Iraq = QLocale::Iraq, 
Ireland = QLocale::Ireland, 
Israel = QLocale::Israel, 
Italy = QLocale::Italy, 
Jamaica = QLocale::Jamaica, 
Japan = QLocale::Japan, 
Jordan = QLocale::Jordan, 
Kazakhstan = QLocale::Kazakhstan, 
Kenya = QLocale::Kenya, 
Kiribati = QLocale::Kiribati, 
DemocraticRepublicOfKorea = QLocale::DemocraticRepublicOfKorea, 
RepublicOfKorea = QLocale::RepublicOfKorea, 
Kuwait = QLocale::Kuwait, 
Kyrgyzstan = QLocale::Kyrgyzstan, 
Lao = QLocale::Lao, 
Latvia = QLocale::Latvia, 
Lebanon = QLocale::Lebanon, 
Lesotho = QLocale::Lesotho, 
Liberia = QLocale::Liberia, 
LibyanArabJamahiriya = QLocale::LibyanArabJamahiriya, 
Liechtenstein = QLocale::Liechtenstein, 
Lithuania = QLocale::Lithuania, 
Luxembourg = QLocale::Luxembourg, 
Macau = QLocale::Macau, 
Macedonia = QLocale::Macedonia, 
Madagascar = QLocale::Madagascar, 
Malawi = QLocale::Malawi, 
Malaysia = QLocale::Malaysia, 
Maldives = QLocale::Maldives, 
Mali = QLocale::Mali, 
Malta = QLocale::Malta, 
MarshallIslands = QLocale::MarshallIslands, 
Martinique = QLocale::Martinique, 
Mauritania = QLocale::Mauritania, 
Mauritius = QLocale::Mauritius, 
Mayotte = QLocale::Mayotte, 
Mexico = QLocale::Mexico, 
Micronesia = QLocale::Micronesia, 
Moldova = QLocale::Moldova, 
Monaco = QLocale::Monaco, 
Mongolia = QLocale::Mongolia, 
Montserrat = QLocale::Montserrat, 
Morocco = QLocale::Morocco, 
Mozambique = QLocale::Mozambique, 
Myanmar = QLocale::Myanmar, 
Namibia = QLocale::Namibia, 
NauruCountry = QLocale::NauruCountry, 
Nepal = QLocale::Nepal, 
Netherlands = QLocale::Netherlands, 
NetherlandsAntilles = QLocale::NetherlandsAntilles, 
NewCaledonia = QLocale::NewCaledonia, 
NewZealand = QLocale::NewZealand, 
Nicaragua = QLocale::Nicaragua, 
Niger = QLocale::Niger, 
Nigeria = QLocale::Nigeria, 
Niue = QLocale::Niue, 
NorfolkIsland = QLocale::NorfolkIsland, 
NorthernMarianaIslands = QLocale::NorthernMarianaIslands, 
Norway = QLocale::Norway, 
Oman = QLocale::Oman, 
Pakistan = QLocale::Pakistan, 
Palau = QLocale::Palau, 
PalestinianTerritory = QLocale::PalestinianTerritory, 
Panama = QLocale::Panama, 
PapuaNewGuinea = QLocale::PapuaNewGuinea, 
Paraguay = QLocale::Paraguay, 
Peru = QLocale::Peru, 
Philippines = QLocale::Philippines, 
Pitcairn = QLocale::Pitcairn, 
Poland = QLocale::Poland, 
Portugal = QLocale::Portugal, 
PuertoRico = QLocale::PuertoRico, 
Qatar = QLocale::Qatar, 
Reunion = QLocale::Reunion, 
Romania = QLocale::Romania, 
RussianFederation = QLocale::RussianFederation, 
Rwanda = QLocale::Rwanda, 
SaintKittsAndNevis = QLocale::SaintKittsAndNevis, 
StLucia = QLocale::StLucia, 
StVincentAndTheGrenadines = QLocale::StVincentAndTheGrenadines, 
Samoa = QLocale::Samoa, 
SanMarino = QLocale::SanMarino, 
SaoTomeAndPrincipe = QLocale::SaoTomeAndPrincipe, 
SaudiArabia = QLocale::SaudiArabia, 
Senegal = QLocale::Senegal, 
Seychelles = QLocale::Seychelles, 
SierraLeone = QLocale::SierraLeone, 
Singapore = QLocale::Singapore, 
Slovakia = QLocale::Slovakia, 
Slovenia = QLocale::Slovenia, 
SolomonIslands = QLocale::SolomonIslands, 
Somalia = QLocale::Somalia, 
SouthAfrica = QLocale::SouthAfrica, 
SouthGeorgiaAndTheSouthSandwichIslands = QLocale::SouthGeorgiaAndTheSouthSandwichIslands, 
Spain = QLocale::Spain, 
SriLanka = QLocale::SriLanka, 
StHelena = QLocale::StHelena, 
StPierreAndMiquelon = QLocale::StPierreAndMiquelon, 
Sudan = QLocale::Sudan, 
Suriname = QLocale::Suriname, 
SvalbardAndJanMayenIslands = QLocale::SvalbardAndJanMayenIslands, 
Swaziland = QLocale::Swaziland, 
Sweden = QLocale::Sweden, 
Switzerland = QLocale::Switzerland, 
SyrianArabRepublic = QLocale::SyrianArabRepublic, 
Taiwan = QLocale::Taiwan, 
Tajikistan = QLocale::Tajikistan, 
Tanzania = QLocale::Tanzania, 
Thailand = QLocale::Thailand, 
Togo = QLocale::Togo, 
Tokelau = QLocale::Tokelau, 
TongaCountry = QLocale::TongaCountry, 
TrinidadAndTobago = QLocale::TrinidadAndTobago, 
Tunisia = QLocale::Tunisia, 
Turkey = QLocale::Turkey, 
Turkmenistan = QLocale::Turkmenistan, 
TurksAndCaicosIslands = QLocale::TurksAndCaicosIslands, 
Tuvalu = QLocale::Tuvalu, 
Uganda = QLocale::Uganda, 
Ukraine = QLocale::Ukraine, 
UnitedArabEmirates = QLocale::UnitedArabEmirates, 
UnitedKingdom = QLocale::UnitedKingdom, 
UnitedStates = QLocale::UnitedStates, 
UnitedStatesMinorOutlyingIslands = QLocale::UnitedStatesMinorOutlyingIslands, 
Uruguay = QLocale::Uruguay, 
Uzbekistan = QLocale::Uzbekistan, 
Vanuatu = QLocale::Vanuatu, 
VaticanCityState = QLocale::VaticanCityState, 
Venezuela = QLocale::Venezuela, 
VietNam = QLocale::VietNam, 
BritishVirginIslands = QLocale::BritishVirginIslands, 
USVirginIslands = QLocale::USVirginIslands, 
WallisAndFutunaIslands = QLocale::WallisAndFutunaIslands, 
WesternSahara = QLocale::WesternSahara, 
Yemen = QLocale::Yemen, 
Yugoslavia = QLocale::Yugoslavia, 
Zambia = QLocale::Zambia, 
Zimbabwe = QLocale::Zimbabwe, 
SerbiaAndMontenegro = QLocale::SerbiaAndMontenegro, 
LastCountry = QLocale::LastCountry }; 
enum FormatType {LongFormat = QLocale::LongFormat, 
ShortFormat = QLocale::ShortFormat }; 
enum NumberOption {OmitGroupSeparator = QLocale::OmitGroupSeparator, 
RejectGroupSeparator = QLocale::RejectGroupSeparator }; 
Q_DECLARE_FLAGS(NumberOptions, NumberOption)
public slots:
QVariant new_QLocale(const QString & arg0) { return QLocale(arg0); }
QVariant new_QLocale(Language arg0,Country arg1) { return QLocale((QLocale::Language)arg0,(QLocale::Country)arg1); }
QVariant new_QLocale(Language arg0) { return QLocale((QLocale::Language)arg0); }
QVariant new_QLocale(const QLocale & arg0) { return QLocale(arg0); }
Language language(QLocale* obj)  const  {return (PythonQtQLocaleWrapper::Language)obj->language(); }
Country country(QLocale* obj)  const  {return (PythonQtQLocaleWrapper::Country)obj->country(); }
QString name(QLocale* obj)  const  {return obj->name(); }
short toShort(QLocale* obj,const QString & arg0,bool * arg1,int arg2)  const  {return obj->toShort(arg0,arg1,arg2); }
short toShort(QLocale* obj,const QString & arg0,bool * arg1)  const  {return obj->toShort(arg0,arg1); }
short toShort(QLocale* obj,const QString & arg0)  const  {return obj->toShort(arg0); }
ushort toUShort(QLocale* obj,const QString & arg0,bool * arg1,int arg2)  const  {return obj->toUShort(arg0,arg1,arg2); }
ushort toUShort(QLocale* obj,const QString & arg0,bool * arg1)  const  {return obj->toUShort(arg0,arg1); }
ushort toUShort(QLocale* obj,const QString & arg0)  const  {return obj->toUShort(arg0); }
int toInt(QLocale* obj,const QString & arg0,bool * arg1,int arg2)  const  {return obj->toInt(arg0,arg1,arg2); }
int toInt(QLocale* obj,const QString & arg0,bool * arg1)  const  {return obj->toInt(arg0,arg1); }
int toInt(QLocale* obj,const QString & arg0)  const  {return obj->toInt(arg0); }
uint toUInt(QLocale* obj,const QString & arg0,bool * arg1,int arg2)  const  {return obj->toUInt(arg0,arg1,arg2); }
uint toUInt(QLocale* obj,const QString & arg0,bool * arg1)  const  {return obj->toUInt(arg0,arg1); }
uint toUInt(QLocale* obj,const QString & arg0)  const  {return obj->toUInt(arg0); }
qlonglong toLongLong(QLocale* obj,const QString & arg0,bool * arg1,int arg2)  const  {return obj->toLongLong(arg0,arg1,arg2); }
qlonglong toLongLong(QLocale* obj,const QString & arg0,bool * arg1)  const  {return obj->toLongLong(arg0,arg1); }
qlonglong toLongLong(QLocale* obj,const QString & arg0)  const  {return obj->toLongLong(arg0); }
qlonglong toULongLong(QLocale* obj,const QString & arg0,bool * arg1,int arg2)  const  {return obj->toULongLong(arg0,arg1,arg2); }
qlonglong toULongLong(QLocale* obj,const QString & arg0,bool * arg1)  const  {return obj->toULongLong(arg0,arg1); }
qlonglong toULongLong(QLocale* obj,const QString & arg0)  const  {return obj->toULongLong(arg0); }
float toFloat(QLocale* obj,const QString & arg0,bool * arg1)  const  {return obj->toFloat(arg0,arg1); }
float toFloat(QLocale* obj,const QString & arg0)  const  {return obj->toFloat(arg0); }
double toDouble(QLocale* obj,const QString & arg0,bool * arg1)  const  {return obj->toDouble(arg0,arg1); }
double toDouble(QLocale* obj,const QString & arg0)  const  {return obj->toDouble(arg0); }
QString toString(QLocale* obj,qlonglong arg0)  const  {return obj->toString(arg0); }
QString toString(QLocale* obj,qulonglong arg0)  const  {return obj->toString(arg0); }
QString toString(QLocale* obj,short arg0)  const  {return obj->toString(arg0); }
QString toString(QLocale* obj,ushort arg0)  const  {return obj->toString(arg0); }
QString toString(QLocale* obj,int arg0)  const  {return obj->toString(arg0); }
QString toString(QLocale* obj,uint arg0)  const  {return obj->toString(arg0); }
QString toString(QLocale* obj,double arg0,char arg1,int arg2)  const  {return obj->toString(arg0,arg1,arg2); }
QString toString(QLocale* obj,double arg0,char arg1)  const  {return obj->toString(arg0,arg1); }
QString toString(QLocale* obj,double arg0)  const  {return obj->toString(arg0); }
QString toString(QLocale* obj,float arg0,char arg1,int arg2)  const  {return obj->toString(arg0,arg1,arg2); }
QString toString(QLocale* obj,float arg0,char arg1)  const  {return obj->toString(arg0,arg1); }
QString toString(QLocale* obj,float arg0)  const  {return obj->toString(arg0); }
QString toString(QLocale* obj,const QDate & arg0,const QString & arg1)  const  {return obj->toString(arg0,arg1); }
QString toString(QLocale* obj,const QDate & arg0,FormatType arg1)  const  {return obj->toString(arg0,(QLocale::FormatType)arg1); }
QString toString(QLocale* obj,const QDate & arg0)  const  {return obj->toString(arg0); }
QString toString(QLocale* obj,const QTime & arg0,const QString & arg1)  const  {return obj->toString(arg0,arg1); }
QString toString(QLocale* obj,const QTime & arg0,FormatType arg1)  const  {return obj->toString(arg0,(QLocale::FormatType)arg1); }
QString toString(QLocale* obj,const QTime & arg0)  const  {return obj->toString(arg0); }
QString dateFormat(QLocale* obj,FormatType arg0)  const  {return obj->dateFormat((QLocale::FormatType)arg0); }
QString dateFormat(QLocale* obj)  const  {return obj->dateFormat(); }
QString timeFormat(QLocale* obj,FormatType arg0)  const  {return obj->timeFormat((QLocale::FormatType)arg0); }
QString timeFormat(QLocale* obj)  const  {return obj->timeFormat(); }
QChar decimalPoint(QLocale* obj)  const  {return obj->decimalPoint(); }
QChar groupSeparator(QLocale* obj)  const  {return obj->groupSeparator(); }
QChar percent(QLocale* obj)  const  {return obj->percent(); }
QChar zeroDigit(QLocale* obj)  const  {return obj->zeroDigit(); }
QChar negativeSign(QLocale* obj)  const  {return obj->negativeSign(); }
QChar exponential(QLocale* obj)  const  {return obj->exponential(); }
QString monthName(QLocale* obj,int arg0,FormatType arg1)  const  {return obj->monthName(arg0,(QLocale::FormatType)arg1); }
QString monthName(QLocale* obj,int arg0)  const  {return obj->monthName(arg0); }
QString dayName(QLocale* obj,int arg0,FormatType arg1)  const  {return obj->dayName(arg0,(QLocale::FormatType)arg1); }
QString dayName(QLocale* obj,int arg0)  const  {return obj->dayName(arg0); }
QString static_QLocale_languageToString(Language arg0)  {return QLocale::languageToString((QLocale::Language)arg0); }
QString static_QLocale_countryToString(Country arg0)  {return QLocale::countryToString((QLocale::Country)arg0); }
void static_QLocale_setDefault(const QLocale & arg0)  {QLocale::setDefault(arg0); }
QLocale static_QLocale_c()  {return QLocale::c(); }
QLocale static_QLocale_system()  {return QLocale::system(); }
void setNumberOptions(QLocale* obj,NumberOptions arg0)  {obj->setNumberOptions((QLocale::NumberOptions)QFlag(arg0)); }
NumberOptions numberOptions(QLocale* obj)  const  {return (PythonQtQLocaleWrapper::NumberOptions)QFlag(obj->numberOptions()); }

};

class PythonQtQSystemLocaleWrapper : public QObject  {
  Q_OBJECT

public:
Q_ENUMS(QueryType )
enum QueryType {LanguageId = QSystemLocale::LanguageId, 
CountryId = QSystemLocale::CountryId, 
DecimalPoint = QSystemLocale::DecimalPoint, 
GroupSeparator = QSystemLocale::GroupSeparator, 
ZeroDigit = QSystemLocale::ZeroDigit, 
NegativeSign = QSystemLocale::NegativeSign, 
DateFormatLong = QSystemLocale::DateFormatLong, 
DateFormatShort = QSystemLocale::DateFormatShort, 
TimeFormatLong = QSystemLocale::TimeFormatLong, 
TimeFormatShort = QSystemLocale::TimeFormatShort, 
DayNameLong = QSystemLocale::DayNameLong, 
DayNameShort = QSystemLocale::DayNameShort, 
MonthNameLong = QSystemLocale::MonthNameLong, 
MonthNameShort = QSystemLocale::MonthNameShort, 
DateToStringLong = QSystemLocale::DateToStringLong, 
DateToStringShort = QSystemLocale::DateToStringShort, 
TimeToStringLong = QSystemLocale::TimeToStringLong, 
TimeToStringShort = QSystemLocale::TimeToStringShort }; 
public slots:
void delete_QSystemLocale(QSystemLocale* obj) { delete obj; }
QSystemLocale* new_QSystemLocale() { return new QSystemLocale(); }
QVariant query(QSystemLocale* obj,QueryType arg0,QVariant arg1)  const  {return obj->query((QSystemLocale::QueryType)arg0,arg1); }
QLocale fallbackLocale(QSystemLocale* obj)  const  {return obj->fallbackLocale(); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qrect.h'
**
** Created: Thu 12. Apr 14:07:28 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qrect.h"
class PythonQtQRectWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
QVariant new_QRect() { return QRect(); }
QVariant new_QRect(const QPoint & arg0,const QPoint & arg1) { return QRect(arg0,arg1); }
QVariant new_QRect(const QPoint & arg0,const QSize & arg1) { return QRect(arg0,arg1); }
QVariant new_QRect(int arg0,int arg1,int arg2,int arg3) { return QRect(arg0,arg1,arg2,arg3); }
bool isNull(QRect* obj)  const  {return obj->isNull(); }
bool isEmpty(QRect* obj)  const  {return obj->isEmpty(); }
bool isValid(QRect* obj)  const  {return obj->isValid(); }
int left(QRect* obj)  const  {return obj->left(); }
int top(QRect* obj)  const  {return obj->top(); }
int right(QRect* obj)  const  {return obj->right(); }
int bottom(QRect* obj)  const  {return obj->bottom(); }
QRect normalized(QRect* obj)  const  {return obj->normalized(); }
int x(QRect* obj)  const  {return obj->x(); }
int y(QRect* obj)  const  {return obj->y(); }
void setLeft(QRect* obj,int arg0)  {obj->setLeft(arg0); }
void setTop(QRect* obj,int arg0)  {obj->setTop(arg0); }
void setRight(QRect* obj,int arg0)  {obj->setRight(arg0); }
void setBottom(QRect* obj,int arg0)  {obj->setBottom(arg0); }
void setX(QRect* obj,int arg0)  {obj->setX(arg0); }
void setY(QRect* obj,int arg0)  {obj->setY(arg0); }
void setTopLeft(QRect* obj,const QPoint & arg0)  {obj->setTopLeft(arg0); }
void setBottomRight(QRect* obj,const QPoint & arg0)  {obj->setBottomRight(arg0); }
void setTopRight(QRect* obj,const QPoint & arg0)  {obj->setTopRight(arg0); }
void setBottomLeft(QRect* obj,const QPoint & arg0)  {obj->setBottomLeft(arg0); }
QPoint topLeft(QRect* obj)  const  {return obj->topLeft(); }
QPoint bottomRight(QRect* obj)  const  {return obj->bottomRight(); }
QPoint topRight(QRect* obj)  const  {return obj->topRight(); }
QPoint bottomLeft(QRect* obj)  const  {return obj->bottomLeft(); }
QPoint center(QRect* obj)  const  {return obj->center(); }
void moveLeft(QRect* obj,int arg0)  {obj->moveLeft(arg0); }
void moveTop(QRect* obj,int arg0)  {obj->moveTop(arg0); }
void moveRight(QRect* obj,int arg0)  {obj->moveRight(arg0); }
void moveBottom(QRect* obj,int arg0)  {obj->moveBottom(arg0); }
void moveTopLeft(QRect* obj,const QPoint & arg0)  {obj->moveTopLeft(arg0); }
void moveBottomRight(QRect* obj,const QPoint & arg0)  {obj->moveBottomRight(arg0); }
void moveTopRight(QRect* obj,const QPoint & arg0)  {obj->moveTopRight(arg0); }
void moveBottomLeft(QRect* obj,const QPoint & arg0)  {obj->moveBottomLeft(arg0); }
void moveCenter(QRect* obj,const QPoint & arg0)  {obj->moveCenter(arg0); }
void translate(QRect* obj,int arg0,int arg1)  {obj->translate(arg0,arg1); }
void translate(QRect* obj,const QPoint & arg0)  {obj->translate(arg0); }
QRect translated(QRect* obj,int arg0,int arg1)  const  {return obj->translated(arg0,arg1); }
QRect translated(QRect* obj,const QPoint & arg0)  const  {return obj->translated(arg0); }
void moveTo(QRect* obj,int arg0,int arg1)  {obj->moveTo(arg0,arg1); }
void moveTo(QRect* obj,const QPoint & arg0)  {obj->moveTo(arg0); }
void setRect(QRect* obj,int arg0,int arg1,int arg2,int arg3)  {obj->setRect(arg0,arg1,arg2,arg3); }
void getRect(QRect* obj,int * arg0,int * arg1,int * arg2,int * arg3)  const  {obj->getRect(arg0,arg1,arg2,arg3); }
void setCoords(QRect* obj,int arg0,int arg1,int arg2,int arg3)  {obj->setCoords(arg0,arg1,arg2,arg3); }
void getCoords(QRect* obj,int * arg0,int * arg1,int * arg2,int * arg3)  const  {obj->getCoords(arg0,arg1,arg2,arg3); }
void adjust(QRect* obj,int arg0,int arg1,int arg2,int arg3)  {obj->adjust(arg0,arg1,arg2,arg3); }
QRect adjusted(QRect* obj,int arg0,int arg1,int arg2,int arg3)  const  {return obj->adjusted(arg0,arg1,arg2,arg3); }
QSize size(QRect* obj)  const  {return obj->size(); }
int width(QRect* obj)  const  {return obj->width(); }
int height(QRect* obj)  const  {return obj->height(); }
void setWidth(QRect* obj,int arg0)  {obj->setWidth(arg0); }
void setHeight(QRect* obj,int arg0)  {obj->setHeight(arg0); }
void setSize(QRect* obj,const QSize & arg0)  {obj->setSize(arg0); }
bool contains(QRect* obj,const QPoint & arg0,bool arg1)  const  {return obj->contains(arg0,arg1); }
bool contains(QRect* obj,const QPoint & arg0)  const  {return obj->contains(arg0); }
bool contains(QRect* obj,int arg0,int arg1)  const  {return obj->contains(arg0,arg1); }
bool contains(QRect* obj,int arg0,int arg1,bool arg2)  const  {return obj->contains(arg0,arg1,arg2); }
bool contains(QRect* obj,const QRect & arg0,bool arg1)  const  {return obj->contains(arg0,arg1); }
bool contains(QRect* obj,const QRect & arg0)  const  {return obj->contains(arg0); }
QRect unite(QRect* obj,const QRect & arg0)  const  {return obj->unite(arg0); }
QRect united(QRect* obj,const QRect & arg0)  const  {return obj->united(arg0); }
QRect intersect(QRect* obj,const QRect & arg0)  const  {return obj->intersect(arg0); }
QRect intersected(QRect* obj,const QRect & arg0)  const  {return obj->intersected(arg0); }
bool intersects(QRect* obj,const QRect & arg0)  const  {return obj->intersects(arg0); }

};

class PythonQtQRectFWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
QVariant new_QRectF() { return QRectF(); }
QVariant new_QRectF(const QPointF & arg0,const QSizeF & arg1) { return QRectF(arg0,arg1); }
QVariant new_QRectF(qreal arg0,qreal arg1,qreal arg2,qreal arg3) { return QRectF(arg0,arg1,arg2,arg3); }
QVariant new_QRectF(const QRect & arg0) { return QRectF(arg0); }
bool isNull(QRectF* obj)  const  {return obj->isNull(); }
bool isEmpty(QRectF* obj)  const  {return obj->isEmpty(); }
bool isValid(QRectF* obj)  const  {return obj->isValid(); }
QRectF normalized(QRectF* obj)  const  {return obj->normalized(); }
qreal left(QRectF* obj)  const  {return obj->left(); }
qreal top(QRectF* obj)  const  {return obj->top(); }
qreal right(QRectF* obj)  const  {return obj->right(); }
qreal bottom(QRectF* obj)  const  {return obj->bottom(); }
qreal x(QRectF* obj)  const  {return obj->x(); }
qreal y(QRectF* obj)  const  {return obj->y(); }
void setLeft(QRectF* obj,qreal arg0)  {obj->setLeft(arg0); }
void setTop(QRectF* obj,qreal arg0)  {obj->setTop(arg0); }
void setRight(QRectF* obj,qreal arg0)  {obj->setRight(arg0); }
void setBottom(QRectF* obj,qreal arg0)  {obj->setBottom(arg0); }
void setX(QRectF* obj,qreal arg0)  {obj->setX(arg0); }
void setY(QRectF* obj,qreal arg0)  {obj->setY(arg0); }
QPointF topLeft(QRectF* obj)  const  {return obj->topLeft(); }
QPointF bottomRight(QRectF* obj)  const  {return obj->bottomRight(); }
QPointF topRight(QRectF* obj)  const  {return obj->topRight(); }
QPointF bottomLeft(QRectF* obj)  const  {return obj->bottomLeft(); }
QPointF center(QRectF* obj)  const  {return obj->center(); }
void setTopLeft(QRectF* obj,const QPointF & arg0)  {obj->setTopLeft(arg0); }
void setBottomRight(QRectF* obj,const QPointF & arg0)  {obj->setBottomRight(arg0); }
void setTopRight(QRectF* obj,const QPointF & arg0)  {obj->setTopRight(arg0); }
void setBottomLeft(QRectF* obj,const QPointF & arg0)  {obj->setBottomLeft(arg0); }
void moveLeft(QRectF* obj,qreal arg0)  {obj->moveLeft(arg0); }
void moveTop(QRectF* obj,qreal arg0)  {obj->moveTop(arg0); }
void moveRight(QRectF* obj,qreal arg0)  {obj->moveRight(arg0); }
void moveBottom(QRectF* obj,qreal arg0)  {obj->moveBottom(arg0); }
void moveTopLeft(QRectF* obj,const QPointF & arg0)  {obj->moveTopLeft(arg0); }
void moveBottomRight(QRectF* obj,const QPointF & arg0)  {obj->moveBottomRight(arg0); }
void moveTopRight(QRectF* obj,const QPointF & arg0)  {obj->moveTopRight(arg0); }
void moveBottomLeft(QRectF* obj,const QPointF & arg0)  {obj->moveBottomLeft(arg0); }
void moveCenter(QRectF* obj,const QPointF & arg0)  {obj->moveCenter(arg0); }
void translate(QRectF* obj,qreal arg0,qreal arg1)  {obj->translate(arg0,arg1); }
void translate(QRectF* obj,const QPointF & arg0)  {obj->translate(arg0); }
QRectF translated(QRectF* obj,qreal arg0,qreal arg1)  const  {return obj->translated(arg0,arg1); }
QRectF translated(QRectF* obj,const QPointF & arg0)  const  {return obj->translated(arg0); }
void moveTo(QRectF* obj,qreal arg0,qreal arg1)  {obj->moveTo(arg0,arg1); }
void moveTo(QRectF* obj,const QPointF & arg0)  {obj->moveTo(arg0); }
void setRect(QRectF* obj,qreal arg0,qreal arg1,qreal arg2,qreal arg3)  {obj->setRect(arg0,arg1,arg2,arg3); }
void getRect(QRectF* obj,qreal * arg0,qreal * arg1,qreal * arg2,qreal * arg3)  const  {obj->getRect(arg0,arg1,arg2,arg3); }
void setCoords(QRectF* obj,qreal arg0,qreal arg1,qreal arg2,qreal arg3)  {obj->setCoords(arg0,arg1,arg2,arg3); }
void getCoords(QRectF* obj,qreal * arg0,qreal * arg1,qreal * arg2,qreal * arg3)  const  {obj->getCoords(arg0,arg1,arg2,arg3); }
void adjust(QRectF* obj,qreal arg0,qreal arg1,qreal arg2,qreal arg3)  {obj->adjust(arg0,arg1,arg2,arg3); }
QRectF adjusted(QRectF* obj,qreal arg0,qreal arg1,qreal arg2,qreal arg3)  const  {return obj->adjusted(arg0,arg1,arg2,arg3); }
QSizeF size(QRectF* obj)  const  {return obj->size(); }
qreal width(QRectF* obj)  const  {return obj->width(); }
qreal height(QRectF* obj)  const  {return obj->height(); }
void setWidth(QRectF* obj,qreal arg0)  {obj->setWidth(arg0); }
void setHeight(QRectF* obj,qreal arg0)  {obj->setHeight(arg0); }
void setSize(QRectF* obj,const QSizeF & arg0)  {obj->setSize(arg0); }
bool contains(QRectF* obj,const QPointF & arg0)  const  {return obj->contains(arg0); }
bool contains(QRectF* obj,qreal arg0,qreal arg1)  const  {return obj->contains(arg0,arg1); }
bool contains(QRectF* obj,const QRectF & arg0)  const  {return obj->contains(arg0); }
QRectF unite(QRectF* obj,const QRectF & arg0)  const  {return obj->unite(arg0); }
QRectF united(QRectF* obj,const QRectF & arg0)  const  {return obj->united(arg0); }
QRectF intersect(QRectF* obj,const QRectF & arg0)  const  {return obj->intersect(arg0); }
QRectF intersected(QRectF* obj,const QRectF & arg0)  const  {return obj->intersected(arg0); }
bool intersects(QRectF* obj,const QRectF & arg0)  const  {return obj->intersects(arg0); }
QRect toRect(QRectF* obj)  const  {return obj->toRect(); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qsize.h'
**
** Created: Thu 12. Apr 14:07:28 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qsize.h"
class PythonQtQSizeWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
QVariant new_QSize() { return QSize(); }
QVariant new_QSize(int arg0,int arg1) { return QSize(arg0,arg1); }
bool isNull(QSize* obj)  const  {return obj->isNull(); }
bool isEmpty(QSize* obj)  const  {return obj->isEmpty(); }
bool isValid(QSize* obj)  const  {return obj->isValid(); }
int width(QSize* obj)  const  {return obj->width(); }
int height(QSize* obj)  const  {return obj->height(); }
void setWidth(QSize* obj,int arg0)  {obj->setWidth(arg0); }
void setHeight(QSize* obj,int arg0)  {obj->setHeight(arg0); }
void transpose(QSize* obj)  {obj->transpose(); }
void scale(QSize* obj,int arg0,int arg1,Qt::AspectRatioMode arg2)  {obj->scale(arg0,arg1,arg2); }
void scale(QSize* obj,const QSize & arg0,Qt::AspectRatioMode arg1)  {obj->scale(arg0,arg1); }
QSize expandedTo(QSize* obj,const QSize & arg0)  const  {return obj->expandedTo(arg0); }
QSize boundedTo(QSize* obj,const QSize & arg0)  const  {return obj->boundedTo(arg0); }
void rwidth(QSize* obj)  {obj->rwidth(); }
void rheight(QSize* obj)  {obj->rheight(); }

};

class PythonQtQSizeFWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
QVariant new_QSizeF() { return QSizeF(); }
QVariant new_QSizeF(const QSize & arg0) { return QSizeF(arg0); }
QVariant new_QSizeF(qreal arg0,qreal arg1) { return QSizeF(arg0,arg1); }
bool isNull(QSizeF* obj)  const  {return obj->isNull(); }
bool isEmpty(QSizeF* obj)  const  {return obj->isEmpty(); }
bool isValid(QSizeF* obj)  const  {return obj->isValid(); }
qreal width(QSizeF* obj)  const  {return obj->width(); }
qreal height(QSizeF* obj)  const  {return obj->height(); }
void setWidth(QSizeF* obj,qreal arg0)  {obj->setWidth(arg0); }
void setHeight(QSizeF* obj,qreal arg0)  {obj->setHeight(arg0); }
void transpose(QSizeF* obj)  {obj->transpose(); }
void scale(QSizeF* obj,qreal arg0,qreal arg1,Qt::AspectRatioMode arg2)  {obj->scale(arg0,arg1,arg2); }
void scale(QSizeF* obj,const QSizeF & arg0,Qt::AspectRatioMode arg1)  {obj->scale(arg0,arg1); }
QSizeF expandedTo(QSizeF* obj,const QSizeF & arg0)  const  {return obj->expandedTo(arg0); }
QSizeF boundedTo(QSizeF* obj,const QSizeF & arg0)  const  {return obj->boundedTo(arg0); }
void rwidth(QSizeF* obj)  {obj->rwidth(); }
void rheight(QSizeF* obj)  {obj->rheight(); }
QSize toSize(QSizeF* obj)  const  {return obj->toSize(); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qline.h'
**
** Created: Thu 12. Apr 14:07:28 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qline.h"
class PythonQtQLineWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
QVariant new_QLine() { return QLine(); }
QVariant new_QLine(const QPoint & arg0,const QPoint & arg1) { return QLine(arg0,arg1); }
QVariant new_QLine(int arg0,int arg1,int arg2,int arg3) { return QLine(arg0,arg1,arg2,arg3); }
bool isNull(QLine* obj)  const  {return obj->isNull(); }
QPoint p1(QLine* obj)  const  {return obj->p1(); }
QPoint p2(QLine* obj)  const  {return obj->p2(); }
int x1(QLine* obj)  const  {return obj->x1(); }
int y1(QLine* obj)  const  {return obj->y1(); }
int x2(QLine* obj)  const  {return obj->x2(); }
int y2(QLine* obj)  const  {return obj->y2(); }
int dx(QLine* obj)  const  {return obj->dx(); }
int dy(QLine* obj)  const  {return obj->dy(); }
void translate(QLine* obj,const QPoint & arg0)  {obj->translate(arg0); }
void translate(QLine* obj,int arg0,int arg1)  {obj->translate(arg0,arg1); }

};

class PythonQtQLineFWrapper : public QObject  {
  Q_OBJECT

public:
Q_ENUMS(IntersectType )
enum IntersectType {NoIntersection = QLineF::NoIntersection, 
BoundedIntersection = QLineF::BoundedIntersection, 
UnboundedIntersection = QLineF::UnboundedIntersection }; 
public slots:
QVariant new_QLineF() { return QLineF(); }
QVariant new_QLineF(const QPointF & arg0,const QPointF & arg1) { return QLineF(arg0,arg1); }
QVariant new_QLineF(qreal arg0,qreal arg1,qreal arg2,qreal arg3) { return QLineF(arg0,arg1,arg2,arg3); }
QVariant new_QLineF(const QLine & arg0) { return QLineF(arg0); }
int isNull(QLineF* obj)  const  {return obj->isNull(); }
QPointF p1(QLineF* obj)  const  {return obj->p1(); }
QPointF p2(QLineF* obj)  const  {return obj->p2(); }
qreal x1(QLineF* obj)  const  {return obj->x1(); }
qreal y1(QLineF* obj)  const  {return obj->y1(); }
qreal x2(QLineF* obj)  const  {return obj->x2(); }
qreal y2(QLineF* obj)  const  {return obj->y2(); }
qreal dx(QLineF* obj)  const  {return obj->dx(); }
qreal dy(QLineF* obj)  const  {return obj->dy(); }
qreal length(QLineF* obj)  const  {return obj->length(); }
void setLength(QLineF* obj,qreal arg0)  {obj->setLength(arg0); }
QLineF unitVector(QLineF* obj)  const  {return obj->unitVector(); }
QLineF normalVector(QLineF* obj)  const  {return obj->normalVector(); }
IntersectType intersect(QLineF* obj,const QLineF & arg0,QPointF * arg1)  const  {return (PythonQtQLineFWrapper::IntersectType)obj->intersect(arg0,arg1); }
qreal angle(QLineF* obj,const QLineF & arg0)  const  {return obj->angle(arg0); }
QPointF pointAt(QLineF* obj,qreal arg0)  const  {return obj->pointAt(arg0); }
void translate(QLineF* obj,const QPointF & arg0)  {obj->translate(arg0); }
void translate(QLineF* obj,qreal arg0,qreal arg1)  {obj->translate(arg0,arg1); }
QLine toLine(QLineF* obj)  const  {return obj->toLine(); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qpoint.h'
**
** Created: Thu 12. Apr 14:07:28 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qpoint.h"
class PythonQtQPointWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
QVariant new_QPoint() { return QPoint(); }
QVariant new_QPoint(int arg0,int arg1) { return QPoint(arg0,arg1); }
bool isNull(QPoint* obj)  const  {return obj->isNull(); }
int x(QPoint* obj)  const  {return obj->x(); }
int y(QPoint* obj)  const  {return obj->y(); }
void setX(QPoint* obj,int arg0)  {obj->setX(arg0); }
void setY(QPoint* obj,int arg0)  {obj->setY(arg0); }
int manhattanLength(QPoint* obj)  const  {return obj->manhattanLength(); }
void rx(QPoint* obj)  {obj->rx(); }
void ry(QPoint* obj)  {obj->ry(); }

};

class PythonQtQPointFWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
QVariant new_QPointF() { return QPointF(); }
QVariant new_QPointF(const QPoint & arg0) { return QPointF(arg0); }
QVariant new_QPointF(qreal arg0,qreal arg1) { return QPointF(arg0,arg1); }
bool isNull(QPointF* obj)  const  {return obj->isNull(); }
qreal x(QPointF* obj)  const  {return obj->x(); }
qreal y(QPointF* obj)  const  {return obj->y(); }
void setX(QPointF* obj,qreal arg0)  {obj->setX(arg0); }
void setY(QPointF* obj,qreal arg0)  {obj->setY(arg0); }
void rx(QPointF* obj)  {obj->rx(); }
void ry(QPointF* obj)  {obj->ry(); }
QPoint toPoint(QPointF* obj)  const  {return obj->toPoint(); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qregexp.h'
**
** Created: Thu 12. Apr 14:07:29 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qregexp.h"
class PythonQtQRegExpWrapper : public QObject  {
  Q_OBJECT

public:
Q_ENUMS(PatternSyntax CaretMode )
enum PatternSyntax {RegExp = QRegExp::RegExp, 
Wildcard = QRegExp::Wildcard, 
FixedString = QRegExp::FixedString, 
RegExp2 = QRegExp::RegExp2 }; 
enum CaretMode {CaretAtZero = QRegExp::CaretAtZero, 
CaretAtOffset = QRegExp::CaretAtOffset, 
CaretWontMatch = QRegExp::CaretWontMatch }; 
public slots:
QVariant new_QRegExp() { return QRegExp(); }
QVariant new_QRegExp(const QString & arg0,Qt::CaseSensitivity arg1,PatternSyntax arg2) { return QRegExp(arg0,arg1,(QRegExp::PatternSyntax)arg2); }
QVariant new_QRegExp(const QString & arg0,Qt::CaseSensitivity arg1) { return QRegExp(arg0,arg1); }
QVariant new_QRegExp(const QString & arg0) { return QRegExp(arg0); }
QVariant new_QRegExp(const QRegExp & arg0) { return QRegExp(arg0); }
bool isEmpty(QRegExp* obj)  const  {return obj->isEmpty(); }
bool isValid(QRegExp* obj)  const  {return obj->isValid(); }
QString pattern(QRegExp* obj)  const  {return obj->pattern(); }
void setPattern(QRegExp* obj,const QString & arg0)  {obj->setPattern(arg0); }
Qt::CaseSensitivity caseSensitivity(QRegExp* obj)  const  {return obj->caseSensitivity(); }
void setCaseSensitivity(QRegExp* obj,Qt::CaseSensitivity arg0)  {obj->setCaseSensitivity(arg0); }
PatternSyntax patternSyntax(QRegExp* obj)  const  {return (PythonQtQRegExpWrapper::PatternSyntax)obj->patternSyntax(); }
void setPatternSyntax(QRegExp* obj,PatternSyntax arg0)  {obj->setPatternSyntax((QRegExp::PatternSyntax)arg0); }
bool isMinimal(QRegExp* obj)  const  {return obj->isMinimal(); }
void setMinimal(QRegExp* obj,bool arg0)  {obj->setMinimal(arg0); }
bool exactMatch(QRegExp* obj,const QString & arg0)  const  {return obj->exactMatch(arg0); }
int indexIn(QRegExp* obj,const QString & arg0,int arg1,CaretMode arg2)  const  {return obj->indexIn(arg0,arg1,(QRegExp::CaretMode)arg2); }
int indexIn(QRegExp* obj,const QString & arg0,int arg1)  const  {return obj->indexIn(arg0,arg1); }
int indexIn(QRegExp* obj,const QString & arg0)  const  {return obj->indexIn(arg0); }
int lastIndexIn(QRegExp* obj,const QString & arg0,int arg1,CaretMode arg2)  const  {return obj->lastIndexIn(arg0,arg1,(QRegExp::CaretMode)arg2); }
int lastIndexIn(QRegExp* obj,const QString & arg0,int arg1)  const  {return obj->lastIndexIn(arg0,arg1); }
int lastIndexIn(QRegExp* obj,const QString & arg0)  const  {return obj->lastIndexIn(arg0); }
int matchedLength(QRegExp* obj)  const  {return obj->matchedLength(); }
int numCaptures(QRegExp* obj)  const  {return obj->numCaptures(); }
QStringList capturedTexts(QRegExp* obj)  {return obj->capturedTexts(); }
QString cap(QRegExp* obj,int arg0)  {return obj->cap(arg0); }
QString cap(QRegExp* obj)  {return obj->cap(); }
int pos(QRegExp* obj,int arg0)  {return obj->pos(arg0); }
int pos(QRegExp* obj)  {return obj->pos(); }
QString errorString(QRegExp* obj)  {return obj->errorString(); }
QString static_QRegExp_escape(const QString & arg0)  {return QRegExp::escape(arg0); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qfont.h'
**
** Created: Thu 12. Apr 14:07:29 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qfont.h"
class PythonQtQFontWrapper : public QObject  {
  Q_OBJECT

public:
Q_ENUMS(StyleHint StyleStrategy Weight Style Stretch )
enum StyleHint {Helvetica = QFont::Helvetica, 
SansSerif = QFont::SansSerif, 
Times = QFont::Times, 
Serif = QFont::Serif, 
Courier = QFont::Courier, 
TypeWriter = QFont::TypeWriter, 
OldEnglish = QFont::OldEnglish, 
Decorative = QFont::Decorative, 
System = QFont::System, 
AnyStyle = QFont::AnyStyle }; 
enum StyleStrategy {PreferDefault = QFont::PreferDefault, 
PreferBitmap = QFont::PreferBitmap, 
PreferDevice = QFont::PreferDevice, 
PreferOutline = QFont::PreferOutline, 
ForceOutline = QFont::ForceOutline, 
PreferMatch = QFont::PreferMatch, 
PreferQuality = QFont::PreferQuality, 
PreferAntialias = QFont::PreferAntialias, 
NoAntialias = QFont::NoAntialias, 
OpenGLCompatible = QFont::OpenGLCompatible, 
NoFontMerging = QFont::NoFontMerging }; 
enum Weight {Light = QFont::Light, 
Normal = QFont::Normal, 
DemiBold = QFont::DemiBold, 
Bold = QFont::Bold, 
Black = QFont::Black }; 
enum Style {StyleNormal = QFont::StyleNormal, 
StyleItalic = QFont::StyleItalic, 
StyleOblique = QFont::StyleOblique }; 
enum Stretch {UltraCondensed = QFont::UltraCondensed, 
ExtraCondensed = QFont::ExtraCondensed, 
Condensed = QFont::Condensed, 
SemiCondensed = QFont::SemiCondensed, 
Unstretched = QFont::Unstretched, 
SemiExpanded = QFont::SemiExpanded, 
Expanded = QFont::Expanded, 
ExtraExpanded = QFont::ExtraExpanded, 
UltraExpanded = QFont::UltraExpanded }; 
public slots:
QVariant new_QFont() { return QFont(); }
QVariant new_QFont(const QString & arg0,int arg1,int arg2,bool arg3) { return QFont(arg0,arg1,arg2,arg3); }
QVariant new_QFont(const QString & arg0,int arg1,int arg2) { return QFont(arg0,arg1,arg2); }
QVariant new_QFont(const QString & arg0,int arg1) { return QFont(arg0,arg1); }
QVariant new_QFont(const QString & arg0) { return QFont(arg0); }
QVariant new_QFont(const QFont & arg0,QPaintDevice * arg1) { return QFont(arg0,arg1); }
QVariant new_QFont(const QFont & arg0) { return QFont(arg0); }
QString family(QFont* obj)  const  {return obj->family(); }
void setFamily(QFont* obj,const QString & arg0)  {obj->setFamily(arg0); }
int pointSize(QFont* obj)  const  {return obj->pointSize(); }
void setPointSize(QFont* obj,int arg0)  {obj->setPointSize(arg0); }
qreal pointSizeF(QFont* obj)  const  {return obj->pointSizeF(); }
void setPointSizeF(QFont* obj,qreal arg0)  {obj->setPointSizeF(arg0); }
int pixelSize(QFont* obj)  const  {return obj->pixelSize(); }
void setPixelSize(QFont* obj,int arg0)  {obj->setPixelSize(arg0); }
int weight(QFont* obj)  const  {return obj->weight(); }
void setWeight(QFont* obj,int arg0)  {obj->setWeight(arg0); }
bool bold(QFont* obj)  const  {return obj->bold(); }
void setBold(QFont* obj,bool arg0)  {obj->setBold(arg0); }
void setStyle(QFont* obj,Style arg0)  {obj->setStyle((QFont::Style)arg0); }
Style style(QFont* obj)  const  {return (PythonQtQFontWrapper::Style)obj->style(); }
bool italic(QFont* obj)  const  {return obj->italic(); }
void setItalic(QFont* obj,bool arg0)  {obj->setItalic(arg0); }
bool underline(QFont* obj)  const  {return obj->underline(); }
void setUnderline(QFont* obj,bool arg0)  {obj->setUnderline(arg0); }
bool overline(QFont* obj)  const  {return obj->overline(); }
void setOverline(QFont* obj,bool arg0)  {obj->setOverline(arg0); }
bool strikeOut(QFont* obj)  const  {return obj->strikeOut(); }
void setStrikeOut(QFont* obj,bool arg0)  {obj->setStrikeOut(arg0); }
bool fixedPitch(QFont* obj)  const  {return obj->fixedPitch(); }
void setFixedPitch(QFont* obj,bool arg0)  {obj->setFixedPitch(arg0); }
bool kerning(QFont* obj)  const  {return obj->kerning(); }
void setKerning(QFont* obj,bool arg0)  {obj->setKerning(arg0); }
StyleHint styleHint(QFont* obj)  const  {return (PythonQtQFontWrapper::StyleHint)obj->styleHint(); }
StyleStrategy styleStrategy(QFont* obj)  const  {return (PythonQtQFontWrapper::StyleStrategy)obj->styleStrategy(); }
void setStyleHint(QFont* obj,StyleHint arg0,StyleStrategy arg1)  {obj->setStyleHint((QFont::StyleHint)arg0,(QFont::StyleStrategy)arg1); }
void setStyleHint(QFont* obj,StyleHint arg0)  {obj->setStyleHint((QFont::StyleHint)arg0); }
void setStyleStrategy(QFont* obj,StyleStrategy arg0)  {obj->setStyleStrategy((QFont::StyleStrategy)arg0); }
int stretch(QFont* obj)  const  {return obj->stretch(); }
void setStretch(QFont* obj,int arg0)  {obj->setStretch(arg0); }
bool rawMode(QFont* obj)  const  {return obj->rawMode(); }
void setRawMode(QFont* obj,bool arg0)  {obj->setRawMode(arg0); }
bool exactMatch(QFont* obj)  const  {return obj->exactMatch(); }
bool isCopyOf(QFont* obj,const QFont & arg0)  const  {return obj->isCopyOf(arg0); }
Qt::HANDLE handle(QFont* obj)  const  {return obj->handle(); }
void setRawName(QFont* obj,const QString & arg0)  {obj->setRawName(arg0); }
QString rawName(QFont* obj)  const  {return obj->rawName(); }
QString key(QFont* obj)  const  {return obj->key(); }
QString toString(QFont* obj)  const  {return obj->toString(); }
bool fromString(QFont* obj,const QString & arg0)  {return obj->fromString(arg0); }
QString static_QFont_substitute(const QString & arg0)  {return QFont::substitute(arg0); }
QStringList static_QFont_substitutes(const QString & arg0)  {return QFont::substitutes(arg0); }
QStringList static_QFont_substitutions()  {return QFont::substitutions(); }
void static_QFont_insertSubstitution(const QString & arg0,const QString & arg1)  {QFont::insertSubstitution(arg0,arg1); }
void static_QFont_insertSubstitutions(const QString & arg0,const QStringList & arg1)  {QFont::insertSubstitutions(arg0,arg1); }
void static_QFont_removeSubstitution(const QString & arg0)  {QFont::removeSubstitution(arg0); }
void static_QFont_initialize()  {QFont::initialize(); }
void static_QFont_cleanup()  {QFont::cleanup(); }
void static_QFont_cacheStatistics()  {QFont::cacheStatistics(); }
QString defaultFamily(QFont* obj)  const  {return obj->defaultFamily(); }
QString lastResortFamily(QFont* obj)  const  {return obj->lastResortFamily(); }
QString lastResortFont(QFont* obj)  const  {return obj->lastResortFont(); }
QFont resolve(QFont* obj,const QFont & arg0)  const  {return obj->resolve(arg0); }
uint resolve(QFont* obj)  const  {return obj->resolve(); }
void resolve(QFont* obj,uint arg0)  {obj->resolve(arg0); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qpixmap.h'
**
** Created: Thu 12. Apr 14:07:29 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qpixmap.h"
class PythonQtQPixmapWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
QVariant new_QPixmap() { return QPixmap(); }
QVariant new_QPixmap(int arg0,int arg1) { return QPixmap(arg0,arg1); }
QVariant new_QPixmap(const QSize & arg0) { return QPixmap(arg0); }
QVariant new_QPixmap(const QString & arg0,const char * arg1,Qt::ImageConversionFlags arg2) { return QPixmap(arg0,arg1,arg2); }
QVariant new_QPixmap(const QString & arg0,const char * arg1) { return QPixmap(arg0,arg1); }
QVariant new_QPixmap(const QString & arg0) { return QPixmap(arg0); }
QVariant new_QPixmap(const QPixmap & arg0) { return QPixmap(arg0); }
bool isNull(QPixmap* obj)  const  {return obj->isNull(); }
int devType(QPixmap* obj)  const  {return obj->devType(); }
int width(QPixmap* obj)  const  {return obj->width(); }
int height(QPixmap* obj)  const  {return obj->height(); }
QSize size(QPixmap* obj)  const  {return obj->size(); }
QRect rect(QPixmap* obj)  const  {return obj->rect(); }
int depth(QPixmap* obj)  const  {return obj->depth(); }
int static_QPixmap_defaultDepth()  {return QPixmap::defaultDepth(); }
void fill(QPixmap* obj,const QColor & arg0)  {obj->fill(arg0); }
void fill(QPixmap* obj)  {obj->fill(); }
void fill(QPixmap* obj,const QWidget * arg0,const QPoint & arg1)  {obj->fill(arg0,arg1); }
void fill(QPixmap* obj,const QWidget * arg0,int arg1,int arg2)  {obj->fill(arg0,arg1,arg2); }
QBitmap mask(QPixmap* obj)  const  {return obj->mask(); }
void setMask(QPixmap* obj,const QBitmap & arg0)  {obj->setMask(arg0); }
QPixmap alphaChannel(QPixmap* obj)  const  {return obj->alphaChannel(); }
void setAlphaChannel(QPixmap* obj,const QPixmap & arg0)  {obj->setAlphaChannel(arg0); }
bool hasAlpha(QPixmap* obj)  const  {return obj->hasAlpha(); }
bool hasAlphaChannel(QPixmap* obj)  const  {return obj->hasAlphaChannel(); }
QBitmap createHeuristicMask(QPixmap* obj,bool arg0)  const  {return obj->createHeuristicMask(arg0); }
QBitmap createHeuristicMask(QPixmap* obj)  const  {return obj->createHeuristicMask(); }
QBitmap createMaskFromColor(QPixmap* obj,const QColor & arg0)  const  {return obj->createMaskFromColor(arg0); }
QPixmap static_QPixmap_grabWindow(WId arg0,int arg1,int arg2,int arg3,int arg4)  {return QPixmap::grabWindow(arg0,arg1,arg2,arg3,arg4); }
QPixmap static_QPixmap_grabWindow(WId arg0,int arg1,int arg2,int arg3)  {return QPixmap::grabWindow(arg0,arg1,arg2,arg3); }
QPixmap static_QPixmap_grabWindow(WId arg0,int arg1,int arg2)  {return QPixmap::grabWindow(arg0,arg1,arg2); }
QPixmap static_QPixmap_grabWindow(WId arg0,int arg1)  {return QPixmap::grabWindow(arg0,arg1); }
QPixmap static_QPixmap_grabWindow(WId arg0)  {return QPixmap::grabWindow(arg0); }
QPixmap static_QPixmap_grabWidget(QWidget * arg0,const QRect & arg1)  {return QPixmap::grabWidget(arg0,arg1); }
QPixmap grabWidget(QPixmap* obj,QWidget * arg0,int arg1,int arg2,int arg3,int arg4)  {return obj->grabWidget(arg0,arg1,arg2,arg3,arg4); }
QPixmap grabWidget(QPixmap* obj,QWidget * arg0,int arg1,int arg2,int arg3)  {return obj->grabWidget(arg0,arg1,arg2,arg3); }
QPixmap grabWidget(QPixmap* obj,QWidget * arg0,int arg1,int arg2)  {return obj->grabWidget(arg0,arg1,arg2); }
QPixmap grabWidget(QPixmap* obj,QWidget * arg0,int arg1)  {return obj->grabWidget(arg0,arg1); }
QPixmap grabWidget(QPixmap* obj,QWidget * arg0)  {return obj->grabWidget(arg0); }
QPixmap scaled(QPixmap* obj,int arg0,int arg1,Qt::AspectRatioMode arg2,Qt::TransformationMode arg3)  const  {return obj->scaled(arg0,arg1,arg2,arg3); }
QPixmap scaled(QPixmap* obj,int arg0,int arg1,Qt::AspectRatioMode arg2)  const  {return obj->scaled(arg0,arg1,arg2); }
QPixmap scaled(QPixmap* obj,int arg0,int arg1)  const  {return obj->scaled(arg0,arg1); }
QPixmap scaled(QPixmap* obj,const QSize & arg0,Qt::AspectRatioMode arg1,Qt::TransformationMode arg2)  const  {return obj->scaled(arg0,arg1,arg2); }
QPixmap scaled(QPixmap* obj,const QSize & arg0,Qt::AspectRatioMode arg1)  const  {return obj->scaled(arg0,arg1); }
QPixmap scaled(QPixmap* obj,const QSize & arg0)  const  {return obj->scaled(arg0); }
QPixmap scaledToWidth(QPixmap* obj,int arg0,Qt::TransformationMode arg1)  const  {return obj->scaledToWidth(arg0,arg1); }
QPixmap scaledToWidth(QPixmap* obj,int arg0)  const  {return obj->scaledToWidth(arg0); }
QPixmap scaledToHeight(QPixmap* obj,int arg0,Qt::TransformationMode arg1)  const  {return obj->scaledToHeight(arg0,arg1); }
QPixmap scaledToHeight(QPixmap* obj,int arg0)  const  {return obj->scaledToHeight(arg0); }
QPixmap transformed(QPixmap* obj,const QMatrix & arg0,Qt::TransformationMode arg1)  const  {return obj->transformed(arg0,arg1); }
QPixmap transformed(QPixmap* obj,const QMatrix & arg0)  const  {return obj->transformed(arg0); }
QMatrix static_QPixmap_trueMatrix(const QMatrix & arg0,int arg1,int arg2)  {return QPixmap::trueMatrix(arg0,arg1,arg2); }
QImage toImage(QPixmap* obj)  const  {return obj->toImage(); }
QPixmap static_QPixmap_fromImage(const QImage & arg0,Qt::ImageConversionFlags arg1)  {return QPixmap::fromImage(arg0,arg1); }
QPixmap static_QPixmap_fromImage(const QImage & arg0)  {return QPixmap::fromImage(arg0); }
bool load(QPixmap* obj,const QString & arg0,const char * arg1,Qt::ImageConversionFlags arg2)  {return obj->load(arg0,arg1,arg2); }
bool load(QPixmap* obj,const QString & arg0,const char * arg1)  {return obj->load(arg0,arg1); }
bool load(QPixmap* obj,const QString & arg0)  {return obj->load(arg0); }
bool loadFromData(QPixmap* obj,const uchar * arg0,uint arg1,const char * arg2,Qt::ImageConversionFlags arg3)  {return obj->loadFromData(arg0,arg1,arg2,arg3); }
bool loadFromData(QPixmap* obj,const uchar * arg0,uint arg1,const char * arg2)  {return obj->loadFromData(arg0,arg1,arg2); }
bool loadFromData(QPixmap* obj,const uchar * arg0,uint arg1)  {return obj->loadFromData(arg0,arg1); }
bool loadFromData(QPixmap* obj,const QByteArray & arg0,const char * arg1,Qt::ImageConversionFlags arg2)  {return obj->loadFromData(arg0,arg1,arg2); }
bool loadFromData(QPixmap* obj,const QByteArray & arg0,const char * arg1)  {return obj->loadFromData(arg0,arg1); }
bool loadFromData(QPixmap* obj,const QByteArray & arg0)  {return obj->loadFromData(arg0); }
bool save(QPixmap* obj,const QString & arg0,const char * arg1,int arg2)  const  {return obj->save(arg0,arg1,arg2); }
bool save(QPixmap* obj,const QString & arg0,const char * arg1)  const  {return obj->save(arg0,arg1); }
bool save(QPixmap* obj,const QString & arg0)  const  {return obj->save(arg0); }
bool save(QPixmap* obj,QIODevice * arg0,const char * arg1,int arg2)  const  {return obj->save(arg0,arg1,arg2); }
bool save(QPixmap* obj,QIODevice * arg0,const char * arg1)  const  {return obj->save(arg0,arg1); }
bool save(QPixmap* obj,QIODevice * arg0)  const  {return obj->save(arg0); }
QPixmap copy(QPixmap* obj,int arg0,int arg1,int arg2,int arg3)  const  {return obj->copy(arg0,arg1,arg2,arg3); }
QPixmap copy(QPixmap* obj,const QRect & arg0)  const  {return obj->copy(arg0); }
QPixmap copy(QPixmap* obj)  const  {return obj->copy(); }
int serialNumber(QPixmap* obj)  const  {return obj->serialNumber(); }
bool isDetached(QPixmap* obj)  const  {return obj->isDetached(); }
void detach(QPixmap* obj)  {obj->detach(); }
bool isQBitmap(QPixmap* obj)  const  {return obj->isQBitmap(); }
QPaintEngine* paintEngine(QPixmap* obj)  const  {return obj->paintEngine(); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qbrush.h'
**
** Created: Thu 12. Apr 14:07:29 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qbrush.h"
class PythonQtQBrushWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
QVariant new_QBrush() { return QBrush(); }
QVariant new_QBrush(Qt::BrushStyle arg0) { return QBrush(arg0); }
QVariant new_QBrush(const QColor & arg0,Qt::BrushStyle arg1) { return QBrush(arg0,arg1); }
QVariant new_QBrush(const QColor & arg0) { return QBrush(arg0); }
QVariant new_QBrush(Qt::GlobalColor arg0,Qt::BrushStyle arg1) { return QBrush(arg0,arg1); }
QVariant new_QBrush(Qt::GlobalColor arg0) { return QBrush(arg0); }
QVariant new_QBrush(const QColor & arg0,const QPixmap & arg1) { return QBrush(arg0,arg1); }
QVariant new_QBrush(Qt::GlobalColor arg0,const QPixmap & arg1) { return QBrush(arg0,arg1); }
QVariant new_QBrush(const QPixmap & arg0) { return QBrush(arg0); }
QVariant new_QBrush(const QImage & arg0) { return QBrush(arg0); }
QVariant new_QBrush(const QBrush & arg0) { return QBrush(arg0); }
QVariant new_QBrush(const QGradient & arg0) { return QBrush(arg0); }
Qt::BrushStyle style(QBrush* obj)  const  {return obj->style(); }
void setStyle(QBrush* obj,Qt::BrushStyle arg0)  {obj->setStyle(arg0); }
void matrix(QBrush* obj)  const  {obj->matrix(); }
void setMatrix(QBrush* obj,const QMatrix & arg0)  {obj->setMatrix(arg0); }
QPixmap texture(QBrush* obj)  const  {return obj->texture(); }
void setTexture(QBrush* obj,const QPixmap & arg0)  {obj->setTexture(arg0); }
QImage textureImage(QBrush* obj)  const  {return obj->textureImage(); }
void setTextureImage(QBrush* obj,const QImage & arg0)  {obj->setTextureImage(arg0); }
void color(QBrush* obj)  const  {obj->color(); }
void setColor(QBrush* obj,const QColor & arg0)  {obj->setColor(arg0); }
void setColor(QBrush* obj,Qt::GlobalColor arg0)  {obj->setColor(arg0); }
const QGradient* gradient(QBrush* obj)  const  {return obj->gradient(); }
bool isOpaque(QBrush* obj)  const  {return obj->isOpaque(); }

};

class PythonQtQBrushDataWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
void delete_QBrushData(QBrushData* obj) { delete obj; }

};

class PythonQtQGradientWrapper : public QObject  {
  Q_OBJECT

public:
Q_ENUMS(Type Spread CoordinateMode )
enum Type {LinearGradient = QGradient::LinearGradient, 
RadialGradient = QGradient::RadialGradient, 
ConicalGradient = QGradient::ConicalGradient, 
NoGradient = QGradient::NoGradient }; 
enum Spread {PadSpread = QGradient::PadSpread, 
ReflectSpread = QGradient::ReflectSpread, 
RepeatSpread = QGradient::RepeatSpread }; 
enum CoordinateMode {LogicalMode = QGradient::LogicalMode, 
StretchToDeviceMode = QGradient::StretchToDeviceMode }; 
public slots:
void delete_QGradient(QGradient* obj) { delete obj; }
QGradient* new_QGradient() { return new QGradient(); }
Type type(QGradient* obj)  const  {return (PythonQtQGradientWrapper::Type)obj->type(); }
void setSpread(QGradient* obj,Spread arg0)  {obj->setSpread((QGradient::Spread)arg0); }
Spread spread(QGradient* obj)  const  {return (PythonQtQGradientWrapper::Spread)obj->spread(); }
void setColorAt(QGradient* obj,qreal arg0,const QColor & arg1)  {obj->setColorAt(arg0,arg1); }
void setStops(QGradient* obj,const QGradientStops & arg0)  {obj->setStops(arg0); }
QGradientStops stops(QGradient* obj)  const  {return obj->stops(); }
CoordinateMode coordinateMode(QGradient* obj)  const  {return (PythonQtQGradientWrapper::CoordinateMode)obj->coordinateMode(); }
void setCoordinateMode(QGradient* obj,CoordinateMode arg0)  {obj->setCoordinateMode((QGradient::CoordinateMode)arg0); }

};

class PythonQtQLinearGradientWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
void delete_QLinearGradient(QLinearGradient* obj) { delete obj; }
QLinearGradient* new_QLinearGradient() { return new QLinearGradient(); }
QLinearGradient* new_QLinearGradient(const QPointF & arg0,const QPointF & arg1) { return new QLinearGradient(arg0,arg1); }
QLinearGradient* new_QLinearGradient(qreal arg0,qreal arg1,qreal arg2,qreal arg3) { return new QLinearGradient(arg0,arg1,arg2,arg3); }
QPointF start(QLinearGradient* obj)  const  {return obj->start(); }
void setStart(QLinearGradient* obj,const QPointF & arg0)  {obj->setStart(arg0); }
void setStart(QLinearGradient* obj,qreal arg0,qreal arg1)  {obj->setStart(arg0,arg1); }
QPointF finalStop(QLinearGradient* obj)  const  {return obj->finalStop(); }
void setFinalStop(QLinearGradient* obj,const QPointF & arg0)  {obj->setFinalStop(arg0); }
void setFinalStop(QLinearGradient* obj,qreal arg0,qreal arg1)  {obj->setFinalStop(arg0,arg1); }

};

class PythonQtQRadialGradientWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
void delete_QRadialGradient(QRadialGradient* obj) { delete obj; }
QRadialGradient* new_QRadialGradient() { return new QRadialGradient(); }
QRadialGradient* new_QRadialGradient(const QPointF & arg0,qreal arg1,const QPointF & arg2) { return new QRadialGradient(arg0,arg1,arg2); }
QRadialGradient* new_QRadialGradient(qreal arg0,qreal arg1,qreal arg2,qreal arg3,qreal arg4) { return new QRadialGradient(arg0,arg1,arg2,arg3,arg4); }
QRadialGradient* new_QRadialGradient(const QPointF & arg0,qreal arg1) { return new QRadialGradient(arg0,arg1); }
QRadialGradient* new_QRadialGradient(qreal arg0,qreal arg1,qreal arg2) { return new QRadialGradient(arg0,arg1,arg2); }
QPointF center(QRadialGradient* obj)  const  {return obj->center(); }
void setCenter(QRadialGradient* obj,const QPointF & arg0)  {obj->setCenter(arg0); }
void setCenter(QRadialGradient* obj,qreal arg0,qreal arg1)  {obj->setCenter(arg0,arg1); }
QPointF focalPoint(QRadialGradient* obj)  const  {return obj->focalPoint(); }
void setFocalPoint(QRadialGradient* obj,const QPointF & arg0)  {obj->setFocalPoint(arg0); }
void setFocalPoint(QRadialGradient* obj,qreal arg0,qreal arg1)  {obj->setFocalPoint(arg0,arg1); }
qreal radius(QRadialGradient* obj)  const  {return obj->radius(); }
void setRadius(QRadialGradient* obj,qreal arg0)  {obj->setRadius(arg0); }

};

class PythonQtQConicalGradientWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
void delete_QConicalGradient(QConicalGradient* obj) { delete obj; }
QConicalGradient* new_QConicalGradient() { return new QConicalGradient(); }
QConicalGradient* new_QConicalGradient(const QPointF & arg0,qreal arg1) { return new QConicalGradient(arg0,arg1); }
QConicalGradient* new_QConicalGradient(qreal arg0,qreal arg1,qreal arg2) { return new QConicalGradient(arg0,arg1,arg2); }
QPointF center(QConicalGradient* obj)  const  {return obj->center(); }
void setCenter(QConicalGradient* obj,const QPointF & arg0)  {obj->setCenter(arg0); }
void setCenter(QConicalGradient* obj,qreal arg0,qreal arg1)  {obj->setCenter(arg0,arg1); }
qreal angle(QConicalGradient* obj)  const  {return obj->angle(); }
void setAngle(QConicalGradient* obj,qreal arg0)  {obj->setAngle(arg0); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qcolor.h'
**
** Created: Thu 12. Apr 14:07:30 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qcolor.h"
class PythonQtQColorWrapper : public QObject  {
  Q_OBJECT

public:
Q_ENUMS(Spec )
enum Spec {Invalid = QColor::Invalid, 
Rgb = QColor::Rgb, 
Hsv = QColor::Hsv, 
Cmyk = QColor::Cmyk }; 
public slots:
QVariant new_QColor() { return QColor(); }
QVariant new_QColor(Qt::GlobalColor arg0) { return QColor(arg0); }
QVariant new_QColor(int arg0,int arg1,int arg2,int arg3) { return QColor(arg0,arg1,arg2,arg3); }
QVariant new_QColor(int arg0,int arg1,int arg2) { return QColor(arg0,arg1,arg2); }
QVariant new_QColor(QRgb arg0) { return QColor(arg0); }
QVariant new_QColor(const QString & arg0) { return QColor(arg0); }
QVariant new_QColor(const char * arg0) { return QColor(arg0); }
QVariant new_QColor(const QColor & arg0) { return QColor(arg0); }
QVariant new_QColor(Spec arg0) { return QColor((QColor::Spec)arg0); }
bool isValid(QColor* obj)  const  {return obj->isValid(); }
QString name(QColor* obj)  const  {return obj->name(); }
void setNamedColor(QColor* obj,const QString & arg0)  {obj->setNamedColor(arg0); }
QStringList static_QColor_colorNames()  {return QColor::colorNames(); }
Spec spec(QColor* obj)  const  {return (PythonQtQColorWrapper::Spec)obj->spec(); }
int alpha(QColor* obj)  const  {return obj->alpha(); }
void setAlpha(QColor* obj,int arg0)  {obj->setAlpha(arg0); }
qreal alphaF(QColor* obj)  const  {return obj->alphaF(); }
void setAlphaF(QColor* obj,qreal arg0)  {obj->setAlphaF(arg0); }
int red(QColor* obj)  const  {return obj->red(); }
int green(QColor* obj)  const  {return obj->green(); }
int blue(QColor* obj)  const  {return obj->blue(); }
void setRed(QColor* obj,int arg0)  {obj->setRed(arg0); }
void setGreen(QColor* obj,int arg0)  {obj->setGreen(arg0); }
void setBlue(QColor* obj,int arg0)  {obj->setBlue(arg0); }
qreal redF(QColor* obj)  const  {return obj->redF(); }
qreal greenF(QColor* obj)  const  {return obj->greenF(); }
qreal blueF(QColor* obj)  const  {return obj->blueF(); }
void setRedF(QColor* obj,qreal arg0)  {obj->setRedF(arg0); }
void setGreenF(QColor* obj,qreal arg0)  {obj->setGreenF(arg0); }
void setBlueF(QColor* obj,qreal arg0)  {obj->setBlueF(arg0); }
void getRgb(QColor* obj,int * arg0,int * arg1,int * arg2,int * arg3)  const  {obj->getRgb(arg0,arg1,arg2,arg3); }
void getRgb(QColor* obj,int * arg0,int * arg1,int * arg2)  const  {obj->getRgb(arg0,arg1,arg2); }
void setRgb(QColor* obj,int arg0,int arg1,int arg2,int arg3)  {obj->setRgb(arg0,arg1,arg2,arg3); }
void setRgb(QColor* obj,int arg0,int arg1,int arg2)  {obj->setRgb(arg0,arg1,arg2); }
void getRgbF(QColor* obj,qreal * arg0,qreal * arg1,qreal * arg2,qreal * arg3)  const  {obj->getRgbF(arg0,arg1,arg2,arg3); }
void getRgbF(QColor* obj,qreal * arg0,qreal * arg1,qreal * arg2)  const  {obj->getRgbF(arg0,arg1,arg2); }
void setRgbF(QColor* obj,qreal arg0,qreal arg1,qreal arg2,qreal arg3)  {obj->setRgbF(arg0,arg1,arg2,arg3); }
void setRgbF(QColor* obj,qreal arg0,qreal arg1,qreal arg2)  {obj->setRgbF(arg0,arg1,arg2); }
QRgb rgba(QColor* obj)  const  {return obj->rgba(); }
void setRgba(QColor* obj,QRgb arg0)  {obj->setRgba(arg0); }
QRgb rgb(QColor* obj)  const  {return obj->rgb(); }
void setRgb(QColor* obj,QRgb arg0)  {obj->setRgb(arg0); }
int hue(QColor* obj)  const  {return obj->hue(); }
int saturation(QColor* obj)  const  {return obj->saturation(); }
int value(QColor* obj)  const  {return obj->value(); }
qreal hueF(QColor* obj)  const  {return obj->hueF(); }
qreal saturationF(QColor* obj)  const  {return obj->saturationF(); }
qreal valueF(QColor* obj)  const  {return obj->valueF(); }
void getHsv(QColor* obj,int * arg0,int * arg1,int * arg2,int * arg3)  const  {obj->getHsv(arg0,arg1,arg2,arg3); }
void getHsv(QColor* obj,int * arg0,int * arg1,int * arg2)  const  {obj->getHsv(arg0,arg1,arg2); }
void setHsv(QColor* obj,int arg0,int arg1,int arg2,int arg3)  {obj->setHsv(arg0,arg1,arg2,arg3); }
void setHsv(QColor* obj,int arg0,int arg1,int arg2)  {obj->setHsv(arg0,arg1,arg2); }
void getHsvF(QColor* obj,qreal * arg0,qreal * arg1,qreal * arg2,qreal * arg3)  const  {obj->getHsvF(arg0,arg1,arg2,arg3); }
void getHsvF(QColor* obj,qreal * arg0,qreal * arg1,qreal * arg2)  const  {obj->getHsvF(arg0,arg1,arg2); }
void setHsvF(QColor* obj,qreal arg0,qreal arg1,qreal arg2,qreal arg3)  {obj->setHsvF(arg0,arg1,arg2,arg3); }
void setHsvF(QColor* obj,qreal arg0,qreal arg1,qreal arg2)  {obj->setHsvF(arg0,arg1,arg2); }
int cyan(QColor* obj)  const  {return obj->cyan(); }
int magenta(QColor* obj)  const  {return obj->magenta(); }
int yellow(QColor* obj)  const  {return obj->yellow(); }
int black(QColor* obj)  const  {return obj->black(); }
qreal cyanF(QColor* obj)  const  {return obj->cyanF(); }
qreal magentaF(QColor* obj)  const  {return obj->magentaF(); }
qreal yellowF(QColor* obj)  const  {return obj->yellowF(); }
qreal blackF(QColor* obj)  const  {return obj->blackF(); }
void getCmyk(QColor* obj,int * arg0,int * arg1,int * arg2,int * arg3,int * arg4)  {obj->getCmyk(arg0,arg1,arg2,arg3,arg4); }
void getCmyk(QColor* obj,int * arg0,int * arg1,int * arg2,int * arg3)  {obj->getCmyk(arg0,arg1,arg2,arg3); }
void setCmyk(QColor* obj,int arg0,int arg1,int arg2,int arg3,int arg4)  {obj->setCmyk(arg0,arg1,arg2,arg3,arg4); }
void setCmyk(QColor* obj,int arg0,int arg1,int arg2,int arg3)  {obj->setCmyk(arg0,arg1,arg2,arg3); }
void getCmykF(QColor* obj,qreal * arg0,qreal * arg1,qreal * arg2,qreal * arg3,qreal * arg4)  {obj->getCmykF(arg0,arg1,arg2,arg3,arg4); }
void getCmykF(QColor* obj,qreal * arg0,qreal * arg1,qreal * arg2,qreal * arg3)  {obj->getCmykF(arg0,arg1,arg2,arg3); }
void setCmykF(QColor* obj,qreal arg0,qreal arg1,qreal arg2,qreal arg3,qreal arg4)  {obj->setCmykF(arg0,arg1,arg2,arg3,arg4); }
void setCmykF(QColor* obj,qreal arg0,qreal arg1,qreal arg2,qreal arg3)  {obj->setCmykF(arg0,arg1,arg2,arg3); }
QColor toRgb(QColor* obj)  const  {return obj->toRgb(); }
QColor toHsv(QColor* obj)  const  {return obj->toHsv(); }
QColor toCmyk(QColor* obj)  const  {return obj->toCmyk(); }
QColor convertTo(QColor* obj,Spec arg0)  const  {return obj->convertTo((QColor::Spec)arg0); }
QColor static_QColor_fromRgb(QRgb arg0)  {return QColor::fromRgb(arg0); }
QColor static_QColor_fromRgba(QRgb arg0)  {return QColor::fromRgba(arg0); }
QColor static_QColor_fromRgb(int arg0,int arg1,int arg2,int arg3)  {return QColor::fromRgb(arg0,arg1,arg2,arg3); }
QColor static_QColor_fromRgb(int arg0,int arg1,int arg2)  {return QColor::fromRgb(arg0,arg1,arg2); }
QColor static_QColor_fromRgbF(qreal arg0,qreal arg1,qreal arg2,qreal arg3)  {return QColor::fromRgbF(arg0,arg1,arg2,arg3); }
QColor static_QColor_fromRgbF(qreal arg0,qreal arg1,qreal arg2)  {return QColor::fromRgbF(arg0,arg1,arg2); }
QColor static_QColor_fromHsv(int arg0,int arg1,int arg2,int arg3)  {return QColor::fromHsv(arg0,arg1,arg2,arg3); }
QColor static_QColor_fromHsv(int arg0,int arg1,int arg2)  {return QColor::fromHsv(arg0,arg1,arg2); }
QColor static_QColor_fromHsvF(qreal arg0,qreal arg1,qreal arg2,qreal arg3)  {return QColor::fromHsvF(arg0,arg1,arg2,arg3); }
QColor static_QColor_fromHsvF(qreal arg0,qreal arg1,qreal arg2)  {return QColor::fromHsvF(arg0,arg1,arg2); }
QColor static_QColor_fromCmyk(int arg0,int arg1,int arg2,int arg3,int arg4)  {return QColor::fromCmyk(arg0,arg1,arg2,arg3,arg4); }
QColor static_QColor_fromCmyk(int arg0,int arg1,int arg2,int arg3)  {return QColor::fromCmyk(arg0,arg1,arg2,arg3); }
QColor static_QColor_fromCmykF(qreal arg0,qreal arg1,qreal arg2,qreal arg3,qreal arg4)  {return QColor::fromCmykF(arg0,arg1,arg2,arg3,arg4); }
QColor static_QColor_fromCmykF(qreal arg0,qreal arg1,qreal arg2,qreal arg3)  {return QColor::fromCmykF(arg0,arg1,arg2,arg3); }
QColor light(QColor* obj,int arg0)  const  {return obj->light(arg0); }
QColor light(QColor* obj)  const  {return obj->light(); }
QColor dark(QColor* obj,int arg0)  const  {return obj->dark(arg0); }
QColor dark(QColor* obj)  const  {return obj->dark(); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qpalette.h'
**
** Created: Thu 12. Apr 14:07:30 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qpalette.h"
class PythonQtQPaletteWrapper : public QObject  {
  Q_OBJECT

public:
Q_ENUMS(ColorGroup ColorRole )
enum ColorGroup {Active = QPalette::Active, 
Disabled = QPalette::Disabled, 
Inactive = QPalette::Inactive, 
NColorGroups = QPalette::NColorGroups, 
Current = QPalette::Current, 
All = QPalette::All, 
Normal = QPalette::Normal }; 
enum ColorRole {WindowText = QPalette::WindowText, 
Button = QPalette::Button, 
Light = QPalette::Light, 
Midlight = QPalette::Midlight, 
Dark = QPalette::Dark, 
Mid = QPalette::Mid, 
Text = QPalette::Text, 
BrightText = QPalette::BrightText, 
ButtonText = QPalette::ButtonText, 
Base = QPalette::Base, 
Window = QPalette::Window, 
Shadow = QPalette::Shadow, 
Highlight = QPalette::Highlight, 
HighlightedText = QPalette::HighlightedText, 
Link = QPalette::Link, 
LinkVisited = QPalette::LinkVisited, 
AlternateBase = QPalette::AlternateBase, 
NoRole = QPalette::NoRole, 
NColorRoles = QPalette::NColorRoles, 
Foreground = QPalette::Foreground, 
Background = QPalette::Background }; 
public slots:
QVariant new_QPalette() { return QPalette(); }
QVariant new_QPalette(const QColor & arg0) { return QPalette(arg0); }
QVariant new_QPalette(Qt::GlobalColor arg0) { return QPalette(arg0); }
QVariant new_QPalette(const QColor & arg0,const QColor & arg1) { return QPalette(arg0,arg1); }
QVariant new_QPalette(const QBrush & arg0,const QBrush & arg1,const QBrush & arg2,const QBrush & arg3,const QBrush & arg4,const QBrush & arg5,const QBrush & arg6,const QBrush & arg7,const QBrush & arg8) { return QPalette(arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8); }
QVariant new_QPalette(const QColor & arg0,const QColor & arg1,const QColor & arg2,const QColor & arg3,const QColor & arg4,const QColor & arg5,const QColor & arg6) { return QPalette(arg0,arg1,arg2,arg3,arg4,arg5,arg6); }
QVariant new_QPalette(const QPalette & arg0) { return QPalette(arg0); }
ColorGroup currentColorGroup(QPalette* obj)  const  {return (PythonQtQPaletteWrapper::ColorGroup)obj->currentColorGroup(); }
void setCurrentColorGroup(QPalette* obj,ColorGroup arg0)  {obj->setCurrentColorGroup((QPalette::ColorGroup)arg0); }
void color(QPalette* obj,ColorGroup arg0,ColorRole arg1)  const  {obj->color((QPalette::ColorGroup)arg0,(QPalette::ColorRole)arg1); }
void brush(QPalette* obj,ColorGroup arg0,ColorRole arg1)  const  {obj->brush((QPalette::ColorGroup)arg0,(QPalette::ColorRole)arg1); }
void setColor(QPalette* obj,ColorGroup arg0,ColorRole arg1,const QColor & arg2)  {obj->setColor((QPalette::ColorGroup)arg0,(QPalette::ColorRole)arg1,arg2); }
void setColor(QPalette* obj,ColorRole arg0,const QColor & arg1)  {obj->setColor((QPalette::ColorRole)arg0,arg1); }
void setBrush(QPalette* obj,ColorRole arg0,const QBrush & arg1)  {obj->setBrush((QPalette::ColorRole)arg0,arg1); }
bool isBrushSet(QPalette* obj,ColorGroup arg0,ColorRole arg1)  const  {return obj->isBrushSet((QPalette::ColorGroup)arg0,(QPalette::ColorRole)arg1); }
void setBrush(QPalette* obj,ColorGroup arg0,ColorRole arg1,const QBrush & arg2)  {obj->setBrush((QPalette::ColorGroup)arg0,(QPalette::ColorRole)arg1,arg2); }
void setColorGroup(QPalette* obj,ColorGroup arg0,const QBrush & arg1,const QBrush & arg2,const QBrush & arg3,const QBrush & arg4,const QBrush & arg5,const QBrush & arg6,const QBrush & arg7,const QBrush & arg8,const QBrush & arg9)  {obj->setColorGroup((QPalette::ColorGroup)arg0,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9); }
bool isEqual(QPalette* obj,ColorGroup arg0,ColorGroup arg1)  const  {return obj->isEqual((QPalette::ColorGroup)arg0,(QPalette::ColorGroup)arg1); }
void color(QPalette* obj,ColorRole arg0)  const  {obj->color((QPalette::ColorRole)arg0); }
void brush(QPalette* obj,ColorRole arg0)  const  {obj->brush((QPalette::ColorRole)arg0); }
void foreground(QPalette* obj)  const  {obj->foreground(); }
void windowText(QPalette* obj)  const  {obj->windowText(); }
void button(QPalette* obj)  const  {obj->button(); }
void light(QPalette* obj)  const  {obj->light(); }
void dark(QPalette* obj)  const  {obj->dark(); }
void mid(QPalette* obj)  const  {obj->mid(); }
void text(QPalette* obj)  const  {obj->text(); }
void base(QPalette* obj)  const  {obj->base(); }
void alternateBase(QPalette* obj)  const  {obj->alternateBase(); }
void background(QPalette* obj)  const  {obj->background(); }
void window(QPalette* obj)  const  {obj->window(); }
void midlight(QPalette* obj)  const  {obj->midlight(); }
void brightText(QPalette* obj)  const  {obj->brightText(); }
void buttonText(QPalette* obj)  const  {obj->buttonText(); }
void shadow(QPalette* obj)  const  {obj->shadow(); }
void highlight(QPalette* obj)  const  {obj->highlight(); }
void highlightedText(QPalette* obj)  const  {obj->highlightedText(); }
void link(QPalette* obj)  const  {obj->link(); }
void linkVisited(QPalette* obj)  const  {obj->linkVisited(); }
bool isCopyOf(QPalette* obj,const QPalette & arg0)  const  {return obj->isCopyOf(arg0); }
int serialNumber(QPalette* obj)  const  {return obj->serialNumber(); }
QPalette resolve(QPalette* obj,const QPalette & arg0)  const  {return obj->resolve(arg0); }
uint resolve(QPalette* obj)  const  {return obj->resolve(); }
void resolve(QPalette* obj,uint arg0)  {obj->resolve(arg0); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qicon.h'
**
** Created: Thu 12. Apr 14:07:30 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qicon.h"
class PythonQtQIconWrapper : public QObject  {
  Q_OBJECT

public:
Q_ENUMS(Mode State )
enum Mode {Normal = QIcon::Normal, 
Disabled = QIcon::Disabled, 
Active = QIcon::Active, 
Selected = QIcon::Selected }; 
enum State {On = QIcon::On, 
Off = QIcon::Off }; 
public slots:
QVariant new_QIcon() { return QIcon(); }
QVariant new_QIcon(const QPixmap & arg0) { return QIcon(arg0); }
QVariant new_QIcon(const QIcon & arg0) { return QIcon(arg0); }
QVariant new_QIcon(const QString & arg0) { return QIcon(arg0); }
QVariant new_QIcon(QIconEngine * arg0) { return QIcon(arg0); }
QPixmap pixmap(QIcon* obj,const QSize & arg0,Mode arg1,State arg2)  const  {return obj->pixmap(arg0,(QIcon::Mode)arg1,(QIcon::State)arg2); }
QPixmap pixmap(QIcon* obj,const QSize & arg0,Mode arg1)  const  {return obj->pixmap(arg0,(QIcon::Mode)arg1); }
QPixmap pixmap(QIcon* obj,const QSize & arg0)  const  {return obj->pixmap(arg0); }
QPixmap pixmap(QIcon* obj,int arg0,int arg1,Mode arg2,State arg3)  const  {return obj->pixmap(arg0,arg1,(QIcon::Mode)arg2,(QIcon::State)arg3); }
QPixmap pixmap(QIcon* obj,int arg0,int arg1,Mode arg2)  const  {return obj->pixmap(arg0,arg1,(QIcon::Mode)arg2); }
QPixmap pixmap(QIcon* obj,int arg0,int arg1)  const  {return obj->pixmap(arg0,arg1); }
QPixmap pixmap(QIcon* obj,int arg0,Mode arg1,State arg2)  const  {return obj->pixmap(arg0,(QIcon::Mode)arg1,(QIcon::State)arg2); }
QPixmap pixmap(QIcon* obj,int arg0,Mode arg1)  const  {return obj->pixmap(arg0,(QIcon::Mode)arg1); }
QPixmap pixmap(QIcon* obj,int arg0)  const  {return obj->pixmap(arg0); }
QSize actualSize(QIcon* obj,const QSize & arg0,Mode arg1,State arg2)  const  {return obj->actualSize(arg0,(QIcon::Mode)arg1,(QIcon::State)arg2); }
QSize actualSize(QIcon* obj,const QSize & arg0,Mode arg1)  const  {return obj->actualSize(arg0,(QIcon::Mode)arg1); }
QSize actualSize(QIcon* obj,const QSize & arg0)  const  {return obj->actualSize(arg0); }
void paint(QIcon* obj,QPainter * arg0,const QRect & arg1,Qt::Alignment arg2,Mode arg3,State arg4)  const  {obj->paint(arg0,arg1,arg2,(QIcon::Mode)arg3,(QIcon::State)arg4); }
void paint(QIcon* obj,QPainter * arg0,const QRect & arg1,Qt::Alignment arg2,Mode arg3)  const  {obj->paint(arg0,arg1,arg2,(QIcon::Mode)arg3); }
void paint(QIcon* obj,QPainter * arg0,const QRect & arg1,Qt::Alignment arg2)  const  {obj->paint(arg0,arg1,arg2); }
void paint(QIcon* obj,QPainter * arg0,const QRect & arg1)  const  {obj->paint(arg0,arg1); }
void paint(QIcon* obj,QPainter * arg0,int arg1,int arg2,int arg3,int arg4,Qt::Alignment arg5,Mode arg6,State arg7)  const  {obj->paint(arg0,arg1,arg2,arg3,arg4,arg5,(QIcon::Mode)arg6,(QIcon::State)arg7); }
void paint(QIcon* obj,QPainter * arg0,int arg1,int arg2,int arg3,int arg4,Qt::Alignment arg5,Mode arg6)  const  {obj->paint(arg0,arg1,arg2,arg3,arg4,arg5,(QIcon::Mode)arg6); }
void paint(QIcon* obj,QPainter * arg0,int arg1,int arg2,int arg3,int arg4,Qt::Alignment arg5)  const  {obj->paint(arg0,arg1,arg2,arg3,arg4,arg5); }
void paint(QIcon* obj,QPainter * arg0,int arg1,int arg2,int arg3,int arg4)  const  {obj->paint(arg0,arg1,arg2,arg3,arg4); }
bool isNull(QIcon* obj)  const  {return obj->isNull(); }
bool isDetached(QIcon* obj)  const  {return obj->isDetached(); }
int serialNumber(QIcon* obj)  const  {return obj->serialNumber(); }
void addPixmap(QIcon* obj,const QPixmap & arg0,Mode arg1,State arg2)  {obj->addPixmap(arg0,(QIcon::Mode)arg1,(QIcon::State)arg2); }
void addPixmap(QIcon* obj,const QPixmap & arg0,Mode arg1)  {obj->addPixmap(arg0,(QIcon::Mode)arg1); }
void addPixmap(QIcon* obj,const QPixmap & arg0)  {obj->addPixmap(arg0); }
void addFile(QIcon* obj,const QString & arg0,const QSize & arg1,Mode arg2,State arg3)  {obj->addFile(arg0,arg1,(QIcon::Mode)arg2,(QIcon::State)arg3); }
void addFile(QIcon* obj,const QString & arg0,const QSize & arg1,Mode arg2)  {obj->addFile(arg0,arg1,(QIcon::Mode)arg2); }
void addFile(QIcon* obj,const QString & arg0,const QSize & arg1)  {obj->addFile(arg0,arg1); }
void addFile(QIcon* obj,const QString & arg0)  {obj->addFile(arg0); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qimage.h'
**
** Created: Thu 12. Apr 14:07:30 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qimage.h"
class PythonQtQImageTextKeyLangWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
void delete_QImageTextKeyLang(QImageTextKeyLang* obj) { delete obj; }
QImageTextKeyLang* new_QImageTextKeyLang(const char * arg0,const char * arg1) { return new QImageTextKeyLang(arg0,arg1); }

};

class PythonQtQImageWrapper : public QObject  {
  Q_OBJECT

public:
Q_ENUMS(InvertMode Format )
enum InvertMode {InvertRgb = QImage::InvertRgb, 
InvertRgba = QImage::InvertRgba }; 
enum Format {Format_Invalid = QImage::Format_Invalid, 
Format_Mono = QImage::Format_Mono, 
Format_MonoLSB = QImage::Format_MonoLSB, 
Format_Indexed8 = QImage::Format_Indexed8, 
Format_RGB32 = QImage::Format_RGB32, 
Format_ARGB32 = QImage::Format_ARGB32, 
Format_ARGB32_Premultiplied = QImage::Format_ARGB32_Premultiplied, 
Format_RGB16 = QImage::Format_RGB16, 
NImageFormats = QImage::NImageFormats }; 
public slots:
QVariant new_QImage() { return QImage(); }
QVariant new_QImage(const QSize & arg0,Format arg1) { return QImage(arg0,(QImage::Format)arg1); }
QVariant new_QImage(int arg0,int arg1,Format arg2) { return QImage(arg0,arg1,(QImage::Format)arg2); }
QVariant new_QImage(uchar * arg0,int arg1,int arg2,Format arg3) { return QImage(arg0,arg1,arg2,(QImage::Format)arg3); }
QVariant new_QImage(const uchar * arg0,int arg1,int arg2,Format arg3) { return QImage(arg0,arg1,arg2,(QImage::Format)arg3); }
QVariant new_QImage(const QString & arg0,const char * arg1) { return QImage(arg0,arg1); }
QVariant new_QImage(const QString & arg0) { return QImage(arg0); }
QVariant new_QImage(const char * arg0,const char * arg1) { return QImage(arg0,arg1); }
QVariant new_QImage(const char * arg0) { return QImage(arg0); }
QVariant new_QImage(const QImage & arg0) { return QImage(arg0); }
bool isNull(QImage* obj)  const  {return obj->isNull(); }
int devType(QImage* obj)  const  {return obj->devType(); }
void detach(QImage* obj)  {obj->detach(); }
bool isDetached(QImage* obj)  const  {return obj->isDetached(); }
QImage copy(QImage* obj,const QRect & arg0)  const  {return obj->copy(arg0); }
QImage copy(QImage* obj)  const  {return obj->copy(); }
QImage copy(QImage* obj,int arg0,int arg1,int arg2,int arg3)  const  {return obj->copy(arg0,arg1,arg2,arg3); }
Format format(QImage* obj)  const  {return (PythonQtQImageWrapper::Format)obj->format(); }
QImage convertToFormat(QImage* obj,Format arg0,Qt::ImageConversionFlags arg1)  const  {return obj->convertToFormat((QImage::Format)arg0,arg1); }
QImage convertToFormat(QImage* obj,Format arg0)  const  {return obj->convertToFormat((QImage::Format)arg0); }
QImage convertToFormat(QImage* obj,Format arg0,const QVector<QRgb> & arg1,Qt::ImageConversionFlags arg2)  const  {return obj->convertToFormat((QImage::Format)arg0,arg1,arg2); }
QImage convertToFormat(QImage* obj,Format arg0,const QVector<QRgb> & arg1)  const  {return obj->convertToFormat((QImage::Format)arg0,arg1); }
int width(QImage* obj)  const  {return obj->width(); }
int height(QImage* obj)  const  {return obj->height(); }
QSize size(QImage* obj)  const  {return obj->size(); }
QRect rect(QImage* obj)  const  {return obj->rect(); }
int depth(QImage* obj)  const  {return obj->depth(); }
int numColors(QImage* obj)  const  {return obj->numColors(); }
QRgb color(QImage* obj,int arg0)  const  {return obj->color(arg0); }
void setColor(QImage* obj,int arg0,QRgb arg1)  {obj->setColor(arg0,arg1); }
void setNumColors(QImage* obj,int arg0)  {obj->setNumColors(arg0); }
bool allGray(QImage* obj)  const  {return obj->allGray(); }
bool isGrayscale(QImage* obj)  const  {return obj->isGrayscale(); }
uchar* bits(QImage* obj)  {return obj->bits(); }
const uchar* bits(QImage* obj)  const  {return obj->bits(); }
int numBytes(QImage* obj)  const  {return obj->numBytes(); }
uchar* scanLine(QImage* obj,int arg0)  {return obj->scanLine(arg0); }
const uchar* scanLine(QImage* obj,int arg0)  const  {return obj->scanLine(arg0); }
int bytesPerLine(QImage* obj)  const  {return obj->bytesPerLine(); }
bool valid(QImage* obj,int arg0,int arg1)  const  {return obj->valid(arg0,arg1); }
bool valid(QImage* obj,const QPoint & arg0)  const  {return obj->valid(arg0); }
int pixelIndex(QImage* obj,int arg0,int arg1)  const  {return obj->pixelIndex(arg0,arg1); }
int pixelIndex(QImage* obj,const QPoint & arg0)  const  {return obj->pixelIndex(arg0); }
QRgb pixel(QImage* obj,int arg0,int arg1)  const  {return obj->pixel(arg0,arg1); }
QRgb pixel(QImage* obj,const QPoint & arg0)  const  {return obj->pixel(arg0); }
void setPixel(QImage* obj,int arg0,int arg1,uint arg2)  {obj->setPixel(arg0,arg1,arg2); }
void setPixel(QImage* obj,const QPoint & arg0,uint arg1)  {obj->setPixel(arg0,arg1); }
QVector<QRgb> colorTable(QImage* obj)  const  {return obj->colorTable(); }
void setColorTable(QImage* obj,const QVector<QRgb> arg0)  {obj->setColorTable(arg0); }
void fill(QImage* obj,uint arg0)  {obj->fill(arg0); }
bool hasAlphaChannel(QImage* obj)  const  {return obj->hasAlphaChannel(); }
void setAlphaChannel(QImage* obj,const QImage & arg0)  {obj->setAlphaChannel(arg0); }
QImage alphaChannel(QImage* obj)  const  {return obj->alphaChannel(); }
QImage createAlphaMask(QImage* obj,Qt::ImageConversionFlags arg0)  const  {return obj->createAlphaMask(arg0); }
QImage createAlphaMask(QImage* obj)  const  {return obj->createAlphaMask(); }
QImage createHeuristicMask(QImage* obj,bool arg0)  const  {return obj->createHeuristicMask(arg0); }
QImage createHeuristicMask(QImage* obj)  const  {return obj->createHeuristicMask(); }
QImage scaled(QImage* obj,int arg0,int arg1,Qt::AspectRatioMode arg2,Qt::TransformationMode arg3)  const  {return obj->scaled(arg0,arg1,arg2,arg3); }
QImage scaled(QImage* obj,int arg0,int arg1,Qt::AspectRatioMode arg2)  const  {return obj->scaled(arg0,arg1,arg2); }
QImage scaled(QImage* obj,int arg0,int arg1)  const  {return obj->scaled(arg0,arg1); }
QImage scaled(QImage* obj,const QSize & arg0,Qt::AspectRatioMode arg1,Qt::TransformationMode arg2)  const  {return obj->scaled(arg0,arg1,arg2); }
QImage scaled(QImage* obj,const QSize & arg0,Qt::AspectRatioMode arg1)  const  {return obj->scaled(arg0,arg1); }
QImage scaled(QImage* obj,const QSize & arg0)  const  {return obj->scaled(arg0); }
QImage scaledToWidth(QImage* obj,int arg0,Qt::TransformationMode arg1)  const  {return obj->scaledToWidth(arg0,arg1); }
QImage scaledToWidth(QImage* obj,int arg0)  const  {return obj->scaledToWidth(arg0); }
QImage scaledToHeight(QImage* obj,int arg0,Qt::TransformationMode arg1)  const  {return obj->scaledToHeight(arg0,arg1); }
QImage scaledToHeight(QImage* obj,int arg0)  const  {return obj->scaledToHeight(arg0); }
QImage transformed(QImage* obj,const QMatrix & arg0,Qt::TransformationMode arg1)  const  {return obj->transformed(arg0,arg1); }
QImage transformed(QImage* obj,const QMatrix & arg0)  const  {return obj->transformed(arg0); }
QMatrix static_QImage_trueMatrix(const QMatrix & arg0,int arg1,int arg2)  {return QImage::trueMatrix(arg0,arg1,arg2); }
QImage mirrored(QImage* obj,bool arg0,bool arg1)  const  {return obj->mirrored(arg0,arg1); }
QImage mirrored(QImage* obj,bool arg0)  const  {return obj->mirrored(arg0); }
QImage mirrored(QImage* obj)  const  {return obj->mirrored(); }
QImage rgbSwapped(QImage* obj)  const  {return obj->rgbSwapped(); }
void invertPixels(QImage* obj,InvertMode arg0)  {obj->invertPixels((QImage::InvertMode)arg0); }
void invertPixels(QImage* obj)  {obj->invertPixels(); }
bool load(QImage* obj,QIODevice * arg0,const char * arg1)  {return obj->load(arg0,arg1); }
bool load(QImage* obj,const QString & arg0,const char * arg1)  {return obj->load(arg0,arg1); }
bool load(QImage* obj,const QString & arg0)  {return obj->load(arg0); }
bool loadFromData(QImage* obj,const uchar * arg0,int arg1,const char * arg2)  {return obj->loadFromData(arg0,arg1,arg2); }
bool loadFromData(QImage* obj,const uchar * arg0,int arg1)  {return obj->loadFromData(arg0,arg1); }
bool loadFromData(QImage* obj,const QByteArray & arg0,const char * arg1)  {return obj->loadFromData(arg0,arg1); }
bool loadFromData(QImage* obj,const QByteArray & arg0)  {return obj->loadFromData(arg0); }
bool save(QImage* obj,const QString & arg0,const char * arg1,int arg2)  const  {return obj->save(arg0,arg1,arg2); }
bool save(QImage* obj,const QString & arg0,const char * arg1)  const  {return obj->save(arg0,arg1); }
bool save(QImage* obj,const QString & arg0)  const  {return obj->save(arg0); }
bool save(QImage* obj,QIODevice * arg0,const char * arg1,int arg2)  const  {return obj->save(arg0,arg1,arg2); }
bool save(QImage* obj,QIODevice * arg0,const char * arg1)  const  {return obj->save(arg0,arg1); }
bool save(QImage* obj,QIODevice * arg0)  const  {return obj->save(arg0); }
QImage static_QImage_fromData(const uchar * arg0,int arg1,const char * arg2)  {return QImage::fromData(arg0,arg1,arg2); }
QImage static_QImage_fromData(const uchar * arg0,int arg1)  {return QImage::fromData(arg0,arg1); }
QImage static_QImage_fromData(const QByteArray & arg0,const char * arg1)  {return QImage::fromData(arg0,arg1); }
QImage static_QImage_fromData(const QByteArray & arg0)  {return QImage::fromData(arg0); }
int serialNumber(QImage* obj)  const  {return obj->serialNumber(); }
QPaintEngine* paintEngine(QImage* obj)  const  {return obj->paintEngine(); }
int dotsPerMeterX(QImage* obj)  const  {return obj->dotsPerMeterX(); }
int dotsPerMeterY(QImage* obj)  const  {return obj->dotsPerMeterY(); }
void setDotsPerMeterX(QImage* obj,int arg0)  {obj->setDotsPerMeterX(arg0); }
void setDotsPerMeterY(QImage* obj,int arg0)  {obj->setDotsPerMeterY(arg0); }
QPoint offset(QImage* obj)  const  {return obj->offset(); }
void setOffset(QImage* obj,const QPoint & arg0)  {obj->setOffset(arg0); }
QStringList textKeys(QImage* obj)  const  {return obj->textKeys(); }
QString text(QImage* obj,const QString & arg0)  const  {return obj->text(arg0); }
QString text(QImage* obj)  const  {return obj->text(); }
void setText(QImage* obj,const QString & arg0,const QString & arg1)  {obj->setText(arg0,arg1); }
QString text(QImage* obj,const char * arg0,const char * arg1)  const  {return obj->text(arg0,arg1); }
QString text(QImage* obj,const char * arg0)  const  {return obj->text(arg0); }
QList<QImageTextKeyLang> textList(QImage* obj)  const  {return obj->textList(); }
QStringList textLanguages(QImage* obj)  const  {return obj->textLanguages(); }
QString text(QImage* obj,const QImageTextKeyLang & arg0)  const  {return obj->text(arg0); }
void setText(QImage* obj,const char * arg0,const char * arg1,const QString & arg2)  {obj->setText(arg0,arg1,arg2); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qpolygon.h'
**
** Created: Thu 12. Apr 14:07:30 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qpolygon.h"
class PythonQtQPolygonWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
QVariant new_QPolygon() { return QPolygon(); }
QVariant new_QPolygon(int arg0) { return QPolygon(arg0); }
QVariant new_QPolygon(const QPolygon & arg0) { return QPolygon(arg0); }
QVariant new_QPolygon(const QVector<QPoint> & arg0) { return QPolygon(arg0); }
QVariant new_QPolygon(int arg0,const int * arg1) { return QPolygon(arg0,arg1); }
void translate(QPolygon* obj,int arg0,int arg1)  {obj->translate(arg0,arg1); }
void translate(QPolygon* obj,const QPoint & arg0)  {obj->translate(arg0); }
QRect boundingRect(QPolygon* obj)  const  {return obj->boundingRect(); }
void point(QPolygon* obj,int arg0,int * arg1,int * arg2)  const  {obj->point(arg0,arg1,arg2); }
QPoint point(QPolygon* obj,int arg0)  const  {return obj->point(arg0); }
void setPoint(QPolygon* obj,int arg0,int arg1,int arg2)  {obj->setPoint(arg0,arg1,arg2); }
void setPoint(QPolygon* obj,int arg0,const QPoint & arg1)  {obj->setPoint(arg0,arg1); }

};

class PythonQtQPolygonFWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
void delete_QPolygonF(QPolygonF* obj) { delete obj; }
QPolygonF* new_QPolygonF() { return new QPolygonF(); }
QPolygonF* new_QPolygonF(int arg0) { return new QPolygonF(arg0); }
QPolygonF* new_QPolygonF(const QPolygonF & arg0) { return new QPolygonF(arg0); }
QPolygonF* new_QPolygonF(const QVector<QPointF> & arg0) { return new QPolygonF(arg0); }
QPolygonF* new_QPolygonF(const QPolygon & arg0) { return new QPolygonF(arg0); }
void translate(QPolygonF* obj,qreal arg0,qreal arg1)  {obj->translate(arg0,arg1); }
void translate(QPolygonF* obj,const QPointF & arg0)  {obj->translate(arg0); }
QPolygon toPolygon(QPolygonF* obj)  const  {return obj->toPolygon(); }
bool isClosed(QPolygonF* obj)  const  {return obj->isClosed(); }
QRectF boundingRect(QPolygonF* obj)  const  {return obj->boundingRect(); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qregion.h'
**
** Created: Thu 12. Apr 14:07:30 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qregion.h"
class PythonQtQRegionWrapper : public QObject  {
  Q_OBJECT

public:
Q_ENUMS(RegionType )
enum RegionType {Rectangle = QRegion::Rectangle, 
Ellipse = QRegion::Ellipse }; 
public slots:
QVariant new_QRegion() { return QRegion(); }
QVariant new_QRegion(int arg0,int arg1,int arg2,int arg3,RegionType arg4) { return QRegion(arg0,arg1,arg2,arg3,(QRegion::RegionType)arg4); }
QVariant new_QRegion(int arg0,int arg1,int arg2,int arg3) { return QRegion(arg0,arg1,arg2,arg3); }
QVariant new_QRegion(const QRect & arg0,RegionType arg1) { return QRegion(arg0,(QRegion::RegionType)arg1); }
QVariant new_QRegion(const QRect & arg0) { return QRegion(arg0); }
QVariant new_QRegion(const QPolygon & arg0,Qt::FillRule arg1) { return QRegion(arg0,arg1); }
QVariant new_QRegion(const QPolygon & arg0) { return QRegion(arg0); }
QVariant new_QRegion(const QRegion & arg0) { return QRegion(arg0); }
QVariant new_QRegion(const QBitmap & arg0) { return QRegion(arg0); }
bool isEmpty(QRegion* obj)  const  {return obj->isEmpty(); }
bool contains(QRegion* obj,const QPoint & arg0)  const  {return obj->contains(arg0); }
bool contains(QRegion* obj,const QRect & arg0)  const  {return obj->contains(arg0); }
void translate(QRegion* obj,int arg0,int arg1)  {obj->translate(arg0,arg1); }
void translate(QRegion* obj,const QPoint & arg0)  {obj->translate(arg0); }
QRegion translated(QRegion* obj,int arg0,int arg1)  const  {return obj->translated(arg0,arg1); }
QRegion translated(QRegion* obj,const QPoint & arg0)  const  {return obj->translated(arg0); }
QRegion unite(QRegion* obj,const QRegion & arg0)  const  {return obj->unite(arg0); }
QRegion intersect(QRegion* obj,const QRegion & arg0)  const  {return obj->intersect(arg0); }
QRegion subtract(QRegion* obj,const QRegion & arg0)  const  {return obj->subtract(arg0); }
QRegion eor(QRegion* obj,const QRegion & arg0)  const  {return obj->eor(arg0); }
QRegion united(QRegion* obj,const QRegion & arg0)  const  {return obj->united(arg0); }
QRegion intersected(QRegion* obj,const QRegion & arg0)  const  {return obj->intersected(arg0); }
QRegion subtracted(QRegion* obj,const QRegion & arg0)  const  {return obj->subtracted(arg0); }
QRegion xored(QRegion* obj,const QRegion & arg0)  const  {return obj->xored(arg0); }
bool intersects(QRegion* obj,const QRegion & arg0)  const  {return obj->intersects(arg0); }
bool intersects(QRegion* obj,const QRect & arg0)  const  {return obj->intersects(arg0); }
QRect boundingRect(QRegion* obj)  const  {return obj->boundingRect(); }
QVector<QRect> rects(QRegion* obj)  const  {return obj->rects(); }
void setRects(QRegion* obj,const QRect * arg0,int arg1)  {obj->setRects(arg0,arg1); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qbitmap.h'
**
** Created: Thu 12. Apr 14:07:31 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qbitmap.h"
class PythonQtQBitmapWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
QVariant new_QBitmap() { return QBitmap(); }
QVariant new_QBitmap(const QPixmap & arg0) { return QBitmap(arg0); }
QVariant new_QBitmap(int arg0,int arg1) { return QBitmap(arg0,arg1); }
QVariant new_QBitmap(const QSize & arg0) { return QBitmap(arg0); }
QVariant new_QBitmap(const QString & arg0,const char * arg1) { return QBitmap(arg0,arg1); }
QVariant new_QBitmap(const QString & arg0) { return QBitmap(arg0); }
void clear(QBitmap* obj)  {obj->clear(); }
QBitmap static_QBitmap_fromImage(const QImage & arg0,Qt::ImageConversionFlags arg1)  {return QBitmap::fromImage(arg0,arg1); }
QBitmap static_QBitmap_fromImage(const QImage & arg0)  {return QBitmap::fromImage(arg0); }
QBitmap static_QBitmap_fromData(const QSize & arg0,const uchar * arg1,QImage::Format arg2)  {return QBitmap::fromData(arg0,arg1,arg2); }
QBitmap static_QBitmap_fromData(const QSize & arg0,const uchar * arg1)  {return QBitmap::fromData(arg0,arg1); }
QBitmap transformed(QBitmap* obj,const QMatrix & arg0)  const  {return obj->transformed(arg0); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qcursor.h'
**
** Created: Thu 12. Apr 14:07:31 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qcursor.h"
class PythonQtQCursorWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
QVariant new_QCursor() { return QCursor(); }
QVariant new_QCursor(Qt::CursorShape arg0) { return QCursor(arg0); }
QVariant new_QCursor(const QBitmap & arg0,const QBitmap & arg1,int arg2,int arg3) { return QCursor(arg0,arg1,arg2,arg3); }
QVariant new_QCursor(const QBitmap & arg0,const QBitmap & arg1,int arg2) { return QCursor(arg0,arg1,arg2); }
QVariant new_QCursor(const QBitmap & arg0,const QBitmap & arg1) { return QCursor(arg0,arg1); }
QVariant new_QCursor(const QPixmap & arg0,int arg1,int arg2) { return QCursor(arg0,arg1,arg2); }
QVariant new_QCursor(const QPixmap & arg0,int arg1) { return QCursor(arg0,arg1); }
QVariant new_QCursor(const QPixmap & arg0) { return QCursor(arg0); }
QVariant new_QCursor(const QCursor & arg0) { return QCursor(arg0); }
Qt::CursorShape shape(QCursor* obj)  const  {return obj->shape(); }
void setShape(QCursor* obj,Qt::CursorShape arg0)  {obj->setShape(arg0); }
const QBitmap* bitmap(QCursor* obj)  const  {return obj->bitmap(); }
const QBitmap* mask(QCursor* obj)  const  {return obj->mask(); }
QPixmap pixmap(QCursor* obj)  const  {return obj->pixmap(); }
QPoint hotSpot(QCursor* obj)  const  {return obj->hotSpot(); }
QPoint static_QCursor_pos()  {return QCursor::pos(); }
void static_QCursor_setPos(int arg0,int arg1)  {QCursor::setPos(arg0,arg1); }
void static_QCursor_setPos(const QPoint & arg0)  {QCursor::setPos(arg0); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qsizepolicy.h'
**
** Created: Thu 12. Apr 14:07:33 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qsizepolicy.h"
class PythonQtQSizePolicyWrapper : public QObject  {
  Q_OBJECT

public:
Q_ENUMS(PolicyFlag Policy )
enum PolicyFlag {GrowFlag = QSizePolicy::GrowFlag, 
ExpandFlag = QSizePolicy::ExpandFlag, 
ShrinkFlag = QSizePolicy::ShrinkFlag, 
IgnoreFlag = QSizePolicy::IgnoreFlag }; 
enum Policy {Fixed = QSizePolicy::Fixed, 
Minimum = QSizePolicy::Minimum, 
Maximum = QSizePolicy::Maximum, 
Preferred = QSizePolicy::Preferred, 
MinimumExpanding = QSizePolicy::MinimumExpanding, 
Expanding = QSizePolicy::Expanding, 
Ignored = QSizePolicy::Ignored }; 
public slots:
QVariant new_QSizePolicy() { return QSizePolicy(); }
Policy horizontalPolicy(QSizePolicy* obj)  const  {return (PythonQtQSizePolicyWrapper::Policy)obj->horizontalPolicy(); }
Policy verticalPolicy(QSizePolicy* obj)  const  {return (PythonQtQSizePolicyWrapper::Policy)obj->verticalPolicy(); }
void setHorizontalPolicy(QSizePolicy* obj,Policy arg0)  {obj->setHorizontalPolicy((QSizePolicy::Policy)arg0); }
void setVerticalPolicy(QSizePolicy* obj,Policy arg0)  {obj->setVerticalPolicy((QSizePolicy::Policy)arg0); }
Qt::Orientations expandingDirections(QSizePolicy* obj)  const  {return obj->expandingDirections(); }
void setHeightForWidth(QSizePolicy* obj,bool arg0)  {obj->setHeightForWidth(arg0); }
bool hasHeightForWidth(QSizePolicy* obj)  const  {return obj->hasHeightForWidth(); }
int horizontalStretch(QSizePolicy* obj)  const  {return obj->horizontalStretch(); }
int verticalStretch(QSizePolicy* obj)  const  {return obj->verticalStretch(); }
void setHorizontalStretch(QSizePolicy* obj,uchar arg0)  {obj->setHorizontalStretch(arg0); }
void setVerticalStretch(QSizePolicy* obj,uchar arg0)  {obj->setVerticalStretch(arg0); }
void transpose(QSizePolicy* obj)  {obj->transpose(); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qkeysequence.h'
**
** Created: Thu 12. Apr 14:07:34 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qkeysequence.h"
class PythonQtQKeySequenceWrapper : public QObject  {
  Q_OBJECT

public:
Q_ENUMS(StandardKey SequenceMatch SequenceFormat )
enum StandardKey {UnknownKey = QKeySequence::UnknownKey, 
HelpContents = QKeySequence::HelpContents, 
WhatsThis = QKeySequence::WhatsThis, 
Open = QKeySequence::Open, 
Close = QKeySequence::Close, 
Save = QKeySequence::Save, 
New = QKeySequence::New, 
Delete = QKeySequence::Delete, 
Cut = QKeySequence::Cut, 
Copy = QKeySequence::Copy, 
Paste = QKeySequence::Paste, 
Undo = QKeySequence::Undo, 
Redo = QKeySequence::Redo, 
Back = QKeySequence::Back, 
Forward = QKeySequence::Forward, 
Refresh = QKeySequence::Refresh, 
ZoomIn = QKeySequence::ZoomIn, 
ZoomOut = QKeySequence::ZoomOut, 
Print = QKeySequence::Print, 
AddTab = QKeySequence::AddTab, 
NextChild = QKeySequence::NextChild, 
PreviousChild = QKeySequence::PreviousChild, 
Find = QKeySequence::Find, 
FindNext = QKeySequence::FindNext, 
FindPrevious = QKeySequence::FindPrevious, 
Replace = QKeySequence::Replace, 
SelectAll = QKeySequence::SelectAll, 
Bold = QKeySequence::Bold, 
Italic = QKeySequence::Italic, 
Underline = QKeySequence::Underline, 
MoveToNextChar = QKeySequence::MoveToNextChar, 
MoveToPreviousChar = QKeySequence::MoveToPreviousChar, 
MoveToNextWord = QKeySequence::MoveToNextWord, 
MoveToPreviousWord = QKeySequence::MoveToPreviousWord, 
MoveToNextLine = QKeySequence::MoveToNextLine, 
MoveToPreviousLine = QKeySequence::MoveToPreviousLine, 
MoveToNextPage = QKeySequence::MoveToNextPage, 
MoveToPreviousPage = QKeySequence::MoveToPreviousPage, 
MoveToStartOfLine = QKeySequence::MoveToStartOfLine, 
MoveToEndOfLine = QKeySequence::MoveToEndOfLine, 
MoveToStartOfBlock = QKeySequence::MoveToStartOfBlock, 
MoveToEndOfBlock = QKeySequence::MoveToEndOfBlock, 
MoveToStartOfDocument = QKeySequence::MoveToStartOfDocument, 
MoveToEndOfDocument = QKeySequence::MoveToEndOfDocument, 
SelectNextChar = QKeySequence::SelectNextChar, 
SelectPreviousChar = QKeySequence::SelectPreviousChar, 
SelectNextWord = QKeySequence::SelectNextWord, 
SelectPreviousWord = QKeySequence::SelectPreviousWord, 
SelectNextLine = QKeySequence::SelectNextLine, 
SelectPreviousLine = QKeySequence::SelectPreviousLine, 
SelectNextPage = QKeySequence::SelectNextPage, 
SelectPreviousPage = QKeySequence::SelectPreviousPage, 
SelectStartOfLine = QKeySequence::SelectStartOfLine, 
SelectEndOfLine = QKeySequence::SelectEndOfLine, 
SelectStartOfBlock = QKeySequence::SelectStartOfBlock, 
SelectEndOfBlock = QKeySequence::SelectEndOfBlock, 
SelectStartOfDocument = QKeySequence::SelectStartOfDocument, 
SelectEndOfDocument = QKeySequence::SelectEndOfDocument, 
DeleteStartOfWord = QKeySequence::DeleteStartOfWord, 
DeleteEndOfWord = QKeySequence::DeleteEndOfWord, 
DeleteEndOfLine = QKeySequence::DeleteEndOfLine }; 
enum SequenceMatch {NoMatch = QKeySequence::NoMatch, 
PartialMatch = QKeySequence::PartialMatch, 
ExactMatch = QKeySequence::ExactMatch }; 
enum SequenceFormat {NativeText = QKeySequence::NativeText, 
PortableText = QKeySequence::PortableText }; 
public slots:
QVariant new_QKeySequence() { return QKeySequence(); }
QVariant new_QKeySequence(const QString & arg0) { return QKeySequence(arg0); }
QVariant new_QKeySequence(int arg0,int arg1,int arg2,int arg3) { return QKeySequence(arg0,arg1,arg2,arg3); }
QVariant new_QKeySequence(int arg0,int arg1,int arg2) { return QKeySequence(arg0,arg1,arg2); }
QVariant new_QKeySequence(int arg0,int arg1) { return QKeySequence(arg0,arg1); }
QVariant new_QKeySequence(int arg0) { return QKeySequence(arg0); }
QVariant new_QKeySequence(const QKeySequence & arg0) { return QKeySequence(arg0); }
QVariant new_QKeySequence(StandardKey arg0) { return QKeySequence((QKeySequence::StandardKey)arg0); }
uint count(QKeySequence* obj)  const  {return obj->count(); }
bool isEmpty(QKeySequence* obj)  const  {return obj->isEmpty(); }
QString toString(QKeySequence* obj,SequenceFormat arg0)  const  {return obj->toString((QKeySequence::SequenceFormat)arg0); }
QString toString(QKeySequence* obj)  const  {return obj->toString(); }
QKeySequence static_QKeySequence_fromString(const QString & arg0,SequenceFormat arg1)  {return QKeySequence::fromString(arg0,(QKeySequence::SequenceFormat)arg1); }
QKeySequence static_QKeySequence_fromString(const QString & arg0)  {return QKeySequence::fromString(arg0); }
SequenceMatch matches(QKeySequence* obj,const QKeySequence & arg0)  const  {return (PythonQtQKeySequenceWrapper::SequenceMatch)obj->matches(arg0); }
QKeySequence static_QKeySequence_mnemonic(const QString & arg0)  {return QKeySequence::mnemonic(arg0); }
QList<QKeySequence> static_QKeySequence_keyBindings(StandardKey arg0)  {return QKeySequence::keyBindings((QKeySequence::StandardKey)arg0); }
bool isDetached(QKeySequence* obj)  const  {return obj->isDetached(); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qpen.h'
**
** Created: Thu 12. Apr 14:07:35 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qpen.h"
class PythonQtQPenWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
QVariant new_QPen() { return QPen(); }
QVariant new_QPen(Qt::PenStyle arg0) { return QPen(arg0); }
QVariant new_QPen(const QColor & arg0) { return QPen(arg0); }
QVariant new_QPen(const QBrush & arg0,qreal arg1,Qt::PenStyle arg2,Qt::PenCapStyle arg3,Qt::PenJoinStyle arg4) { return QPen(arg0,arg1,arg2,arg3,arg4); }
QVariant new_QPen(const QBrush & arg0,qreal arg1,Qt::PenStyle arg2,Qt::PenCapStyle arg3) { return QPen(arg0,arg1,arg2,arg3); }
QVariant new_QPen(const QBrush & arg0,qreal arg1,Qt::PenStyle arg2) { return QPen(arg0,arg1,arg2); }
QVariant new_QPen(const QBrush & arg0,qreal arg1) { return QPen(arg0,arg1); }
QVariant new_QPen(const QPen & arg0) { return QPen(arg0); }
Qt::PenStyle style(QPen* obj)  const  {return obj->style(); }
void setStyle(QPen* obj,Qt::PenStyle arg0)  {obj->setStyle(arg0); }
QVector<qreal> dashPattern(QPen* obj)  const  {return obj->dashPattern(); }
void setDashPattern(QPen* obj,const QVector<qreal> & arg0)  {obj->setDashPattern(arg0); }
qreal miterLimit(QPen* obj)  const  {return obj->miterLimit(); }
void setMiterLimit(QPen* obj,qreal arg0)  {obj->setMiterLimit(arg0); }
qreal widthF(QPen* obj)  const  {return obj->widthF(); }
void setWidthF(QPen* obj,qreal arg0)  {obj->setWidthF(arg0); }
int width(QPen* obj)  const  {return obj->width(); }
void setWidth(QPen* obj,int arg0)  {obj->setWidth(arg0); }
QColor color(QPen* obj)  const  {return obj->color(); }
void setColor(QPen* obj,const QColor & arg0)  {obj->setColor(arg0); }
QBrush brush(QPen* obj)  const  {return obj->brush(); }
void setBrush(QPen* obj,const QBrush & arg0)  {obj->setBrush(arg0); }
bool isSolid(QPen* obj)  const  {return obj->isSolid(); }
Qt::PenCapStyle capStyle(QPen* obj)  const  {return obj->capStyle(); }
void setCapStyle(QPen* obj,Qt::PenCapStyle arg0)  {obj->setCapStyle(arg0); }
Qt::PenJoinStyle joinStyle(QPen* obj)  const  {return obj->joinStyle(); }
void setJoinStyle(QPen* obj,Qt::PenJoinStyle arg0)  {obj->setJoinStyle(arg0); }
bool isDetached(QPen* obj)  {return obj->isDetached(); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qtextformat.h'
**
** Created: Thu 12. Apr 14:07:35 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qtextformat.h"
class PythonQtQTextLengthWrapper : public QObject  {
  Q_OBJECT

public:
Q_ENUMS(Type )
enum Type {VariableLength = QTextLength::VariableLength, 
FixedLength = QTextLength::FixedLength, 
PercentageLength = QTextLength::PercentageLength }; 
public slots:
QVariant new_QTextLength() { return QTextLength(); }
QVariant new_QTextLength(Type arg0,qreal arg1) { return QTextLength((QTextLength::Type)arg0,arg1); }
Type type(QTextLength* obj)  const  {return (PythonQtQTextLengthWrapper::Type)obj->type(); }
qreal value(QTextLength* obj,qreal arg0)  const  {return obj->value(arg0); }
qreal rawValue(QTextLength* obj)  const  {return obj->rawValue(); }

};

class PythonQtQTextFormatWrapper : public QObject  {
  Q_OBJECT

public:
Q_ENUMS(FormatType Property ObjectTypes PageBreakFlag )
enum FormatType {InvalidFormat = QTextFormat::InvalidFormat, 
BlockFormat = QTextFormat::BlockFormat, 
CharFormat = QTextFormat::CharFormat, 
ListFormat = QTextFormat::ListFormat, 
TableFormat = QTextFormat::TableFormat, 
FrameFormat = QTextFormat::FrameFormat, 
UserFormat = QTextFormat::UserFormat }; 
enum Property {ObjectIndex = QTextFormat::ObjectIndex, 
CssFloat = QTextFormat::CssFloat, 
LayoutDirection = QTextFormat::LayoutDirection, 
OutlinePen = QTextFormat::OutlinePen, 
BackgroundBrush = QTextFormat::BackgroundBrush, 
ForegroundBrush = QTextFormat::ForegroundBrush, 
BlockAlignment = QTextFormat::BlockAlignment, 
BlockTopMargin = QTextFormat::BlockTopMargin, 
BlockBottomMargin = QTextFormat::BlockBottomMargin, 
BlockLeftMargin = QTextFormat::BlockLeftMargin, 
BlockRightMargin = QTextFormat::BlockRightMargin, 
TextIndent = QTextFormat::TextIndent, 
BlockIndent = QTextFormat::BlockIndent, 
BlockNonBreakableLines = QTextFormat::BlockNonBreakableLines, 
BlockTrailingHorizontalRulerWidth = QTextFormat::BlockTrailingHorizontalRulerWidth, 
FontFamily = QTextFormat::FontFamily, 
FontPointSize = QTextFormat::FontPointSize, 
FontSizeAdjustment = QTextFormat::FontSizeAdjustment, 
FontSizeIncrement = QTextFormat::FontSizeIncrement, 
FontWeight = QTextFormat::FontWeight, 
FontItalic = QTextFormat::FontItalic, 
FontUnderline = QTextFormat::FontUnderline, 
FontOverline = QTextFormat::FontOverline, 
FontStrikeOut = QTextFormat::FontStrikeOut, 
FontFixedPitch = QTextFormat::FontFixedPitch, 
FontPixelSize = QTextFormat::FontPixelSize, 
TextUnderlineColor = QTextFormat::TextUnderlineColor, 
TextVerticalAlignment = QTextFormat::TextVerticalAlignment, 
TextOutline = QTextFormat::TextOutline, 
TextUnderlineStyle = QTextFormat::TextUnderlineStyle, 
IsAnchor = QTextFormat::IsAnchor, 
AnchorHref = QTextFormat::AnchorHref, 
AnchorName = QTextFormat::AnchorName, 
ObjectType = QTextFormat::ObjectType, 
ListStyle = QTextFormat::ListStyle, 
ListIndent = QTextFormat::ListIndent, 
FrameBorder = QTextFormat::FrameBorder, 
FrameMargin = QTextFormat::FrameMargin, 
FramePadding = QTextFormat::FramePadding, 
FrameWidth = QTextFormat::FrameWidth, 
FrameHeight = QTextFormat::FrameHeight, 
TableColumns = QTextFormat::TableColumns, 
TableColumnWidthConstraints = QTextFormat::TableColumnWidthConstraints, 
TableCellSpacing = QTextFormat::TableCellSpacing, 
TableCellPadding = QTextFormat::TableCellPadding, 
TableHeaderRowCount = QTextFormat::TableHeaderRowCount, 
TableCellRowSpan = QTextFormat::TableCellRowSpan, 
TableCellColumnSpan = QTextFormat::TableCellColumnSpan, 
ImageName = QTextFormat::ImageName, 
ImageWidth = QTextFormat::ImageWidth, 
ImageHeight = QTextFormat::ImageHeight, 
FullWidthSelection = QTextFormat::FullWidthSelection, 
PageBreakPolicy = QTextFormat::PageBreakPolicy, 
UserProperty = QTextFormat::UserProperty }; 
enum ObjectTypes {NoObject = QTextFormat::NoObject, 
ImageObject = QTextFormat::ImageObject, 
TableObject = QTextFormat::TableObject, 
UserObject = QTextFormat::UserObject }; 
enum PageBreakFlag {PageBreak_Auto = QTextFormat::PageBreak_Auto, 
PageBreak_AlwaysBefore = QTextFormat::PageBreak_AlwaysBefore, 
PageBreak_AlwaysAfter = QTextFormat::PageBreak_AlwaysAfter }; 
Q_DECLARE_FLAGS(PageBreakFlags, PageBreakFlag)
public slots:
QVariant new_QTextFormat(int arg0) { return QTextFormat(arg0); }
QVariant new_QTextFormat(const QTextFormat & arg0) { return QTextFormat(arg0); }
void merge(QTextFormat* obj,const QTextFormat & arg0)  {obj->merge(arg0); }
bool isValid(QTextFormat* obj)  const  {return obj->isValid(); }
int type(QTextFormat* obj)  const  {return obj->type(); }
int objectIndex(QTextFormat* obj)  const  {return obj->objectIndex(); }
void setObjectIndex(QTextFormat* obj,int arg0)  {obj->setObjectIndex(arg0); }
QVariant property(QTextFormat* obj,int arg0)  const  {return obj->property(arg0); }
void setProperty(QTextFormat* obj,int arg0,const QVariant & arg1)  {obj->setProperty(arg0,arg1); }
void clearProperty(QTextFormat* obj,int arg0)  {obj->clearProperty(arg0); }
bool hasProperty(QTextFormat* obj,int arg0)  const  {return obj->hasProperty(arg0); }
bool boolProperty(QTextFormat* obj,int arg0)  const  {return obj->boolProperty(arg0); }
int intProperty(QTextFormat* obj,int arg0)  const  {return obj->intProperty(arg0); }
qreal doubleProperty(QTextFormat* obj,int arg0)  const  {return obj->doubleProperty(arg0); }
QString stringProperty(QTextFormat* obj,int arg0)  const  {return obj->stringProperty(arg0); }
QColor colorProperty(QTextFormat* obj,int arg0)  const  {return obj->colorProperty(arg0); }
QPen penProperty(QTextFormat* obj,int arg0)  const  {return obj->penProperty(arg0); }
QBrush brushProperty(QTextFormat* obj,int arg0)  const  {return obj->brushProperty(arg0); }
QTextLength lengthProperty(QTextFormat* obj,int arg0)  const  {return obj->lengthProperty(arg0); }
QVector<QTextLength> lengthVectorProperty(QTextFormat* obj,int arg0)  const  {return obj->lengthVectorProperty(arg0); }
void setProperty(QTextFormat* obj,int arg0,const QVector<QTextLength> & arg1)  {obj->setProperty(arg0,arg1); }
QMap<int,QVariant> properties(QTextFormat* obj)  const  {return obj->properties(); }
void setObjectType(QTextFormat* obj,int arg0)  {obj->setObjectType(arg0); }
int objectType(QTextFormat* obj)  const  {return obj->objectType(); }
bool isCharFormat(QTextFormat* obj)  const  {return obj->isCharFormat(); }
bool isBlockFormat(QTextFormat* obj)  const  {return obj->isBlockFormat(); }
bool isListFormat(QTextFormat* obj)  const  {return obj->isListFormat(); }
bool isFrameFormat(QTextFormat* obj)  const  {return obj->isFrameFormat(); }
bool isImageFormat(QTextFormat* obj)  const  {return obj->isImageFormat(); }
bool isTableFormat(QTextFormat* obj)  const  {return obj->isTableFormat(); }
QTextBlockFormat toBlockFormat(QTextFormat* obj)  const  {return obj->toBlockFormat(); }
QTextCharFormat toCharFormat(QTextFormat* obj)  const  {return obj->toCharFormat(); }
QTextListFormat toListFormat(QTextFormat* obj)  const  {return obj->toListFormat(); }
QTextTableFormat toTableFormat(QTextFormat* obj)  const  {return obj->toTableFormat(); }
QTextFrameFormat toFrameFormat(QTextFormat* obj)  const  {return obj->toFrameFormat(); }
QTextImageFormat toImageFormat(QTextFormat* obj)  const  {return obj->toImageFormat(); }
void setLayoutDirection(QTextFormat* obj,Qt::LayoutDirection arg0)  {obj->setLayoutDirection(arg0); }
Qt::LayoutDirection layoutDirection(QTextFormat* obj)  const  {return obj->layoutDirection(); }
void setBackground(QTextFormat* obj,const QBrush & arg0)  {obj->setBackground(arg0); }
QBrush background(QTextFormat* obj)  const  {return obj->background(); }
void clearBackground(QTextFormat* obj)  {obj->clearBackground(); }
void setForeground(QTextFormat* obj,const QBrush & arg0)  {obj->setForeground(arg0); }
QBrush foreground(QTextFormat* obj)  const  {return obj->foreground(); }
void clearForeground(QTextFormat* obj)  {obj->clearForeground(); }

};

/****************************************************************************
** Meta object code from reading C++ file 'qmatrix.h'
**
** Created: Thu 12. Apr 14:07:35 2007
**      by: The Qt Meta Object Compiler version 59 (Qt 4.2.3)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include "qmatrix.h"
class PythonQtQMatrixWrapper : public QObject  {
  Q_OBJECT

public:
public slots:
QVariant new_QMatrix() { return QMatrix(); }
QVariant new_QMatrix(qreal arg0,qreal arg1,qreal arg2,qreal arg3,qreal arg4,qreal arg5) { return QMatrix(arg0,arg1,arg2,arg3,arg4,arg5); }
QVariant new_QMatrix(const QMatrix & arg0) { return QMatrix(arg0); }
void setMatrix(QMatrix* obj,qreal arg0,qreal arg1,qreal arg2,qreal arg3,qreal arg4,qreal arg5)  {obj->setMatrix(arg0,arg1,arg2,arg3,arg4,arg5); }
qreal m11(QMatrix* obj)  const  {return obj->m11(); }
qreal m12(QMatrix* obj)  const  {return obj->m12(); }
qreal m21(QMatrix* obj)  const  {return obj->m21(); }
qreal m22(QMatrix* obj)  const  {return obj->m22(); }
qreal dx(QMatrix* obj)  const  {return obj->dx(); }
qreal dy(QMatrix* obj)  const  {return obj->dy(); }
void map(QMatrix* obj,int arg0,int arg1,int * arg2,int * arg3)  const  {obj->map(arg0,arg1,arg2,arg3); }
void map(QMatrix* obj,qreal arg0,qreal arg1,qreal * arg2,qreal * arg3)  const  {obj->map(arg0,arg1,arg2,arg3); }
QRect mapRect(QMatrix* obj,const QRect & arg0)  const  {return obj->mapRect(arg0); }
QRectF mapRect(QMatrix* obj,const QRectF & arg0)  const  {return obj->mapRect(arg0); }
QPoint map(QMatrix* obj,const QPoint & arg0)  const  {return obj->map(arg0); }
QPointF map(QMatrix* obj,const QPointF & arg0)  const  {return obj->map(arg0); }
QLine map(QMatrix* obj,const QLine & arg0)  const  {return obj->map(arg0); }
QLineF map(QMatrix* obj,const QLineF & arg0)  const  {return obj->map(arg0); }
QPolygonF map(QMatrix* obj,const QPolygonF & arg0)  const  {return obj->map(arg0); }
QPolygon map(QMatrix* obj,const QPolygon & arg0)  const  {return obj->map(arg0); }
QRegion map(QMatrix* obj,const QRegion & arg0)  const  {return obj->map(arg0); }
QPainterPath map(QMatrix* obj,const QPainterPath & arg0)  const  {return obj->map(arg0); }
QPolygon mapToPolygon(QMatrix* obj,const QRect & arg0)  const  {return obj->mapToPolygon(arg0); }
void reset(QMatrix* obj)  {obj->reset(); }
bool isIdentity(QMatrix* obj)  const  {return obj->isIdentity(); }
void translate(QMatrix* obj,qreal arg0,qreal arg1)  {obj->translate(arg0,arg1); }
void scale(QMatrix* obj,qreal arg0,qreal arg1)  {obj->scale(arg0,arg1); }
void shear(QMatrix* obj,qreal arg0,qreal arg1)  {obj->shear(arg0,arg1); }
void rotate(QMatrix* obj,qreal arg0)  {obj->rotate(arg0); }
bool isInvertible(QMatrix* obj)  const  {return obj->isInvertible(); }
qreal det(QMatrix* obj)  const  {return obj->det(); }
QMatrix inverted(QMatrix* obj,bool * arg0)  const  {return obj->inverted(arg0); }
QMatrix inverted(QMatrix* obj)  const  {return obj->inverted(); }

};

