#include "com_trolltech_qt_gui_builtin0.h"
#include <PythonQtConversion.h>
#include <PythonQtMethodInfo.h>
#include <PythonQtSignalReceiver.h>
#include <QBrush>
#include <QMatrix>
#include <QPixmap>
#include <QStringList>
#include <QVariant>
#include <qbitmap.h>
#include <qbrush.h>
#include <qbytearray.h>
#include <qcolor.h>
#include <qcolorspace.h>
#include <qcolortransform.h>
#include <qcursor.h>
#include <qdatastream.h>
#include <qfont.h>
#include <qicon.h>
#include <qiconengine.h>
#include <qimage.h>
#include <qimagereader.h>
#include <qimagewriter.h>
#include <qiodevice.h>
#include <qkeysequence.h>
#include <qline.h>
#include <qlist.h>
#include <qmatrix.h>
#include <qmatrix4x4.h>
#include <qobject.h>
#include <qpaintdevice.h>
#include <qpaintengine.h>
#include <qpainter.h>
#include <qpainterpath.h>
#include <qpalette.h>
#include <qpen.h>
#include <qpixelformat.h>
#include <qpixmap.h>
#include <qpoint.h>
#include <qpolygon.h>
#include <qquaternion.h>
#include <qrect.h>
#include <qregion.h>
#include <qrgba64.h>
#include <qscreen.h>
#include <qsize.h>
#include <qsizepolicy.h>
#include <qstringlist.h>
#include <qtextformat.h>
#include <qtransform.h>
#include <qvector.h>
#include <qvector3d.h>
#include <qvector4d.h>
#include <qwindow.h>

PythonQtShell_QBitmap::~PythonQtShell_QBitmap() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
int  PythonQtShell_QBitmap::devType() const
{
if (_wrapper) {
  PYTHONQT_GIL_SCOPE
  if (Py_REFCNT((PyObject*)_wrapper) > 0) {
    static PyObject* name = PyUnicode_FromString("devType");
    PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
    if (obj) {
      static const char* argumentList[] ={"int"};
      static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      int returnValue{};
      void* args[1] = {nullptr};
      PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
      if (result) {
        args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue);
        if (args[0]!=&returnValue) {
          if (args[0]==nullptr) {
            PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
          } else {
            returnValue = *((int*)args[0]);
          }
        }
      }
      if (result) { Py_DECREF(result); }
      Py_DECREF(obj);
      return returnValue;
    } else {
      PyErr_Clear();
    }
  }
}
  return QBitmap::devType();
}
void PythonQtShell_QBitmap::initPainter(QPainter*  painter0) const
{
if (_wrapper) {
  PYTHONQT_GIL_SCOPE
  if (Py_REFCNT((PyObject*)_wrapper) > 0) {
    static PyObject* name = PyUnicode_FromString("initPainter");
    PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
    if (obj) {
      static const char* argumentList[] ={"" , "QPainter*"};
      static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      void* args[2] = {nullptr, (void*)&painter0};
      PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
      if (result) { Py_DECREF(result); }
      Py_DECREF(obj);
      return;
    } else {
      PyErr_Clear();
    }
  }
}
  QBitmap::initPainter(painter0);
}
int  PythonQtShell_QBitmap::metric(QPaintDevice::PaintDeviceMetric  arg__1) const
{
if (_wrapper) {
  PYTHONQT_GIL_SCOPE
  if (Py_REFCNT((PyObject*)_wrapper) > 0) {
    static PyObject* name = PyUnicode_FromString("metric");
    PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
    if (obj) {
      static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
      static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      int returnValue{};
      void* args[2] = {nullptr, (void*)&arg__1};
      PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
      if (result) {
        args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue);
        if (args[0]!=&returnValue) {
          if (args[0]==nullptr) {
            PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
          } else {
            returnValue = *((int*)args[0]);
          }
        }
      }
      if (result) { Py_DECREF(result); }
      Py_DECREF(obj);
      return returnValue;
    } else {
      PyErr_Clear();
    }
  }
}
  return QBitmap::metric(arg__1);
}
QPaintEngine*  PythonQtShell_QBitmap::paintEngine() const
{
if (_wrapper) {
  PYTHONQT_GIL_SCOPE
  if (Py_REFCNT((PyObject*)_wrapper) > 0) {
    static PyObject* name = PyUnicode_FromString("paintEngine");
    PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
    if (obj) {
      static const char* argumentList[] ={"QPaintEngine*"};
      static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QPaintEngine* returnValue{};
      void* args[1] = {nullptr};
      PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
      if (result) {
        args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue);
        if (args[0]!=&returnValue) {
          if (args[0]==nullptr) {
            PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
          } else {
            returnValue = *((QPaintEngine**)args[0]);
          }
        }
      }
      if (result) { Py_DECREF(result); }
      Py_DECREF(obj);
      return returnValue;
    } else {
      PyErr_Clear();
    }
  }
}
  return QBitmap::paintEngine();
}
QPaintDevice*  PythonQtShell_QBitmap::redirected(QPoint*  offset0) const
{
if (_wrapper) {
  PYTHONQT_GIL_SCOPE
  if (Py_REFCNT((PyObject*)_wrapper) > 0) {
    static PyObject* name = PyUnicode_FromString("redirected");
    PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
    if (obj) {
      static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
      static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      QPaintDevice* returnValue{};
      void* args[2] = {nullptr, (void*)&offset0};
      PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
      if (result) {
        args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue);
        if (args[0]!=&returnValue) {
          if (args[0]==nullptr) {
            PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
          } else {
            returnValue = *((QPaintDevice**)args[0]);
          }
        }
      }
      if (result) { Py_DECREF(result); }
      Py_DECREF(obj);
      return returnValue;
    } else {
      PyErr_Clear();
    }
  }
}
  return QBitmap::redirected(offset0);
}
QPainter*  PythonQtShell_QBitmap::sharedPainter() const
{
if (_wrapper) {
  PYTHONQT_GIL_SCOPE
  if (Py_REFCNT((PyObject*)_wrapper) > 0) {
    static PyObject* name = PyUnicode_FromString("sharedPainter");
    PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
    if (obj) {
      static const char* argumentList[] ={"QPainter*"};
      static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QPainter* returnValue{};
      void* args[1] = {nullptr};
      PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
      if (result) {
        args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue);
        if (args[0]!=&returnValue) {
          if (args[0]==nullptr) {
            PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
          } else {
            returnValue = *((QPainter**)args[0]);
          }
        }
      }
      if (result) { Py_DECREF(result); }
      Py_DECREF(obj);
      return returnValue;
    } else {
      PyErr_Clear();
    }
  }
}
  return QBitmap::sharedPainter();
}
QBitmap* PythonQtWrapper_QBitmap::new_QBitmap()
{
return new PythonQtShell_QBitmap(); }

QBitmap* PythonQtWrapper_QBitmap::new_QBitmap(const QBitmap&  other)
{
return new PythonQtShell_QBitmap(other); }

QBitmap* PythonQtWrapper_QBitmap::new_QBitmap(const QPixmap&  arg__1)
{
return new PythonQtShell_QBitmap(arg__1); }

QBitmap* PythonQtWrapper_QBitmap::new_QBitmap(const QSize&  arg__1)
{
return new PythonQtShell_QBitmap(arg__1); }

QBitmap* PythonQtWrapper_QBitmap::new_QBitmap(const QString&  fileName, const char*  format)
{
return new PythonQtShell_QBitmap(fileName, format); }

QBitmap* PythonQtWrapper_QBitmap::new_QBitmap(int  w, int  h)
{
return new PythonQtShell_QBitmap(w, h); }

void PythonQtWrapper_QBitmap::clear(QBitmap* theWrappedObject)
{
  ( theWrappedObject->clear());
}

QBitmap  PythonQtWrapper_QBitmap::static_QBitmap_fromImage(const QImage&  image, Qt::ImageConversionFlags  flags)
{
  return (QBitmap::fromImage(image, flags));
}

QBitmap*  PythonQtWrapper_QBitmap::operator_assign(QBitmap* theWrappedObject, const QBitmap&  other)
{
  return &( (*theWrappedObject)= other);
}

void PythonQtWrapper_QBitmap::swap(QBitmap* theWrappedObject, QBitmap&  other)
{
  ( theWrappedObject->swap(other));
}

QBitmap  PythonQtWrapper_QBitmap::transformed(QBitmap* theWrappedObject, const QMatrix&  arg__1) const
{
  return ( theWrappedObject->transformed(arg__1));
}

QBitmap  PythonQtWrapper_QBitmap::transformed(QBitmap* theWrappedObject, const QTransform&  matrix) const
{
  return ( theWrappedObject->transformed(matrix));
}



QBrush* PythonQtWrapper_QBrush::new_QBrush()
{
return new QBrush(); }

QBrush* PythonQtWrapper_QBrush::new_QBrush(Qt::BrushStyle  bs)
{
return new QBrush(bs); }

QBrush* PythonQtWrapper_QBrush::new_QBrush(Qt::GlobalColor  color, const QPixmap&  pixmap)
{
return new QBrush(color, pixmap); }

QBrush* PythonQtWrapper_QBrush::new_QBrush(const QBrush&  brush)
{
return new QBrush(brush); }

QBrush* PythonQtWrapper_QBrush::new_QBrush(const QColor&  color, Qt::BrushStyle  bs)
{
return new QBrush(color, bs); }

QBrush* PythonQtWrapper_QBrush::new_QBrush(const QColor&  color, const QPixmap&  pixmap)
{
return new QBrush(color, pixmap); }

QBrush* PythonQtWrapper_QBrush::new_QBrush(const QGradient&  gradient)
{
return new QBrush(gradient); }

QBrush* PythonQtWrapper_QBrush::new_QBrush(const QImage&  image)
{
return new QBrush(image); }

QBrush* PythonQtWrapper_QBrush::new_QBrush(const QPixmap&  pixmap)
{
return new QBrush(pixmap); }

const QColor*  PythonQtWrapper_QBrush::color(QBrush* theWrappedObject) const
{
  return &( theWrappedObject->color());
}

const QGradient*  PythonQtWrapper_QBrush::gradient(QBrush* theWrappedObject) const
{
  return ( theWrappedObject->gradient());
}

bool  PythonQtWrapper_QBrush::isOpaque(QBrush* theWrappedObject) const
{
  return ( theWrappedObject->isOpaque());
}

const QMatrix*  PythonQtWrapper_QBrush::matrix(QBrush* theWrappedObject) const
{
  return &( theWrappedObject->matrix());
}

bool  PythonQtWrapper_QBrush::__ne__(QBrush* theWrappedObject, const QBrush&  b) const
{
  return ( (*theWrappedObject)!= b);
}

void PythonQtWrapper_QBrush::writeTo(QBrush* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 <<  (*theWrappedObject);
}

bool  PythonQtWrapper_QBrush::__eq__(QBrush* theWrappedObject, const QBrush&  b) const
{
  return ( (*theWrappedObject)== b);
}

void PythonQtWrapper_QBrush::readFrom(QBrush* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 >>  (*theWrappedObject);
}

void PythonQtWrapper_QBrush::setColor(QBrush* theWrappedObject, Qt::GlobalColor  color)
{
  ( theWrappedObject->setColor(color));
}

void PythonQtWrapper_QBrush::setColor(QBrush* theWrappedObject, const QColor&  color)
{
  ( theWrappedObject->setColor(color));
}

void PythonQtWrapper_QBrush::setMatrix(QBrush* theWrappedObject, const QMatrix&  mat)
{
  ( theWrappedObject->setMatrix(mat));
}

void PythonQtWrapper_QBrush::setStyle(QBrush* theWrappedObject, Qt::BrushStyle  arg__1)
{
  ( theWrappedObject->setStyle(arg__1));
}

void PythonQtWrapper_QBrush::setTexture(QBrush* theWrappedObject, const QPixmap&  pixmap)
{
  ( theWrappedObject->setTexture(pixmap));
}

void PythonQtWrapper_QBrush::setTextureImage(QBrush* theWrappedObject, const QImage&  image)
{
  ( theWrappedObject->setTextureImage(image));
}

void PythonQtWrapper_QBrush::setTransform(QBrush* theWrappedObject, const QTransform&  arg__1)
{
  ( theWrappedObject->setTransform(arg__1));
}

Qt::BrushStyle  PythonQtWrapper_QBrush::style(QBrush* theWrappedObject) const
{
  return ( theWrappedObject->style());
}

void PythonQtWrapper_QBrush::swap(QBrush* theWrappedObject, QBrush&  other)
{
  ( theWrappedObject->swap(other));
}

QPixmap  PythonQtWrapper_QBrush::texture(QBrush* theWrappedObject) const
{
  return ( theWrappedObject->texture());
}

QImage  PythonQtWrapper_QBrush::textureImage(QBrush* theWrappedObject) const
{
  return ( theWrappedObject->textureImage());
}

QTransform  PythonQtWrapper_QBrush::transform(QBrush* theWrappedObject) const
{
  return ( theWrappedObject->transform());
}

QString PythonQtWrapper_QBrush::py_toString(QBrush* obj) {
  QString result;
  QDebug d(&result);
  d << *obj;
  return result;
}



QColor* PythonQtWrapper_QColor::new_QColor()
{
return new QColor(); }

QColor* PythonQtWrapper_QColor::new_QColor(QRgba64  rgba64)
{
return new QColor(rgba64); }

QColor* PythonQtWrapper_QColor::new_QColor(Qt::GlobalColor  color)
{
return new QColor(color); }

QColor* PythonQtWrapper_QColor::new_QColor(const QColor&  color)
{
return new QColor(color); }

QColor* PythonQtWrapper_QColor::new_QColor(const QString&  name)
{
return new QColor(name); }

QColor* PythonQtWrapper_QColor::new_QColor(int  r, int  g, int  b, int  a)
{
return new QColor(r, g, b, a); }

QColor* PythonQtWrapper_QColor::new_QColor(unsigned int  rgb)
{
return new QColor(rgb); }

int  PythonQtWrapper_QColor::alpha(QColor* theWrappedObject) const
{
  return ( theWrappedObject->alpha());
}

qreal  PythonQtWrapper_QColor::alphaF(QColor* theWrappedObject) const
{
  return ( theWrappedObject->alphaF());
}

int  PythonQtWrapper_QColor::black(QColor* theWrappedObject) const
{
  return ( theWrappedObject->black());
}

qreal  PythonQtWrapper_QColor::blackF(QColor* theWrappedObject) const
{
  return ( theWrappedObject->blackF());
}

int  PythonQtWrapper_QColor::blue(QColor* theWrappedObject) const
{
  return ( theWrappedObject->blue());
}

qreal  PythonQtWrapper_QColor::blueF(QColor* theWrappedObject) const
{
  return ( theWrappedObject->blueF());
}

QStringList  PythonQtWrapper_QColor::static_QColor_colorNames()
{
  return (QColor::colorNames());
}

QColor  PythonQtWrapper_QColor::convertTo(QColor* theWrappedObject, QColor::Spec  colorSpec) const
{
  return ( theWrappedObject->convertTo(colorSpec));
}

int  PythonQtWrapper_QColor::cyan(QColor* theWrappedObject) const
{
  return ( theWrappedObject->cyan());
}

qreal  PythonQtWrapper_QColor::cyanF(QColor* theWrappedObject) const
{
  return ( theWrappedObject->cyanF());
}

QColor  PythonQtWrapper_QColor::darker(QColor* theWrappedObject, int  f) const
{
  return ( theWrappedObject->darker(f));
}

QColor  PythonQtWrapper_QColor::static_QColor_fromCmyk(int  c, int  m, int  y, int  k, int  a)
{
  return (QColor::fromCmyk(c, m, y, k, a));
}

QColor  PythonQtWrapper_QColor::static_QColor_fromCmykF(qreal  c, qreal  m, qreal  y, qreal  k, qreal  a)
{
  return (QColor::fromCmykF(c, m, y, k, a));
}

QColor  PythonQtWrapper_QColor::static_QColor_fromHsl(int  h, int  s, int  l, int  a)
{
  return (QColor::fromHsl(h, s, l, a));
}

QColor  PythonQtWrapper_QColor::static_QColor_fromHslF(qreal  h, qreal  s, qreal  l, qreal  a)
{
  return (QColor::fromHslF(h, s, l, a));
}

QColor  PythonQtWrapper_QColor::static_QColor_fromHsv(int  h, int  s, int  v, int  a)
{
  return (QColor::fromHsv(h, s, v, a));
}

QColor  PythonQtWrapper_QColor::static_QColor_fromHsvF(qreal  h, qreal  s, qreal  v, qreal  a)
{
  return (QColor::fromHsvF(h, s, v, a));
}

QColor  PythonQtWrapper_QColor::static_QColor_fromRgb(int  r, int  g, int  b, int  a)
{
  return (QColor::fromRgb(r, g, b, a));
}

QColor  PythonQtWrapper_QColor::static_QColor_fromRgb(unsigned int  rgb)
{
  return (QColor::fromRgb(rgb));
}

QColor  PythonQtWrapper_QColor::static_QColor_fromRgbF(qreal  r, qreal  g, qreal  b, qreal  a)
{
  return (QColor::fromRgbF(r, g, b, a));
}

QColor  PythonQtWrapper_QColor::static_QColor_fromRgba(unsigned int  rgba)
{
  return (QColor::fromRgba(rgba));
}

QColor  PythonQtWrapper_QColor::static_QColor_fromRgba64(QRgba64  rgba)
{
  return (QColor::fromRgba64(rgba));
}

QColor  PythonQtWrapper_QColor::static_QColor_fromRgba64(ushort  r, ushort  g, ushort  b, ushort  a)
{
  return (QColor::fromRgba64(r, g, b, a));
}

void PythonQtWrapper_QColor::getCmyk(QColor* theWrappedObject, int*  c, int*  m, int*  y, int*  k, int*  a) const
{
  ( theWrappedObject->getCmyk(c, m, y, k, a));
}

void PythonQtWrapper_QColor::getCmykF(QColor* theWrappedObject, qreal*  c, qreal*  m, qreal*  y, qreal*  k, qreal*  a) const
{
  ( theWrappedObject->getCmykF(c, m, y, k, a));
}

void PythonQtWrapper_QColor::getHsl(QColor* theWrappedObject, int*  h, int*  s, int*  l, int*  a) const
{
  ( theWrappedObject->getHsl(h, s, l, a));
}

void PythonQtWrapper_QColor::getHslF(QColor* theWrappedObject, qreal*  h, qreal*  s, qreal*  l, qreal*  a) const
{
  ( theWrappedObject->getHslF(h, s, l, a));
}

int  PythonQtWrapper_QColor::green(QColor* theWrappedObject) const
{
  return ( theWrappedObject->green());
}

qreal  PythonQtWrapper_QColor::greenF(QColor* theWrappedObject) const
{
  return ( theWrappedObject->greenF());
}

int  PythonQtWrapper_QColor::hslHue(QColor* theWrappedObject) const
{
  return ( theWrappedObject->hslHue());
}

qreal  PythonQtWrapper_QColor::hslHueF(QColor* theWrappedObject) const
{
  return ( theWrappedObject->hslHueF());
}

int  PythonQtWrapper_QColor::hslSaturation(QColor* theWrappedObject) const
{
  return ( theWrappedObject->hslSaturation());
}

qreal  PythonQtWrapper_QColor::hslSaturationF(QColor* theWrappedObject) const
{
  return ( theWrappedObject->hslSaturationF());
}

int  PythonQtWrapper_QColor::hsvHue(QColor* theWrappedObject) const
{
  return ( theWrappedObject->hsvHue());
}

qreal  PythonQtWrapper_QColor::hsvHueF(QColor* theWrappedObject) const
{
  return ( theWrappedObject->hsvHueF());
}

int  PythonQtWrapper_QColor::hsvSaturation(QColor* theWrappedObject) const
{
  return ( theWrappedObject->hsvSaturation());
}

qreal  PythonQtWrapper_QColor::hsvSaturationF(QColor* theWrappedObject) const
{
  return ( theWrappedObject->hsvSaturationF());
}

int  PythonQtWrapper_QColor::hue(QColor* theWrappedObject) const
{
  return ( theWrappedObject->hue());
}

qreal  PythonQtWrapper_QColor::hueF(QColor* theWrappedObject) const
{
  return ( theWrappedObject->hueF());
}

bool  PythonQtWrapper_QColor::isValid(QColor* theWrappedObject) const
{
  return ( theWrappedObject->isValid());
}

bool  PythonQtWrapper_QColor::static_QColor_isValidColor(const QString&  name)
{
  return (QColor::isValidColor(name));
}

QColor  PythonQtWrapper_QColor::lighter(QColor* theWrappedObject, int  f) const
{
  return ( theWrappedObject->lighter(f));
}

int  PythonQtWrapper_QColor::lightness(QColor* theWrappedObject) const
{
  return ( theWrappedObject->lightness());
}

qreal  PythonQtWrapper_QColor::lightnessF(QColor* theWrappedObject) const
{
  return ( theWrappedObject->lightnessF());
}

int  PythonQtWrapper_QColor::magenta(QColor* theWrappedObject) const
{
  return ( theWrappedObject->magenta());
}

qreal  PythonQtWrapper_QColor::magentaF(QColor* theWrappedObject) const
{
  return ( theWrappedObject->magentaF());
}

QString  PythonQtWrapper_QColor::name(QColor* theWrappedObject) const
{
  return ( theWrappedObject->name());
}

QString  PythonQtWrapper_QColor::name(QColor* theWrappedObject, QColor::NameFormat  format) const
{
  return ( theWrappedObject->name(format));
}

bool  PythonQtWrapper_QColor::__ne__(QColor* theWrappedObject, const QColor&  c) const
{
  return ( (*theWrappedObject)!= c);
}

void PythonQtWrapper_QColor::writeTo(QColor* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 <<  (*theWrappedObject);
}

bool  PythonQtWrapper_QColor::__eq__(QColor* theWrappedObject, const QColor&  c) const
{
  return ( (*theWrappedObject)== c);
}

void PythonQtWrapper_QColor::readFrom(QColor* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 >>  (*theWrappedObject);
}

int  PythonQtWrapper_QColor::red(QColor* theWrappedObject) const
{
  return ( theWrappedObject->red());
}

qreal  PythonQtWrapper_QColor::redF(QColor* theWrappedObject) const
{
  return ( theWrappedObject->redF());
}

unsigned int  PythonQtWrapper_QColor::rgb(QColor* theWrappedObject) const
{
  return ( theWrappedObject->rgb());
}

unsigned int  PythonQtWrapper_QColor::rgba(QColor* theWrappedObject) const
{
  return ( theWrappedObject->rgba());
}

QRgba64  PythonQtWrapper_QColor::rgba64(QColor* theWrappedObject) const
{
  return ( theWrappedObject->rgba64());
}

int  PythonQtWrapper_QColor::saturation(QColor* theWrappedObject) const
{
  return ( theWrappedObject->saturation());
}

qreal  PythonQtWrapper_QColor::saturationF(QColor* theWrappedObject) const
{
  return ( theWrappedObject->saturationF());
}

void PythonQtWrapper_QColor::setAlpha(QColor* theWrappedObject, int  alpha)
{
  ( theWrappedObject->setAlpha(alpha));
}

void PythonQtWrapper_QColor::setAlphaF(QColor* theWrappedObject, qreal  alpha)
{
  ( theWrappedObject->setAlphaF(alpha));
}

void PythonQtWrapper_QColor::setBlue(QColor* theWrappedObject, int  blue)
{
  ( theWrappedObject->setBlue(blue));
}

void PythonQtWrapper_QColor::setBlueF(QColor* theWrappedObject, qreal  blue)
{
  ( theWrappedObject->setBlueF(blue));
}

void PythonQtWrapper_QColor::setCmyk(QColor* theWrappedObject, int  c, int  m, int  y, int  k, int  a)
{
  ( theWrappedObject->setCmyk(c, m, y, k, a));
}

void PythonQtWrapper_QColor::setCmykF(QColor* theWrappedObject, qreal  c, qreal  m, qreal  y, qreal  k, qreal  a)
{
  ( theWrappedObject->setCmykF(c, m, y, k, a));
}

void PythonQtWrapper_QColor::setGreen(QColor* theWrappedObject, int  green)
{
  ( theWrappedObject->setGreen(green));
}

void PythonQtWrapper_QColor::setGreenF(QColor* theWrappedObject, qreal  green)
{
  ( theWrappedObject->setGreenF(green));
}

void PythonQtWrapper_QColor::setHsl(QColor* theWrappedObject, int  h, int  s, int  l, int  a)
{
  ( theWrappedObject->setHsl(h, s, l, a));
}

void PythonQtWrapper_QColor::setHslF(QColor* theWrappedObject, qreal  h, qreal  s, qreal  l, qreal  a)
{
  ( theWrappedObject->setHslF(h, s, l, a));
}

void PythonQtWrapper_QColor::setHsv(QColor* theWrappedObject, int  h, int  s, int  v, int  a)
{
  ( theWrappedObject->setHsv(h, s, v, a));
}

void PythonQtWrapper_QColor::setHsvF(QColor* theWrappedObject, qreal  h, qreal  s, qreal  v, qreal  a)
{
  ( theWrappedObject->setHsvF(h, s, v, a));
}

void PythonQtWrapper_QColor::setNamedColor(QColor* theWrappedObject, const QString&  name)
{
  ( theWrappedObject->setNamedColor(name));
}

void PythonQtWrapper_QColor::setRed(QColor* theWrappedObject, int  red)
{
  ( theWrappedObject->setRed(red));
}

void PythonQtWrapper_QColor::setRedF(QColor* theWrappedObject, qreal  red)
{
  ( theWrappedObject->setRedF(red));
}

void PythonQtWrapper_QColor::setRgb(QColor* theWrappedObject, int  r, int  g, int  b, int  a)
{
  ( theWrappedObject->setRgb(r, g, b, a));
}

void PythonQtWrapper_QColor::setRgb(QColor* theWrappedObject, unsigned int  rgb)
{
  ( theWrappedObject->setRgb(rgb));
}

void PythonQtWrapper_QColor::setRgbF(QColor* theWrappedObject, qreal  r, qreal  g, qreal  b, qreal  a)
{
  ( theWrappedObject->setRgbF(r, g, b, a));
}

void PythonQtWrapper_QColor::setRgba(QColor* theWrappedObject, unsigned int  rgba)
{
  ( theWrappedObject->setRgba(rgba));
}

void PythonQtWrapper_QColor::setRgba64(QColor* theWrappedObject, QRgba64  rgba)
{
  ( theWrappedObject->setRgba64(rgba));
}

QColor::Spec  PythonQtWrapper_QColor::spec(QColor* theWrappedObject) const
{
  return ( theWrappedObject->spec());
}

QColor  PythonQtWrapper_QColor::toCmyk(QColor* theWrappedObject) const
{
  return ( theWrappedObject->toCmyk());
}

QColor  PythonQtWrapper_QColor::toExtendedRgb(QColor* theWrappedObject) const
{
  return ( theWrappedObject->toExtendedRgb());
}

QColor  PythonQtWrapper_QColor::toHsl(QColor* theWrappedObject) const
{
  return ( theWrappedObject->toHsl());
}

QColor  PythonQtWrapper_QColor::toHsv(QColor* theWrappedObject) const
{
  return ( theWrappedObject->toHsv());
}

QColor  PythonQtWrapper_QColor::toRgb(QColor* theWrappedObject) const
{
  return ( theWrappedObject->toRgb());
}

int  PythonQtWrapper_QColor::value(QColor* theWrappedObject) const
{
  return ( theWrappedObject->value());
}

qreal  PythonQtWrapper_QColor::valueF(QColor* theWrappedObject) const
{
  return ( theWrappedObject->valueF());
}

int  PythonQtWrapper_QColor::yellow(QColor* theWrappedObject) const
{
  return ( theWrappedObject->yellow());
}

qreal  PythonQtWrapper_QColor::yellowF(QColor* theWrappedObject) const
{
  return ( theWrappedObject->yellowF());
}

QString PythonQtWrapper_QColor::py_toString(QColor* obj) {
  QString result;
  QDebug d(&result);
  d << *obj;
  return result;
}



QCursor* PythonQtWrapper_QCursor::new_QCursor()
{
return new QCursor(); }

QCursor* PythonQtWrapper_QCursor::new_QCursor(Qt::CursorShape  shape)
{
return new QCursor(shape); }

QCursor* PythonQtWrapper_QCursor::new_QCursor(const QBitmap&  bitmap, const QBitmap&  mask, int  hotX, int  hotY)
{
return new QCursor(bitmap, mask, hotX, hotY); }

QCursor* PythonQtWrapper_QCursor::new_QCursor(const QCursor&  cursor)
{
return new QCursor(cursor); }

QCursor* PythonQtWrapper_QCursor::new_QCursor(const QPixmap&  pixmap, int  hotX, int  hotY)
{
return new QCursor(pixmap, hotX, hotY); }

const QBitmap*  PythonQtWrapper_QCursor::bitmap(QCursor* theWrappedObject) const
{
  return ( theWrappedObject->bitmap());
}

QPoint  PythonQtWrapper_QCursor::hotSpot(QCursor* theWrappedObject) const
{
  return ( theWrappedObject->hotSpot());
}

const QBitmap*  PythonQtWrapper_QCursor::mask(QCursor* theWrappedObject) const
{
  return ( theWrappedObject->mask());
}

bool  PythonQtWrapper_QCursor::__ne__(QCursor* theWrappedObject, const QCursor&  rhs)
{
  return ( (*theWrappedObject)!= rhs);
}

void PythonQtWrapper_QCursor::writeTo(QCursor* theWrappedObject, QDataStream&  outS)
{
  outS <<  (*theWrappedObject);
}

bool  PythonQtWrapper_QCursor::__eq__(QCursor* theWrappedObject, const QCursor&  rhs)
{
  return ( (*theWrappedObject)== rhs);
}

void PythonQtWrapper_QCursor::readFrom(QCursor* theWrappedObject, QDataStream&  inS)
{
  inS >>  (*theWrappedObject);
}

QPixmap  PythonQtWrapper_QCursor::pixmap(QCursor* theWrappedObject) const
{
  return ( theWrappedObject->pixmap());
}

QPoint  PythonQtWrapper_QCursor::static_QCursor_pos()
{
  return (QCursor::pos());
}

QPoint  PythonQtWrapper_QCursor::static_QCursor_pos(const QScreen*  screen)
{
  return (QCursor::pos(screen));
}

void PythonQtWrapper_QCursor::static_QCursor_setPos(QScreen*  screen, const QPoint&  p)
{
  (QCursor::setPos(screen, p));
}

void PythonQtWrapper_QCursor::static_QCursor_setPos(QScreen*  screen, int  x, int  y)
{
  (QCursor::setPos(screen, x, y));
}

void PythonQtWrapper_QCursor::static_QCursor_setPos(const QPoint&  p)
{
  (QCursor::setPos(p));
}

void PythonQtWrapper_QCursor::static_QCursor_setPos(int  x, int  y)
{
  (QCursor::setPos(x, y));
}

void PythonQtWrapper_QCursor::setShape(QCursor* theWrappedObject, Qt::CursorShape  newShape)
{
  ( theWrappedObject->setShape(newShape));
}

Qt::CursorShape  PythonQtWrapper_QCursor::shape(QCursor* theWrappedObject) const
{
  return ( theWrappedObject->shape());
}

void PythonQtWrapper_QCursor::swap(QCursor* theWrappedObject, QCursor&  other)
{
  ( theWrappedObject->swap(other));
}

QString PythonQtWrapper_QCursor::py_toString(QCursor* obj) {
  QString result;
  QDebug d(&result);
  d << *obj;
  return result;
}



QFont* PythonQtWrapper_QFont::new_QFont()
{
return new QFont(); }

QFont* PythonQtWrapper_QFont::new_QFont(const QFont&  font)
{
return new QFont(font); }

QFont* PythonQtWrapper_QFont::new_QFont(const QFont&  font, QPaintDevice*  pd)
{
return new QFont(font, pd); }

QFont* PythonQtWrapper_QFont::new_QFont(const QFont&  font, const QPaintDevice*  pd)
{
return new QFont(font, pd); }

QFont* PythonQtWrapper_QFont::new_QFont(const QString&  family, int  pointSize, int  weight, bool  italic)
{
return new QFont(family, pointSize, weight, italic); }

bool  PythonQtWrapper_QFont::bold(QFont* theWrappedObject) const
{
  return ( theWrappedObject->bold());
}

void PythonQtWrapper_QFont::static_QFont_cacheStatistics()
{
  (QFont::cacheStatistics());
}

QFont::Capitalization  PythonQtWrapper_QFont::capitalization(QFont* theWrappedObject) const
{
  return ( theWrappedObject->capitalization());
}

void PythonQtWrapper_QFont::static_QFont_cleanup()
{
  (QFont::cleanup());
}

QString  PythonQtWrapper_QFont::defaultFamily(QFont* theWrappedObject) const
{
  return ( theWrappedObject->defaultFamily());
}

bool  PythonQtWrapper_QFont::exactMatch(QFont* theWrappedObject) const
{
  return ( theWrappedObject->exactMatch());
}

QStringList  PythonQtWrapper_QFont::families(QFont* theWrappedObject) const
{
  return ( theWrappedObject->families());
}

QString  PythonQtWrapper_QFont::family(QFont* theWrappedObject) const
{
  return ( theWrappedObject->family());
}

bool  PythonQtWrapper_QFont::fixedPitch(QFont* theWrappedObject) const
{
  return ( theWrappedObject->fixedPitch());
}

bool  PythonQtWrapper_QFont::fromString(QFont* theWrappedObject, const QString&  arg__1)
{
  return ( theWrappedObject->fromString(arg__1));
}

QFont::HintingPreference  PythonQtWrapper_QFont::hintingPreference(QFont* theWrappedObject) const
{
  return ( theWrappedObject->hintingPreference());
}

void PythonQtWrapper_QFont::static_QFont_initialize()
{
  (QFont::initialize());
}

void PythonQtWrapper_QFont::static_QFont_insertSubstitution(const QString&  arg__1, const QString&  arg__2)
{
  (QFont::insertSubstitution(arg__1, arg__2));
}

void PythonQtWrapper_QFont::static_QFont_insertSubstitutions(const QString&  arg__1, const QStringList&  arg__2)
{
  (QFont::insertSubstitutions(arg__1, arg__2));
}

bool  PythonQtWrapper_QFont::isCopyOf(QFont* theWrappedObject, const QFont&  arg__1) const
{
  return ( theWrappedObject->isCopyOf(arg__1));
}

bool  PythonQtWrapper_QFont::italic(QFont* theWrappedObject) const
{
  return ( theWrappedObject->italic());
}

bool  PythonQtWrapper_QFont::kerning(QFont* theWrappedObject) const
{
  return ( theWrappedObject->kerning());
}

QString  PythonQtWrapper_QFont::key(QFont* theWrappedObject) const
{
  return ( theWrappedObject->key());
}

QString  PythonQtWrapper_QFont::lastResortFamily(QFont* theWrappedObject) const
{
  return ( theWrappedObject->lastResortFamily());
}

QString  PythonQtWrapper_QFont::lastResortFont(QFont* theWrappedObject) const
{
  return ( theWrappedObject->lastResortFont());
}

qreal  PythonQtWrapper_QFont::letterSpacing(QFont* theWrappedObject) const
{
  return ( theWrappedObject->letterSpacing());
}

QFont::SpacingType  PythonQtWrapper_QFont::letterSpacingType(QFont* theWrappedObject) const
{
  return ( theWrappedObject->letterSpacingType());
}

bool  PythonQtWrapper_QFont::__ne__(QFont* theWrappedObject, const QFont&  arg__1) const
{
  return ( (*theWrappedObject)!= arg__1);
}

bool  PythonQtWrapper_QFont::__lt__(QFont* theWrappedObject, const QFont&  arg__1) const
{
  return ( (*theWrappedObject)< arg__1);
}

void PythonQtWrapper_QFont::writeTo(QFont* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 <<  (*theWrappedObject);
}

bool  PythonQtWrapper_QFont::__eq__(QFont* theWrappedObject, const QFont&  arg__1) const
{
  return ( (*theWrappedObject)== arg__1);
}

void PythonQtWrapper_QFont::readFrom(QFont* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 >>  (*theWrappedObject);
}

bool  PythonQtWrapper_QFont::overline(QFont* theWrappedObject) const
{
  return ( theWrappedObject->overline());
}

int  PythonQtWrapper_QFont::pixelSize(QFont* theWrappedObject) const
{
  return ( theWrappedObject->pixelSize());
}

int  PythonQtWrapper_QFont::pointSize(QFont* theWrappedObject) const
{
  return ( theWrappedObject->pointSize());
}

qreal  PythonQtWrapper_QFont::pointSizeF(QFont* theWrappedObject) const
{
  return ( theWrappedObject->pointSizeF());
}

bool  PythonQtWrapper_QFont::rawMode(QFont* theWrappedObject) const
{
  return ( theWrappedObject->rawMode());
}

QString  PythonQtWrapper_QFont::rawName(QFont* theWrappedObject) const
{
  return ( theWrappedObject->rawName());
}

void PythonQtWrapper_QFont::static_QFont_removeSubstitutions(const QString&  arg__1)
{
  (QFont::removeSubstitutions(arg__1));
}

uint  PythonQtWrapper_QFont::resolve(QFont* theWrappedObject) const
{
  return ( theWrappedObject->resolve());
}

QFont  PythonQtWrapper_QFont::resolve(QFont* theWrappedObject, const QFont&  arg__1) const
{
  return ( theWrappedObject->resolve(arg__1));
}

void PythonQtWrapper_QFont::resolve(QFont* theWrappedObject, uint  mask)
{
  ( theWrappedObject->resolve(mask));
}

void PythonQtWrapper_QFont::setBold(QFont* theWrappedObject, bool  arg__1)
{
  ( theWrappedObject->setBold(arg__1));
}

void PythonQtWrapper_QFont::setCapitalization(QFont* theWrappedObject, QFont::Capitalization  arg__1)
{
  ( theWrappedObject->setCapitalization(arg__1));
}

void PythonQtWrapper_QFont::setFamilies(QFont* theWrappedObject, const QStringList&  arg__1)
{
  ( theWrappedObject->setFamilies(arg__1));
}

void PythonQtWrapper_QFont::setFamily(QFont* theWrappedObject, const QString&  arg__1)
{
  ( theWrappedObject->setFamily(arg__1));
}

void PythonQtWrapper_QFont::setFixedPitch(QFont* theWrappedObject, bool  arg__1)
{
  ( theWrappedObject->setFixedPitch(arg__1));
}

void PythonQtWrapper_QFont::setHintingPreference(QFont* theWrappedObject, QFont::HintingPreference  hintingPreference)
{
  ( theWrappedObject->setHintingPreference(hintingPreference));
}

void PythonQtWrapper_QFont::setItalic(QFont* theWrappedObject, bool  b)
{
  ( theWrappedObject->setItalic(b));
}

void PythonQtWrapper_QFont::setKerning(QFont* theWrappedObject, bool  arg__1)
{
  ( theWrappedObject->setKerning(arg__1));
}

void PythonQtWrapper_QFont::setLetterSpacing(QFont* theWrappedObject, QFont::SpacingType  type, qreal  spacing)
{
  ( theWrappedObject->setLetterSpacing(type, spacing));
}

void PythonQtWrapper_QFont::setOverline(QFont* theWrappedObject, bool  arg__1)
{
  ( theWrappedObject->setOverline(arg__1));
}

void PythonQtWrapper_QFont::setPixelSize(QFont* theWrappedObject, int  arg__1)
{
  ( theWrappedObject->setPixelSize(arg__1));
}

void PythonQtWrapper_QFont::setPointSize(QFont* theWrappedObject, int  arg__1)
{
  ( theWrappedObject->setPointSize(arg__1));
}

void PythonQtWrapper_QFont::setPointSizeF(QFont* theWrappedObject, qreal  arg__1)
{
  ( theWrappedObject->setPointSizeF(arg__1));
}

void PythonQtWrapper_QFont::setRawMode(QFont* theWrappedObject, bool  arg__1)
{
  ( theWrappedObject->setRawMode(arg__1));
}

void PythonQtWrapper_QFont::setRawName(QFont* theWrappedObject, const QString&  arg__1)
{
  ( theWrappedObject->setRawName(arg__1));
}

void PythonQtWrapper_QFont::setStretch(QFont* theWrappedObject, int  arg__1)
{
  ( theWrappedObject->setStretch(arg__1));
}

void PythonQtWrapper_QFont::setStrikeOut(QFont* theWrappedObject, bool  arg__1)
{
  ( theWrappedObject->setStrikeOut(arg__1));
}

void PythonQtWrapper_QFont::setStyle(QFont* theWrappedObject, QFont::Style  style)
{
  ( theWrappedObject->setStyle(style));
}

void PythonQtWrapper_QFont::setStyleHint(QFont* theWrappedObject, QFont::StyleHint  arg__1, QFont::StyleStrategy  arg__2)
{
  ( theWrappedObject->setStyleHint(arg__1, arg__2));
}

void PythonQtWrapper_QFont::setStyleName(QFont* theWrappedObject, const QString&  arg__1)
{
  ( theWrappedObject->setStyleName(arg__1));
}

void PythonQtWrapper_QFont::setStyleStrategy(QFont* theWrappedObject, QFont::StyleStrategy  s)
{
  ( theWrappedObject->setStyleStrategy(s));
}

void PythonQtWrapper_QFont::setUnderline(QFont* theWrappedObject, bool  arg__1)
{
  ( theWrappedObject->setUnderline(arg__1));
}

void PythonQtWrapper_QFont::setWeight(QFont* theWrappedObject, int  arg__1)
{
  ( theWrappedObject->setWeight(arg__1));
}

void PythonQtWrapper_QFont::setWordSpacing(QFont* theWrappedObject, qreal  spacing)
{
  ( theWrappedObject->setWordSpacing(spacing));
}

int  PythonQtWrapper_QFont::stretch(QFont* theWrappedObject) const
{
  return ( theWrappedObject->stretch());
}

bool  PythonQtWrapper_QFont::strikeOut(QFont* theWrappedObject) const
{
  return ( theWrappedObject->strikeOut());
}

QFont::Style  PythonQtWrapper_QFont::style(QFont* theWrappedObject) const
{
  return ( theWrappedObject->style());
}

QFont::StyleHint  PythonQtWrapper_QFont::styleHint(QFont* theWrappedObject) const
{
  return ( theWrappedObject->styleHint());
}

QString  PythonQtWrapper_QFont::styleName(QFont* theWrappedObject) const
{
  return ( theWrappedObject->styleName());
}

QFont::StyleStrategy  PythonQtWrapper_QFont::styleStrategy(QFont* theWrappedObject) const
{
  return ( theWrappedObject->styleStrategy());
}

QString  PythonQtWrapper_QFont::static_QFont_substitute(const QString&  arg__1)
{
  return (QFont::substitute(arg__1));
}

QStringList  PythonQtWrapper_QFont::static_QFont_substitutes(const QString&  arg__1)
{
  return (QFont::substitutes(arg__1));
}

QStringList  PythonQtWrapper_QFont::static_QFont_substitutions()
{
  return (QFont::substitutions());
}

void PythonQtWrapper_QFont::swap(QFont* theWrappedObject, QFont&  other)
{
  ( theWrappedObject->swap(other));
}

QString  PythonQtWrapper_QFont::toString(QFont* theWrappedObject) const
{
  return ( theWrappedObject->toString());
}

bool  PythonQtWrapper_QFont::underline(QFont* theWrappedObject) const
{
  return ( theWrappedObject->underline());
}

int  PythonQtWrapper_QFont::weight(QFont* theWrappedObject) const
{
  return ( theWrappedObject->weight());
}

qreal  PythonQtWrapper_QFont::wordSpacing(QFont* theWrappedObject) const
{
  return ( theWrappedObject->wordSpacing());
}

QString PythonQtWrapper_QFont::py_toString(QFont* obj) { return obj->toString(); }


QIcon* PythonQtWrapper_QIcon::new_QIcon()
{
return new QIcon(); }

QIcon* PythonQtWrapper_QIcon::new_QIcon(PythonQtPassOwnershipToCPP<QIconEngine* >  engine)
{
return new QIcon(engine); }

QIcon* PythonQtWrapper_QIcon::new_QIcon(const QIcon&  other)
{
return new QIcon(other); }

QIcon* PythonQtWrapper_QIcon::new_QIcon(const QPixmap&  pixmap)
{
return new QIcon(pixmap); }

QIcon* PythonQtWrapper_QIcon::new_QIcon(const QString&  fileName)
{
return new QIcon(fileName); }

QSize  PythonQtWrapper_QIcon::actualSize(QIcon* theWrappedObject, QWindow*  window, const QSize&  size, QIcon::Mode  mode, QIcon::State  state) const
{
  return ( theWrappedObject->actualSize(window, size, mode, state));
}

QSize  PythonQtWrapper_QIcon::actualSize(QIcon* theWrappedObject, const QSize&  size, QIcon::Mode  mode, QIcon::State  state) const
{
  return ( theWrappedObject->actualSize(size, mode, state));
}

void PythonQtWrapper_QIcon::addFile(QIcon* theWrappedObject, const QString&  fileName, const QSize&  size, QIcon::Mode  mode, QIcon::State  state)
{
  ( theWrappedObject->addFile(fileName, size, mode, state));
}

void PythonQtWrapper_QIcon::addPixmap(QIcon* theWrappedObject, const QPixmap&  pixmap, QIcon::Mode  mode, QIcon::State  state)
{
  ( theWrappedObject->addPixmap(pixmap, mode, state));
}

QList<QSize >  PythonQtWrapper_QIcon::availableSizes(QIcon* theWrappedObject, QIcon::Mode  mode, QIcon::State  state) const
{
  return ( theWrappedObject->availableSizes(mode, state));
}

qint64  PythonQtWrapper_QIcon::cacheKey(QIcon* theWrappedObject) const
{
  return ( theWrappedObject->cacheKey());
}

QStringList  PythonQtWrapper_QIcon::static_QIcon_fallbackSearchPaths()
{
  return (QIcon::fallbackSearchPaths());
}

QString  PythonQtWrapper_QIcon::static_QIcon_fallbackThemeName()
{
  return (QIcon::fallbackThemeName());
}

QIcon  PythonQtWrapper_QIcon::static_QIcon_fromTheme(const QString&  name)
{
  return (QIcon::fromTheme(name));
}

QIcon  PythonQtWrapper_QIcon::static_QIcon_fromTheme(const QString&  name, const QIcon&  fallback)
{
  return (QIcon::fromTheme(name, fallback));
}

bool  PythonQtWrapper_QIcon::static_QIcon_hasThemeIcon(const QString&  name)
{
  return (QIcon::hasThemeIcon(name));
}

bool  PythonQtWrapper_QIcon::isMask(QIcon* theWrappedObject) const
{
  return ( theWrappedObject->isMask());
}

bool  PythonQtWrapper_QIcon::isNull(QIcon* theWrappedObject) const
{
  return ( theWrappedObject->isNull());
}

QString  PythonQtWrapper_QIcon::name(QIcon* theWrappedObject) const
{
  return ( theWrappedObject->name());
}

void PythonQtWrapper_QIcon::writeTo(QIcon* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 <<  (*theWrappedObject);
}

void PythonQtWrapper_QIcon::readFrom(QIcon* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 >>  (*theWrappedObject);
}

void PythonQtWrapper_QIcon::paint(QIcon* theWrappedObject, QPainter*  painter, const QRect&  rect, Qt::Alignment  alignment, QIcon::Mode  mode, QIcon::State  state) const
{
  ( theWrappedObject->paint(painter, rect, alignment, mode, state));
}

void PythonQtWrapper_QIcon::paint(QIcon* theWrappedObject, QPainter*  painter, int  x, int  y, int  w, int  h, Qt::Alignment  alignment, QIcon::Mode  mode, QIcon::State  state) const
{
  ( theWrappedObject->paint(painter, x, y, w, h, alignment, mode, state));
}

QPixmap  PythonQtWrapper_QIcon::pixmap(QIcon* theWrappedObject, QWindow*  window, const QSize&  size, QIcon::Mode  mode, QIcon::State  state) const
{
  return ( theWrappedObject->pixmap(window, size, mode, state));
}

QPixmap  PythonQtWrapper_QIcon::pixmap(QIcon* theWrappedObject, const QSize&  size, QIcon::Mode  mode, QIcon::State  state) const
{
  return ( theWrappedObject->pixmap(size, mode, state));
}

QPixmap  PythonQtWrapper_QIcon::pixmap(QIcon* theWrappedObject, int  extent, QIcon::Mode  mode, QIcon::State  state) const
{
  return ( theWrappedObject->pixmap(extent, mode, state));
}

QPixmap  PythonQtWrapper_QIcon::pixmap(QIcon* theWrappedObject, int  w, int  h, QIcon::Mode  mode, QIcon::State  state) const
{
  return ( theWrappedObject->pixmap(w, h, mode, state));
}

void PythonQtWrapper_QIcon::static_QIcon_setFallbackSearchPaths(const QStringList&  paths)
{
  (QIcon::setFallbackSearchPaths(paths));
}

void PythonQtWrapper_QIcon::static_QIcon_setFallbackThemeName(const QString&  name)
{
  (QIcon::setFallbackThemeName(name));
}

void PythonQtWrapper_QIcon::setIsMask(QIcon* theWrappedObject, bool  isMask)
{
  ( theWrappedObject->setIsMask(isMask));
}

void PythonQtWrapper_QIcon::static_QIcon_setThemeName(const QString&  path)
{
  (QIcon::setThemeName(path));
}

void PythonQtWrapper_QIcon::static_QIcon_setThemeSearchPaths(const QStringList&  searchpath)
{
  (QIcon::setThemeSearchPaths(searchpath));
}

void PythonQtWrapper_QIcon::swap(QIcon* theWrappedObject, QIcon&  other)
{
  ( theWrappedObject->swap(other));
}

QString  PythonQtWrapper_QIcon::static_QIcon_themeName()
{
  return (QIcon::themeName());
}

QStringList  PythonQtWrapper_QIcon::static_QIcon_themeSearchPaths()
{
  return (QIcon::themeSearchPaths());
}

QString PythonQtWrapper_QIcon::py_toString(QIcon* obj) {
  QString result;
  QDebug d(&result);
  d << *obj;
  return result;
}



PythonQtShell_QImage::~PythonQtShell_QImage() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
int  PythonQtShell_QImage::devType() const
{
if (_wrapper) {
  PYTHONQT_GIL_SCOPE
  if (Py_REFCNT((PyObject*)_wrapper) > 0) {
    static PyObject* name = PyUnicode_FromString("devType");
    PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
    if (obj) {
      static const char* argumentList[] ={"int"};
      static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      int returnValue{};
      void* args[1] = {nullptr};
      PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
      if (result) {
        args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue);
        if (args[0]!=&returnValue) {
          if (args[0]==nullptr) {
            PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
          } else {
            returnValue = *((int*)args[0]);
          }
        }
      }
      if (result) { Py_DECREF(result); }
      Py_DECREF(obj);
      return returnValue;
    } else {
      PyErr_Clear();
    }
  }
}
  return QImage::devType();
}
void PythonQtShell_QImage::initPainter(QPainter*  painter0) const
{
if (_wrapper) {
  PYTHONQT_GIL_SCOPE
  if (Py_REFCNT((PyObject*)_wrapper) > 0) {
    static PyObject* name = PyUnicode_FromString("initPainter");
    PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
    if (obj) {
      static const char* argumentList[] ={"" , "QPainter*"};
      static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      void* args[2] = {nullptr, (void*)&painter0};
      PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
      if (result) { Py_DECREF(result); }
      Py_DECREF(obj);
      return;
    } else {
      PyErr_Clear();
    }
  }
}
  QImage::initPainter(painter0);
}
int  PythonQtShell_QImage::metric(QPaintDevice::PaintDeviceMetric  metric0) const
{
if (_wrapper) {
  PYTHONQT_GIL_SCOPE
  if (Py_REFCNT((PyObject*)_wrapper) > 0) {
    static PyObject* name = PyUnicode_FromString("metric");
    PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
    if (obj) {
      static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
      static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      int returnValue{};
      void* args[2] = {nullptr, (void*)&metric0};
      PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
      if (result) {
        args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue);
        if (args[0]!=&returnValue) {
          if (args[0]==nullptr) {
            PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
          } else {
            returnValue = *((int*)args[0]);
          }
        }
      }
      if (result) { Py_DECREF(result); }
      Py_DECREF(obj);
      return returnValue;
    } else {
      PyErr_Clear();
    }
  }
}
  return QImage::metric(metric0);
}
QPaintEngine*  PythonQtShell_QImage::paintEngine() const
{
if (_wrapper) {
  PYTHONQT_GIL_SCOPE
  if (Py_REFCNT((PyObject*)_wrapper) > 0) {
    static PyObject* name = PyUnicode_FromString("paintEngine");
    PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
    if (obj) {
      static const char* argumentList[] ={"QPaintEngine*"};
      static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QPaintEngine* returnValue{};
      void* args[1] = {nullptr};
      PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
      if (result) {
        args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue);
        if (args[0]!=&returnValue) {
          if (args[0]==nullptr) {
            PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
          } else {
            returnValue = *((QPaintEngine**)args[0]);
          }
        }
      }
      if (result) { Py_DECREF(result); }
      Py_DECREF(obj);
      return returnValue;
    } else {
      PyErr_Clear();
    }
  }
}
  return QImage::paintEngine();
}
QPaintDevice*  PythonQtShell_QImage::redirected(QPoint*  offset0) const
{
if (_wrapper) {
  PYTHONQT_GIL_SCOPE
  if (Py_REFCNT((PyObject*)_wrapper) > 0) {
    static PyObject* name = PyUnicode_FromString("redirected");
    PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
    if (obj) {
      static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
      static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      QPaintDevice* returnValue{};
      void* args[2] = {nullptr, (void*)&offset0};
      PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
      if (result) {
        args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue);
        if (args[0]!=&returnValue) {
          if (args[0]==nullptr) {
            PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
          } else {
            returnValue = *((QPaintDevice**)args[0]);
          }
        }
      }
      if (result) { Py_DECREF(result); }
      Py_DECREF(obj);
      return returnValue;
    } else {
      PyErr_Clear();
    }
  }
}
  return QImage::redirected(offset0);
}
QPainter*  PythonQtShell_QImage::sharedPainter() const
{
if (_wrapper) {
  PYTHONQT_GIL_SCOPE
  if (Py_REFCNT((PyObject*)_wrapper) > 0) {
    static PyObject* name = PyUnicode_FromString("sharedPainter");
    PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
    if (obj) {
      static const char* argumentList[] ={"QPainter*"};
      static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QPainter* returnValue{};
      void* args[1] = {nullptr};
      PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
      if (result) {
        args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue);
        if (args[0]!=&returnValue) {
          if (args[0]==nullptr) {
            PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
          } else {
            returnValue = *((QPainter**)args[0]);
          }
        }
      }
      if (result) { Py_DECREF(result); }
      Py_DECREF(obj);
      return returnValue;
    } else {
      PyErr_Clear();
    }
  }
}
  return QImage::sharedPainter();
}
QImage* PythonQtWrapper_QImage::new_QImage()
{
return new PythonQtShell_QImage(); }

QImage* PythonQtWrapper_QImage::new_QImage(const QImage&  arg__1)
{
return new PythonQtShell_QImage(arg__1); }

QImage* PythonQtWrapper_QImage::new_QImage(const QSize&  size, QImage::Format  format)
{
return new PythonQtShell_QImage(size, format); }

QImage* PythonQtWrapper_QImage::new_QImage(const QString&  fileName, const char*  format)
{
return new PythonQtShell_QImage(fileName, format); }

QImage* PythonQtWrapper_QImage::new_QImage(int  width, int  height, QImage::Format  format)
{
return new PythonQtShell_QImage(width, height, format); }

bool  PythonQtWrapper_QImage::allGray(QImage* theWrappedObject) const
{
  return ( theWrappedObject->allGray());
}

QImage  PythonQtWrapper_QImage::alphaChannel(QImage* theWrappedObject) const
{
  return ( theWrappedObject->alphaChannel());
}

void PythonQtWrapper_QImage::applyColorTransform(QImage* theWrappedObject, const QColorTransform&  transform)
{
  ( theWrappedObject->applyColorTransform(transform));
}

int  PythonQtWrapper_QImage::bitPlaneCount(QImage* theWrappedObject) const
{
  return ( theWrappedObject->bitPlaneCount());
}

int  PythonQtWrapper_QImage::byteCount(QImage* theWrappedObject) const
{
  return ( theWrappedObject->byteCount());
}

int  PythonQtWrapper_QImage::bytesPerLine(QImage* theWrappedObject) const
{
  return ( theWrappedObject->bytesPerLine());
}

qint64  PythonQtWrapper_QImage::cacheKey(QImage* theWrappedObject) const
{
  return ( theWrappedObject->cacheKey());
}

unsigned int  PythonQtWrapper_QImage::color(QImage* theWrappedObject, int  i) const
{
  return ( theWrappedObject->color(i));
}

int  PythonQtWrapper_QImage::colorCount(QImage* theWrappedObject) const
{
  return ( theWrappedObject->colorCount());
}

QColorSpace  PythonQtWrapper_QImage::colorSpace(QImage* theWrappedObject) const
{
  return ( theWrappedObject->colorSpace());
}

QVector<unsigned int >  PythonQtWrapper_QImage::colorTable(QImage* theWrappedObject) const
{
  return ( theWrappedObject->colorTable());
}

void PythonQtWrapper_QImage::convertTo(QImage* theWrappedObject, QImage::Format  f, Qt::ImageConversionFlags  flags)
{
  ( theWrappedObject->convertTo(f, flags));
}

void PythonQtWrapper_QImage::convertToColorSpace(QImage* theWrappedObject, const QColorSpace&  arg__1)
{
  ( theWrappedObject->convertToColorSpace(arg__1));
}

QImage  PythonQtWrapper_QImage::convertToFormat(QImage* theWrappedObject, QImage::Format  f, Qt::ImageConversionFlags  flags) const
{
  return ( theWrappedObject->convertToFormat(f, flags));
}

QImage  PythonQtWrapper_QImage::convertToFormat(QImage* theWrappedObject, QImage::Format  f, const QVector<unsigned int >&  colorTable, Qt::ImageConversionFlags  flags) const
{
  return ( theWrappedObject->convertToFormat(f, colorTable, flags));
}

QImage  PythonQtWrapper_QImage::convertToFormat_helper(QImage* theWrappedObject, QImage::Format  format, Qt::ImageConversionFlags  flags) const
{
  return ( ((PythonQtPublicPromoter_QImage*)theWrappedObject)->promoted_convertToFormat_helper(format, flags));
}

bool  PythonQtWrapper_QImage::convertToFormat_inplace(QImage* theWrappedObject, QImage::Format  format, Qt::ImageConversionFlags  flags)
{
  return ( ((PythonQtPublicPromoter_QImage*)theWrappedObject)->promoted_convertToFormat_inplace(format, flags));
}

QImage  PythonQtWrapper_QImage::convertedToColorSpace(QImage* theWrappedObject, const QColorSpace&  arg__1) const
{
  return ( theWrappedObject->convertedToColorSpace(arg__1));
}

QImage  PythonQtWrapper_QImage::copy(QImage* theWrappedObject, const QRect&  rect) const
{
  return ( theWrappedObject->copy(rect));
}

QImage  PythonQtWrapper_QImage::copy(QImage* theWrappedObject, int  x, int  y, int  w, int  h) const
{
  return ( theWrappedObject->copy(x, y, w, h));
}

QImage  PythonQtWrapper_QImage::createAlphaMask(QImage* theWrappedObject, Qt::ImageConversionFlags  flags) const
{
  return ( theWrappedObject->createAlphaMask(flags));
}

QImage  PythonQtWrapper_QImage::createHeuristicMask(QImage* theWrappedObject, bool  clipTight) const
{
  return ( theWrappedObject->createHeuristicMask(clipTight));
}

QImage  PythonQtWrapper_QImage::createMaskFromColor(QImage* theWrappedObject, unsigned int  color, Qt::MaskMode  mode) const
{
  return ( theWrappedObject->createMaskFromColor(color, mode));
}

int  PythonQtWrapper_QImage::depth(QImage* theWrappedObject) const
{
  return ( theWrappedObject->depth());
}

qreal  PythonQtWrapper_QImage::devicePixelRatio(QImage* theWrappedObject) const
{
  return ( theWrappedObject->devicePixelRatio());
}

int  PythonQtWrapper_QImage::dotsPerMeterX(QImage* theWrappedObject) const
{
  return ( theWrappedObject->dotsPerMeterX());
}

int  PythonQtWrapper_QImage::dotsPerMeterY(QImage* theWrappedObject) const
{
  return ( theWrappedObject->dotsPerMeterY());
}

void PythonQtWrapper_QImage::fill(QImage* theWrappedObject, Qt::GlobalColor  color)
{
  ( theWrappedObject->fill(color));
}

void PythonQtWrapper_QImage::fill(QImage* theWrappedObject, const QColor&  color)
{
  ( theWrappedObject->fill(color));
}

void PythonQtWrapper_QImage::fill(QImage* theWrappedObject, uint  pixel)
{
  ( theWrappedObject->fill(pixel));
}

QImage::Format  PythonQtWrapper_QImage::format(QImage* theWrappedObject) const
{
  return ( theWrappedObject->format());
}

QImage  PythonQtWrapper_QImage::static_QImage_fromData(const QByteArray&  data, const char*  format)
{
  return (QImage::fromData(data, format));
}

bool  PythonQtWrapper_QImage::hasAlphaChannel(QImage* theWrappedObject) const
{
  return ( theWrappedObject->hasAlphaChannel());
}

int  PythonQtWrapper_QImage::height(QImage* theWrappedObject) const
{
  return ( theWrappedObject->height());
}

void PythonQtWrapper_QImage::invertPixels(QImage* theWrappedObject, QImage::InvertMode  arg__1)
{
  ( theWrappedObject->invertPixels(arg__1));
}

bool  PythonQtWrapper_QImage::isGrayscale(QImage* theWrappedObject) const
{
  return ( theWrappedObject->isGrayscale());
}

bool  PythonQtWrapper_QImage::isNull(QImage* theWrappedObject) const
{
  return ( theWrappedObject->isNull());
}

bool  PythonQtWrapper_QImage::load(QImage* theWrappedObject, QIODevice*  device, const char*  format)
{
  return ( theWrappedObject->load(device, format));
}

bool  PythonQtWrapper_QImage::load(QImage* theWrappedObject, const QString&  fileName, const char*  format)
{
  return ( theWrappedObject->load(fileName, format));
}

bool  PythonQtWrapper_QImage::loadFromData(QImage* theWrappedObject, const QByteArray&  data, const char*  aformat)
{
  return ( theWrappedObject->loadFromData(data, aformat));
}

QImage  PythonQtWrapper_QImage::mirrored(QImage* theWrappedObject, bool  horizontally, bool  vertically) const
{
  return ( theWrappedObject->mirrored(horizontally, vertically));
}

QImage  PythonQtWrapper_QImage::mirrored_helper(QImage* theWrappedObject, bool  horizontal, bool  vertical) const
{
  return ( ((PythonQtPublicPromoter_QImage*)theWrappedObject)->promoted_mirrored_helper(horizontal, vertical));
}

void PythonQtWrapper_QImage::mirrored_inplace(QImage* theWrappedObject, bool  horizontal, bool  vertical)
{
  ( ((PythonQtPublicPromoter_QImage*)theWrappedObject)->promoted_mirrored_inplace(horizontal, vertical));
}

QPoint  PythonQtWrapper_QImage::offset(QImage* theWrappedObject) const
{
  return ( theWrappedObject->offset());
}

bool  PythonQtWrapper_QImage::__ne__(QImage* theWrappedObject, const QImage&  arg__1) const
{
  return ( (*theWrappedObject)!= arg__1);
}

void PythonQtWrapper_QImage::writeTo(QImage* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 <<  (*theWrappedObject);
}

bool  PythonQtWrapper_QImage::__eq__(QImage* theWrappedObject, const QImage&  arg__1) const
{
  return ( (*theWrappedObject)== arg__1);
}

void PythonQtWrapper_QImage::readFrom(QImage* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 >>  (*theWrappedObject);
}

unsigned int  PythonQtWrapper_QImage::pixel(QImage* theWrappedObject, const QPoint&  pt) const
{
  return ( theWrappedObject->pixel(pt));
}

unsigned int  PythonQtWrapper_QImage::pixel(QImage* theWrappedObject, int  x, int  y) const
{
  return ( theWrappedObject->pixel(x, y));
}

QColor  PythonQtWrapper_QImage::pixelColor(QImage* theWrappedObject, const QPoint&  pt) const
{
  return ( theWrappedObject->pixelColor(pt));
}

QColor  PythonQtWrapper_QImage::pixelColor(QImage* theWrappedObject, int  x, int  y) const
{
  return ( theWrappedObject->pixelColor(x, y));
}

QPixelFormat  PythonQtWrapper_QImage::pixelFormat(QImage* theWrappedObject) const
{
  return ( theWrappedObject->pixelFormat());
}

int  PythonQtWrapper_QImage::pixelIndex(QImage* theWrappedObject, const QPoint&  pt) const
{
  return ( theWrappedObject->pixelIndex(pt));
}

int  PythonQtWrapper_QImage::pixelIndex(QImage* theWrappedObject, int  x, int  y) const
{
  return ( theWrappedObject->pixelIndex(x, y));
}

QRect  PythonQtWrapper_QImage::rect(QImage* theWrappedObject) const
{
  return ( theWrappedObject->rect());
}

bool  PythonQtWrapper_QImage::reinterpretAsFormat(QImage* theWrappedObject, QImage::Format  f)
{
  return ( theWrappedObject->reinterpretAsFormat(f));
}

QImage  PythonQtWrapper_QImage::rgbSwapped(QImage* theWrappedObject) const
{
  return ( theWrappedObject->rgbSwapped());
}

QImage  PythonQtWrapper_QImage::rgbSwapped_helper(QImage* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QImage*)theWrappedObject)->promoted_rgbSwapped_helper());
}

void PythonQtWrapper_QImage::rgbSwapped_inplace(QImage* theWrappedObject)
{
  ( ((PythonQtPublicPromoter_QImage*)theWrappedObject)->promoted_rgbSwapped_inplace());
}

bool  PythonQtWrapper_QImage::save(QImage* theWrappedObject, QIODevice*  device, const char*  format, int  quality) const
{
  return ( theWrappedObject->save(device, format, quality));
}

bool  PythonQtWrapper_QImage::save(QImage* theWrappedObject, const QString&  fileName, const char*  format, int  quality) const
{
  return ( theWrappedObject->save(fileName, format, quality));
}

QImage  PythonQtWrapper_QImage::scaled(QImage* theWrappedObject, const QSize&  s, Qt::AspectRatioMode  aspectMode, Qt::TransformationMode  mode) const
{
  return ( theWrappedObject->scaled(s, aspectMode, mode));
}

QImage  PythonQtWrapper_QImage::scaled(QImage* theWrappedObject, int  w, int  h, Qt::AspectRatioMode  aspectMode, Qt::TransformationMode  mode) const
{
  return ( theWrappedObject->scaled(w, h, aspectMode, mode));
}

QImage  PythonQtWrapper_QImage::scaledToHeight(QImage* theWrappedObject, int  h, Qt::TransformationMode  mode) const
{
  return ( theWrappedObject->scaledToHeight(h, mode));
}

QImage  PythonQtWrapper_QImage::scaledToWidth(QImage* theWrappedObject, int  w, Qt::TransformationMode  mode) const
{
  return ( theWrappedObject->scaledToWidth(w, mode));
}

void PythonQtWrapper_QImage::setAlphaChannel(QImage* theWrappedObject, const QImage&  alphaChannel)
{
  ( theWrappedObject->setAlphaChannel(alphaChannel));
}

void PythonQtWrapper_QImage::setColor(QImage* theWrappedObject, int  i, unsigned int  c)
{
  ( theWrappedObject->setColor(i, c));
}

void PythonQtWrapper_QImage::setColorCount(QImage* theWrappedObject, int  arg__1)
{
  ( theWrappedObject->setColorCount(arg__1));
}

void PythonQtWrapper_QImage::setColorSpace(QImage* theWrappedObject, const QColorSpace&  arg__1)
{
  ( theWrappedObject->setColorSpace(arg__1));
}

void PythonQtWrapper_QImage::setDevicePixelRatio(QImage* theWrappedObject, qreal  scaleFactor)
{
  ( theWrappedObject->setDevicePixelRatio(scaleFactor));
}

void PythonQtWrapper_QImage::setDotsPerMeterX(QImage* theWrappedObject, int  arg__1)
{
  ( theWrappedObject->setDotsPerMeterX(arg__1));
}

void PythonQtWrapper_QImage::setDotsPerMeterY(QImage* theWrappedObject, int  arg__1)
{
  ( theWrappedObject->setDotsPerMeterY(arg__1));
}

void PythonQtWrapper_QImage::setOffset(QImage* theWrappedObject, const QPoint&  arg__1)
{
  ( theWrappedObject->setOffset(arg__1));
}

void PythonQtWrapper_QImage::setPixel(QImage* theWrappedObject, const QPoint&  pt, uint  index_or_rgb)
{
  ( theWrappedObject->setPixel(pt, index_or_rgb));
}

void PythonQtWrapper_QImage::setPixel(QImage* theWrappedObject, int  x, int  y, uint  index_or_rgb)
{
  ( theWrappedObject->setPixel(x, y, index_or_rgb));
}

void PythonQtWrapper_QImage::setPixelColor(QImage* theWrappedObject, const QPoint&  pt, const QColor&  c)
{
  ( theWrappedObject->setPixelColor(pt, c));
}

void PythonQtWrapper_QImage::setPixelColor(QImage* theWrappedObject, int  x, int  y, const QColor&  c)
{
  ( theWrappedObject->setPixelColor(x, y, c));
}

void PythonQtWrapper_QImage::setText(QImage* theWrappedObject, const QString&  key, const QString&  value)
{
  ( theWrappedObject->setText(key, value));
}

QSize  PythonQtWrapper_QImage::size(QImage* theWrappedObject) const
{
  return ( theWrappedObject->size());
}

qsizetype  PythonQtWrapper_QImage::sizeInBytes(QImage* theWrappedObject) const
{
  return ( theWrappedObject->sizeInBytes());
}

QImage  PythonQtWrapper_QImage::smoothScaled(QImage* theWrappedObject, int  w, int  h) const
{
  return ( ((PythonQtPublicPromoter_QImage*)theWrappedObject)->promoted_smoothScaled(w, h));
}

void PythonQtWrapper_QImage::swap(QImage* theWrappedObject, QImage&  other)
{
  ( theWrappedObject->swap(other));
}

QString  PythonQtWrapper_QImage::text(QImage* theWrappedObject, const QString&  key) const
{
  return ( theWrappedObject->text(key));
}

QStringList  PythonQtWrapper_QImage::textKeys(QImage* theWrappedObject) const
{
  return ( theWrappedObject->textKeys());
}

QImage::Format  PythonQtWrapper_QImage::static_QImage_toImageFormat(QPixelFormat  format)
{
  return (QImage::toImageFormat(format));
}

QPixelFormat  PythonQtWrapper_QImage::static_QImage_toPixelFormat(QImage::Format  format)
{
  return (QImage::toPixelFormat(format));
}

QImage  PythonQtWrapper_QImage::transformed(QImage* theWrappedObject, const QMatrix&  matrix, Qt::TransformationMode  mode) const
{
  return ( theWrappedObject->transformed(matrix, mode));
}

QImage  PythonQtWrapper_QImage::transformed(QImage* theWrappedObject, const QTransform&  matrix, Qt::TransformationMode  mode) const
{
  return ( theWrappedObject->transformed(matrix, mode));
}

QMatrix  PythonQtWrapper_QImage::static_QImage_trueMatrix(const QMatrix&  arg__1, int  w, int  h)
{
  return (QImage::trueMatrix(arg__1, w, h));
}

QTransform  PythonQtWrapper_QImage::static_QImage_trueMatrix(const QTransform&  arg__1, int  w, int  h)
{
  return (QImage::trueMatrix(arg__1, w, h));
}

bool  PythonQtWrapper_QImage::valid(QImage* theWrappedObject, const QPoint&  pt) const
{
  return ( theWrappedObject->valid(pt));
}

bool  PythonQtWrapper_QImage::valid(QImage* theWrappedObject, int  x, int  y) const
{
  return ( theWrappedObject->valid(x, y));
}

int  PythonQtWrapper_QImage::width(QImage* theWrappedObject) const
{
  return ( theWrappedObject->width());
}

QString PythonQtWrapper_QImage::py_toString(QImage* obj) {
  QString result;
  QDebug d(&result);
  d << *obj;
  return result;
}



QKeySequence* PythonQtWrapper_QKeySequence::new_QKeySequence()
{
return new QKeySequence(); }

QKeySequence* PythonQtWrapper_QKeySequence::new_QKeySequence(QKeySequence::StandardKey  key)
{
return new QKeySequence(key); }

QKeySequence* PythonQtWrapper_QKeySequence::new_QKeySequence(const QKeySequence&  ks)
{
return new QKeySequence(ks); }

QKeySequence* PythonQtWrapper_QKeySequence::new_QKeySequence(const QString&  key, QKeySequence::SequenceFormat  format)
{
return new QKeySequence(key, format); }

QKeySequence* PythonQtWrapper_QKeySequence::new_QKeySequence(int  k1, int  k2, int  k3, int  k4)
{
return new QKeySequence(k1, k2, k3, k4); }

int  PythonQtWrapper_QKeySequence::count(QKeySequence* theWrappedObject) const
{
  return ( theWrappedObject->count());
}

QKeySequence  PythonQtWrapper_QKeySequence::static_QKeySequence_fromString(const QString&  str, QKeySequence::SequenceFormat  format)
{
  return (QKeySequence::fromString(str, format));
}

bool  PythonQtWrapper_QKeySequence::isEmpty(QKeySequence* theWrappedObject) const
{
  return ( theWrappedObject->isEmpty());
}

QList<QKeySequence >  PythonQtWrapper_QKeySequence::static_QKeySequence_keyBindings(QKeySequence::StandardKey  key)
{
  return (QKeySequence::keyBindings(key));
}

QList<QKeySequence >  PythonQtWrapper_QKeySequence::static_QKeySequence_listFromString(const QString&  str, QKeySequence::SequenceFormat  format)
{
  return (QKeySequence::listFromString(str, format));
}

QString  PythonQtWrapper_QKeySequence::static_QKeySequence_listToString(const QList<QKeySequence >&  list, QKeySequence::SequenceFormat  format)
{
  return (QKeySequence::listToString(list, format));
}

QKeySequence::SequenceMatch  PythonQtWrapper_QKeySequence::matches(QKeySequence* theWrappedObject, const QKeySequence&  seq) const
{
  return ( theWrappedObject->matches(seq));
}

QKeySequence  PythonQtWrapper_QKeySequence::static_QKeySequence_mnemonic(const QString&  text)
{
  return (QKeySequence::mnemonic(text));
}

bool  PythonQtWrapper_QKeySequence::__ne__(QKeySequence* theWrappedObject, const QKeySequence&  other) const
{
  return ( (*theWrappedObject)!= other);
}

bool  PythonQtWrapper_QKeySequence::__lt__(QKeySequence* theWrappedObject, const QKeySequence&  ks) const
{
  return ( (*theWrappedObject)< ks);
}

void PythonQtWrapper_QKeySequence::writeTo(QKeySequence* theWrappedObject, QDataStream&  in)
{
  in <<  (*theWrappedObject);
}

bool  PythonQtWrapper_QKeySequence::__le__(QKeySequence* theWrappedObject, const QKeySequence&  other) const
{
  return ( (*theWrappedObject)<= other);
}

bool  PythonQtWrapper_QKeySequence::__eq__(QKeySequence* theWrappedObject, const QKeySequence&  other) const
{
  return ( (*theWrappedObject)== other);
}

bool  PythonQtWrapper_QKeySequence::__gt__(QKeySequence* theWrappedObject, const QKeySequence&  other) const
{
  return ( (*theWrappedObject)> other);
}

bool  PythonQtWrapper_QKeySequence::__ge__(QKeySequence* theWrappedObject, const QKeySequence&  other) const
{
  return ( (*theWrappedObject)>= other);
}

void PythonQtWrapper_QKeySequence::readFrom(QKeySequence* theWrappedObject, QDataStream&  out)
{
  out >>  (*theWrappedObject);
}

int  PythonQtWrapper_QKeySequence::operator_subscript(QKeySequence* theWrappedObject, uint  i) const
{
  return ( (*theWrappedObject)[i]);
}

void PythonQtWrapper_QKeySequence::swap(QKeySequence* theWrappedObject, QKeySequence&  other)
{
  ( theWrappedObject->swap(other));
}

QString  PythonQtWrapper_QKeySequence::toString(QKeySequence* theWrappedObject, QKeySequence::SequenceFormat  format) const
{
  return ( theWrappedObject->toString(format));
}

QString PythonQtWrapper_QKeySequence::py_toString(QKeySequence* obj) { return obj->toString(); }


QMatrix4x4* PythonQtWrapper_QMatrix4x4::new_QMatrix4x4()
{
return new QMatrix4x4(); }

QMatrix4x4* PythonQtWrapper_QMatrix4x4::new_QMatrix4x4(const QMatrix&  matrix)
{
return new QMatrix4x4(matrix); }

QMatrix4x4* PythonQtWrapper_QMatrix4x4::new_QMatrix4x4(const QTransform&  transform)
{
return new QMatrix4x4(transform); }

QMatrix4x4* PythonQtWrapper_QMatrix4x4::new_QMatrix4x4(const float*  values)
{
return new QMatrix4x4(values); }

QMatrix4x4* PythonQtWrapper_QMatrix4x4::new_QMatrix4x4(const float*  values, int  cols, int  rows)
{
return new QMatrix4x4(values, cols, rows); }

QMatrix4x4* PythonQtWrapper_QMatrix4x4::new_QMatrix4x4(float  m11, float  m12, float  m13, float  m14, float  m21, float  m22, float  m23, float  m24, float  m31, float  m32, float  m33, float  m34, float  m41, float  m42, float  m43, float  m44)
{
return new QMatrix4x4(m11, m12, m13, m14, m21, m22, m23, m24, m31, m32, m33, m34, m41, m42, m43, m44); }

QVector4D  PythonQtWrapper_QMatrix4x4::column(QMatrix4x4* theWrappedObject, int  index) const
{
  return ( theWrappedObject->column(index));
}

const float*  PythonQtWrapper_QMatrix4x4::constData(QMatrix4x4* theWrappedObject) const
{
  return ( theWrappedObject->constData());
}

void PythonQtWrapper_QMatrix4x4::copyDataTo(QMatrix4x4* theWrappedObject, float*  values) const
{
  ( theWrappedObject->copyDataTo(values));
}

float*  PythonQtWrapper_QMatrix4x4::data(QMatrix4x4* theWrappedObject)
{
  return ( theWrappedObject->data());
}

double  PythonQtWrapper_QMatrix4x4::determinant(QMatrix4x4* theWrappedObject) const
{
  return ( theWrappedObject->determinant());
}

void PythonQtWrapper_QMatrix4x4::fill(QMatrix4x4* theWrappedObject, float  value)
{
  ( theWrappedObject->fill(value));
}

void PythonQtWrapper_QMatrix4x4::flipCoordinates(QMatrix4x4* theWrappedObject)
{
  ( theWrappedObject->flipCoordinates());
}

void PythonQtWrapper_QMatrix4x4::frustum(QMatrix4x4* theWrappedObject, float  left, float  right, float  bottom, float  top, float  nearPlane, float  farPlane)
{
  ( theWrappedObject->frustum(left, right, bottom, top, nearPlane, farPlane));
}

QMatrix4x4  PythonQtWrapper_QMatrix4x4::inverted(QMatrix4x4* theWrappedObject, bool*  invertible) const
{
  return ( theWrappedObject->inverted(invertible));
}

bool  PythonQtWrapper_QMatrix4x4::isAffine(QMatrix4x4* theWrappedObject) const
{
  return ( theWrappedObject->isAffine());
}

bool  PythonQtWrapper_QMatrix4x4::isIdentity(QMatrix4x4* theWrappedObject) const
{
  return ( theWrappedObject->isIdentity());
}

void PythonQtWrapper_QMatrix4x4::lookAt(QMatrix4x4* theWrappedObject, const QVector3D&  eye, const QVector3D&  center, const QVector3D&  up)
{
  ( theWrappedObject->lookAt(eye, center, up));
}

QPoint  PythonQtWrapper_QMatrix4x4::map(QMatrix4x4* theWrappedObject, const QPoint&  point) const
{
  return ( theWrappedObject->map(point));
}

QPointF  PythonQtWrapper_QMatrix4x4::map(QMatrix4x4* theWrappedObject, const QPointF&  point) const
{
  return ( theWrappedObject->map(point));
}

QVector3D  PythonQtWrapper_QMatrix4x4::map(QMatrix4x4* theWrappedObject, const QVector3D&  point) const
{
  return ( theWrappedObject->map(point));
}

QVector4D  PythonQtWrapper_QMatrix4x4::map(QMatrix4x4* theWrappedObject, const QVector4D&  point) const
{
  return ( theWrappedObject->map(point));
}

QRect  PythonQtWrapper_QMatrix4x4::mapRect(QMatrix4x4* theWrappedObject, const QRect&  rect) const
{
  return ( theWrappedObject->mapRect(rect));
}

QRectF  PythonQtWrapper_QMatrix4x4::mapRect(QMatrix4x4* theWrappedObject, const QRectF&  rect) const
{
  return ( theWrappedObject->mapRect(rect));
}

QVector3D  PythonQtWrapper_QMatrix4x4::mapVector(QMatrix4x4* theWrappedObject, const QVector3D&  vector) const
{
  return ( theWrappedObject->mapVector(vector));
}

bool  PythonQtWrapper_QMatrix4x4::__ne__(QMatrix4x4* theWrappedObject, const QMatrix4x4&  other) const
{
  return ( (*theWrappedObject)!= other);
}

float*  PythonQtWrapper_QMatrix4x4::operator_cast_(QMatrix4x4* theWrappedObject, int  row, int  column)
{
  return &( theWrappedObject->operator()(row, column));
}

QMatrix4x4  PythonQtWrapper_QMatrix4x4::__mul__(QMatrix4x4* theWrappedObject, const QMatrix4x4&  m2)
{
  return ( (*theWrappedObject)* m2);
}

QPoint  PythonQtWrapper_QMatrix4x4::__mul__(QMatrix4x4* theWrappedObject, const QPoint&  point)
{
  return ( (*theWrappedObject)* point);
}

QPointF  PythonQtWrapper_QMatrix4x4::__mul__(QMatrix4x4* theWrappedObject, const QPointF&  point)
{
  return ( (*theWrappedObject)* point);
}

QVector3D  PythonQtWrapper_QMatrix4x4::__mul__(QMatrix4x4* theWrappedObject, const QVector3D&  vector)
{
  return ( (*theWrappedObject)* vector);
}

QVector4D  PythonQtWrapper_QMatrix4x4::__mul__(QMatrix4x4* theWrappedObject, const QVector4D&  vector)
{
  return ( (*theWrappedObject)* vector);
}

QMatrix4x4  PythonQtWrapper_QMatrix4x4::__mul__(QMatrix4x4* theWrappedObject, float  factor)
{
  return ( (*theWrappedObject)* factor);
}

QMatrix4x4*  PythonQtWrapper_QMatrix4x4::__imul__(QMatrix4x4* theWrappedObject, const QMatrix4x4&  other)
{
  return &( (*theWrappedObject)*= other);
}

QMatrix4x4*  PythonQtWrapper_QMatrix4x4::__imul__(QMatrix4x4* theWrappedObject, float  factor)
{
  return &( (*theWrappedObject)*= factor);
}

QMatrix4x4  PythonQtWrapper_QMatrix4x4::__add__(QMatrix4x4* theWrappedObject, const QMatrix4x4&  m2)
{
  return ( (*theWrappedObject)+ m2);
}

QMatrix4x4*  PythonQtWrapper_QMatrix4x4::__iadd__(QMatrix4x4* theWrappedObject, const QMatrix4x4&  other)
{
  return &( (*theWrappedObject)+= other);
}

QMatrix4x4  PythonQtWrapper_QMatrix4x4::__sub__(QMatrix4x4* theWrappedObject, const QMatrix4x4&  m2)
{
  return ( (*theWrappedObject)- m2);
}

QMatrix4x4*  PythonQtWrapper_QMatrix4x4::__isub__(QMatrix4x4* theWrappedObject, const QMatrix4x4&  other)
{
  return &( (*theWrappedObject)-= other);
}

QMatrix4x4  PythonQtWrapper_QMatrix4x4::__div__(QMatrix4x4* theWrappedObject, float  divisor)
{
  return ( (*theWrappedObject)/ divisor);
}

QMatrix4x4*  PythonQtWrapper_QMatrix4x4::__idiv__(QMatrix4x4* theWrappedObject, float  divisor)
{
  return &( (*theWrappedObject)/= divisor);
}

void PythonQtWrapper_QMatrix4x4::writeTo(QMatrix4x4* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 <<  (*theWrappedObject);
}

bool  PythonQtWrapper_QMatrix4x4::__eq__(QMatrix4x4* theWrappedObject, const QMatrix4x4&  other) const
{
  return ( (*theWrappedObject)== other);
}

void PythonQtWrapper_QMatrix4x4::readFrom(QMatrix4x4* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 >>  (*theWrappedObject);
}

void PythonQtWrapper_QMatrix4x4::optimize(QMatrix4x4* theWrappedObject)
{
  ( theWrappedObject->optimize());
}

void PythonQtWrapper_QMatrix4x4::ortho(QMatrix4x4* theWrappedObject, const QRect&  rect)
{
  ( theWrappedObject->ortho(rect));
}

void PythonQtWrapper_QMatrix4x4::ortho(QMatrix4x4* theWrappedObject, const QRectF&  rect)
{
  ( theWrappedObject->ortho(rect));
}

void PythonQtWrapper_QMatrix4x4::ortho(QMatrix4x4* theWrappedObject, float  left, float  right, float  bottom, float  top, float  nearPlane, float  farPlane)
{
  ( theWrappedObject->ortho(left, right, bottom, top, nearPlane, farPlane));
}

void PythonQtWrapper_QMatrix4x4::perspective(QMatrix4x4* theWrappedObject, float  verticalAngle, float  aspectRatio, float  nearPlane, float  farPlane)
{
  ( theWrappedObject->perspective(verticalAngle, aspectRatio, nearPlane, farPlane));
}

void PythonQtWrapper_QMatrix4x4::rotate(QMatrix4x4* theWrappedObject, const QQuaternion&  quaternion)
{
  ( theWrappedObject->rotate(quaternion));
}

void PythonQtWrapper_QMatrix4x4::rotate(QMatrix4x4* theWrappedObject, float  angle, const QVector3D&  vector)
{
  ( theWrappedObject->rotate(angle, vector));
}

void PythonQtWrapper_QMatrix4x4::rotate(QMatrix4x4* theWrappedObject, float  angle, float  x, float  y, float  z)
{
  ( theWrappedObject->rotate(angle, x, y, z));
}

QVector4D  PythonQtWrapper_QMatrix4x4::row(QMatrix4x4* theWrappedObject, int  index) const
{
  return ( theWrappedObject->row(index));
}

void PythonQtWrapper_QMatrix4x4::scale(QMatrix4x4* theWrappedObject, const QVector3D&  vector)
{
  ( theWrappedObject->scale(vector));
}

void PythonQtWrapper_QMatrix4x4::scale(QMatrix4x4* theWrappedObject, float  factor)
{
  ( theWrappedObject->scale(factor));
}

void PythonQtWrapper_QMatrix4x4::scale(QMatrix4x4* theWrappedObject, float  x, float  y)
{
  ( theWrappedObject->scale(x, y));
}

void PythonQtWrapper_QMatrix4x4::scale(QMatrix4x4* theWrappedObject, float  x, float  y, float  z)
{
  ( theWrappedObject->scale(x, y, z));
}

void PythonQtWrapper_QMatrix4x4::setColumn(QMatrix4x4* theWrappedObject, int  index, const QVector4D&  value)
{
  ( theWrappedObject->setColumn(index, value));
}

void PythonQtWrapper_QMatrix4x4::setRow(QMatrix4x4* theWrappedObject, int  index, const QVector4D&  value)
{
  ( theWrappedObject->setRow(index, value));
}

void PythonQtWrapper_QMatrix4x4::setToIdentity(QMatrix4x4* theWrappedObject)
{
  ( theWrappedObject->setToIdentity());
}

QMatrix  PythonQtWrapper_QMatrix4x4::toAffine(QMatrix4x4* theWrappedObject) const
{
  return ( theWrappedObject->toAffine());
}

QTransform  PythonQtWrapper_QMatrix4x4::toTransform(QMatrix4x4* theWrappedObject) const
{
  return ( theWrappedObject->toTransform());
}

QTransform  PythonQtWrapper_QMatrix4x4::toTransform(QMatrix4x4* theWrappedObject, float  distanceToPlane) const
{
  return ( theWrappedObject->toTransform(distanceToPlane));
}

void PythonQtWrapper_QMatrix4x4::translate(QMatrix4x4* theWrappedObject, const QVector3D&  vector)
{
  ( theWrappedObject->translate(vector));
}

void PythonQtWrapper_QMatrix4x4::translate(QMatrix4x4* theWrappedObject, float  x, float  y)
{
  ( theWrappedObject->translate(x, y));
}

void PythonQtWrapper_QMatrix4x4::translate(QMatrix4x4* theWrappedObject, float  x, float  y, float  z)
{
  ( theWrappedObject->translate(x, y, z));
}

QMatrix4x4  PythonQtWrapper_QMatrix4x4::transposed(QMatrix4x4* theWrappedObject) const
{
  return ( theWrappedObject->transposed());
}

void PythonQtWrapper_QMatrix4x4::viewport(QMatrix4x4* theWrappedObject, const QRectF&  rect)
{
  ( theWrappedObject->viewport(rect));
}

void PythonQtWrapper_QMatrix4x4::viewport(QMatrix4x4* theWrappedObject, float  left, float  bottom, float  width, float  height, float  nearPlane, float  farPlane)
{
  ( theWrappedObject->viewport(left, bottom, width, height, nearPlane, farPlane));
}

QString PythonQtWrapper_QMatrix4x4::py_toString(QMatrix4x4* obj) {
  QString result;
  QDebug d(&result);
  d << *obj;
  return result;
}



QPalette* PythonQtWrapper_QPalette::new_QPalette()
{
return new QPalette(); }

QPalette* PythonQtWrapper_QPalette::new_QPalette(Qt::GlobalColor  button)
{
return new QPalette(button); }

QPalette* PythonQtWrapper_QPalette::new_QPalette(const QBrush&  windowText, const QBrush&  button, const QBrush&  light, const QBrush&  dark, const QBrush&  mid, const QBrush&  text, const QBrush&  bright_text, const QBrush&  base, const QBrush&  window)
{
return new QPalette(windowText, button, light, dark, mid, text, bright_text, base, window); }

QPalette* PythonQtWrapper_QPalette::new_QPalette(const QColor&  button)
{
return new QPalette(button); }

QPalette* PythonQtWrapper_QPalette::new_QPalette(const QColor&  button, const QColor&  window)
{
return new QPalette(button, window); }

QPalette* PythonQtWrapper_QPalette::new_QPalette(const QPalette&  palette)
{
return new QPalette(palette); }

const QBrush*  PythonQtWrapper_QPalette::alternateBase(QPalette* theWrappedObject) const
{
  return &( theWrappedObject->alternateBase());
}

const QBrush*  PythonQtWrapper_QPalette::base(QPalette* theWrappedObject) const
{
  return &( theWrappedObject->base());
}

const QBrush*  PythonQtWrapper_QPalette::brightText(QPalette* theWrappedObject) const
{
  return &( theWrappedObject->brightText());
}

const QBrush*  PythonQtWrapper_QPalette::brush(QPalette* theWrappedObject, QPalette::ColorGroup  cg, QPalette::ColorRole  cr) const
{
  return &( theWrappedObject->brush(cg, cr));
}

const QBrush*  PythonQtWrapper_QPalette::brush(QPalette* theWrappedObject, QPalette::ColorRole  cr) const
{
  return &( theWrappedObject->brush(cr));
}

const QBrush*  PythonQtWrapper_QPalette::button(QPalette* theWrappedObject) const
{
  return &( theWrappedObject->button());
}

const QBrush*  PythonQtWrapper_QPalette::buttonText(QPalette* theWrappedObject) const
{
  return &( theWrappedObject->buttonText());
}

qint64  PythonQtWrapper_QPalette::cacheKey(QPalette* theWrappedObject) const
{
  return ( theWrappedObject->cacheKey());
}

const QColor*  PythonQtWrapper_QPalette::color(QPalette* theWrappedObject, QPalette::ColorGroup  cg, QPalette::ColorRole  cr) const
{
  return &( theWrappedObject->color(cg, cr));
}

const QColor*  PythonQtWrapper_QPalette::color(QPalette* theWrappedObject, QPalette::ColorRole  cr) const
{
  return &( theWrappedObject->color(cr));
}

QPalette::ColorGroup  PythonQtWrapper_QPalette::currentColorGroup(QPalette* theWrappedObject) const
{
  return ( theWrappedObject->currentColorGroup());
}

const QBrush*  PythonQtWrapper_QPalette::dark(QPalette* theWrappedObject) const
{
  return &( theWrappedObject->dark());
}

const QBrush*  PythonQtWrapper_QPalette::highlight(QPalette* theWrappedObject) const
{
  return &( theWrappedObject->highlight());
}

const QBrush*  PythonQtWrapper_QPalette::highlightedText(QPalette* theWrappedObject) const
{
  return &( theWrappedObject->highlightedText());
}

bool  PythonQtWrapper_QPalette::isBrushSet(QPalette* theWrappedObject, QPalette::ColorGroup  cg, QPalette::ColorRole  cr) const
{
  return ( theWrappedObject->isBrushSet(cg, cr));
}

bool  PythonQtWrapper_QPalette::isCopyOf(QPalette* theWrappedObject, const QPalette&  p) const
{
  return ( theWrappedObject->isCopyOf(p));
}

bool  PythonQtWrapper_QPalette::isEqual(QPalette* theWrappedObject, QPalette::ColorGroup  cr1, QPalette::ColorGroup  cr2) const
{
  return ( theWrappedObject->isEqual(cr1, cr2));
}

const QBrush*  PythonQtWrapper_QPalette::light(QPalette* theWrappedObject) const
{
  return &( theWrappedObject->light());
}

const QBrush*  PythonQtWrapper_QPalette::link(QPalette* theWrappedObject) const
{
  return &( theWrappedObject->link());
}

const QBrush*  PythonQtWrapper_QPalette::linkVisited(QPalette* theWrappedObject) const
{
  return &( theWrappedObject->linkVisited());
}

const QBrush*  PythonQtWrapper_QPalette::mid(QPalette* theWrappedObject) const
{
  return &( theWrappedObject->mid());
}

const QBrush*  PythonQtWrapper_QPalette::midlight(QPalette* theWrappedObject) const
{
  return &( theWrappedObject->midlight());
}

bool  PythonQtWrapper_QPalette::__ne__(QPalette* theWrappedObject, const QPalette&  p) const
{
  return ( (*theWrappedObject)!= p);
}

void PythonQtWrapper_QPalette::writeTo(QPalette* theWrappedObject, QDataStream&  ds)
{
  ds <<  (*theWrappedObject);
}

bool  PythonQtWrapper_QPalette::__eq__(QPalette* theWrappedObject, const QPalette&  p) const
{
  return ( (*theWrappedObject)== p);
}

void PythonQtWrapper_QPalette::readFrom(QPalette* theWrappedObject, QDataStream&  ds)
{
  ds >>  (*theWrappedObject);
}

const QBrush*  PythonQtWrapper_QPalette::placeholderText(QPalette* theWrappedObject) const
{
  return &( theWrappedObject->placeholderText());
}

uint  PythonQtWrapper_QPalette::resolve(QPalette* theWrappedObject) const
{
  return ( theWrappedObject->resolve());
}

QPalette  PythonQtWrapper_QPalette::resolve(QPalette* theWrappedObject, const QPalette&  arg__1) const
{
  return ( theWrappedObject->resolve(arg__1));
}

void PythonQtWrapper_QPalette::resolve(QPalette* theWrappedObject, uint  mask)
{
  ( theWrappedObject->resolve(mask));
}

void PythonQtWrapper_QPalette::setBrush(QPalette* theWrappedObject, QPalette::ColorGroup  cg, QPalette::ColorRole  cr, const QBrush&  brush)
{
  ( theWrappedObject->setBrush(cg, cr, brush));
}

void PythonQtWrapper_QPalette::setBrush(QPalette* theWrappedObject, QPalette::ColorRole  cr, const QBrush&  brush)
{
  ( theWrappedObject->setBrush(cr, brush));
}

void PythonQtWrapper_QPalette::setColor(QPalette* theWrappedObject, QPalette::ColorGroup  cg, QPalette::ColorRole  cr, const QColor&  color)
{
  ( theWrappedObject->setColor(cg, cr, color));
}

void PythonQtWrapper_QPalette::setColor(QPalette* theWrappedObject, QPalette::ColorRole  cr, const QColor&  color)
{
  ( theWrappedObject->setColor(cr, color));
}

void PythonQtWrapper_QPalette::setColorGroup(QPalette* theWrappedObject, QPalette::ColorGroup  cr, const QBrush&  windowText, const QBrush&  button, const QBrush&  light, const QBrush&  dark, const QBrush&  mid, const QBrush&  text, const QBrush&  bright_text, const QBrush&  base, const QBrush&  window)
{
  ( theWrappedObject->setColorGroup(cr, windowText, button, light, dark, mid, text, bright_text, base, window));
}

void PythonQtWrapper_QPalette::setCurrentColorGroup(QPalette* theWrappedObject, QPalette::ColorGroup  cg)
{
  ( theWrappedObject->setCurrentColorGroup(cg));
}

const QBrush*  PythonQtWrapper_QPalette::shadow(QPalette* theWrappedObject) const
{
  return &( theWrappedObject->shadow());
}

void PythonQtWrapper_QPalette::swap(QPalette* theWrappedObject, QPalette&  other)
{
  ( theWrappedObject->swap(other));
}

const QBrush*  PythonQtWrapper_QPalette::text(QPalette* theWrappedObject) const
{
  return &( theWrappedObject->text());
}

const QBrush*  PythonQtWrapper_QPalette::toolTipBase(QPalette* theWrappedObject) const
{
  return &( theWrappedObject->toolTipBase());
}

const QBrush*  PythonQtWrapper_QPalette::toolTipText(QPalette* theWrappedObject) const
{
  return &( theWrappedObject->toolTipText());
}

const QBrush*  PythonQtWrapper_QPalette::window(QPalette* theWrappedObject) const
{
  return &( theWrappedObject->window());
}

const QBrush*  PythonQtWrapper_QPalette::windowText(QPalette* theWrappedObject) const
{
  return &( theWrappedObject->windowText());
}

QString PythonQtWrapper_QPalette::py_toString(QPalette* obj) {
  QString result;
  QDebug d(&result);
  d << *obj;
  return result;
}



QPen* PythonQtWrapper_QPen::new_QPen()
{
return new QPen(); }

QPen* PythonQtWrapper_QPen::new_QPen(Qt::PenStyle  arg__1)
{
return new QPen(arg__1); }

QPen* PythonQtWrapper_QPen::new_QPen(const QBrush&  brush, qreal  width, Qt::PenStyle  s, Qt::PenCapStyle  c, Qt::PenJoinStyle  j)
{
return new QPen(brush, width, s, c, j); }

QPen* PythonQtWrapper_QPen::new_QPen(const QColor&  color)
{
return new QPen(color); }

QPen* PythonQtWrapper_QPen::new_QPen(const QPen&  pen)
{
return new QPen(pen); }

QBrush  PythonQtWrapper_QPen::brush(QPen* theWrappedObject) const
{
  return ( theWrappedObject->brush());
}

Qt::PenCapStyle  PythonQtWrapper_QPen::capStyle(QPen* theWrappedObject) const
{
  return ( theWrappedObject->capStyle());
}

QColor  PythonQtWrapper_QPen::color(QPen* theWrappedObject) const
{
  return ( theWrappedObject->color());
}

qreal  PythonQtWrapper_QPen::dashOffset(QPen* theWrappedObject) const
{
  return ( theWrappedObject->dashOffset());
}

QVector<qreal >  PythonQtWrapper_QPen::dashPattern(QPen* theWrappedObject) const
{
  return ( theWrappedObject->dashPattern());
}

bool  PythonQtWrapper_QPen::isCosmetic(QPen* theWrappedObject) const
{
  return ( theWrappedObject->isCosmetic());
}

bool  PythonQtWrapper_QPen::isSolid(QPen* theWrappedObject) const
{
  return ( theWrappedObject->isSolid());
}

Qt::PenJoinStyle  PythonQtWrapper_QPen::joinStyle(QPen* theWrappedObject) const
{
  return ( theWrappedObject->joinStyle());
}

qreal  PythonQtWrapper_QPen::miterLimit(QPen* theWrappedObject) const
{
  return ( theWrappedObject->miterLimit());
}

bool  PythonQtWrapper_QPen::__ne__(QPen* theWrappedObject, const QPen&  p) const
{
  return ( (*theWrappedObject)!= p);
}

void PythonQtWrapper_QPen::writeTo(QPen* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 <<  (*theWrappedObject);
}

bool  PythonQtWrapper_QPen::__eq__(QPen* theWrappedObject, const QPen&  p) const
{
  return ( (*theWrappedObject)== p);
}

void PythonQtWrapper_QPen::readFrom(QPen* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 >>  (*theWrappedObject);
}

void PythonQtWrapper_QPen::setBrush(QPen* theWrappedObject, const QBrush&  brush)
{
  ( theWrappedObject->setBrush(brush));
}

void PythonQtWrapper_QPen::setCapStyle(QPen* theWrappedObject, Qt::PenCapStyle  pcs)
{
  ( theWrappedObject->setCapStyle(pcs));
}

void PythonQtWrapper_QPen::setColor(QPen* theWrappedObject, const QColor&  color)
{
  ( theWrappedObject->setColor(color));
}

void PythonQtWrapper_QPen::setCosmetic(QPen* theWrappedObject, bool  cosmetic)
{
  ( theWrappedObject->setCosmetic(cosmetic));
}

void PythonQtWrapper_QPen::setDashOffset(QPen* theWrappedObject, qreal  doffset)
{
  ( theWrappedObject->setDashOffset(doffset));
}

void PythonQtWrapper_QPen::setDashPattern(QPen* theWrappedObject, const QVector<qreal >&  pattern)
{
  ( theWrappedObject->setDashPattern(pattern));
}

void PythonQtWrapper_QPen::setJoinStyle(QPen* theWrappedObject, Qt::PenJoinStyle  pcs)
{
  ( theWrappedObject->setJoinStyle(pcs));
}

void PythonQtWrapper_QPen::setMiterLimit(QPen* theWrappedObject, qreal  limit)
{
  ( theWrappedObject->setMiterLimit(limit));
}

void PythonQtWrapper_QPen::setStyle(QPen* theWrappedObject, Qt::PenStyle  arg__1)
{
  ( theWrappedObject->setStyle(arg__1));
}

void PythonQtWrapper_QPen::setWidth(QPen* theWrappedObject, int  width)
{
  ( theWrappedObject->setWidth(width));
}

void PythonQtWrapper_QPen::setWidthF(QPen* theWrappedObject, qreal  width)
{
  ( theWrappedObject->setWidthF(width));
}

Qt::PenStyle  PythonQtWrapper_QPen::style(QPen* theWrappedObject) const
{
  return ( theWrappedObject->style());
}

void PythonQtWrapper_QPen::swap(QPen* theWrappedObject, QPen&  other)
{
  ( theWrappedObject->swap(other));
}

int  PythonQtWrapper_QPen::width(QPen* theWrappedObject) const
{
  return ( theWrappedObject->width());
}

qreal  PythonQtWrapper_QPen::widthF(QPen* theWrappedObject) const
{
  return ( theWrappedObject->widthF());
}

QString PythonQtWrapper_QPen::py_toString(QPen* obj) {
  QString result;
  QDebug d(&result);
  d << *obj;
  return result;
}



PythonQtShell_QPixmap::~PythonQtShell_QPixmap() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
int  PythonQtShell_QPixmap::devType() const
{
if (_wrapper) {
  PYTHONQT_GIL_SCOPE
  if (Py_REFCNT((PyObject*)_wrapper) > 0) {
    static PyObject* name = PyUnicode_FromString("devType");
    PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
    if (obj) {
      static const char* argumentList[] ={"int"};
      static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      int returnValue{};
      void* args[1] = {nullptr};
      PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
      if (result) {
        args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue);
        if (args[0]!=&returnValue) {
          if (args[0]==nullptr) {
            PythonQt::priv()->handleVirtualOverloadReturnError("devType", methodInfo, result);
          } else {
            returnValue = *((int*)args[0]);
          }
        }
      }
      if (result) { Py_DECREF(result); }
      Py_DECREF(obj);
      return returnValue;
    } else {
      PyErr_Clear();
    }
  }
}
  return QPixmap::devType();
}
void PythonQtShell_QPixmap::initPainter(QPainter*  painter0) const
{
if (_wrapper) {
  PYTHONQT_GIL_SCOPE
  if (Py_REFCNT((PyObject*)_wrapper) > 0) {
    static PyObject* name = PyUnicode_FromString("initPainter");
    PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
    if (obj) {
      static const char* argumentList[] ={"" , "QPainter*"};
      static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      void* args[2] = {nullptr, (void*)&painter0};
      PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
      if (result) { Py_DECREF(result); }
      Py_DECREF(obj);
      return;
    } else {
      PyErr_Clear();
    }
  }
}
  QPixmap::initPainter(painter0);
}
int  PythonQtShell_QPixmap::metric(QPaintDevice::PaintDeviceMetric  arg__1) const
{
if (_wrapper) {
  PYTHONQT_GIL_SCOPE
  if (Py_REFCNT((PyObject*)_wrapper) > 0) {
    static PyObject* name = PyUnicode_FromString("metric");
    PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
    if (obj) {
      static const char* argumentList[] ={"int" , "QPaintDevice::PaintDeviceMetric"};
      static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      int returnValue{};
      void* args[2] = {nullptr, (void*)&arg__1};
      PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
      if (result) {
        args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue);
        if (args[0]!=&returnValue) {
          if (args[0]==nullptr) {
            PythonQt::priv()->handleVirtualOverloadReturnError("metric", methodInfo, result);
          } else {
            returnValue = *((int*)args[0]);
          }
        }
      }
      if (result) { Py_DECREF(result); }
      Py_DECREF(obj);
      return returnValue;
    } else {
      PyErr_Clear();
    }
  }
}
  return QPixmap::metric(arg__1);
}
QPaintEngine*  PythonQtShell_QPixmap::paintEngine() const
{
if (_wrapper) {
  PYTHONQT_GIL_SCOPE
  if (Py_REFCNT((PyObject*)_wrapper) > 0) {
    static PyObject* name = PyUnicode_FromString("paintEngine");
    PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
    if (obj) {
      static const char* argumentList[] ={"QPaintEngine*"};
      static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QPaintEngine* returnValue{};
      void* args[1] = {nullptr};
      PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
      if (result) {
        args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue);
        if (args[0]!=&returnValue) {
          if (args[0]==nullptr) {
            PythonQt::priv()->handleVirtualOverloadReturnError("paintEngine", methodInfo, result);
          } else {
            returnValue = *((QPaintEngine**)args[0]);
          }
        }
      }
      if (result) { Py_DECREF(result); }
      Py_DECREF(obj);
      return returnValue;
    } else {
      PyErr_Clear();
    }
  }
}
  return QPixmap::paintEngine();
}
QPaintDevice*  PythonQtShell_QPixmap::redirected(QPoint*  offset0) const
{
if (_wrapper) {
  PYTHONQT_GIL_SCOPE
  if (Py_REFCNT((PyObject*)_wrapper) > 0) {
    static PyObject* name = PyUnicode_FromString("redirected");
    PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
    if (obj) {
      static const char* argumentList[] ={"QPaintDevice*" , "QPoint*"};
      static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      QPaintDevice* returnValue{};
      void* args[2] = {nullptr, (void*)&offset0};
      PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
      if (result) {
        args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue);
        if (args[0]!=&returnValue) {
          if (args[0]==nullptr) {
            PythonQt::priv()->handleVirtualOverloadReturnError("redirected", methodInfo, result);
          } else {
            returnValue = *((QPaintDevice**)args[0]);
          }
        }
      }
      if (result) { Py_DECREF(result); }
      Py_DECREF(obj);
      return returnValue;
    } else {
      PyErr_Clear();
    }
  }
}
  return QPixmap::redirected(offset0);
}
QPainter*  PythonQtShell_QPixmap::sharedPainter() const
{
if (_wrapper) {
  PYTHONQT_GIL_SCOPE
  if (Py_REFCNT((PyObject*)_wrapper) > 0) {
    static PyObject* name = PyUnicode_FromString("sharedPainter");
    PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
    if (obj) {
      static const char* argumentList[] ={"QPainter*"};
      static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QPainter* returnValue{};
      void* args[1] = {nullptr};
      PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
      if (result) {
        args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, nullptr, &returnValue);
        if (args[0]!=&returnValue) {
          if (args[0]==nullptr) {
            PythonQt::priv()->handleVirtualOverloadReturnError("sharedPainter", methodInfo, result);
          } else {
            returnValue = *((QPainter**)args[0]);
          }
        }
      }
      if (result) { Py_DECREF(result); }
      Py_DECREF(obj);
      return returnValue;
    } else {
      PyErr_Clear();
    }
  }
}
  return QPixmap::sharedPainter();
}
QPixmap* PythonQtWrapper_QPixmap::new_QPixmap()
{
return new PythonQtShell_QPixmap(); }

QPixmap* PythonQtWrapper_QPixmap::new_QPixmap(const QPixmap&  arg__1)
{
return new PythonQtShell_QPixmap(arg__1); }

QPixmap* PythonQtWrapper_QPixmap::new_QPixmap(const QSize&  arg__1)
{
return new PythonQtShell_QPixmap(arg__1); }

QPixmap* PythonQtWrapper_QPixmap::new_QPixmap(const QString&  fileName, const char*  format, Qt::ImageConversionFlags  flags)
{
return new PythonQtShell_QPixmap(fileName, format, flags); }

QPixmap* PythonQtWrapper_QPixmap::new_QPixmap(int  w, int  h)
{
return new PythonQtShell_QPixmap(w, h); }

qint64  PythonQtWrapper_QPixmap::cacheKey(QPixmap* theWrappedObject) const
{
  return ( theWrappedObject->cacheKey());
}

bool  PythonQtWrapper_QPixmap::convertFromImage(QPixmap* theWrappedObject, const QImage&  img, Qt::ImageConversionFlags  flags)
{
  return ( theWrappedObject->convertFromImage(img, flags));
}

QPixmap  PythonQtWrapper_QPixmap::copy(QPixmap* theWrappedObject, const QRect&  rect) const
{
  return ( theWrappedObject->copy(rect));
}

QPixmap  PythonQtWrapper_QPixmap::copy(QPixmap* theWrappedObject, int  x, int  y, int  width, int  height) const
{
  return ( theWrappedObject->copy(x, y, width, height));
}

QBitmap  PythonQtWrapper_QPixmap::createHeuristicMask(QPixmap* theWrappedObject, bool  clipTight) const
{
  return ( theWrappedObject->createHeuristicMask(clipTight));
}

QBitmap  PythonQtWrapper_QPixmap::createMaskFromColor(QPixmap* theWrappedObject, const QColor&  maskColor, Qt::MaskMode  mode) const
{
  return ( theWrappedObject->createMaskFromColor(maskColor, mode));
}

int  PythonQtWrapper_QPixmap::static_QPixmap_defaultDepth()
{
  return (QPixmap::defaultDepth());
}

int  PythonQtWrapper_QPixmap::depth(QPixmap* theWrappedObject) const
{
  return ( theWrappedObject->depth());
}

qreal  PythonQtWrapper_QPixmap::devicePixelRatio(QPixmap* theWrappedObject) const
{
  return ( theWrappedObject->devicePixelRatio());
}

void PythonQtWrapper_QPixmap::fill(QPixmap* theWrappedObject, const QColor&  fillColor)
{
  ( theWrappedObject->fill(fillColor));
}

void PythonQtWrapper_QPixmap::fill(QPixmap* theWrappedObject, const QPaintDevice*  device, const QPoint&  ofs)
{
  ( theWrappedObject->fill(device, ofs));
}

void PythonQtWrapper_QPixmap::fill(QPixmap* theWrappedObject, const QPaintDevice*  device, int  xofs, int  yofs)
{
  ( theWrappedObject->fill(device, xofs, yofs));
}

QPixmap  PythonQtWrapper_QPixmap::static_QPixmap_fromImage(const QImage&  image, Qt::ImageConversionFlags  flags)
{
  return (QPixmap::fromImage(image, flags));
}

QPixmap  PythonQtWrapper_QPixmap::static_QPixmap_fromImageReader(QImageReader*  imageReader, Qt::ImageConversionFlags  flags)
{
  return (QPixmap::fromImageReader(imageReader, flags));
}

QPixmap  PythonQtWrapper_QPixmap::static_QPixmap_grabWidget(QObject*  widget, const QRect&  rect)
{
  return (QPixmap::grabWidget(widget, rect));
}

QPixmap  PythonQtWrapper_QPixmap::static_QPixmap_grabWidget(QObject*  widget, int  x, int  y, int  w, int  h)
{
  return (QPixmap::grabWidget(widget, x, y, w, h));
}

QPixmap  PythonQtWrapper_QPixmap::static_QPixmap_grabWindow(WId  arg__1, int  x, int  y, int  w, int  h)
{
  return (QPixmap::grabWindow(arg__1, x, y, w, h));
}

bool  PythonQtWrapper_QPixmap::hasAlpha(QPixmap* theWrappedObject) const
{
  return ( theWrappedObject->hasAlpha());
}

bool  PythonQtWrapper_QPixmap::hasAlphaChannel(QPixmap* theWrappedObject) const
{
  return ( theWrappedObject->hasAlphaChannel());
}

int  PythonQtWrapper_QPixmap::height(QPixmap* theWrappedObject) const
{
  return ( theWrappedObject->height());
}

bool  PythonQtWrapper_QPixmap::isNull(QPixmap* theWrappedObject) const
{
  return ( theWrappedObject->isNull());
}

bool  PythonQtWrapper_QPixmap::isQBitmap(QPixmap* theWrappedObject) const
{
  return ( theWrappedObject->isQBitmap());
}

bool  PythonQtWrapper_QPixmap::load(QPixmap* theWrappedObject, const QString&  fileName, const char*  format, Qt::ImageConversionFlags  flags)
{
  return ( theWrappedObject->load(fileName, format, flags));
}

bool  PythonQtWrapper_QPixmap::loadFromData(QPixmap* theWrappedObject, const QByteArray&  data, const char*  format, Qt::ImageConversionFlags  flags)
{
  return ( theWrappedObject->loadFromData(data, format, flags));
}

QBitmap  PythonQtWrapper_QPixmap::mask(QPixmap* theWrappedObject) const
{
  return ( theWrappedObject->mask());
}

void PythonQtWrapper_QPixmap::writeTo(QPixmap* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 <<  (*theWrappedObject);
}

void PythonQtWrapper_QPixmap::readFrom(QPixmap* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 >>  (*theWrappedObject);
}

QRect  PythonQtWrapper_QPixmap::rect(QPixmap* theWrappedObject) const
{
  return ( theWrappedObject->rect());
}

bool  PythonQtWrapper_QPixmap::save(QPixmap* theWrappedObject, QIODevice*  device, const char*  format, int  quality) const
{
  return ( theWrappedObject->save(device, format, quality));
}

bool  PythonQtWrapper_QPixmap::save(QPixmap* theWrappedObject, const QString&  fileName, const char*  format, int  quality) const
{
  return ( theWrappedObject->save(fileName, format, quality));
}

QPixmap  PythonQtWrapper_QPixmap::scaled(QPixmap* theWrappedObject, const QSize&  s, Qt::AspectRatioMode  aspectMode, Qt::TransformationMode  mode) const
{
  return ( theWrappedObject->scaled(s, aspectMode, mode));
}

QPixmap  PythonQtWrapper_QPixmap::scaled(QPixmap* theWrappedObject, int  w, int  h, Qt::AspectRatioMode  aspectMode, Qt::TransformationMode  mode) const
{
  return ( theWrappedObject->scaled(w, h, aspectMode, mode));
}

QPixmap  PythonQtWrapper_QPixmap::scaledToHeight(QPixmap* theWrappedObject, int  h, Qt::TransformationMode  mode) const
{
  return ( theWrappedObject->scaledToHeight(h, mode));
}

QPixmap  PythonQtWrapper_QPixmap::scaledToWidth(QPixmap* theWrappedObject, int  w, Qt::TransformationMode  mode) const
{
  return ( theWrappedObject->scaledToWidth(w, mode));
}

void PythonQtWrapper_QPixmap::scroll(QPixmap* theWrappedObject, int  dx, int  dy, const QRect&  rect, QRegion*  exposed)
{
  ( theWrappedObject->scroll(dx, dy, rect, exposed));
}

void PythonQtWrapper_QPixmap::scroll(QPixmap* theWrappedObject, int  dx, int  dy, int  x, int  y, int  width, int  height, QRegion*  exposed)
{
  ( theWrappedObject->scroll(dx, dy, x, y, width, height, exposed));
}

void PythonQtWrapper_QPixmap::setDevicePixelRatio(QPixmap* theWrappedObject, qreal  scaleFactor)
{
  ( theWrappedObject->setDevicePixelRatio(scaleFactor));
}

void PythonQtWrapper_QPixmap::setMask(QPixmap* theWrappedObject, const QBitmap&  arg__1)
{
  ( theWrappedObject->setMask(arg__1));
}

QSize  PythonQtWrapper_QPixmap::size(QPixmap* theWrappedObject) const
{
  return ( theWrappedObject->size());
}

void PythonQtWrapper_QPixmap::swap(QPixmap* theWrappedObject, QPixmap&  other)
{
  ( theWrappedObject->swap(other));
}

QImage  PythonQtWrapper_QPixmap::toImage(QPixmap* theWrappedObject) const
{
  return ( theWrappedObject->toImage());
}

QPixmap  PythonQtWrapper_QPixmap::transformed(QPixmap* theWrappedObject, const QMatrix&  arg__1, Qt::TransformationMode  mode) const
{
  return ( theWrappedObject->transformed(arg__1, mode));
}

QPixmap  PythonQtWrapper_QPixmap::transformed(QPixmap* theWrappedObject, const QTransform&  arg__1, Qt::TransformationMode  mode) const
{
  return ( theWrappedObject->transformed(arg__1, mode));
}

QMatrix  PythonQtWrapper_QPixmap::static_QPixmap_trueMatrix(const QMatrix&  m, int  w, int  h)
{
  return (QPixmap::trueMatrix(m, w, h));
}

QTransform  PythonQtWrapper_QPixmap::static_QPixmap_trueMatrix(const QTransform&  m, int  w, int  h)
{
  return (QPixmap::trueMatrix(m, w, h));
}

int  PythonQtWrapper_QPixmap::width(QPixmap* theWrappedObject) const
{
  return ( theWrappedObject->width());
}

QString PythonQtWrapper_QPixmap::py_toString(QPixmap* obj) {
  QString result;
  QDebug d(&result);
  d << *obj;
  return result;
}



QPolygon* PythonQtWrapper_QPolygon::new_QPolygon()
{
return new QPolygon(); }

QPolygon* PythonQtWrapper_QPolygon::new_QPolygon(const QPolygon&  other)
{
return new QPolygon(other); }

QPolygon* PythonQtWrapper_QPolygon::new_QPolygon(const QRect&  r, bool  closed)
{
return new QPolygon(r, closed); }

QPolygon* PythonQtWrapper_QPolygon::new_QPolygon(const QVector<QPoint >&  v)
{
return new QPolygon(v); }

QPolygon* PythonQtWrapper_QPolygon::new_QPolygon(int  size)
{
return new QPolygon(size); }

void PythonQtWrapper_QPolygon::append(QPolygon* theWrappedObject, const QPoint&  t)
{
  ( theWrappedObject->append(t));
}

void PythonQtWrapper_QPolygon::append(QPolygon* theWrappedObject, const QVector<QPoint >&  l)
{
  ( theWrappedObject->append(l));
}

const QPoint*  PythonQtWrapper_QPolygon::at(QPolygon* theWrappedObject, int  i) const
{
  return &( theWrappedObject->at(i));
}

QRect  PythonQtWrapper_QPolygon::boundingRect(QPolygon* theWrappedObject) const
{
  return ( theWrappedObject->boundingRect());
}

int  PythonQtWrapper_QPolygon::capacity(QPolygon* theWrappedObject) const
{
  return ( theWrappedObject->capacity());
}

void PythonQtWrapper_QPolygon::clear(QPolygon* theWrappedObject)
{
  ( theWrappedObject->clear());
}

const QPoint*  PythonQtWrapper_QPolygon::constFirst(QPolygon* theWrappedObject) const
{
  return &( theWrappedObject->constFirst());
}

const QPoint*  PythonQtWrapper_QPolygon::constLast(QPolygon* theWrappedObject) const
{
  return &( theWrappedObject->constLast());
}

bool  PythonQtWrapper_QPolygon::contains(QPolygon* theWrappedObject, const QPoint&  t) const
{
  return ( theWrappedObject->contains(t));
}

bool  PythonQtWrapper_QPolygon::containsPoint(QPolygon* theWrappedObject, const QPoint&  pt, Qt::FillRule  fillRule) const
{
  return ( theWrappedObject->containsPoint(pt, fillRule));
}

int  PythonQtWrapper_QPolygon::count(QPolygon* theWrappedObject) const
{
  return ( theWrappedObject->count());
}

int  PythonQtWrapper_QPolygon::count(QPolygon* theWrappedObject, const QPoint&  t) const
{
  return ( theWrappedObject->count(t));
}

bool  PythonQtWrapper_QPolygon::empty(QPolygon* theWrappedObject) const
{
  return ( theWrappedObject->empty());
}

bool  PythonQtWrapper_QPolygon::endsWith(QPolygon* theWrappedObject, const QPoint&  t) const
{
  return ( theWrappedObject->endsWith(t));
}

QVector<QPoint >*  PythonQtWrapper_QPolygon::fill(QPolygon* theWrappedObject, const QPoint&  t, int  size)
{
  return &( theWrappedObject->fill(t, size));
}

const QPoint*  PythonQtWrapper_QPolygon::first(QPolygon* theWrappedObject) const
{
  return &( theWrappedObject->first());
}

QVector<QPoint >  PythonQtWrapper_QPolygon::static_QPolygon_fromList(const QList<QPoint >&  list)
{
  return (QPolygon::fromList(list));
}

int  PythonQtWrapper_QPolygon::indexOf(QPolygon* theWrappedObject, const QPoint&  t, int  from) const
{
  return ( theWrappedObject->indexOf(t, from));
}

QPolygon  PythonQtWrapper_QPolygon::intersected(QPolygon* theWrappedObject, const QPolygon&  r) const
{
  return ( theWrappedObject->intersected(r));
}

bool  PythonQtWrapper_QPolygon::intersects(QPolygon* theWrappedObject, const QPolygon&  r) const
{
  return ( theWrappedObject->intersects(r));
}

bool  PythonQtWrapper_QPolygon::isEmpty(QPolygon* theWrappedObject) const
{
  return ( theWrappedObject->isEmpty());
}

bool  PythonQtWrapper_QPolygon::isSharedWith(QPolygon* theWrappedObject, const QVector<QPoint >&  other) const
{
  return ( theWrappedObject->isSharedWith(other));
}

const QPoint*  PythonQtWrapper_QPolygon::last(QPolygon* theWrappedObject) const
{
  return &( theWrappedObject->last());
}

int  PythonQtWrapper_QPolygon::lastIndexOf(QPolygon* theWrappedObject, const QPoint&  t, int  from) const
{
  return ( theWrappedObject->lastIndexOf(t, from));
}

int  PythonQtWrapper_QPolygon::length(QPolygon* theWrappedObject) const
{
  return ( theWrappedObject->length());
}

QVector<QPoint >  PythonQtWrapper_QPolygon::mid(QPolygon* theWrappedObject, int  pos, int  len) const
{
  return ( theWrappedObject->mid(pos, len));
}

void PythonQtWrapper_QPolygon::move(QPolygon* theWrappedObject, int  from, int  to)
{
  ( theWrappedObject->move(from, to));
}

bool  PythonQtWrapper_QPolygon::__ne__(QPolygon* theWrappedObject, const QVector<QPoint >&  v) const
{
  return ( (*theWrappedObject)!= v);
}

QPolygon  PythonQtWrapper_QPolygon::__mul__(QPolygon* theWrappedObject, const QMatrix&  m)
{
  return ( (*theWrappedObject)* m);
}

QPolygon  PythonQtWrapper_QPolygon::__mul__(QPolygon* theWrappedObject, const QTransform&  m)
{
  return ( (*theWrappedObject)* m);
}

void PythonQtWrapper_QPolygon::writeTo(QPolygon* theWrappedObject, QDataStream&  stream)
{
  stream <<  (*theWrappedObject);
}

QPolygon*  PythonQtWrapper_QPolygon::operator_assign(QPolygon* theWrappedObject, const QPolygon&  other)
{
  return &( (*theWrappedObject)= other);
}

bool  PythonQtWrapper_QPolygon::__eq__(QPolygon* theWrappedObject, const QVector<QPoint >&  v) const
{
  return ( (*theWrappedObject)== v);
}

void PythonQtWrapper_QPolygon::readFrom(QPolygon* theWrappedObject, QDataStream&  stream)
{
  stream >>  (*theWrappedObject);
}

void PythonQtWrapper_QPolygon::pop_back(QPolygon* theWrappedObject)
{
  ( theWrappedObject->pop_back());
}

void PythonQtWrapper_QPolygon::pop_front(QPolygon* theWrappedObject)
{
  ( theWrappedObject->pop_front());
}

void PythonQtWrapper_QPolygon::prepend(QPolygon* theWrappedObject, const QPoint&  t)
{
  ( theWrappedObject->prepend(t));
}

void PythonQtWrapper_QPolygon::push_back(QPolygon* theWrappedObject, const QPoint&  t)
{
  ( theWrappedObject->push_back(t));
}

void PythonQtWrapper_QPolygon::push_front(QPolygon* theWrappedObject, const QPoint&  t)
{
  ( theWrappedObject->push_front(t));
}

void PythonQtWrapper_QPolygon::remove(QPolygon* theWrappedObject, int  i)
{
  ( theWrappedObject->remove(i));
}

void PythonQtWrapper_QPolygon::remove(QPolygon* theWrappedObject, int  i, int  n)
{
  ( theWrappedObject->remove(i, n));
}

int  PythonQtWrapper_QPolygon::removeAll(QPolygon* theWrappedObject, const QPoint&  t)
{
  return ( theWrappedObject->removeAll(t));
}

void PythonQtWrapper_QPolygon::removeAt(QPolygon* theWrappedObject, int  i)
{
  ( theWrappedObject->removeAt(i));
}

void PythonQtWrapper_QPolygon::removeFirst(QPolygon* theWrappedObject)
{
  ( theWrappedObject->removeFirst());
}

void PythonQtWrapper_QPolygon::removeLast(QPolygon* theWrappedObject)
{
  ( theWrappedObject->removeLast());
}

bool  PythonQtWrapper_QPolygon::removeOne(QPolygon* theWrappedObject, const QPoint&  t)
{
  return ( theWrappedObject->removeOne(t));
}

void PythonQtWrapper_QPolygon::replace(QPolygon* theWrappedObject, int  i, const QPoint&  t)
{
  ( theWrappedObject->replace(i, t));
}

void PythonQtWrapper_QPolygon::reserve(QPolygon* theWrappedObject, int  size)
{
  ( theWrappedObject->reserve(size));
}

void PythonQtWrapper_QPolygon::resize(QPolygon* theWrappedObject, int  size)
{
  ( theWrappedObject->resize(size));
}

void PythonQtWrapper_QPolygon::setSharable(QPolygon* theWrappedObject, bool  sharable)
{
  ( theWrappedObject->setSharable(sharable));
}

void PythonQtWrapper_QPolygon::shrink_to_fit(QPolygon* theWrappedObject)
{
  ( theWrappedObject->shrink_to_fit());
}

int  PythonQtWrapper_QPolygon::size(QPolygon* theWrappedObject) const
{
  return ( theWrappedObject->size());
}

void PythonQtWrapper_QPolygon::squeeze(QPolygon* theWrappedObject)
{
  ( theWrappedObject->squeeze());
}

bool  PythonQtWrapper_QPolygon::startsWith(QPolygon* theWrappedObject, const QPoint&  t) const
{
  return ( theWrappedObject->startsWith(t));
}

QPolygon  PythonQtWrapper_QPolygon::subtracted(QPolygon* theWrappedObject, const QPolygon&  r) const
{
  return ( theWrappedObject->subtracted(r));
}

void PythonQtWrapper_QPolygon::swap(QPolygon* theWrappedObject, QPolygon&  other)
{
  ( theWrappedObject->swap(other));
}

void PythonQtWrapper_QPolygon::swapItemsAt(QPolygon* theWrappedObject, int  i, int  j)
{
  ( theWrappedObject->swapItemsAt(i, j));
}

QPoint  PythonQtWrapper_QPolygon::takeAt(QPolygon* theWrappedObject, int  i)
{
  return ( theWrappedObject->takeAt(i));
}

QPoint  PythonQtWrapper_QPolygon::takeFirst(QPolygon* theWrappedObject)
{
  return ( theWrappedObject->takeFirst());
}

QPoint  PythonQtWrapper_QPolygon::takeLast(QPolygon* theWrappedObject)
{
  return ( theWrappedObject->takeLast());
}

QList<QPoint >  PythonQtWrapper_QPolygon::toList(QPolygon* theWrappedObject) const
{
  return ( theWrappedObject->toList());
}

void PythonQtWrapper_QPolygon::translate(QPolygon* theWrappedObject, const QPoint&  offset)
{
  ( theWrappedObject->translate(offset));
}

void PythonQtWrapper_QPolygon::translate(QPolygon* theWrappedObject, int  dx, int  dy)
{
  ( theWrappedObject->translate(dx, dy));
}

QPolygon  PythonQtWrapper_QPolygon::translated(QPolygon* theWrappedObject, const QPoint&  offset) const
{
  return ( theWrappedObject->translated(offset));
}

QPolygon  PythonQtWrapper_QPolygon::translated(QPolygon* theWrappedObject, int  dx, int  dy) const
{
  return ( theWrappedObject->translated(dx, dy));
}

QPolygon  PythonQtWrapper_QPolygon::united(QPolygon* theWrappedObject, const QPolygon&  r) const
{
  return ( theWrappedObject->united(r));
}

QPoint  PythonQtWrapper_QPolygon::value(QPolygon* theWrappedObject, int  i) const
{
  return ( theWrappedObject->value(i));
}

QPoint  PythonQtWrapper_QPolygon::value(QPolygon* theWrappedObject, int  i, const QPoint&  defaultValue) const
{
  return ( theWrappedObject->value(i, defaultValue));
}

QString PythonQtWrapper_QPolygon::py_toString(QPolygon* obj) {
  QString result;
  QDebug d(&result);
  d << *obj;
  return result;
}



QRegion* PythonQtWrapper_QRegion::new_QRegion()
{
return new QRegion(); }

QRegion* PythonQtWrapper_QRegion::new_QRegion(const QBitmap&  bitmap)
{
return new QRegion(bitmap); }

QRegion* PythonQtWrapper_QRegion::new_QRegion(const QPolygon&  pa, Qt::FillRule  fillRule)
{
return new QRegion(pa, fillRule); }

QRegion* PythonQtWrapper_QRegion::new_QRegion(const QRect&  r, QRegion::RegionType  t)
{
return new QRegion(r, t); }

QRegion* PythonQtWrapper_QRegion::new_QRegion(const QRegion&  region)
{
return new QRegion(region); }

QRegion* PythonQtWrapper_QRegion::new_QRegion(int  x, int  y, int  w, int  h, QRegion::RegionType  t)
{
return new QRegion(x, y, w, h, t); }

const QRect*  PythonQtWrapper_QRegion::begin(QRegion* theWrappedObject) const
{
  return ( theWrappedObject->begin());
}

QRect  PythonQtWrapper_QRegion::boundingRect(QRegion* theWrappedObject) const
{
  return ( theWrappedObject->boundingRect());
}

const QRect*  PythonQtWrapper_QRegion::cbegin(QRegion* theWrappedObject) const
{
  return ( theWrappedObject->cbegin());
}

const QRect*  PythonQtWrapper_QRegion::cend(QRegion* theWrappedObject) const
{
  return ( theWrappedObject->cend());
}

bool  PythonQtWrapper_QRegion::contains(QRegion* theWrappedObject, const QPoint&  p) const
{
  return ( theWrappedObject->contains(p));
}

bool  PythonQtWrapper_QRegion::contains(QRegion* theWrappedObject, const QRect&  r) const
{
  return ( theWrappedObject->contains(r));
}

const QRect*  PythonQtWrapper_QRegion::end(QRegion* theWrappedObject) const
{
  return ( theWrappedObject->end());
}

QRegion  PythonQtWrapper_QRegion::intersected(QRegion* theWrappedObject, const QRect&  r) const
{
  return ( theWrappedObject->intersected(r));
}

QRegion  PythonQtWrapper_QRegion::intersected(QRegion* theWrappedObject, const QRegion&  r) const
{
  return ( theWrappedObject->intersected(r));
}

bool  PythonQtWrapper_QRegion::intersects(QRegion* theWrappedObject, const QRect&  r) const
{
  return ( theWrappedObject->intersects(r));
}

bool  PythonQtWrapper_QRegion::intersects(QRegion* theWrappedObject, const QRegion&  r) const
{
  return ( theWrappedObject->intersects(r));
}

bool  PythonQtWrapper_QRegion::isEmpty(QRegion* theWrappedObject) const
{
  return ( theWrappedObject->isEmpty());
}

bool  PythonQtWrapper_QRegion::isNull(QRegion* theWrappedObject) const
{
  return ( theWrappedObject->isNull());
}

bool  PythonQtWrapper_QRegion::__ne__(QRegion* theWrappedObject, const QRegion&  r) const
{
  return ( (*theWrappedObject)!= r);
}

QRegion  PythonQtWrapper_QRegion::__and__(QRegion* theWrappedObject, const QRect&  r) const
{
  return ( (*theWrappedObject)& r);
}

QRegion  PythonQtWrapper_QRegion::__mul__(QRegion* theWrappedObject, const QMatrix&  m)
{
  return ( (*theWrappedObject)* m);
}

QRegion  PythonQtWrapper_QRegion::__mul__(QRegion* theWrappedObject, const QTransform&  m)
{
  return ( (*theWrappedObject)* m);
}

QRegion  PythonQtWrapper_QRegion::__add__(QRegion* theWrappedObject, const QRect&  r) const
{
  return ( (*theWrappedObject)+ r);
}

void PythonQtWrapper_QRegion::writeTo(QRegion* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 <<  (*theWrappedObject);
}

bool  PythonQtWrapper_QRegion::__eq__(QRegion* theWrappedObject, const QRegion&  r) const
{
  return ( (*theWrappedObject)== r);
}

void PythonQtWrapper_QRegion::readFrom(QRegion* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 >>  (*theWrappedObject);
}

int  PythonQtWrapper_QRegion::rectCount(QRegion* theWrappedObject) const
{
  return ( theWrappedObject->rectCount());
}

QVector<QRect >  PythonQtWrapper_QRegion::rects(QRegion* theWrappedObject) const
{
  return ( theWrappedObject->rects());
}

void PythonQtWrapper_QRegion::setRects(QRegion* theWrappedObject, const QRect*  rect, int  num)
{
  ( theWrappedObject->setRects(rect, num));
}

QRegion  PythonQtWrapper_QRegion::subtracted(QRegion* theWrappedObject, const QRegion&  r) const
{
  return ( theWrappedObject->subtracted(r));
}

void PythonQtWrapper_QRegion::swap(QRegion* theWrappedObject, QRegion&  other)
{
  ( theWrappedObject->swap(other));
}

void PythonQtWrapper_QRegion::translate(QRegion* theWrappedObject, const QPoint&  p)
{
  ( theWrappedObject->translate(p));
}

void PythonQtWrapper_QRegion::translate(QRegion* theWrappedObject, int  dx, int  dy)
{
  ( theWrappedObject->translate(dx, dy));
}

QRegion  PythonQtWrapper_QRegion::translated(QRegion* theWrappedObject, const QPoint&  p) const
{
  return ( theWrappedObject->translated(p));
}

QRegion  PythonQtWrapper_QRegion::translated(QRegion* theWrappedObject, int  dx, int  dy) const
{
  return ( theWrappedObject->translated(dx, dy));
}

QRegion  PythonQtWrapper_QRegion::united(QRegion* theWrappedObject, const QRect&  r) const
{
  return ( theWrappedObject->united(r));
}

QRegion  PythonQtWrapper_QRegion::united(QRegion* theWrappedObject, const QRegion&  r) const
{
  return ( theWrappedObject->united(r));
}

QRegion  PythonQtWrapper_QRegion::xored(QRegion* theWrappedObject, const QRegion&  r) const
{
  return ( theWrappedObject->xored(r));
}

QString PythonQtWrapper_QRegion::py_toString(QRegion* obj) {
  QString result;
  QDebug d(&result);
  d << *obj;
  return result;
}



QSizePolicy* PythonQtWrapper_QSizePolicy::new_QSizePolicy()
{
return new QSizePolicy(); }

QSizePolicy* PythonQtWrapper_QSizePolicy::new_QSizePolicy(QSizePolicy::Policy  horizontal, QSizePolicy::Policy  vertical, QSizePolicy::ControlType  type)
{
return new QSizePolicy(horizontal, vertical, type); }

QSizePolicy::ControlType  PythonQtWrapper_QSizePolicy::controlType(QSizePolicy* theWrappedObject) const
{
  return ( theWrappedObject->controlType());
}

Qt::Orientations  PythonQtWrapper_QSizePolicy::expandingDirections(QSizePolicy* theWrappedObject) const
{
  return ( theWrappedObject->expandingDirections());
}

bool  PythonQtWrapper_QSizePolicy::hasHeightForWidth(QSizePolicy* theWrappedObject) const
{
  return ( theWrappedObject->hasHeightForWidth());
}

bool  PythonQtWrapper_QSizePolicy::hasWidthForHeight(QSizePolicy* theWrappedObject) const
{
  return ( theWrappedObject->hasWidthForHeight());
}

QSizePolicy::Policy  PythonQtWrapper_QSizePolicy::horizontalPolicy(QSizePolicy* theWrappedObject) const
{
  return ( theWrappedObject->horizontalPolicy());
}

int  PythonQtWrapper_QSizePolicy::horizontalStretch(QSizePolicy* theWrappedObject) const
{
  return ( theWrappedObject->horizontalStretch());
}

bool  PythonQtWrapper_QSizePolicy::__ne__(QSizePolicy* theWrappedObject, const QSizePolicy&  s) const
{
  return ( (*theWrappedObject)!= s);
}

void PythonQtWrapper_QSizePolicy::writeTo(QSizePolicy* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 <<  (*theWrappedObject);
}

bool  PythonQtWrapper_QSizePolicy::__eq__(QSizePolicy* theWrappedObject, const QSizePolicy&  s) const
{
  return ( (*theWrappedObject)== s);
}

void PythonQtWrapper_QSizePolicy::readFrom(QSizePolicy* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 >>  (*theWrappedObject);
}

bool  PythonQtWrapper_QSizePolicy::retainSizeWhenHidden(QSizePolicy* theWrappedObject) const
{
  return ( theWrappedObject->retainSizeWhenHidden());
}

void PythonQtWrapper_QSizePolicy::setControlType(QSizePolicy* theWrappedObject, QSizePolicy::ControlType  type)
{
  ( theWrappedObject->setControlType(type));
}

void PythonQtWrapper_QSizePolicy::setHeightForWidth(QSizePolicy* theWrappedObject, bool  b)
{
  ( theWrappedObject->setHeightForWidth(b));
}

void PythonQtWrapper_QSizePolicy::setHorizontalPolicy(QSizePolicy* theWrappedObject, QSizePolicy::Policy  d)
{
  ( theWrappedObject->setHorizontalPolicy(d));
}

void PythonQtWrapper_QSizePolicy::setHorizontalStretch(QSizePolicy* theWrappedObject, int  stretchFactor)
{
  ( theWrappedObject->setHorizontalStretch(stretchFactor));
}

void PythonQtWrapper_QSizePolicy::setRetainSizeWhenHidden(QSizePolicy* theWrappedObject, bool  retainSize)
{
  ( theWrappedObject->setRetainSizeWhenHidden(retainSize));
}

void PythonQtWrapper_QSizePolicy::setVerticalPolicy(QSizePolicy* theWrappedObject, QSizePolicy::Policy  d)
{
  ( theWrappedObject->setVerticalPolicy(d));
}

void PythonQtWrapper_QSizePolicy::setVerticalStretch(QSizePolicy* theWrappedObject, int  stretchFactor)
{
  ( theWrappedObject->setVerticalStretch(stretchFactor));
}

void PythonQtWrapper_QSizePolicy::setWidthForHeight(QSizePolicy* theWrappedObject, bool  b)
{
  ( theWrappedObject->setWidthForHeight(b));
}

void PythonQtWrapper_QSizePolicy::transpose(QSizePolicy* theWrappedObject)
{
  ( theWrappedObject->transpose());
}

QSizePolicy  PythonQtWrapper_QSizePolicy::transposed(QSizePolicy* theWrappedObject) const
{
  return ( theWrappedObject->transposed());
}

QSizePolicy::Policy  PythonQtWrapper_QSizePolicy::verticalPolicy(QSizePolicy* theWrappedObject) const
{
  return ( theWrappedObject->verticalPolicy());
}

int  PythonQtWrapper_QSizePolicy::verticalStretch(QSizePolicy* theWrappedObject) const
{
  return ( theWrappedObject->verticalStretch());
}

QString PythonQtWrapper_QSizePolicy::py_toString(QSizePolicy* obj) {
  QString result;
  QDebug d(&result);
  d << *obj;
  return result;
}



QTextFormat* PythonQtWrapper_QTextFormat::new_QTextFormat()
{
return new QTextFormat(); }

QTextFormat* PythonQtWrapper_QTextFormat::new_QTextFormat(const QTextFormat&  rhs)
{
return new QTextFormat(rhs); }

QTextFormat* PythonQtWrapper_QTextFormat::new_QTextFormat(int  type)
{
return new QTextFormat(type); }

QBrush  PythonQtWrapper_QTextFormat::background(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->background());
}

bool  PythonQtWrapper_QTextFormat::boolProperty(QTextFormat* theWrappedObject, int  propertyId) const
{
  return ( theWrappedObject->boolProperty(propertyId));
}

QBrush  PythonQtWrapper_QTextFormat::brushProperty(QTextFormat* theWrappedObject, int  propertyId) const
{
  return ( theWrappedObject->brushProperty(propertyId));
}

void PythonQtWrapper_QTextFormat::clearBackground(QTextFormat* theWrappedObject)
{
  ( theWrappedObject->clearBackground());
}

void PythonQtWrapper_QTextFormat::clearForeground(QTextFormat* theWrappedObject)
{
  ( theWrappedObject->clearForeground());
}

void PythonQtWrapper_QTextFormat::clearProperty(QTextFormat* theWrappedObject, int  propertyId)
{
  ( theWrappedObject->clearProperty(propertyId));
}

QColor  PythonQtWrapper_QTextFormat::colorProperty(QTextFormat* theWrappedObject, int  propertyId) const
{
  return ( theWrappedObject->colorProperty(propertyId));
}

qreal  PythonQtWrapper_QTextFormat::doubleProperty(QTextFormat* theWrappedObject, int  propertyId) const
{
  return ( theWrappedObject->doubleProperty(propertyId));
}

QBrush  PythonQtWrapper_QTextFormat::foreground(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->foreground());
}

bool  PythonQtWrapper_QTextFormat::hasProperty(QTextFormat* theWrappedObject, int  propertyId) const
{
  return ( theWrappedObject->hasProperty(propertyId));
}

int  PythonQtWrapper_QTextFormat::intProperty(QTextFormat* theWrappedObject, int  propertyId) const
{
  return ( theWrappedObject->intProperty(propertyId));
}

bool  PythonQtWrapper_QTextFormat::isBlockFormat(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->isBlockFormat());
}

bool  PythonQtWrapper_QTextFormat::isCharFormat(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->isCharFormat());
}

bool  PythonQtWrapper_QTextFormat::isEmpty(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->isEmpty());
}

bool  PythonQtWrapper_QTextFormat::isFrameFormat(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->isFrameFormat());
}

bool  PythonQtWrapper_QTextFormat::isImageFormat(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->isImageFormat());
}

bool  PythonQtWrapper_QTextFormat::isListFormat(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->isListFormat());
}

bool  PythonQtWrapper_QTextFormat::isTableCellFormat(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->isTableCellFormat());
}

bool  PythonQtWrapper_QTextFormat::isTableFormat(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->isTableFormat());
}

bool  PythonQtWrapper_QTextFormat::isValid(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->isValid());
}

Qt::LayoutDirection  PythonQtWrapper_QTextFormat::layoutDirection(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->layoutDirection());
}

QTextLength  PythonQtWrapper_QTextFormat::lengthProperty(QTextFormat* theWrappedObject, int  propertyId) const
{
  return ( theWrappedObject->lengthProperty(propertyId));
}

QVector<QTextLength >  PythonQtWrapper_QTextFormat::lengthVectorProperty(QTextFormat* theWrappedObject, int  propertyId) const
{
  return ( theWrappedObject->lengthVectorProperty(propertyId));
}

void PythonQtWrapper_QTextFormat::merge(QTextFormat* theWrappedObject, const QTextFormat&  other)
{
  ( theWrappedObject->merge(other));
}

int  PythonQtWrapper_QTextFormat::objectIndex(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->objectIndex());
}

int  PythonQtWrapper_QTextFormat::objectType(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->objectType());
}

bool  PythonQtWrapper_QTextFormat::__ne__(QTextFormat* theWrappedObject, const QTextFormat&  rhs) const
{
  return ( (*theWrappedObject)!= rhs);
}

void PythonQtWrapper_QTextFormat::writeTo(QTextFormat* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 <<  (*theWrappedObject);
}

bool  PythonQtWrapper_QTextFormat::__eq__(QTextFormat* theWrappedObject, const QTextFormat&  rhs) const
{
  return ( (*theWrappedObject)== rhs);
}

void PythonQtWrapper_QTextFormat::readFrom(QTextFormat* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 >>  (*theWrappedObject);
}

QPen  PythonQtWrapper_QTextFormat::penProperty(QTextFormat* theWrappedObject, int  propertyId) const
{
  return ( theWrappedObject->penProperty(propertyId));
}

QMap<int , QVariant >  PythonQtWrapper_QTextFormat::properties(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->properties());
}

QVariant  PythonQtWrapper_QTextFormat::property(QTextFormat* theWrappedObject, int  propertyId) const
{
  return ( theWrappedObject->property(propertyId));
}

int  PythonQtWrapper_QTextFormat::propertyCount(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->propertyCount());
}

void PythonQtWrapper_QTextFormat::setBackground(QTextFormat* theWrappedObject, const QBrush&  brush)
{
  ( theWrappedObject->setBackground(brush));
}

void PythonQtWrapper_QTextFormat::setForeground(QTextFormat* theWrappedObject, const QBrush&  brush)
{
  ( theWrappedObject->setForeground(brush));
}

void PythonQtWrapper_QTextFormat::setLayoutDirection(QTextFormat* theWrappedObject, Qt::LayoutDirection  direction)
{
  ( theWrappedObject->setLayoutDirection(direction));
}

void PythonQtWrapper_QTextFormat::setObjectIndex(QTextFormat* theWrappedObject, int  object)
{
  ( theWrappedObject->setObjectIndex(object));
}

void PythonQtWrapper_QTextFormat::setObjectType(QTextFormat* theWrappedObject, int  type)
{
  ( theWrappedObject->setObjectType(type));
}

void PythonQtWrapper_QTextFormat::setProperty(QTextFormat* theWrappedObject, int  propertyId, const QVariant&  value)
{
  ( theWrappedObject->setProperty(propertyId, value));
}

void PythonQtWrapper_QTextFormat::setProperty(QTextFormat* theWrappedObject, int  propertyId, const QVector<QTextLength >&  lengths)
{
  ( theWrappedObject->setProperty(propertyId, lengths));
}

QString  PythonQtWrapper_QTextFormat::stringProperty(QTextFormat* theWrappedObject, int  propertyId) const
{
  return ( theWrappedObject->stringProperty(propertyId));
}

void PythonQtWrapper_QTextFormat::swap(QTextFormat* theWrappedObject, QTextFormat&  other)
{
  ( theWrappedObject->swap(other));
}

QTextBlockFormat  PythonQtWrapper_QTextFormat::toBlockFormat(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->toBlockFormat());
}

QTextCharFormat  PythonQtWrapper_QTextFormat::toCharFormat(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->toCharFormat());
}

QTextFrameFormat  PythonQtWrapper_QTextFormat::toFrameFormat(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->toFrameFormat());
}

QTextImageFormat  PythonQtWrapper_QTextFormat::toImageFormat(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->toImageFormat());
}

QTextListFormat  PythonQtWrapper_QTextFormat::toListFormat(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->toListFormat());
}

QTextTableCellFormat  PythonQtWrapper_QTextFormat::toTableCellFormat(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->toTableCellFormat());
}

QTextTableFormat  PythonQtWrapper_QTextFormat::toTableFormat(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->toTableFormat());
}

int  PythonQtWrapper_QTextFormat::type(QTextFormat* theWrappedObject) const
{
  return ( theWrappedObject->type());
}

QString PythonQtWrapper_QTextFormat::py_toString(QTextFormat* obj) {
  QString result;
  QDebug d(&result);
  d << *obj;
  return result;
}



QTextLength* PythonQtWrapper_QTextLength::new_QTextLength()
{
return new QTextLength(); }

QTextLength* PythonQtWrapper_QTextLength::new_QTextLength(QTextLength::Type  type, qreal  value)
{
return new QTextLength(type, value); }

bool  PythonQtWrapper_QTextLength::__ne__(QTextLength* theWrappedObject, const QTextLength&  other) const
{
  return ( (*theWrappedObject)!= other);
}

void PythonQtWrapper_QTextLength::writeTo(QTextLength* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 <<  (*theWrappedObject);
}

bool  PythonQtWrapper_QTextLength::__eq__(QTextLength* theWrappedObject, const QTextLength&  other) const
{
  return ( (*theWrappedObject)== other);
}

void PythonQtWrapper_QTextLength::readFrom(QTextLength* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 >>  (*theWrappedObject);
}

qreal  PythonQtWrapper_QTextLength::rawValue(QTextLength* theWrappedObject) const
{
  return ( theWrappedObject->rawValue());
}

QTextLength::Type  PythonQtWrapper_QTextLength::type(QTextLength* theWrappedObject) const
{
  return ( theWrappedObject->type());
}

qreal  PythonQtWrapper_QTextLength::value(QTextLength* theWrappedObject, qreal  maximumLength) const
{
  return ( theWrappedObject->value(maximumLength));
}

QString PythonQtWrapper_QTextLength::py_toString(QTextLength* obj) {
  QString result;
  QDebug d(&result);
  d << *obj;
  return result;
}



QTransform* PythonQtWrapper_QTransform::new_QTransform()
{
return new QTransform(); }

QTransform* PythonQtWrapper_QTransform::new_QTransform(const QMatrix&  mtx)
{
return new QTransform(mtx); }

QTransform* PythonQtWrapper_QTransform::new_QTransform(const QTransform&  other)
{
return new QTransform(other); }

QTransform* PythonQtWrapper_QTransform::new_QTransform(qreal  h11, qreal  h12, qreal  h13, qreal  h21, qreal  h22, qreal  h23, qreal  h31, qreal  h32, qreal  h33)
{
return new QTransform(h11, h12, h13, h21, h22, h23, h31, h32, h33); }

QTransform* PythonQtWrapper_QTransform::new_QTransform(qreal  h11, qreal  h12, qreal  h21, qreal  h22, qreal  dx, qreal  dy)
{
return new QTransform(h11, h12, h21, h22, dx, dy); }

QTransform  PythonQtWrapper_QTransform::adjoint(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->adjoint());
}

qreal  PythonQtWrapper_QTransform::det(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->det());
}

qreal  PythonQtWrapper_QTransform::determinant(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->determinant());
}

qreal  PythonQtWrapper_QTransform::dx(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->dx());
}

qreal  PythonQtWrapper_QTransform::dy(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->dy());
}

QTransform  PythonQtWrapper_QTransform::static_QTransform_fromScale(qreal  dx, qreal  dy)
{
  return (QTransform::fromScale(dx, dy));
}

QTransform  PythonQtWrapper_QTransform::static_QTransform_fromTranslate(qreal  dx, qreal  dy)
{
  return (QTransform::fromTranslate(dx, dy));
}

QTransform  PythonQtWrapper_QTransform::inverted(QTransform* theWrappedObject, bool*  invertible) const
{
  return ( theWrappedObject->inverted(invertible));
}

bool  PythonQtWrapper_QTransform::isAffine(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->isAffine());
}

bool  PythonQtWrapper_QTransform::isIdentity(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->isIdentity());
}

bool  PythonQtWrapper_QTransform::isInvertible(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->isInvertible());
}

bool  PythonQtWrapper_QTransform::isRotating(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->isRotating());
}

bool  PythonQtWrapper_QTransform::isScaling(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->isScaling());
}

bool  PythonQtWrapper_QTransform::isTranslating(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->isTranslating());
}

qreal  PythonQtWrapper_QTransform::m11(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->m11());
}

qreal  PythonQtWrapper_QTransform::m12(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->m12());
}

qreal  PythonQtWrapper_QTransform::m13(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->m13());
}

qreal  PythonQtWrapper_QTransform::m21(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->m21());
}

qreal  PythonQtWrapper_QTransform::m22(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->m22());
}

qreal  PythonQtWrapper_QTransform::m23(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->m23());
}

qreal  PythonQtWrapper_QTransform::m31(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->m31());
}

qreal  PythonQtWrapper_QTransform::m32(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->m32());
}

qreal  PythonQtWrapper_QTransform::m33(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->m33());
}

QLine  PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QLine&  l) const
{
  return ( theWrappedObject->map(l));
}

QLineF  PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QLineF&  l) const
{
  return ( theWrappedObject->map(l));
}

QPainterPath  PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QPainterPath&  p) const
{
  return ( theWrappedObject->map(p));
}

QPoint  PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QPoint&  p) const
{
  return ( theWrappedObject->map(p));
}

QPointF  PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QPointF&  p) const
{
  return ( theWrappedObject->map(p));
}

QPolygon  PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QPolygon&  a) const
{
  return ( theWrappedObject->map(a));
}

QPolygonF  PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QPolygonF&  a) const
{
  return ( theWrappedObject->map(a));
}

QRegion  PythonQtWrapper_QTransform::map(QTransform* theWrappedObject, const QRegion&  r) const
{
  return ( theWrappedObject->map(r));
}

QRect  PythonQtWrapper_QTransform::mapRect(QTransform* theWrappedObject, const QRect&  arg__1) const
{
  return ( theWrappedObject->mapRect(arg__1));
}

QRectF  PythonQtWrapper_QTransform::mapRect(QTransform* theWrappedObject, const QRectF&  arg__1) const
{
  return ( theWrappedObject->mapRect(arg__1));
}

QPolygon  PythonQtWrapper_QTransform::mapToPolygon(QTransform* theWrappedObject, const QRect&  r) const
{
  return ( theWrappedObject->mapToPolygon(r));
}

bool  PythonQtWrapper_QTransform::__ne__(QTransform* theWrappedObject, const QTransform&  arg__1) const
{
  return ( (*theWrappedObject)!= arg__1);
}

QTransform  PythonQtWrapper_QTransform::multiplied(QTransform* theWrappedObject, const QTransform&  o) const
{
  return ( (*theWrappedObject)* o);
}

QTransform  PythonQtWrapper_QTransform::__mul__(QTransform* theWrappedObject, qreal  n)
{
  return ( (*theWrappedObject)* n);
}

QTransform*  PythonQtWrapper_QTransform::__imul__(QTransform* theWrappedObject, const QTransform&  arg__1)
{
  return &( (*theWrappedObject)*= arg__1);
}

QTransform*  PythonQtWrapper_QTransform::__imul__(QTransform* theWrappedObject, qreal  div)
{
  return &( (*theWrappedObject)*= div);
}

QTransform  PythonQtWrapper_QTransform::__add__(QTransform* theWrappedObject, qreal  n)
{
  return ( (*theWrappedObject)+ n);
}

QTransform*  PythonQtWrapper_QTransform::__iadd__(QTransform* theWrappedObject, qreal  div)
{
  return &( (*theWrappedObject)+= div);
}

QTransform  PythonQtWrapper_QTransform::__sub__(QTransform* theWrappedObject, qreal  n)
{
  return ( (*theWrappedObject)- n);
}

QTransform*  PythonQtWrapper_QTransform::__isub__(QTransform* theWrappedObject, qreal  div)
{
  return &( (*theWrappedObject)-= div);
}

QTransform  PythonQtWrapper_QTransform::__div__(QTransform* theWrappedObject, qreal  n)
{
  return ( (*theWrappedObject)/ n);
}

QTransform*  PythonQtWrapper_QTransform::__idiv__(QTransform* theWrappedObject, qreal  div)
{
  return &( (*theWrappedObject)/= div);
}

void PythonQtWrapper_QTransform::writeTo(QTransform* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 <<  (*theWrappedObject);
}

bool  PythonQtWrapper_QTransform::__eq__(QTransform* theWrappedObject, const QTransform&  arg__1) const
{
  return ( (*theWrappedObject)== arg__1);
}

void PythonQtWrapper_QTransform::readFrom(QTransform* theWrappedObject, QDataStream&  arg__1)
{
  arg__1 >>  (*theWrappedObject);
}

bool  PythonQtWrapper_QTransform::static_QTransform_quadToQuad(const QPolygonF&  one, const QPolygonF&  two, QTransform&  result)
{
  return (QTransform::quadToQuad(one, two, result));
}

bool  PythonQtWrapper_QTransform::static_QTransform_quadToSquare(const QPolygonF&  quad, QTransform&  result)
{
  return (QTransform::quadToSquare(quad, result));
}

void PythonQtWrapper_QTransform::reset(QTransform* theWrappedObject)
{
  ( theWrappedObject->reset());
}

QTransform*  PythonQtWrapper_QTransform::rotate(QTransform* theWrappedObject, qreal  a, Qt::Axis  axis)
{
  return &( theWrappedObject->rotate(a, axis));
}

QTransform*  PythonQtWrapper_QTransform::rotateRadians(QTransform* theWrappedObject, qreal  a, Qt::Axis  axis)
{
  return &( theWrappedObject->rotateRadians(a, axis));
}

QTransform*  PythonQtWrapper_QTransform::scale(QTransform* theWrappedObject, qreal  sx, qreal  sy)
{
  return &( theWrappedObject->scale(sx, sy));
}

void PythonQtWrapper_QTransform::setMatrix(QTransform* theWrappedObject, qreal  m11, qreal  m12, qreal  m13, qreal  m21, qreal  m22, qreal  m23, qreal  m31, qreal  m32, qreal  m33)
{
  ( theWrappedObject->setMatrix(m11, m12, m13, m21, m22, m23, m31, m32, m33));
}

QTransform*  PythonQtWrapper_QTransform::shear(QTransform* theWrappedObject, qreal  sh, qreal  sv)
{
  return &( theWrappedObject->shear(sh, sv));
}

bool  PythonQtWrapper_QTransform::static_QTransform_squareToQuad(const QPolygonF&  square, QTransform&  result)
{
  return (QTransform::squareToQuad(square, result));
}

const QMatrix*  PythonQtWrapper_QTransform::toAffine(QTransform* theWrappedObject) const
{
  return &( theWrappedObject->toAffine());
}

QTransform*  PythonQtWrapper_QTransform::translate(QTransform* theWrappedObject, qreal  dx, qreal  dy)
{
  return &( theWrappedObject->translate(dx, dy));
}

QTransform  PythonQtWrapper_QTransform::transposed(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->transposed());
}

QTransform::TransformationType  PythonQtWrapper_QTransform::type(QTransform* theWrappedObject) const
{
  return ( theWrappedObject->type());
}

QString PythonQtWrapper_QTransform::py_toString(QTransform* obj) {
  QString result;
  QDebug d(&result);
  d << *obj;
  return result;
}


