#include "PyQLop0.h"
#include <PythonQtConversion.h>
#include <PythonQtMethodInfo.h>
#include <PythonQtSignalReceiver.h>
#include <QVariant>
#include <qabstractitemmodel.h>
#include <qaction.h>
#include <qbackingstore.h>
#include <qbitmap.h>
#include <qbrush.h>
#include <qbytearray.h>
#include <qcolor.h>
#include <qcoreevent.h>
#include <qcursor.h>
#include <qcustomplot.h>
#include <qdockwidget.h>
#include <qevent.h>
#include <qfont.h>
#include <qfontinfo.h>
#include <qfontmetrics.h>
#include <qglyphrun.h>
#include <qgraphicseffect.h>
#include <qgraphicsproxywidget.h>
#include <qicon.h>
#include <qimage.h>
#include <qkeysequence.h>
#include <qlayout.h>
#include <qline.h>
#include <qlist.h>
#include <qlocale.h>
#include <qlopdata.h>
#include <qmargins.h>
#include <qmatrix.h>
#include <qmetaobject.h>
#include <qobject.h>
#include <qpaintdevice.h>
#include <qpaintengine.h>
#include <qpainter.h>
#include <qpainterpath.h>
#include <qpalette.h>
#include <qpen.h>
#include <qpicture.h>
#include <qpixmap.h>
#include <qpoint.h>
#include <qpolygon.h>
#include <qrect.h>
#include <qregion.h>
#include <qsize.h>
#include <qsizepolicy.h>
#include <qstatictext.h>
#include <qstringlist.h>
#include <qstyle.h>
#include <qstyleoption.h>
#include <qtextoption.h>
#include <qtransform.h>
#include <qvector.h>
#include <qwidget.h>
#include <qwindow.h>

PythonQtShell_FileBrowser::~PythonQtShell_FileBrowser() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_FileBrowser::actionEvent(QActionEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("actionEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QActionEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::actionEvent(arg__1);
}
void PythonQtShell_FileBrowser::changeEvent(QEvent*  e0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("changeEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&e0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::changeEvent(e0);
}
void PythonQtShell_FileBrowser::childEvent(QChildEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("childEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QChildEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::childEvent(arg__1);
}
void PythonQtShell_FileBrowser::closeEvent(QCloseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("closeEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCloseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::closeEvent(event0);
}
void PythonQtShell_FileBrowser::contextMenuEvent(QContextMenuEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("contextMenuEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QContextMenuEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::contextMenuEvent(arg__1);
}
void PythonQtShell_FileBrowser::customEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("customEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::customEvent(arg__1);
}
int  PythonQtShell_FileBrowser::devType() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_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] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          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 FileBrowser::devType();
}
void PythonQtShell_FileBrowser::dragEnterEvent(QDragEnterEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("dragEnterEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QDragEnterEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::dragEnterEvent(arg__1);
}
void PythonQtShell_FileBrowser::dragLeaveEvent(QDragLeaveEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("dragLeaveEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::dragLeaveEvent(arg__1);
}
void PythonQtShell_FileBrowser::dragMoveEvent(QDragMoveEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("dragMoveEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QDragMoveEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::dragMoveEvent(arg__1);
}
void PythonQtShell_FileBrowser::dropEvent(QDropEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("dropEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QDropEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::dropEvent(arg__1);
}
void PythonQtShell_FileBrowser::enterEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("enterEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::enterEvent(arg__1);
}
bool  PythonQtShell_FileBrowser::event(QEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("event");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      bool returnValue;
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return FileBrowser::event(event0);
}
bool  PythonQtShell_FileBrowser::eventFilter(QObject*  arg__1, QEvent*  arg__2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("eventFilter");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
      bool returnValue;
    void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return FileBrowser::eventFilter(arg__1, arg__2);
}
void PythonQtShell_FileBrowser::focusInEvent(QFocusEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("focusInEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QFocusEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::focusInEvent(arg__1);
}
bool  PythonQtShell_FileBrowser::focusNextPrevChild(bool  next0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("focusNextPrevChild");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "bool"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      bool returnValue;
    void* args[2] = {NULL, (void*)&next0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return FileBrowser::focusNextPrevChild(next0);
}
void PythonQtShell_FileBrowser::focusOutEvent(QFocusEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("focusOutEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QFocusEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::focusOutEvent(arg__1);
}
bool  PythonQtShell_FileBrowser::hasHeightForWidth() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("hasHeightForWidth");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      bool returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return FileBrowser::hasHeightForWidth();
}
int  PythonQtShell_FileBrowser::heightForWidth(int  arg__1) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("heightForWidth");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"int" , "int"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      int returnValue;
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
        } else {
          returnValue = *((int*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return FileBrowser::heightForWidth(arg__1);
}
void PythonQtShell_FileBrowser::hideEvent(QHideEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("hideEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QHideEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::hideEvent(arg__1);
}
void PythonQtShell_FileBrowser::initPainter(QPainter*  painter0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_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] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::initPainter(painter0);
}
void PythonQtShell_FileBrowser::inputMethodEvent(QInputMethodEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("inputMethodEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QInputMethodEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::inputMethodEvent(arg__1);
}
QVariant  PythonQtShell_FileBrowser::inputMethodQuery(Qt::InputMethodQuery  arg__1) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("inputMethodQuery");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      QVariant returnValue;
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
        } else {
          returnValue = *((QVariant*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return FileBrowser::inputMethodQuery(arg__1);
}
void PythonQtShell_FileBrowser::keyPressEvent(QKeyEvent*  e0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("keyPressEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QKeyEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&e0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::keyPressEvent(e0);
}
void PythonQtShell_FileBrowser::keyReleaseEvent(QKeyEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("keyReleaseEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QKeyEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::keyReleaseEvent(arg__1);
}
void PythonQtShell_FileBrowser::leaveEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("leaveEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::leaveEvent(arg__1);
}
int  PythonQtShell_FileBrowser::metric(QPaintDevice::PaintDeviceMetric  arg__1) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_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] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          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 FileBrowser::metric(arg__1);
}
QSize  PythonQtShell_FileBrowser::minimumSizeHint() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("getMinimumSizeHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QSize"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QSize returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
        } else {
          returnValue = *((QSize*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return FileBrowser::minimumSizeHint();
}
void PythonQtShell_FileBrowser::mouseDoubleClickEvent(QMouseEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::mouseDoubleClickEvent(arg__1);
}
void PythonQtShell_FileBrowser::mouseMoveEvent(QMouseEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseMoveEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::mouseMoveEvent(arg__1);
}
void PythonQtShell_FileBrowser::mousePressEvent(QMouseEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mousePressEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::mousePressEvent(arg__1);
}
void PythonQtShell_FileBrowser::mouseReleaseEvent(QMouseEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseReleaseEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::mouseReleaseEvent(arg__1);
}
void PythonQtShell_FileBrowser::moveEvent(QMoveEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("moveEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMoveEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::moveEvent(arg__1);
}
bool  PythonQtShell_FileBrowser::nativeEvent(const QByteArray&  eventType0, void*  message1, long*  result2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("nativeEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
      bool returnValue;
    void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return FileBrowser::nativeEvent(eventType0, message1, result2);
}
QPaintEngine*  PythonQtShell_FileBrowser::paintEngine() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_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] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          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 FileBrowser::paintEngine();
}
void PythonQtShell_FileBrowser::paintEvent(QPaintEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("paintEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QPaintEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::paintEvent(event0);
}
QPaintDevice*  PythonQtShell_FileBrowser::redirected(QPoint*  offset0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_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] = {NULL, (void*)&offset0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          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 FileBrowser::redirected(offset0);
}
void PythonQtShell_FileBrowser::resizeEvent(QResizeEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("resizeEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QResizeEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::resizeEvent(arg__1);
}
QPainter*  PythonQtShell_FileBrowser::sharedPainter() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_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] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          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 FileBrowser::sharedPainter();
}
void PythonQtShell_FileBrowser::showEvent(QShowEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("showEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QShowEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::showEvent(arg__1);
}
QSize  PythonQtShell_FileBrowser::sizeHint() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("getSizeHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QSize"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QSize returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
        } else {
          returnValue = *((QSize*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return FileBrowser::sizeHint();
}
void PythonQtShell_FileBrowser::tabletEvent(QTabletEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("tabletEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QTabletEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::tabletEvent(arg__1);
}
void PythonQtShell_FileBrowser::timerEvent(QTimerEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("timerEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QTimerEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::timerEvent(arg__1);
}
void PythonQtShell_FileBrowser::wheelEvent(QWheelEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("wheelEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QWheelEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  FileBrowser::wheelEvent(arg__1);
}
FileBrowser* PythonQtWrapper_FileBrowser::new_FileBrowser(QWidget*  parent)
{ 
return new PythonQtShell_FileBrowser(parent); }

void PythonQtWrapper_FileBrowser::changeEvent(FileBrowser* theWrappedObject, QEvent*  e)
{
  ( ((PythonQtPublicPromoter_FileBrowser*)theWrappedObject)->promoted_changeEvent(e));
}

void PythonQtWrapper_FileBrowser::keyPressEvent(FileBrowser* theWrappedObject, QKeyEvent*  e)
{
  ( ((PythonQtPublicPromoter_FileBrowser*)theWrappedObject)->promoted_keyPressEvent(e));
}

void PythonQtWrapper_FileBrowser::setNameFilters(FileBrowser* theWrappedObject, const QStringList&  filters, bool  disables)
{
  ( theWrappedObject->setNameFilters(filters, disables));
}



PythonQtShell_QCPAbstractItem::~PythonQtShell_QCPAbstractItem() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
QPointF  PythonQtShell_QCPAbstractItem::anchorPixelPoint(int  anchorId0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("anchorPixelPoint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QPointF" , "int"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      QPointF returnValue;
    void* args[2] = {NULL, (void*)&anchorId0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("anchorPixelPoint", methodInfo, result);
        } else {
          returnValue = *((QPointF*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPAbstractItem::anchorPixelPoint(anchorId0);
}
void PythonQtShell_QCPAbstractItem::applyDefaultAntialiasingHint(QCPPainter*  painter0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAbstractItem::applyDefaultAntialiasingHint(painter0);
}
void PythonQtShell_QCPAbstractItem::childEvent(QChildEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("childEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QChildEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAbstractItem::childEvent(arg__1);
}
QRect  PythonQtShell_QCPAbstractItem::clipRect() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("clipRect");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QRect"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QRect returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("clipRect", methodInfo, result);
        } else {
          returnValue = *((QRect*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPAbstractItem::clipRect();
}
void PythonQtShell_QCPAbstractItem::customEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("customEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAbstractItem::customEvent(arg__1);
}
void PythonQtShell_QCPAbstractItem::deselectEvent(bool*  selectionStateChanged0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("deselectEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "bool*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&selectionStateChanged0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAbstractItem::deselectEvent(selectionStateChanged0);
}
void PythonQtShell_QCPAbstractItem::draw(QCPPainter*  painter0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("draw");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  
}
bool  PythonQtShell_QCPAbstractItem::event(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("event");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      bool returnValue;
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPAbstractItem::event(arg__1);
}
bool  PythonQtShell_QCPAbstractItem::eventFilter(QObject*  arg__1, QEvent*  arg__2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("eventFilter");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
      bool returnValue;
    void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPAbstractItem::eventFilter(arg__1, arg__2);
}
void PythonQtShell_QCPAbstractItem::parentPlotInitialized(QCustomPlot*  parentPlot0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("parentPlotInitialized");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCustomPlot*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&parentPlot0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAbstractItem::parentPlotInitialized(parentPlot0);
}
void PythonQtShell_QCPAbstractItem::selectEvent(QMouseEvent*  event0, bool  additive1, const QVariant&  details2, bool*  selectionStateChanged3)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("selectEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
    void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAbstractItem::selectEvent(event0, additive1, details2, selectionStateChanged3);
}
double  PythonQtShell_QCPAbstractItem::selectTest(const QPointF&  pos0, bool  onlySelectable1, QVariant*  details2) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("selectTest");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
      double returnValue;
    void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
        } else {
          returnValue = *((double*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return double();
}
void PythonQtShell_QCPAbstractItem::timerEvent(QTimerEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("timerEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QTimerEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAbstractItem::timerEvent(arg__1);
}
QCPAbstractItem* PythonQtWrapper_QCPAbstractItem::new_QCPAbstractItem(QCustomPlot*  parentPlot)
{ 
return new PythonQtShell_QCPAbstractItem(parentPlot); }

QPointF  PythonQtWrapper_QCPAbstractItem::anchorPixelPoint(QCPAbstractItem* theWrappedObject, int  anchorId) const
{
  return ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_anchorPixelPoint(anchorId));
}

void PythonQtWrapper_QCPAbstractItem::applyDefaultAntialiasingHint(QCPAbstractItem* theWrappedObject, QCPPainter*  painter) const
{
  ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter));
}

QCPAxisRect*  PythonQtWrapper_QCPAbstractItem::clipAxisRect(QCPAbstractItem* theWrappedObject) const
{
  return ( theWrappedObject->clipAxisRect());
}

QRect  PythonQtWrapper_QCPAbstractItem::clipRect(QCPAbstractItem* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_clipRect());
}

bool  PythonQtWrapper_QCPAbstractItem::clipToAxisRect(QCPAbstractItem* theWrappedObject) const
{
  return ( theWrappedObject->clipToAxisRect());
}

QCPItemPosition*  PythonQtWrapper_QCPAbstractItem::createPosition(QCPAbstractItem* theWrappedObject, const QString&  name)
{
  return ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_createPosition(name));
}

void PythonQtWrapper_QCPAbstractItem::deselectEvent(QCPAbstractItem* theWrappedObject, bool*  selectionStateChanged)
{
  ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_deselectEvent(selectionStateChanged));
}

double  PythonQtWrapper_QCPAbstractItem::distSqrToLine(QCPAbstractItem* theWrappedObject, const QPointF&  start, const QPointF&  end, const QPointF&  point) const
{
  return ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_distSqrToLine(start, end, point));
}

void PythonQtWrapper_QCPAbstractItem::draw(QCPAbstractItem* theWrappedObject, QCPPainter*  painter)
{
  ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_draw(painter));
}

bool  PythonQtWrapper_QCPAbstractItem::hasAnchor(QCPAbstractItem* theWrappedObject, const QString&  name) const
{
  return ( theWrappedObject->hasAnchor(name));
}

QCPItemPosition*  PythonQtWrapper_QCPAbstractItem::position(QCPAbstractItem* theWrappedObject, const QString&  name) const
{
  return ( theWrappedObject->position(name));
}

QList<QCPItemPosition* >  PythonQtWrapper_QCPAbstractItem::positions(QCPAbstractItem* theWrappedObject) const
{
  return ( theWrappedObject->positions());
}

double  PythonQtWrapper_QCPAbstractItem::rectSelectTest(QCPAbstractItem* theWrappedObject, const QRectF&  rect, const QPointF&  pos, bool  filledRect) const
{
  return ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_rectSelectTest(rect, pos, filledRect));
}

void PythonQtWrapper_QCPAbstractItem::selectEvent(QCPAbstractItem* theWrappedObject, QMouseEvent*  event, bool  additive, const QVariant&  details, bool*  selectionStateChanged)
{
  ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_selectEvent(event, additive, details, selectionStateChanged));
}

double  PythonQtWrapper_QCPAbstractItem::selectTest(QCPAbstractItem* theWrappedObject, const QPointF&  pos, bool  onlySelectable, QVariant*  details) const
{
  return ( ((PythonQtPublicPromoter_QCPAbstractItem*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details));
}

bool  PythonQtWrapper_QCPAbstractItem::selectable(QCPAbstractItem* theWrappedObject) const
{
  return ( theWrappedObject->selectable());
}

bool  PythonQtWrapper_QCPAbstractItem::selected(QCPAbstractItem* theWrappedObject) const
{
  return ( theWrappedObject->selected());
}

void PythonQtWrapper_QCPAbstractItem::setClipAxisRect(QCPAbstractItem* theWrappedObject, QCPAxisRect*  rect)
{
  ( theWrappedObject->setClipAxisRect(rect));
}

void PythonQtWrapper_QCPAbstractItem::setClipToAxisRect(QCPAbstractItem* theWrappedObject, bool  clip)
{
  ( theWrappedObject->setClipToAxisRect(clip));
}

void PythonQtWrapper_QCPAbstractItem::setSelectable(QCPAbstractItem* theWrappedObject, bool  selectable)
{
  ( theWrappedObject->setSelectable(selectable));
}

void PythonQtWrapper_QCPAbstractItem::setSelected(QCPAbstractItem* theWrappedObject, bool  selected)
{
  ( theWrappedObject->setSelected(selected));
}



PythonQtShell_QCPAbstractLegendItem::~PythonQtShell_QCPAbstractLegendItem() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QCPAbstractLegendItem::applyDefaultAntialiasingHint(QCPPainter*  painter0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAbstractLegendItem::applyDefaultAntialiasingHint(painter0);
}
void PythonQtShell_QCPAbstractLegendItem::childEvent(QChildEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("childEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QChildEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAbstractLegendItem::childEvent(arg__1);
}
QRect  PythonQtShell_QCPAbstractLegendItem::clipRect() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("clipRect");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QRect"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QRect returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("clipRect", methodInfo, result);
        } else {
          returnValue = *((QRect*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPAbstractLegendItem::clipRect();
}
void PythonQtShell_QCPAbstractLegendItem::customEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("customEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAbstractLegendItem::customEvent(arg__1);
}
void PythonQtShell_QCPAbstractLegendItem::deselectEvent(bool*  selectionStateChanged0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("deselectEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "bool*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&selectionStateChanged0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAbstractLegendItem::deselectEvent(selectionStateChanged0);
}
void PythonQtShell_QCPAbstractLegendItem::draw(QCPPainter*  painter0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("draw");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  
}
QList<QCPLayoutElement* >  PythonQtShell_QCPAbstractLegendItem::elements(bool  recursive0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("elements");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QList<QCPLayoutElement* >" , "bool"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      QList<QCPLayoutElement* > returnValue;
    void* args[2] = {NULL, (void*)&recursive0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("elements", methodInfo, result);
        } else {
          returnValue = *((QList<QCPLayoutElement* >*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPAbstractLegendItem::elements(recursive0);
}
bool  PythonQtShell_QCPAbstractLegendItem::event(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("event");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      bool returnValue;
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPAbstractLegendItem::event(arg__1);
}
bool  PythonQtShell_QCPAbstractLegendItem::eventFilter(QObject*  arg__1, QEvent*  arg__2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("eventFilter");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
      bool returnValue;
    void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPAbstractLegendItem::eventFilter(arg__1, arg__2);
}
QSize  PythonQtShell_QCPAbstractLegendItem::maximumSizeHint() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("maximumSizeHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QSize"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QSize returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("maximumSizeHint", methodInfo, result);
        } else {
          returnValue = *((QSize*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPAbstractLegendItem::maximumSizeHint();
}
QSize  PythonQtShell_QCPAbstractLegendItem::minimumSizeHint() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("minimumSizeHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QSize"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QSize returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result);
        } else {
          returnValue = *((QSize*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPAbstractLegendItem::minimumSizeHint();
}
void PythonQtShell_QCPAbstractLegendItem::mouseDoubleClickEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAbstractLegendItem::mouseDoubleClickEvent(event0);
}
void PythonQtShell_QCPAbstractLegendItem::mouseMoveEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseMoveEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAbstractLegendItem::mouseMoveEvent(event0);
}
void PythonQtShell_QCPAbstractLegendItem::mousePressEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mousePressEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAbstractLegendItem::mousePressEvent(event0);
}
void PythonQtShell_QCPAbstractLegendItem::mouseReleaseEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseReleaseEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAbstractLegendItem::mouseReleaseEvent(event0);
}
void PythonQtShell_QCPAbstractLegendItem::parentPlotInitialized(QCustomPlot*  parentPlot0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("parentPlotInitialized");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCustomPlot*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&parentPlot0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAbstractLegendItem::parentPlotInitialized(parentPlot0);
}
void PythonQtShell_QCPAbstractLegendItem::selectEvent(QMouseEvent*  event0, bool  additive1, const QVariant&  details2, bool*  selectionStateChanged3)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("selectEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
    void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAbstractLegendItem::selectEvent(event0, additive1, details2, selectionStateChanged3);
}
double  PythonQtShell_QCPAbstractLegendItem::selectTest(const QPointF&  pos0, bool  onlySelectable1, QVariant*  details2) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("selectTest");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
      double returnValue;
    void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
        } else {
          returnValue = *((double*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPAbstractLegendItem::selectTest(pos0, onlySelectable1, details2);
}
void PythonQtShell_QCPAbstractLegendItem::timerEvent(QTimerEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("timerEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QTimerEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAbstractLegendItem::timerEvent(arg__1);
}
void PythonQtShell_QCPAbstractLegendItem::wheelEvent(QWheelEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("wheelEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QWheelEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAbstractLegendItem::wheelEvent(event0);
}
QCPAbstractLegendItem* PythonQtWrapper_QCPAbstractLegendItem::new_QCPAbstractLegendItem(QCPLegend*  parent)
{ 
return new PythonQtShell_QCPAbstractLegendItem(parent); }

void PythonQtWrapper_QCPAbstractLegendItem::applyDefaultAntialiasingHint(QCPAbstractLegendItem* theWrappedObject, QCPPainter*  painter) const
{
  ( ((PythonQtPublicPromoter_QCPAbstractLegendItem*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter));
}

QRect  PythonQtWrapper_QCPAbstractLegendItem::clipRect(QCPAbstractLegendItem* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCPAbstractLegendItem*)theWrappedObject)->promoted_clipRect());
}

void PythonQtWrapper_QCPAbstractLegendItem::deselectEvent(QCPAbstractLegendItem* theWrappedObject, bool*  selectionStateChanged)
{
  ( ((PythonQtPublicPromoter_QCPAbstractLegendItem*)theWrappedObject)->promoted_deselectEvent(selectionStateChanged));
}

void PythonQtWrapper_QCPAbstractLegendItem::draw(QCPAbstractLegendItem* theWrappedObject, QCPPainter*  painter)
{
  ( ((PythonQtPublicPromoter_QCPAbstractLegendItem*)theWrappedObject)->promoted_draw(painter));
}

QFont  PythonQtWrapper_QCPAbstractLegendItem::font(QCPAbstractLegendItem* theWrappedObject) const
{
  return ( theWrappedObject->font());
}

QCPLegend*  PythonQtWrapper_QCPAbstractLegendItem::parentLegend(QCPAbstractLegendItem* theWrappedObject) const
{
  return ( theWrappedObject->parentLegend());
}

void PythonQtWrapper_QCPAbstractLegendItem::selectEvent(QCPAbstractLegendItem* theWrappedObject, QMouseEvent*  event, bool  additive, const QVariant&  details, bool*  selectionStateChanged)
{
  ( ((PythonQtPublicPromoter_QCPAbstractLegendItem*)theWrappedObject)->promoted_selectEvent(event, additive, details, selectionStateChanged));
}

double  PythonQtWrapper_QCPAbstractLegendItem::selectTest(QCPAbstractLegendItem* theWrappedObject, const QPointF&  pos, bool  onlySelectable, QVariant*  details) const
{
  return ( ((PythonQtPublicPromoter_QCPAbstractLegendItem*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details));
}

bool  PythonQtWrapper_QCPAbstractLegendItem::selectable(QCPAbstractLegendItem* theWrappedObject) const
{
  return ( theWrappedObject->selectable());
}

bool  PythonQtWrapper_QCPAbstractLegendItem::selected(QCPAbstractLegendItem* theWrappedObject) const
{
  return ( theWrappedObject->selected());
}

QFont  PythonQtWrapper_QCPAbstractLegendItem::selectedFont(QCPAbstractLegendItem* theWrappedObject) const
{
  return ( theWrappedObject->selectedFont());
}

QColor  PythonQtWrapper_QCPAbstractLegendItem::selectedTextColor(QCPAbstractLegendItem* theWrappedObject) const
{
  return ( theWrappedObject->selectedTextColor());
}

void PythonQtWrapper_QCPAbstractLegendItem::setFont(QCPAbstractLegendItem* theWrappedObject, const QFont&  font)
{
  ( theWrappedObject->setFont(font));
}

void PythonQtWrapper_QCPAbstractLegendItem::setSelectable(QCPAbstractLegendItem* theWrappedObject, bool  selectable)
{
  ( theWrappedObject->setSelectable(selectable));
}

void PythonQtWrapper_QCPAbstractLegendItem::setSelected(QCPAbstractLegendItem* theWrappedObject, bool  selected)
{
  ( theWrappedObject->setSelected(selected));
}

void PythonQtWrapper_QCPAbstractLegendItem::setSelectedFont(QCPAbstractLegendItem* theWrappedObject, const QFont&  font)
{
  ( theWrappedObject->setSelectedFont(font));
}

void PythonQtWrapper_QCPAbstractLegendItem::setSelectedTextColor(QCPAbstractLegendItem* theWrappedObject, const QColor&  color)
{
  ( theWrappedObject->setSelectedTextColor(color));
}

void PythonQtWrapper_QCPAbstractLegendItem::setTextColor(QCPAbstractLegendItem* theWrappedObject, const QColor&  color)
{
  ( theWrappedObject->setTextColor(color));
}

QColor  PythonQtWrapper_QCPAbstractLegendItem::textColor(QCPAbstractLegendItem* theWrappedObject) const
{
  return ( theWrappedObject->textColor());
}



void PythonQtWrapper_QCPAxis::applyDefaultAntialiasingHint(QCPAxis* theWrappedObject, QCPPainter*  painter) const
{
  ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter));
}

bool  PythonQtWrapper_QCPAxis::autoSubTicks(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->autoSubTicks());
}

int  PythonQtWrapper_QCPAxis::autoTickCount(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->autoTickCount());
}

bool  PythonQtWrapper_QCPAxis::autoTickLabels(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->autoTickLabels());
}

bool  PythonQtWrapper_QCPAxis::autoTickStep(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->autoTickStep());
}

bool  PythonQtWrapper_QCPAxis::autoTicks(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->autoTicks());
}

QCPAxisRect*  PythonQtWrapper_QCPAxis::axisRect(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->axisRect());
}

double  PythonQtWrapper_QCPAxis::baseLog(QCPAxis* theWrappedObject, double  value) const
{
  return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_baseLog(value));
}

QPen  PythonQtWrapper_QCPAxis::basePen(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->basePen());
}

double  PythonQtWrapper_QCPAxis::basePow(QCPAxis* theWrappedObject, double  value) const
{
  return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_basePow(value));
}

int  PythonQtWrapper_QCPAxis::calculateAutoSubTickCount(QCPAxis* theWrappedObject, double  tickStep) const
{
  return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_calculateAutoSubTickCount(tickStep));
}

int  PythonQtWrapper_QCPAxis::calculateMargin(QCPAxis* theWrappedObject)
{
  return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_calculateMargin());
}

double  PythonQtWrapper_QCPAxis::coordToPixel(QCPAxis* theWrappedObject, double  value) const
{
  return ( theWrappedObject->coordToPixel(value));
}

QString  PythonQtWrapper_QCPAxis::dateTimeFormat(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->dateTimeFormat());
}

Qt::TimeSpec  PythonQtWrapper_QCPAxis::dateTimeSpec(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->dateTimeSpec());
}

void PythonQtWrapper_QCPAxis::deselectEvent(QCPAxis* theWrappedObject, bool*  selectionStateChanged)
{
  ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_deselectEvent(selectionStateChanged));
}

void PythonQtWrapper_QCPAxis::draw(QCPAxis* theWrappedObject, QCPPainter*  painter)
{
  ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_draw(painter));
}

void PythonQtWrapper_QCPAxis::generateAutoTicks(QCPAxis* theWrappedObject)
{
  ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_generateAutoTicks());
}

QPen  PythonQtWrapper_QCPAxis::getBasePen(QCPAxis* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_getBasePen());
}

QColor  PythonQtWrapper_QCPAxis::getLabelColor(QCPAxis* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_getLabelColor());
}

QFont  PythonQtWrapper_QCPAxis::getLabelFont(QCPAxis* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_getLabelFont());
}

QPen  PythonQtWrapper_QCPAxis::getSubTickPen(QCPAxis* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_getSubTickPen());
}

QColor  PythonQtWrapper_QCPAxis::getTickLabelColor(QCPAxis* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_getTickLabelColor());
}

QFont  PythonQtWrapper_QCPAxis::getTickLabelFont(QCPAxis* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_getTickLabelFont());
}

QPen  PythonQtWrapper_QCPAxis::getTickPen(QCPAxis* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_getTickPen());
}

QList<QCPGraph* >  PythonQtWrapper_QCPAxis::graphs(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->graphs());
}

QList<QCPAbstractItem* >  PythonQtWrapper_QCPAxis::items(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->items());
}

QString  PythonQtWrapper_QCPAxis::label(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->label());
}

QColor  PythonQtWrapper_QCPAxis::labelColor(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->labelColor());
}

QFont  PythonQtWrapper_QCPAxis::labelFont(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->labelFont());
}

int  PythonQtWrapper_QCPAxis::labelPadding(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->labelPadding());
}

void PythonQtWrapper_QCPAxis::moveRange(QCPAxis* theWrappedObject, double  diff)
{
  ( theWrappedObject->moveRange(diff));
}

QString  PythonQtWrapper_QCPAxis::numberFormat(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->numberFormat());
}

int  PythonQtWrapper_QCPAxis::numberPrecision(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->numberPrecision());
}

int  PythonQtWrapper_QCPAxis::offset(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->offset());
}

Qt::Orientation  PythonQtWrapper_QCPAxis::orientation(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->orientation());
}

int  PythonQtWrapper_QCPAxis::padding(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->padding());
}

double  PythonQtWrapper_QCPAxis::pixelToCoord(QCPAxis* theWrappedObject, double  value) const
{
  return ( theWrappedObject->pixelToCoord(value));
}

bool  PythonQtWrapper_QCPAxis::rangeReversed(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->rangeReversed());
}

void PythonQtWrapper_QCPAxis::rescale(QCPAxis* theWrappedObject, bool  onlyVisiblePlottables)
{
  ( theWrappedObject->rescale(onlyVisiblePlottables));
}

double  PythonQtWrapper_QCPAxis::scaleLogBase(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->scaleLogBase());
}

void PythonQtWrapper_QCPAxis::scaleRange(QCPAxis* theWrappedObject, double  factor, double  center)
{
  ( theWrappedObject->scaleRange(factor, center));
}

void PythonQtWrapper_QCPAxis::selectEvent(QCPAxis* theWrappedObject, QMouseEvent*  event, bool  additive, const QVariant&  details, bool*  selectionStateChanged)
{
  ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_selectEvent(event, additive, details, selectionStateChanged));
}

double  PythonQtWrapper_QCPAxis::selectTest(QCPAxis* theWrappedObject, const QPointF&  pos, bool  onlySelectable, QVariant*  details) const
{
  return ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details));
}

QPen  PythonQtWrapper_QCPAxis::selectedBasePen(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->selectedBasePen());
}

QColor  PythonQtWrapper_QCPAxis::selectedLabelColor(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->selectedLabelColor());
}

QFont  PythonQtWrapper_QCPAxis::selectedLabelFont(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->selectedLabelFont());
}

QPen  PythonQtWrapper_QCPAxis::selectedSubTickPen(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->selectedSubTickPen());
}

QColor  PythonQtWrapper_QCPAxis::selectedTickLabelColor(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->selectedTickLabelColor());
}

QFont  PythonQtWrapper_QCPAxis::selectedTickLabelFont(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->selectedTickLabelFont());
}

QPen  PythonQtWrapper_QCPAxis::selectedTickPen(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->selectedTickPen());
}

void PythonQtWrapper_QCPAxis::setAutoSubTicks(QCPAxis* theWrappedObject, bool  on)
{
  ( theWrappedObject->setAutoSubTicks(on));
}

void PythonQtWrapper_QCPAxis::setAutoTickCount(QCPAxis* theWrappedObject, int  approximateCount)
{
  ( theWrappedObject->setAutoTickCount(approximateCount));
}

void PythonQtWrapper_QCPAxis::setAutoTickLabels(QCPAxis* theWrappedObject, bool  on)
{
  ( theWrappedObject->setAutoTickLabels(on));
}

void PythonQtWrapper_QCPAxis::setAutoTickStep(QCPAxis* theWrappedObject, bool  on)
{
  ( theWrappedObject->setAutoTickStep(on));
}

void PythonQtWrapper_QCPAxis::setAutoTicks(QCPAxis* theWrappedObject, bool  on)
{
  ( theWrappedObject->setAutoTicks(on));
}

void PythonQtWrapper_QCPAxis::setBasePen(QCPAxis* theWrappedObject, const QPen&  pen)
{
  ( theWrappedObject->setBasePen(pen));
}

void PythonQtWrapper_QCPAxis::setDateTimeFormat(QCPAxis* theWrappedObject, const QString&  format)
{
  ( theWrappedObject->setDateTimeFormat(format));
}

void PythonQtWrapper_QCPAxis::setDateTimeSpec(QCPAxis* theWrappedObject, const Qt::TimeSpec&  timeSpec)
{
  ( theWrappedObject->setDateTimeSpec(timeSpec));
}

void PythonQtWrapper_QCPAxis::setLabel(QCPAxis* theWrappedObject, const QString&  str)
{
  ( theWrappedObject->setLabel(str));
}

void PythonQtWrapper_QCPAxis::setLabelColor(QCPAxis* theWrappedObject, const QColor&  color)
{
  ( theWrappedObject->setLabelColor(color));
}

void PythonQtWrapper_QCPAxis::setLabelFont(QCPAxis* theWrappedObject, const QFont&  font)
{
  ( theWrappedObject->setLabelFont(font));
}

void PythonQtWrapper_QCPAxis::setLabelPadding(QCPAxis* theWrappedObject, int  padding)
{
  ( theWrappedObject->setLabelPadding(padding));
}

void PythonQtWrapper_QCPAxis::setNumberFormat(QCPAxis* theWrappedObject, const QString&  formatCode)
{
  ( theWrappedObject->setNumberFormat(formatCode));
}

void PythonQtWrapper_QCPAxis::setNumberPrecision(QCPAxis* theWrappedObject, int  precision)
{
  ( theWrappedObject->setNumberPrecision(precision));
}

void PythonQtWrapper_QCPAxis::setOffset(QCPAxis* theWrappedObject, int  offset)
{
  ( theWrappedObject->setOffset(offset));
}

void PythonQtWrapper_QCPAxis::setPadding(QCPAxis* theWrappedObject, int  padding)
{
  ( theWrappedObject->setPadding(padding));
}

void PythonQtWrapper_QCPAxis::setRange(QCPAxis* theWrappedObject, double  lower, double  upper)
{
  ( theWrappedObject->setRange(lower, upper));
}

void PythonQtWrapper_QCPAxis::setRange(QCPAxis* theWrappedObject, double  position, double  size, Qt::AlignmentFlag  alignment)
{
  ( theWrappedObject->setRange(position, size, alignment));
}

void PythonQtWrapper_QCPAxis::setRangeLower(QCPAxis* theWrappedObject, double  lower)
{
  ( theWrappedObject->setRangeLower(lower));
}

void PythonQtWrapper_QCPAxis::setRangeReversed(QCPAxis* theWrappedObject, bool  reversed)
{
  ( theWrappedObject->setRangeReversed(reversed));
}

void PythonQtWrapper_QCPAxis::setRangeUpper(QCPAxis* theWrappedObject, double  upper)
{
  ( theWrappedObject->setRangeUpper(upper));
}

void PythonQtWrapper_QCPAxis::setScaleLogBase(QCPAxis* theWrappedObject, double  base)
{
  ( theWrappedObject->setScaleLogBase(base));
}

void PythonQtWrapper_QCPAxis::setScaleRatio(QCPAxis* theWrappedObject, const QCPAxis*  otherAxis, double  ratio)
{
  ( theWrappedObject->setScaleRatio(otherAxis, ratio));
}

void PythonQtWrapper_QCPAxis::setSelectedBasePen(QCPAxis* theWrappedObject, const QPen&  pen)
{
  ( theWrappedObject->setSelectedBasePen(pen));
}

void PythonQtWrapper_QCPAxis::setSelectedLabelColor(QCPAxis* theWrappedObject, const QColor&  color)
{
  ( theWrappedObject->setSelectedLabelColor(color));
}

void PythonQtWrapper_QCPAxis::setSelectedLabelFont(QCPAxis* theWrappedObject, const QFont&  font)
{
  ( theWrappedObject->setSelectedLabelFont(font));
}

void PythonQtWrapper_QCPAxis::setSelectedSubTickPen(QCPAxis* theWrappedObject, const QPen&  pen)
{
  ( theWrappedObject->setSelectedSubTickPen(pen));
}

void PythonQtWrapper_QCPAxis::setSelectedTickLabelColor(QCPAxis* theWrappedObject, const QColor&  color)
{
  ( theWrappedObject->setSelectedTickLabelColor(color));
}

void PythonQtWrapper_QCPAxis::setSelectedTickLabelFont(QCPAxis* theWrappedObject, const QFont&  font)
{
  ( theWrappedObject->setSelectedTickLabelFont(font));
}

void PythonQtWrapper_QCPAxis::setSelectedTickPen(QCPAxis* theWrappedObject, const QPen&  pen)
{
  ( theWrappedObject->setSelectedTickPen(pen));
}

void PythonQtWrapper_QCPAxis::setSubTickCount(QCPAxis* theWrappedObject, int  count)
{
  ( theWrappedObject->setSubTickCount(count));
}

void PythonQtWrapper_QCPAxis::setSubTickLength(QCPAxis* theWrappedObject, int  inside, int  outside)
{
  ( theWrappedObject->setSubTickLength(inside, outside));
}

void PythonQtWrapper_QCPAxis::setSubTickLengthIn(QCPAxis* theWrappedObject, int  inside)
{
  ( theWrappedObject->setSubTickLengthIn(inside));
}

void PythonQtWrapper_QCPAxis::setSubTickLengthOut(QCPAxis* theWrappedObject, int  outside)
{
  ( theWrappedObject->setSubTickLengthOut(outside));
}

void PythonQtWrapper_QCPAxis::setSubTickPen(QCPAxis* theWrappedObject, const QPen&  pen)
{
  ( theWrappedObject->setSubTickPen(pen));
}

void PythonQtWrapper_QCPAxis::setTickLabelColor(QCPAxis* theWrappedObject, const QColor&  color)
{
  ( theWrappedObject->setTickLabelColor(color));
}

void PythonQtWrapper_QCPAxis::setTickLabelFont(QCPAxis* theWrappedObject, const QFont&  font)
{
  ( theWrappedObject->setTickLabelFont(font));
}

void PythonQtWrapper_QCPAxis::setTickLabelPadding(QCPAxis* theWrappedObject, int  padding)
{
  ( theWrappedObject->setTickLabelPadding(padding));
}

void PythonQtWrapper_QCPAxis::setTickLabelRotation(QCPAxis* theWrappedObject, double  degrees)
{
  ( theWrappedObject->setTickLabelRotation(degrees));
}

void PythonQtWrapper_QCPAxis::setTickLabels(QCPAxis* theWrappedObject, bool  show)
{
  ( theWrappedObject->setTickLabels(show));
}

void PythonQtWrapper_QCPAxis::setTickLength(QCPAxis* theWrappedObject, int  inside, int  outside)
{
  ( theWrappedObject->setTickLength(inside, outside));
}

void PythonQtWrapper_QCPAxis::setTickLengthIn(QCPAxis* theWrappedObject, int  inside)
{
  ( theWrappedObject->setTickLengthIn(inside));
}

void PythonQtWrapper_QCPAxis::setTickLengthOut(QCPAxis* theWrappedObject, int  outside)
{
  ( theWrappedObject->setTickLengthOut(outside));
}

void PythonQtWrapper_QCPAxis::setTickPen(QCPAxis* theWrappedObject, const QPen&  pen)
{
  ( theWrappedObject->setTickPen(pen));
}

void PythonQtWrapper_QCPAxis::setTickStep(QCPAxis* theWrappedObject, double  step)
{
  ( theWrappedObject->setTickStep(step));
}

void PythonQtWrapper_QCPAxis::setTickVector(QCPAxis* theWrappedObject, const QVector<double >&  vec)
{
  ( theWrappedObject->setTickVector(vec));
}

void PythonQtWrapper_QCPAxis::setTickVectorLabels(QCPAxis* theWrappedObject, const QVector<QString >&  vec)
{
  ( theWrappedObject->setTickVectorLabels(vec));
}

void PythonQtWrapper_QCPAxis::setTicks(QCPAxis* theWrappedObject, bool  show)
{
  ( theWrappedObject->setTicks(show));
}

void PythonQtWrapper_QCPAxis::setupTickVectors(QCPAxis* theWrappedObject)
{
  ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_setupTickVectors());
}

int  PythonQtWrapper_QCPAxis::subTickCount(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->subTickCount());
}

int  PythonQtWrapper_QCPAxis::subTickLengthIn(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->subTickLengthIn());
}

int  PythonQtWrapper_QCPAxis::subTickLengthOut(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->subTickLengthOut());
}

QPen  PythonQtWrapper_QCPAxis::subTickPen(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->subTickPen());
}

QColor  PythonQtWrapper_QCPAxis::tickLabelColor(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->tickLabelColor());
}

QFont  PythonQtWrapper_QCPAxis::tickLabelFont(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->tickLabelFont());
}

int  PythonQtWrapper_QCPAxis::tickLabelPadding(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->tickLabelPadding());
}

double  PythonQtWrapper_QCPAxis::tickLabelRotation(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->tickLabelRotation());
}

bool  PythonQtWrapper_QCPAxis::tickLabels(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->tickLabels());
}

int  PythonQtWrapper_QCPAxis::tickLengthIn(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->tickLengthIn());
}

int  PythonQtWrapper_QCPAxis::tickLengthOut(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->tickLengthOut());
}

QPen  PythonQtWrapper_QCPAxis::tickPen(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->tickPen());
}

double  PythonQtWrapper_QCPAxis::tickStep(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->tickStep());
}

QVector<double >  PythonQtWrapper_QCPAxis::tickVector(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->tickVector());
}

QVector<QString >  PythonQtWrapper_QCPAxis::tickVectorLabels(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->tickVectorLabels());
}

bool  PythonQtWrapper_QCPAxis::ticks(QCPAxis* theWrappedObject) const
{
  return ( theWrappedObject->ticks());
}

void PythonQtWrapper_QCPAxis::visibleTickBounds(QCPAxis* theWrappedObject, int&  lowIndex, int&  highIndex) const
{
  ( ((PythonQtPublicPromoter_QCPAxis*)theWrappedObject)->promoted_visibleTickBounds(lowIndex, highIndex));
}



PythonQtShell_QCPAxisRect::~PythonQtShell_QCPAxisRect() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QCPAxisRect::applyDefaultAntialiasingHint(QCPPainter*  painter0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAxisRect::applyDefaultAntialiasingHint(painter0);
}
void PythonQtShell_QCPAxisRect::childEvent(QChildEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("childEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QChildEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAxisRect::childEvent(arg__1);
}
QRect  PythonQtShell_QCPAxisRect::clipRect() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("clipRect");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QRect"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QRect returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("clipRect", methodInfo, result);
        } else {
          returnValue = *((QRect*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPAxisRect::clipRect();
}
void PythonQtShell_QCPAxisRect::customEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("customEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAxisRect::customEvent(arg__1);
}
void PythonQtShell_QCPAxisRect::deselectEvent(bool*  selectionStateChanged0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("deselectEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "bool*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&selectionStateChanged0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAxisRect::deselectEvent(selectionStateChanged0);
}
void PythonQtShell_QCPAxisRect::draw(QCPPainter*  painter0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("draw");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAxisRect::draw(painter0);
}
QList<QCPLayoutElement* >  PythonQtShell_QCPAxisRect::elements(bool  recursive0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("elements");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QList<QCPLayoutElement* >" , "bool"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      QList<QCPLayoutElement* > returnValue;
    void* args[2] = {NULL, (void*)&recursive0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("elements", methodInfo, result);
        } else {
          returnValue = *((QList<QCPLayoutElement* >*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPAxisRect::elements(recursive0);
}
bool  PythonQtShell_QCPAxisRect::event(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("event");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      bool returnValue;
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPAxisRect::event(arg__1);
}
bool  PythonQtShell_QCPAxisRect::eventFilter(QObject*  arg__1, QEvent*  arg__2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("eventFilter");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
      bool returnValue;
    void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPAxisRect::eventFilter(arg__1, arg__2);
}
QSize  PythonQtShell_QCPAxisRect::maximumSizeHint() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("maximumSizeHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QSize"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QSize returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("maximumSizeHint", methodInfo, result);
        } else {
          returnValue = *((QSize*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPAxisRect::maximumSizeHint();
}
QSize  PythonQtShell_QCPAxisRect::minimumSizeHint() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("minimumSizeHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QSize"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QSize returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result);
        } else {
          returnValue = *((QSize*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPAxisRect::minimumSizeHint();
}
void PythonQtShell_QCPAxisRect::mouseDoubleClickEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAxisRect::mouseDoubleClickEvent(event0);
}
void PythonQtShell_QCPAxisRect::mouseMoveEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseMoveEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAxisRect::mouseMoveEvent(event0);
}
void PythonQtShell_QCPAxisRect::mousePressEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mousePressEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAxisRect::mousePressEvent(event0);
}
void PythonQtShell_QCPAxisRect::mouseReleaseEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseReleaseEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAxisRect::mouseReleaseEvent(event0);
}
void PythonQtShell_QCPAxisRect::parentPlotInitialized(QCustomPlot*  parentPlot0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("parentPlotInitialized");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCustomPlot*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&parentPlot0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAxisRect::parentPlotInitialized(parentPlot0);
}
void PythonQtShell_QCPAxisRect::selectEvent(QMouseEvent*  event0, bool  additive1, const QVariant&  details2, bool*  selectionStateChanged3)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("selectEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
    void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAxisRect::selectEvent(event0, additive1, details2, selectionStateChanged3);
}
double  PythonQtShell_QCPAxisRect::selectTest(const QPointF&  pos0, bool  onlySelectable1, QVariant*  details2) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("selectTest");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
      double returnValue;
    void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
        } else {
          returnValue = *((double*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPAxisRect::selectTest(pos0, onlySelectable1, details2);
}
void PythonQtShell_QCPAxisRect::timerEvent(QTimerEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("timerEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QTimerEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAxisRect::timerEvent(arg__1);
}
void PythonQtShell_QCPAxisRect::wheelEvent(QWheelEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("wheelEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QWheelEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPAxisRect::wheelEvent(event0);
}
QCPAxisRect* PythonQtWrapper_QCPAxisRect::new_QCPAxisRect(QCustomPlot*  parentPlot, bool  setupDefaultAxes)
{ 
return new PythonQtShell_QCPAxisRect(parentPlot, setupDefaultAxes); }

void PythonQtWrapper_QCPAxisRect::applyDefaultAntialiasingHint(QCPAxisRect* theWrappedObject, QCPPainter*  painter) const
{
  ( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter));
}

QList<QCPAxis* >  PythonQtWrapper_QCPAxisRect::axes(QCPAxisRect* theWrappedObject) const
{
  return ( theWrappedObject->axes());
}

QPixmap  PythonQtWrapper_QCPAxisRect::background(QCPAxisRect* theWrappedObject) const
{
  return ( theWrappedObject->background());
}

bool  PythonQtWrapper_QCPAxisRect::backgroundScaled(QCPAxisRect* theWrappedObject) const
{
  return ( theWrappedObject->backgroundScaled());
}

Qt::AspectRatioMode  PythonQtWrapper_QCPAxisRect::backgroundScaledMode(QCPAxisRect* theWrappedObject) const
{
  return ( theWrappedObject->backgroundScaledMode());
}

int  PythonQtWrapper_QCPAxisRect::bottom(QCPAxisRect* theWrappedObject) const
{
  return ( theWrappedObject->bottom());
}

QPoint  PythonQtWrapper_QCPAxisRect::bottomLeft(QCPAxisRect* theWrappedObject) const
{
  return ( theWrappedObject->bottomLeft());
}

QPoint  PythonQtWrapper_QCPAxisRect::bottomRight(QCPAxisRect* theWrappedObject) const
{
  return ( theWrappedObject->bottomRight());
}

QPoint  PythonQtWrapper_QCPAxisRect::center(QCPAxisRect* theWrappedObject) const
{
  return ( theWrappedObject->center());
}

void PythonQtWrapper_QCPAxisRect::draw(QCPAxisRect* theWrappedObject, QCPPainter*  painter)
{
  ( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_draw(painter));
}

void PythonQtWrapper_QCPAxisRect::drawBackground(QCPAxisRect* theWrappedObject, QCPPainter*  painter)
{
  ( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_drawBackground(painter));
}

QList<QCPLayoutElement* >  PythonQtWrapper_QCPAxisRect::elements(QCPAxisRect* theWrappedObject, bool  recursive) const
{
  return ( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_elements(recursive));
}

QList<QCPGraph* >  PythonQtWrapper_QCPAxisRect::graphs(QCPAxisRect* theWrappedObject) const
{
  return ( theWrappedObject->graphs());
}

int  PythonQtWrapper_QCPAxisRect::height(QCPAxisRect* theWrappedObject) const
{
  return ( theWrappedObject->height());
}

QList<QCPAbstractItem* >  PythonQtWrapper_QCPAxisRect::items(QCPAxisRect* theWrappedObject) const
{
  return ( theWrappedObject->items());
}

int  PythonQtWrapper_QCPAxisRect::left(QCPAxisRect* theWrappedObject) const
{
  return ( theWrappedObject->left());
}

void PythonQtWrapper_QCPAxisRect::mouseMoveEvent(QCPAxisRect* theWrappedObject, QMouseEvent*  event)
{
  ( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_mouseMoveEvent(event));
}

void PythonQtWrapper_QCPAxisRect::mousePressEvent(QCPAxisRect* theWrappedObject, QMouseEvent*  event)
{
  ( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_mousePressEvent(event));
}

void PythonQtWrapper_QCPAxisRect::mouseReleaseEvent(QCPAxisRect* theWrappedObject, QMouseEvent*  event)
{
  ( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_mouseReleaseEvent(event));
}

Qt::Orientations  PythonQtWrapper_QCPAxisRect::rangeDrag(QCPAxisRect* theWrappedObject) const
{
  return ( theWrappedObject->rangeDrag());
}

QCPAxis*  PythonQtWrapper_QCPAxisRect::rangeDragAxis(QCPAxisRect* theWrappedObject, Qt::Orientation  orientation)
{
  return ( theWrappedObject->rangeDragAxis(orientation));
}

Qt::Orientations  PythonQtWrapper_QCPAxisRect::rangeZoom(QCPAxisRect* theWrappedObject) const
{
  return ( theWrappedObject->rangeZoom());
}

QCPAxis*  PythonQtWrapper_QCPAxisRect::rangeZoomAxis(QCPAxisRect* theWrappedObject, Qt::Orientation  orientation)
{
  return ( theWrappedObject->rangeZoomAxis(orientation));
}

double  PythonQtWrapper_QCPAxisRect::rangeZoomFactor(QCPAxisRect* theWrappedObject, Qt::Orientation  orientation)
{
  return ( theWrappedObject->rangeZoomFactor(orientation));
}

bool  PythonQtWrapper_QCPAxisRect::removeAxis(QCPAxisRect* theWrappedObject, QCPAxis*  axis)
{
  return ( theWrappedObject->removeAxis(axis));
}

int  PythonQtWrapper_QCPAxisRect::right(QCPAxisRect* theWrappedObject) const
{
  return ( theWrappedObject->right());
}

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

void PythonQtWrapper_QCPAxisRect::setBackground(QCPAxisRect* theWrappedObject, const QPixmap&  pm)
{
  ( theWrappedObject->setBackground(pm));
}

void PythonQtWrapper_QCPAxisRect::setBackground(QCPAxisRect* theWrappedObject, const QPixmap&  pm, bool  scaled, Qt::AspectRatioMode  mode)
{
  ( theWrappedObject->setBackground(pm, scaled, mode));
}

void PythonQtWrapper_QCPAxisRect::setBackgroundScaled(QCPAxisRect* theWrappedObject, bool  scaled)
{
  ( theWrappedObject->setBackgroundScaled(scaled));
}

void PythonQtWrapper_QCPAxisRect::setBackgroundScaledMode(QCPAxisRect* theWrappedObject, Qt::AspectRatioMode  mode)
{
  ( theWrappedObject->setBackgroundScaledMode(mode));
}

void PythonQtWrapper_QCPAxisRect::setRangeDrag(QCPAxisRect* theWrappedObject, Qt::Orientations  orientations)
{
  ( theWrappedObject->setRangeDrag(orientations));
}

void PythonQtWrapper_QCPAxisRect::setRangeDragAxes(QCPAxisRect* theWrappedObject, QCPAxis*  horizontal, QCPAxis*  vertical)
{
  ( theWrappedObject->setRangeDragAxes(horizontal, vertical));
}

void PythonQtWrapper_QCPAxisRect::setRangeZoom(QCPAxisRect* theWrappedObject, Qt::Orientations  orientations)
{
  ( theWrappedObject->setRangeZoom(orientations));
}

void PythonQtWrapper_QCPAxisRect::setRangeZoomAxes(QCPAxisRect* theWrappedObject, QCPAxis*  horizontal, QCPAxis*  vertical)
{
  ( theWrappedObject->setRangeZoomAxes(horizontal, vertical));
}

void PythonQtWrapper_QCPAxisRect::setRangeZoomFactor(QCPAxisRect* theWrappedObject, double  factor)
{
  ( theWrappedObject->setRangeZoomFactor(factor));
}

void PythonQtWrapper_QCPAxisRect::setRangeZoomFactor(QCPAxisRect* theWrappedObject, double  horizontalFactor, double  verticalFactor)
{
  ( theWrappedObject->setRangeZoomFactor(horizontalFactor, verticalFactor));
}

void PythonQtWrapper_QCPAxisRect::setupFullAxesBox(QCPAxisRect* theWrappedObject, bool  connectRanges)
{
  ( theWrappedObject->setupFullAxesBox(connectRanges));
}

QSize  PythonQtWrapper_QCPAxisRect::size(QCPAxisRect* theWrappedObject) const
{
  return ( theWrappedObject->size());
}

int  PythonQtWrapper_QCPAxisRect::top(QCPAxisRect* theWrappedObject) const
{
  return ( theWrappedObject->top());
}

QPoint  PythonQtWrapper_QCPAxisRect::topLeft(QCPAxisRect* theWrappedObject) const
{
  return ( theWrappedObject->topLeft());
}

QPoint  PythonQtWrapper_QCPAxisRect::topRight(QCPAxisRect* theWrappedObject) const
{
  return ( theWrappedObject->topRight());
}

void PythonQtWrapper_QCPAxisRect::wheelEvent(QCPAxisRect* theWrappedObject, QWheelEvent*  event)
{
  ( ((PythonQtPublicPromoter_QCPAxisRect*)theWrappedObject)->promoted_wheelEvent(event));
}

int  PythonQtWrapper_QCPAxisRect::width(QCPAxisRect* theWrappedObject) const
{
  return ( theWrappedObject->width());
}



PythonQtShell_QCPBars::~PythonQtShell_QCPBars() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QCPBars::clearData()
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("clearData");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={""};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPBars::clearData();
}
void PythonQtShell_QCPBars::draw(QCPPainter*  painter0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("draw");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPBars::draw(painter0);
}
void PythonQtShell_QCPBars::drawLegendIcon(QCPPainter*  painter0, const QRectF&  rect1) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("drawLegendIcon");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*" , "const QRectF&"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
    void* args[3] = {NULL, (void*)&painter0, (void*)&rect1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPBars::drawLegendIcon(painter0, rect1);
}
double  PythonQtShell_QCPBars::selectTest(const QPointF&  pos0, bool  onlySelectable1, QVariant*  details2) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("selectTest");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
      double returnValue;
    void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
        } else {
          returnValue = *((double*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPBars::selectTest(pos0, onlySelectable1, details2);
}
QCPBars* PythonQtWrapper_QCPBars::new_QCPBars(QCPAxis*  keyAxis, QCPAxis*  valueAxis)
{ 
return new PythonQtShell_QCPBars(keyAxis, valueAxis); }

void PythonQtWrapper_QCPBars::addData(QCPBars* theWrappedObject, const QVector<double >&  keys, const QVector<double >&  values)
{
  ( theWrappedObject->addData(keys, values));
}

void PythonQtWrapper_QCPBars::addData(QCPBars* theWrappedObject, double  key, double  value)
{
  ( theWrappedObject->addData(key, value));
}

QCPBars*  PythonQtWrapper_QCPBars::barAbove(QCPBars* theWrappedObject) const
{
  return ( theWrappedObject->barAbove());
}

QCPBars*  PythonQtWrapper_QCPBars::barBelow(QCPBars* theWrappedObject) const
{
  return ( theWrappedObject->barBelow());
}

double  PythonQtWrapper_QCPBars::baseValue(QCPBars* theWrappedObject) const
{
  return ( theWrappedObject->baseValue());
}

void PythonQtWrapper_QCPBars::clearData(QCPBars* theWrappedObject)
{
  ( ((PythonQtPublicPromoter_QCPBars*)theWrappedObject)->promoted_clearData());
}

void PythonQtWrapper_QCPBars::static_QCPBars_connectBars(QCPBars*  lower, QCPBars*  upper)
{
  (PythonQtPublicPromoter_QCPBars::promoted_connectBars(lower, upper));
}

void PythonQtWrapper_QCPBars::draw(QCPBars* theWrappedObject, QCPPainter*  painter)
{
  ( ((PythonQtPublicPromoter_QCPBars*)theWrappedObject)->promoted_draw(painter));
}

void PythonQtWrapper_QCPBars::drawLegendIcon(QCPBars* theWrappedObject, QCPPainter*  painter, const QRectF&  rect) const
{
  ( ((PythonQtPublicPromoter_QCPBars*)theWrappedObject)->promoted_drawLegendIcon(painter, rect));
}

QPolygonF  PythonQtWrapper_QCPBars::getBarPolygon(QCPBars* theWrappedObject, double  key, double  value) const
{
  return ( ((PythonQtPublicPromoter_QCPBars*)theWrappedObject)->promoted_getBarPolygon(key, value));
}

void PythonQtWrapper_QCPBars::getPixelWidth(QCPBars* theWrappedObject, double  key, double&  lower, double&  upper) const
{
  ( ((PythonQtPublicPromoter_QCPBars*)theWrappedObject)->promoted_getPixelWidth(key, lower, upper));
}

double  PythonQtWrapper_QCPBars::getStackedBaseValue(QCPBars* theWrappedObject, double  key, bool  positive) const
{
  return ( ((PythonQtPublicPromoter_QCPBars*)theWrappedObject)->promoted_getStackedBaseValue(key, positive));
}

void PythonQtWrapper_QCPBars::moveAbove(QCPBars* theWrappedObject, QCPBars*  bars)
{
  ( theWrappedObject->moveAbove(bars));
}

void PythonQtWrapper_QCPBars::moveBelow(QCPBars* theWrappedObject, QCPBars*  bars)
{
  ( theWrappedObject->moveBelow(bars));
}

void PythonQtWrapper_QCPBars::removeData(QCPBars* theWrappedObject, double  fromKey, double  toKey)
{
  ( theWrappedObject->removeData(fromKey, toKey));
}

void PythonQtWrapper_QCPBars::removeData(QCPBars* theWrappedObject, double  key)
{
  ( theWrappedObject->removeData(key));
}

void PythonQtWrapper_QCPBars::removeDataAfter(QCPBars* theWrappedObject, double  key)
{
  ( theWrappedObject->removeDataAfter(key));
}

void PythonQtWrapper_QCPBars::removeDataBefore(QCPBars* theWrappedObject, double  key)
{
  ( theWrappedObject->removeDataBefore(key));
}

double  PythonQtWrapper_QCPBars::selectTest(QCPBars* theWrappedObject, const QPointF&  pos, bool  onlySelectable, QVariant*  details) const
{
  return ( ((PythonQtPublicPromoter_QCPBars*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details));
}

void PythonQtWrapper_QCPBars::setBaseValue(QCPBars* theWrappedObject, double  baseValue)
{
  ( theWrappedObject->setBaseValue(baseValue));
}

void PythonQtWrapper_QCPBars::setData(QCPBars* theWrappedObject, const QVector<double >&  key, const QVector<double >&  value)
{
  ( theWrappedObject->setData(key, value));
}

void PythonQtWrapper_QCPBars::setWidth(QCPBars* theWrappedObject, double  width)
{
  ( theWrappedObject->setWidth(width));
}

double  PythonQtWrapper_QCPBars::width(QCPBars* theWrappedObject) const
{
  return ( theWrappedObject->width());
}



PythonQtShell_QCPColorMap::~PythonQtShell_QCPColorMap() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QCPColorMap::clearData()
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("clearData");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={""};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPColorMap::clearData();
}
void PythonQtShell_QCPColorMap::draw(QCPPainter*  painter0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("draw");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPColorMap::draw(painter0);
}
void PythonQtShell_QCPColorMap::drawLegendIcon(QCPPainter*  painter0, const QRectF&  rect1) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("drawLegendIcon");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*" , "const QRectF&"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
    void* args[3] = {NULL, (void*)&painter0, (void*)&rect1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPColorMap::drawLegendIcon(painter0, rect1);
}
double  PythonQtShell_QCPColorMap::selectTest(const QPointF&  pos0, bool  onlySelectable1, QVariant*  details2) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("selectTest");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
      double returnValue;
    void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
        } else {
          returnValue = *((double*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPColorMap::selectTest(pos0, onlySelectable1, details2);
}
void PythonQtShell_QCPColorMap::updateMapImage()
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("updateMapImage");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={""};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPColorMap::updateMapImage();
}
QCPColorMap* PythonQtWrapper_QCPColorMap::new_QCPColorMap(QCPAxis*  keyAxis, QCPAxis*  valueAxis)
{ 
return new PythonQtShell_QCPColorMap(keyAxis, valueAxis); }

void PythonQtWrapper_QCPColorMap::clearData(QCPColorMap* theWrappedObject)
{
  ( ((PythonQtPublicPromoter_QCPColorMap*)theWrappedObject)->promoted_clearData());
}

QCPColorScale*  PythonQtWrapper_QCPColorMap::colorScale(QCPColorMap* theWrappedObject) const
{
  return ( theWrappedObject->colorScale());
}

void PythonQtWrapper_QCPColorMap::draw(QCPColorMap* theWrappedObject, QCPPainter*  painter)
{
  ( ((PythonQtPublicPromoter_QCPColorMap*)theWrappedObject)->promoted_draw(painter));
}

void PythonQtWrapper_QCPColorMap::drawLegendIcon(QCPColorMap* theWrappedObject, QCPPainter*  painter, const QRectF&  rect) const
{
  ( ((PythonQtPublicPromoter_QCPColorMap*)theWrappedObject)->promoted_drawLegendIcon(painter, rect));
}

bool  PythonQtWrapper_QCPColorMap::interpolate(QCPColorMap* theWrappedObject) const
{
  return ( theWrappedObject->interpolate());
}

void PythonQtWrapper_QCPColorMap::rescaleDataRange(QCPColorMap* theWrappedObject, bool  recalculateDataBounds)
{
  ( theWrappedObject->rescaleDataRange(recalculateDataBounds));
}

double  PythonQtWrapper_QCPColorMap::selectTest(QCPColorMap* theWrappedObject, const QPointF&  pos, bool  onlySelectable, QVariant*  details) const
{
  return ( ((PythonQtPublicPromoter_QCPColorMap*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details));
}

void PythonQtWrapper_QCPColorMap::setColorScale(QCPColorMap* theWrappedObject, QCPColorScale*  colorScale)
{
  ( theWrappedObject->setColorScale(colorScale));
}

void PythonQtWrapper_QCPColorMap::setInterpolate(QCPColorMap* theWrappedObject, bool  enabled)
{
  ( theWrappedObject->setInterpolate(enabled));
}

void PythonQtWrapper_QCPColorMap::setTightBoundary(QCPColorMap* theWrappedObject, bool  enabled)
{
  ( theWrappedObject->setTightBoundary(enabled));
}

bool  PythonQtWrapper_QCPColorMap::tightBoundary(QCPColorMap* theWrappedObject) const
{
  return ( theWrappedObject->tightBoundary());
}

void PythonQtWrapper_QCPColorMap::updateLegendIcon(QCPColorMap* theWrappedObject, Qt::TransformationMode  transformMode, const QSize&  thumbSize)
{
  ( theWrappedObject->updateLegendIcon(transformMode, thumbSize));
}

void PythonQtWrapper_QCPColorMap::updateMapImage(QCPColorMap* theWrappedObject)
{
  ( ((PythonQtPublicPromoter_QCPColorMap*)theWrappedObject)->promoted_updateMapImage());
}



PythonQtShell_QCPColorScale::~PythonQtShell_QCPColorScale() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QCPColorScale::applyDefaultAntialiasingHint(QCPPainter*  painter0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPColorScale::applyDefaultAntialiasingHint(painter0);
}
void PythonQtShell_QCPColorScale::childEvent(QChildEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("childEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QChildEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPColorScale::childEvent(arg__1);
}
QRect  PythonQtShell_QCPColorScale::clipRect() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("clipRect");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QRect"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QRect returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("clipRect", methodInfo, result);
        } else {
          returnValue = *((QRect*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPColorScale::clipRect();
}
void PythonQtShell_QCPColorScale::customEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("customEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPColorScale::customEvent(arg__1);
}
void PythonQtShell_QCPColorScale::deselectEvent(bool*  selectionStateChanged0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("deselectEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "bool*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&selectionStateChanged0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPColorScale::deselectEvent(selectionStateChanged0);
}
void PythonQtShell_QCPColorScale::draw(QCPPainter*  painter0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("draw");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPColorScale::draw(painter0);
}
QList<QCPLayoutElement* >  PythonQtShell_QCPColorScale::elements(bool  recursive0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("elements");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QList<QCPLayoutElement* >" , "bool"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      QList<QCPLayoutElement* > returnValue;
    void* args[2] = {NULL, (void*)&recursive0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("elements", methodInfo, result);
        } else {
          returnValue = *((QList<QCPLayoutElement* >*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPColorScale::elements(recursive0);
}
bool  PythonQtShell_QCPColorScale::event(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("event");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      bool returnValue;
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPColorScale::event(arg__1);
}
bool  PythonQtShell_QCPColorScale::eventFilter(QObject*  arg__1, QEvent*  arg__2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("eventFilter");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
      bool returnValue;
    void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPColorScale::eventFilter(arg__1, arg__2);
}
QSize  PythonQtShell_QCPColorScale::maximumSizeHint() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("maximumSizeHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QSize"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QSize returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("maximumSizeHint", methodInfo, result);
        } else {
          returnValue = *((QSize*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPColorScale::maximumSizeHint();
}
QSize  PythonQtShell_QCPColorScale::minimumSizeHint() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("minimumSizeHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QSize"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QSize returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result);
        } else {
          returnValue = *((QSize*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPColorScale::minimumSizeHint();
}
void PythonQtShell_QCPColorScale::mouseDoubleClickEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPColorScale::mouseDoubleClickEvent(event0);
}
void PythonQtShell_QCPColorScale::mouseMoveEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseMoveEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPColorScale::mouseMoveEvent(event0);
}
void PythonQtShell_QCPColorScale::mousePressEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mousePressEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPColorScale::mousePressEvent(event0);
}
void PythonQtShell_QCPColorScale::mouseReleaseEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseReleaseEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPColorScale::mouseReleaseEvent(event0);
}
void PythonQtShell_QCPColorScale::parentPlotInitialized(QCustomPlot*  parentPlot0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("parentPlotInitialized");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCustomPlot*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&parentPlot0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPColorScale::parentPlotInitialized(parentPlot0);
}
void PythonQtShell_QCPColorScale::selectEvent(QMouseEvent*  event0, bool  additive1, const QVariant&  details2, bool*  selectionStateChanged3)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("selectEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
    void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPColorScale::selectEvent(event0, additive1, details2, selectionStateChanged3);
}
double  PythonQtShell_QCPColorScale::selectTest(const QPointF&  pos0, bool  onlySelectable1, QVariant*  details2) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("selectTest");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
      double returnValue;
    void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
        } else {
          returnValue = *((double*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPColorScale::selectTest(pos0, onlySelectable1, details2);
}
void PythonQtShell_QCPColorScale::timerEvent(QTimerEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("timerEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QTimerEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPColorScale::timerEvent(arg__1);
}
void PythonQtShell_QCPColorScale::wheelEvent(QWheelEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("wheelEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QWheelEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPColorScale::wheelEvent(event0);
}
QCPColorScale* PythonQtWrapper_QCPColorScale::new_QCPColorScale(QCustomPlot*  parentPlot)
{ 
return new PythonQtShell_QCPColorScale(parentPlot); }

void PythonQtWrapper_QCPColorScale::applyDefaultAntialiasingHint(QCPColorScale* theWrappedObject, QCPPainter*  painter) const
{
  ( ((PythonQtPublicPromoter_QCPColorScale*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter));
}

QCPAxis*  PythonQtWrapper_QCPColorScale::axis(QCPColorScale* theWrappedObject) const
{
  return ( theWrappedObject->axis());
}

int  PythonQtWrapper_QCPColorScale::barWidth(QCPColorScale* theWrappedObject) const
{
  return ( theWrappedObject->barWidth());
}

QList<QCPColorMap* >  PythonQtWrapper_QCPColorScale::colorMaps(QCPColorScale* theWrappedObject) const
{
  return ( theWrappedObject->colorMaps());
}

QString  PythonQtWrapper_QCPColorScale::label(QCPColorScale* theWrappedObject) const
{
  return ( theWrappedObject->label());
}

void PythonQtWrapper_QCPColorScale::mouseMoveEvent(QCPColorScale* theWrappedObject, QMouseEvent*  event)
{
  ( ((PythonQtPublicPromoter_QCPColorScale*)theWrappedObject)->promoted_mouseMoveEvent(event));
}

void PythonQtWrapper_QCPColorScale::mousePressEvent(QCPColorScale* theWrappedObject, QMouseEvent*  event)
{
  ( ((PythonQtPublicPromoter_QCPColorScale*)theWrappedObject)->promoted_mousePressEvent(event));
}

void PythonQtWrapper_QCPColorScale::mouseReleaseEvent(QCPColorScale* theWrappedObject, QMouseEvent*  event)
{
  ( ((PythonQtPublicPromoter_QCPColorScale*)theWrappedObject)->promoted_mouseReleaseEvent(event));
}

bool  PythonQtWrapper_QCPColorScale::rangeDrag(QCPColorScale* theWrappedObject) const
{
  return ( theWrappedObject->rangeDrag());
}

bool  PythonQtWrapper_QCPColorScale::rangeZoom(QCPColorScale* theWrappedObject) const
{
  return ( theWrappedObject->rangeZoom());
}

void PythonQtWrapper_QCPColorScale::rescaleDataRange(QCPColorScale* theWrappedObject, bool  onlyVisibleMaps)
{
  ( theWrappedObject->rescaleDataRange(onlyVisibleMaps));
}

void PythonQtWrapper_QCPColorScale::setBarWidth(QCPColorScale* theWrappedObject, int  width)
{
  ( theWrappedObject->setBarWidth(width));
}

void PythonQtWrapper_QCPColorScale::setLabel(QCPColorScale* theWrappedObject, const QString&  str)
{
  ( theWrappedObject->setLabel(str));
}

void PythonQtWrapper_QCPColorScale::setRangeDrag(QCPColorScale* theWrappedObject, bool  enabled)
{
  ( theWrappedObject->setRangeDrag(enabled));
}

void PythonQtWrapper_QCPColorScale::setRangeZoom(QCPColorScale* theWrappedObject, bool  enabled)
{
  ( theWrappedObject->setRangeZoom(enabled));
}

void PythonQtWrapper_QCPColorScale::wheelEvent(QCPColorScale* theWrappedObject, QWheelEvent*  event)
{
  ( ((PythonQtPublicPromoter_QCPColorScale*)theWrappedObject)->promoted_wheelEvent(event));
}



PythonQtShell_QCPGraph::~PythonQtShell_QCPGraph() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QCPGraph::clearData()
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("clearData");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={""};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPGraph::clearData();
}
void PythonQtShell_QCPGraph::draw(QCPPainter*  painter0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("draw");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPGraph::draw(painter0);
}
void PythonQtShell_QCPGraph::drawFill(QCPPainter*  painter0, QVector<QPointF >*  lineData1) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("drawFill");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*" , "QVector<QPointF >*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
    void* args[3] = {NULL, (void*)&painter0, (void*)&lineData1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPGraph::drawFill(painter0, lineData1);
}
void PythonQtShell_QCPGraph::drawImpulsePlot(QCPPainter*  painter0, QVector<QPointF >*  lineData1) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("drawImpulsePlot");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*" , "QVector<QPointF >*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
    void* args[3] = {NULL, (void*)&painter0, (void*)&lineData1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPGraph::drawImpulsePlot(painter0, lineData1);
}
void PythonQtShell_QCPGraph::drawLegendIcon(QCPPainter*  painter0, const QRectF&  rect1) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("drawLegendIcon");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*" , "const QRectF&"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
    void* args[3] = {NULL, (void*)&painter0, (void*)&rect1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPGraph::drawLegendIcon(painter0, rect1);
}
void PythonQtShell_QCPGraph::drawLinePlot(QCPPainter*  painter0, QVector<QPointF >*  lineData1) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("drawLinePlot");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*" , "QVector<QPointF >*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
    void* args[3] = {NULL, (void*)&painter0, (void*)&lineData1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPGraph::drawLinePlot(painter0, lineData1);
}
double  PythonQtShell_QCPGraph::selectTest(const QPointF&  pos0, bool  onlySelectable1, QVariant*  details2) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("selectTest");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
      double returnValue;
    void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
        } else {
          returnValue = *((double*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPGraph::selectTest(pos0, onlySelectable1, details2);
}
QCPGraph* PythonQtWrapper_QCPGraph::new_QCPGraph(QCPAxis*  keyAxis, QCPAxis*  valueAxis)
{ 
return new PythonQtShell_QCPGraph(keyAxis, valueAxis); }

bool  PythonQtWrapper_QCPGraph::adaptiveSampling(QCPGraph* theWrappedObject) const
{
  return ( theWrappedObject->adaptiveSampling());
}

void PythonQtWrapper_QCPGraph::addData(QCPGraph* theWrappedObject, const QVector<double >&  keys, const QVector<double >&  values)
{
  ( theWrappedObject->addData(keys, values));
}

void PythonQtWrapper_QCPGraph::addData(QCPGraph* theWrappedObject, double  key, double  value)
{
  ( theWrappedObject->addData(key, value));
}

void PythonQtWrapper_QCPGraph::addFillBasePoints(QCPGraph* theWrappedObject, QVector<QPointF >*  lineData) const
{
  ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_addFillBasePoints(lineData));
}

QCPGraph*  PythonQtWrapper_QCPGraph::channelFillGraph(QCPGraph* theWrappedObject) const
{
  return ( theWrappedObject->channelFillGraph());
}

void PythonQtWrapper_QCPGraph::clearData(QCPGraph* theWrappedObject)
{
  ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_clearData());
}

void PythonQtWrapper_QCPGraph::draw(QCPGraph* theWrappedObject, QCPPainter*  painter)
{
  ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_draw(painter));
}

void PythonQtWrapper_QCPGraph::drawFill(QCPGraph* theWrappedObject, QCPPainter*  painter, QVector<QPointF >*  lineData) const
{
  ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_drawFill(painter, lineData));
}

void PythonQtWrapper_QCPGraph::drawImpulsePlot(QCPGraph* theWrappedObject, QCPPainter*  painter, QVector<QPointF >*  lineData) const
{
  ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_drawImpulsePlot(painter, lineData));
}

void PythonQtWrapper_QCPGraph::drawLegendIcon(QCPGraph* theWrappedObject, QCPPainter*  painter, const QRectF&  rect) const
{
  ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_drawLegendIcon(painter, rect));
}

void PythonQtWrapper_QCPGraph::drawLinePlot(QCPGraph* theWrappedObject, QCPPainter*  painter, QVector<QPointF >*  lineData) const
{
  ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_drawLinePlot(painter, lineData));
}

double  PythonQtWrapper_QCPGraph::errorBarSize(QCPGraph* theWrappedObject) const
{
  return ( theWrappedObject->errorBarSize());
}

bool  PythonQtWrapper_QCPGraph::errorBarSkipSymbol(QCPGraph* theWrappedObject) const
{
  return ( theWrappedObject->errorBarSkipSymbol());
}

QPen  PythonQtWrapper_QCPGraph::errorPen(QCPGraph* theWrappedObject) const
{
  return ( theWrappedObject->errorPen());
}

int  PythonQtWrapper_QCPGraph::findIndexAboveX(QCPGraph* theWrappedObject, const QVector<QPointF >*  data, double  x) const
{
  return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_findIndexAboveX(data, x));
}

int  PythonQtWrapper_QCPGraph::findIndexAboveY(QCPGraph* theWrappedObject, const QVector<QPointF >*  data, double  y) const
{
  return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_findIndexAboveY(data, y));
}

int  PythonQtWrapper_QCPGraph::findIndexBelowX(QCPGraph* theWrappedObject, const QVector<QPointF >*  data, double  x) const
{
  return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_findIndexBelowX(data, x));
}

int  PythonQtWrapper_QCPGraph::findIndexBelowY(QCPGraph* theWrappedObject, const QVector<QPointF >*  data, double  y) const
{
  return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_findIndexBelowY(data, y));
}

const QPolygonF  PythonQtWrapper_QCPGraph::getChannelFillPolygon(QCPGraph* theWrappedObject, const QVector<QPointF >*  lineData) const
{
  return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_getChannelFillPolygon(lineData));
}

QPointF  PythonQtWrapper_QCPGraph::lowerFillBasePoint(QCPGraph* theWrappedObject, double  lowerKey) const
{
  return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_lowerFillBasePoint(lowerKey));
}

double  PythonQtWrapper_QCPGraph::pointDistance(QCPGraph* theWrappedObject, const QPointF&  pixelPoint) const
{
  return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_pointDistance(pixelPoint));
}

void PythonQtWrapper_QCPGraph::removeData(QCPGraph* theWrappedObject, double  fromKey, double  toKey)
{
  ( theWrappedObject->removeData(fromKey, toKey));
}

void PythonQtWrapper_QCPGraph::removeData(QCPGraph* theWrappedObject, double  key)
{
  ( theWrappedObject->removeData(key));
}

void PythonQtWrapper_QCPGraph::removeDataAfter(QCPGraph* theWrappedObject, double  key)
{
  ( theWrappedObject->removeDataAfter(key));
}

void PythonQtWrapper_QCPGraph::removeDataBefore(QCPGraph* theWrappedObject, double  key)
{
  ( theWrappedObject->removeDataBefore(key));
}

void PythonQtWrapper_QCPGraph::removeFillBasePoints(QCPGraph* theWrappedObject, QVector<QPointF >*  lineData) const
{
  ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_removeFillBasePoints(lineData));
}

void PythonQtWrapper_QCPGraph::rescaleAxes(QCPGraph* theWrappedObject, bool  onlyEnlarge, bool  includeErrorBars) const
{
  ( theWrappedObject->rescaleAxes(onlyEnlarge, includeErrorBars));
}

void PythonQtWrapper_QCPGraph::rescaleKeyAxis(QCPGraph* theWrappedObject, bool  onlyEnlarge, bool  includeErrorBars) const
{
  ( theWrappedObject->rescaleKeyAxis(onlyEnlarge, includeErrorBars));
}

void PythonQtWrapper_QCPGraph::rescaleValueAxis(QCPGraph* theWrappedObject, bool  onlyEnlarge, bool  includeErrorBars) const
{
  ( theWrappedObject->rescaleValueAxis(onlyEnlarge, includeErrorBars));
}

double  PythonQtWrapper_QCPGraph::selectTest(QCPGraph* theWrappedObject, const QPointF&  pos, bool  onlySelectable, QVariant*  details) const
{
  return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details));
}

void PythonQtWrapper_QCPGraph::setAdaptiveSampling(QCPGraph* theWrappedObject, bool  enabled)
{
  ( theWrappedObject->setAdaptiveSampling(enabled));
}

void PythonQtWrapper_QCPGraph::setChannelFillGraph(QCPGraph* theWrappedObject, QCPGraph*  targetGraph)
{
  ( theWrappedObject->setChannelFillGraph(targetGraph));
}

void PythonQtWrapper_QCPGraph::setData(QCPGraph* theWrappedObject, const QVector<double >&  key, const QVector<double >&  value)
{
  ( theWrappedObject->setData(key, value));
}

void PythonQtWrapper_QCPGraph::setDataBothError(QCPGraph* theWrappedObject, const QVector<double >&  key, const QVector<double >&  value, const QVector<double >&  keyError, const QVector<double >&  valueError)
{
  ( theWrappedObject->setDataBothError(key, value, keyError, valueError));
}

void PythonQtWrapper_QCPGraph::setDataBothError(QCPGraph* theWrappedObject, const QVector<double >&  key, const QVector<double >&  value, const QVector<double >&  keyErrorMinus, const QVector<double >&  keyErrorPlus, const QVector<double >&  valueErrorMinus, const QVector<double >&  valueErrorPlus)
{
  ( theWrappedObject->setDataBothError(key, value, keyErrorMinus, keyErrorPlus, valueErrorMinus, valueErrorPlus));
}

void PythonQtWrapper_QCPGraph::setDataKeyError(QCPGraph* theWrappedObject, const QVector<double >&  key, const QVector<double >&  value, const QVector<double >&  keyError)
{
  ( theWrappedObject->setDataKeyError(key, value, keyError));
}

void PythonQtWrapper_QCPGraph::setDataKeyError(QCPGraph* theWrappedObject, const QVector<double >&  key, const QVector<double >&  value, const QVector<double >&  keyErrorMinus, const QVector<double >&  keyErrorPlus)
{
  ( theWrappedObject->setDataKeyError(key, value, keyErrorMinus, keyErrorPlus));
}

void PythonQtWrapper_QCPGraph::setDataValueError(QCPGraph* theWrappedObject, const QVector<double >&  key, const QVector<double >&  value, const QVector<double >&  valueError)
{
  ( theWrappedObject->setDataValueError(key, value, valueError));
}

void PythonQtWrapper_QCPGraph::setDataValueError(QCPGraph* theWrappedObject, const QVector<double >&  key, const QVector<double >&  value, const QVector<double >&  valueErrorMinus, const QVector<double >&  valueErrorPlus)
{
  ( theWrappedObject->setDataValueError(key, value, valueErrorMinus, valueErrorPlus));
}

void PythonQtWrapper_QCPGraph::setErrorBarSize(QCPGraph* theWrappedObject, double  size)
{
  ( theWrappedObject->setErrorBarSize(size));
}

void PythonQtWrapper_QCPGraph::setErrorBarSkipSymbol(QCPGraph* theWrappedObject, bool  enabled)
{
  ( theWrappedObject->setErrorBarSkipSymbol(enabled));
}

void PythonQtWrapper_QCPGraph::setErrorPen(QCPGraph* theWrappedObject, const QPen&  pen)
{
  ( theWrappedObject->setErrorPen(pen));
}

void PythonQtWrapper_QCPGraph::setUseFastVectors(QCPGraph* theWrappedObject, bool  useFastVectors)
{
  ( theWrappedObject->setUseFastVectors(useFastVectors));
}

QPointF  PythonQtWrapper_QCPGraph::upperFillBasePoint(QCPGraph* theWrappedObject, double  upperKey) const
{
  return ( ((PythonQtPublicPromoter_QCPGraph*)theWrappedObject)->promoted_upperFillBasePoint(upperKey));
}

bool  PythonQtWrapper_QCPGraph::useFastVectors(QCPGraph* theWrappedObject) const
{
  return ( theWrappedObject->useFastVectors());
}



PythonQtShell_QCPItemPosition::~PythonQtShell_QCPItemPosition() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
QPointF  PythonQtShell_QCPItemPosition::pixelPoint() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("pixelPoint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QPointF"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QPointF returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("pixelPoint", methodInfo, result);
        } else {
          returnValue = *((QPointF*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPItemPosition::pixelPoint();
}
QCPItemPosition*  PythonQtShell_QCPItemPosition::toQCPItemPosition()
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("toQCPItemPosition");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QCPItemPosition*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QCPItemPosition* returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("toQCPItemPosition", methodInfo, result);
        } else {
          returnValue = *((QCPItemPosition**)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPItemPosition::toQCPItemPosition();
}
QCPItemPosition* PythonQtWrapper_QCPItemPosition::new_QCPItemPosition(QCustomPlot*  parentPlot, QCPAbstractItem*  parentItem, const QString  name)
{ 
return new PythonQtShell_QCPItemPosition(parentPlot, parentItem, name); }

QCPAxisRect*  PythonQtWrapper_QCPItemPosition::axisRect(QCPItemPosition* theWrappedObject) const
{
  return ( theWrappedObject->axisRect());
}

QPointF  PythonQtWrapper_QCPItemPosition::coords(QCPItemPosition* theWrappedObject) const
{
  return ( theWrappedObject->coords());
}

double  PythonQtWrapper_QCPItemPosition::key(QCPItemPosition* theWrappedObject) const
{
  return ( theWrappedObject->key());
}

QCPAxis*  PythonQtWrapper_QCPItemPosition::keyAxis(QCPItemPosition* theWrappedObject) const
{
  return ( theWrappedObject->keyAxis());
}

QPointF  PythonQtWrapper_QCPItemPosition::pixelPoint(QCPItemPosition* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCPItemPosition*)theWrappedObject)->promoted_pixelPoint());
}

void PythonQtWrapper_QCPItemPosition::setAxes(QCPItemPosition* theWrappedObject, QCPAxis*  keyAxis, QCPAxis*  valueAxis)
{
  ( theWrappedObject->setAxes(keyAxis, valueAxis));
}

void PythonQtWrapper_QCPItemPosition::setAxisRect(QCPItemPosition* theWrappedObject, QCPAxisRect*  axisRect)
{
  ( theWrappedObject->setAxisRect(axisRect));
}

void PythonQtWrapper_QCPItemPosition::setCoords(QCPItemPosition* theWrappedObject, const QPointF&  coords)
{
  ( theWrappedObject->setCoords(coords));
}

void PythonQtWrapper_QCPItemPosition::setCoords(QCPItemPosition* theWrappedObject, double  key, double  value)
{
  ( theWrappedObject->setCoords(key, value));
}

void PythonQtWrapper_QCPItemPosition::setPixelPoint(QCPItemPosition* theWrappedObject, const QPointF&  pixelPoint)
{
  ( theWrappedObject->setPixelPoint(pixelPoint));
}

QCPItemPosition*  PythonQtWrapper_QCPItemPosition::toQCPItemPosition(QCPItemPosition* theWrappedObject)
{
  return ( ((PythonQtPublicPromoter_QCPItemPosition*)theWrappedObject)->promoted_toQCPItemPosition());
}

double  PythonQtWrapper_QCPItemPosition::value(QCPItemPosition* theWrappedObject) const
{
  return ( theWrappedObject->value());
}

QCPAxis*  PythonQtWrapper_QCPItemPosition::valueAxis(QCPItemPosition* theWrappedObject) const
{
  return ( theWrappedObject->valueAxis());
}



PythonQtShell_QCPLayer::~PythonQtShell_QCPLayer() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QCPLayer::childEvent(QChildEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("childEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QChildEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayer::childEvent(arg__1);
}
void PythonQtShell_QCPLayer::customEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("customEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayer::customEvent(arg__1);
}
bool  PythonQtShell_QCPLayer::event(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("event");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      bool returnValue;
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPLayer::event(arg__1);
}
bool  PythonQtShell_QCPLayer::eventFilter(QObject*  arg__1, QEvent*  arg__2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("eventFilter");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
      bool returnValue;
    void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPLayer::eventFilter(arg__1, arg__2);
}
void PythonQtShell_QCPLayer::timerEvent(QTimerEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("timerEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QTimerEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayer::timerEvent(arg__1);
}
QCPLayer* PythonQtWrapper_QCPLayer::new_QCPLayer(QCustomPlot*  parentPlot, const QString&  layerName)
{ 
return new PythonQtShell_QCPLayer(parentPlot, layerName); }

void PythonQtWrapper_QCPLayer::addChild(QCPLayer* theWrappedObject, QCPLayerable*  layerable, bool  prepend)
{
  ( ((PythonQtPublicPromoter_QCPLayer*)theWrappedObject)->promoted_addChild(layerable, prepend));
}

QList<QCPLayerable* >  PythonQtWrapper_QCPLayer::children(QCPLayer* theWrappedObject) const
{
  return ( theWrappedObject->children());
}

int  PythonQtWrapper_QCPLayer::index(QCPLayer* theWrappedObject) const
{
  return ( theWrappedObject->index());
}

QString  PythonQtWrapper_QCPLayer::name(QCPLayer* theWrappedObject) const
{
  return ( theWrappedObject->name());
}

QCustomPlot*  PythonQtWrapper_QCPLayer::parentPlot(QCPLayer* theWrappedObject) const
{
  return ( theWrappedObject->parentPlot());
}

void PythonQtWrapper_QCPLayer::removeChild(QCPLayer* theWrappedObject, QCPLayerable*  layerable)
{
  ( ((PythonQtPublicPromoter_QCPLayer*)theWrappedObject)->promoted_removeChild(layerable));
}

void PythonQtWrapper_QCPLayer::setVisible(QCPLayer* theWrappedObject, bool  visible)
{
  ( theWrappedObject->setVisible(visible));
}

bool  PythonQtWrapper_QCPLayer::visible(QCPLayer* theWrappedObject) const
{
  return ( theWrappedObject->visible());
}



PythonQtShell_QCPLayerable::~PythonQtShell_QCPLayerable() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QCPLayerable::applyDefaultAntialiasingHint(QCPPainter*  painter0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  
}
void PythonQtShell_QCPLayerable::childEvent(QChildEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("childEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QChildEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayerable::childEvent(arg__1);
}
QRect  PythonQtShell_QCPLayerable::clipRect() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("clipRect");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QRect"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QRect returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("clipRect", methodInfo, result);
        } else {
          returnValue = *((QRect*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPLayerable::clipRect();
}
void PythonQtShell_QCPLayerable::customEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("customEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayerable::customEvent(arg__1);
}
void PythonQtShell_QCPLayerable::deselectEvent(bool*  selectionStateChanged0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("deselectEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "bool*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&selectionStateChanged0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayerable::deselectEvent(selectionStateChanged0);
}
void PythonQtShell_QCPLayerable::draw(QCPPainter*  painter0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("draw");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  
}
bool  PythonQtShell_QCPLayerable::event(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("event");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      bool returnValue;
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPLayerable::event(arg__1);
}
bool  PythonQtShell_QCPLayerable::eventFilter(QObject*  arg__1, QEvent*  arg__2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("eventFilter");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
      bool returnValue;
    void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPLayerable::eventFilter(arg__1, arg__2);
}
void PythonQtShell_QCPLayerable::parentPlotInitialized(QCustomPlot*  parentPlot0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("parentPlotInitialized");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCustomPlot*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&parentPlot0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayerable::parentPlotInitialized(parentPlot0);
}
void PythonQtShell_QCPLayerable::selectEvent(QMouseEvent*  event0, bool  additive1, const QVariant&  details2, bool*  selectionStateChanged3)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("selectEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
    void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayerable::selectEvent(event0, additive1, details2, selectionStateChanged3);
}
double  PythonQtShell_QCPLayerable::selectTest(const QPointF&  pos0, bool  onlySelectable1, QVariant*  details2) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("selectTest");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
      double returnValue;
    void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
        } else {
          returnValue = *((double*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPLayerable::selectTest(pos0, onlySelectable1, details2);
}
void PythonQtShell_QCPLayerable::timerEvent(QTimerEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("timerEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QTimerEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayerable::timerEvent(arg__1);
}
QCPLayerable* PythonQtWrapper_QCPLayerable::new_QCPLayerable(QCustomPlot*  plot, QString  targetLayer, QCPLayerable*  parentLayerable)
{ 
return new PythonQtShell_QCPLayerable(plot, targetLayer, parentLayerable); }

bool  PythonQtWrapper_QCPLayerable::antialiased(QCPLayerable* theWrappedObject) const
{
  return ( theWrappedObject->antialiased());
}

void PythonQtWrapper_QCPLayerable::applyDefaultAntialiasingHint(QCPLayerable* theWrappedObject, QCPPainter*  painter) const
{
  ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter));
}

QRect  PythonQtWrapper_QCPLayerable::clipRect(QCPLayerable* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_clipRect());
}

void PythonQtWrapper_QCPLayerable::deselectEvent(QCPLayerable* theWrappedObject, bool*  selectionStateChanged)
{
  ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_deselectEvent(selectionStateChanged));
}

void PythonQtWrapper_QCPLayerable::draw(QCPLayerable* theWrappedObject, QCPPainter*  painter)
{
  ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_draw(painter));
}

void PythonQtWrapper_QCPLayerable::initializeParentPlot(QCPLayerable* theWrappedObject, QCustomPlot*  parentPlot)
{
  ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_initializeParentPlot(parentPlot));
}

QCPLayer*  PythonQtWrapper_QCPLayerable::layer(QCPLayerable* theWrappedObject) const
{
  return ( theWrappedObject->layer());
}

bool  PythonQtWrapper_QCPLayerable::moveToLayer(QCPLayerable* theWrappedObject, QCPLayer*  layer, bool  prepend)
{
  return ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_moveToLayer(layer, prepend));
}

QCPLayerable*  PythonQtWrapper_QCPLayerable::parentLayerable(QCPLayerable* theWrappedObject) const
{
  return ( theWrappedObject->parentLayerable());
}

QCustomPlot*  PythonQtWrapper_QCPLayerable::parentPlot(QCPLayerable* theWrappedObject) const
{
  return ( theWrappedObject->parentPlot());
}

void PythonQtWrapper_QCPLayerable::parentPlotInitialized(QCPLayerable* theWrappedObject, QCustomPlot*  parentPlot)
{
  ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_parentPlotInitialized(parentPlot));
}

bool  PythonQtWrapper_QCPLayerable::realVisibility(QCPLayerable* theWrappedObject) const
{
  return ( theWrappedObject->realVisibility());
}

void PythonQtWrapper_QCPLayerable::selectEvent(QCPLayerable* theWrappedObject, QMouseEvent*  event, bool  additive, const QVariant&  details, bool*  selectionStateChanged)
{
  ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_selectEvent(event, additive, details, selectionStateChanged));
}

double  PythonQtWrapper_QCPLayerable::selectTest(QCPLayerable* theWrappedObject, const QPointF&  pos, bool  onlySelectable, QVariant*  details) const
{
  return ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details));
}

void PythonQtWrapper_QCPLayerable::setAntialiased(QCPLayerable* theWrappedObject, bool  enabled)
{
  ( theWrappedObject->setAntialiased(enabled));
}

bool  PythonQtWrapper_QCPLayerable::setLayer(QCPLayerable* theWrappedObject, QCPLayer*  layer)
{
  return ( theWrappedObject->setLayer(layer));
}

bool  PythonQtWrapper_QCPLayerable::setLayer(QCPLayerable* theWrappedObject, const QString&  layerName)
{
  return ( theWrappedObject->setLayer(layerName));
}

void PythonQtWrapper_QCPLayerable::setParentLayerable(QCPLayerable* theWrappedObject, QCPLayerable*  parentLayerable)
{
  ( ((PythonQtPublicPromoter_QCPLayerable*)theWrappedObject)->promoted_setParentLayerable(parentLayerable));
}

void PythonQtWrapper_QCPLayerable::setVisible(QCPLayerable* theWrappedObject, bool  on)
{
  ( theWrappedObject->setVisible(on));
}

bool  PythonQtWrapper_QCPLayerable::visible(QCPLayerable* theWrappedObject) const
{
  return ( theWrappedObject->visible());
}



PythonQtShell_QCPLayout::~PythonQtShell_QCPLayout() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QCPLayout::applyDefaultAntialiasingHint(QCPPainter*  painter0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayout::applyDefaultAntialiasingHint(painter0);
}
void PythonQtShell_QCPLayout::childEvent(QChildEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("childEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QChildEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayout::childEvent(arg__1);
}
QRect  PythonQtShell_QCPLayout::clipRect() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("clipRect");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QRect"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QRect returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("clipRect", methodInfo, result);
        } else {
          returnValue = *((QRect*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPLayout::clipRect();
}
void PythonQtShell_QCPLayout::customEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("customEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayout::customEvent(arg__1);
}
void PythonQtShell_QCPLayout::deselectEvent(bool*  selectionStateChanged0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("deselectEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "bool*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&selectionStateChanged0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayout::deselectEvent(selectionStateChanged0);
}
void PythonQtShell_QCPLayout::draw(QCPPainter*  painter0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("draw");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayout::draw(painter0);
}
QCPLayoutElement*  PythonQtShell_QCPLayout::elementAt(int  index0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("elementAt");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QCPLayoutElement*" , "int"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      QCPLayoutElement* returnValue;
    void* args[2] = {NULL, (void*)&index0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("elementAt", methodInfo, result);
        } else {
          returnValue = *((QCPLayoutElement**)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return 0;
}
int  PythonQtShell_QCPLayout::elementCount() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("elementCount");
  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] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("elementCount", methodInfo, result);
        } else {
          returnValue = *((int*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return int();
}
QList<QCPLayoutElement* >  PythonQtShell_QCPLayout::elements(bool  recursive0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("elements");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QList<QCPLayoutElement* >" , "bool"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      QList<QCPLayoutElement* > returnValue;
    void* args[2] = {NULL, (void*)&recursive0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("elements", methodInfo, result);
        } else {
          returnValue = *((QList<QCPLayoutElement* >*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPLayout::elements(recursive0);
}
bool  PythonQtShell_QCPLayout::event(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("event");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      bool returnValue;
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPLayout::event(arg__1);
}
bool  PythonQtShell_QCPLayout::eventFilter(QObject*  arg__1, QEvent*  arg__2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("eventFilter");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
      bool returnValue;
    void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPLayout::eventFilter(arg__1, arg__2);
}
QSize  PythonQtShell_QCPLayout::maximumSizeHint() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("maximumSizeHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QSize"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QSize returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("maximumSizeHint", methodInfo, result);
        } else {
          returnValue = *((QSize*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPLayout::maximumSizeHint();
}
QSize  PythonQtShell_QCPLayout::minimumSizeHint() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("minimumSizeHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QSize"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QSize returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result);
        } else {
          returnValue = *((QSize*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPLayout::minimumSizeHint();
}
void PythonQtShell_QCPLayout::mouseDoubleClickEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayout::mouseDoubleClickEvent(event0);
}
void PythonQtShell_QCPLayout::mouseMoveEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseMoveEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayout::mouseMoveEvent(event0);
}
void PythonQtShell_QCPLayout::mousePressEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mousePressEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayout::mousePressEvent(event0);
}
void PythonQtShell_QCPLayout::mouseReleaseEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseReleaseEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayout::mouseReleaseEvent(event0);
}
void PythonQtShell_QCPLayout::parentPlotInitialized(QCustomPlot*  parentPlot0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("parentPlotInitialized");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCustomPlot*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&parentPlot0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayout::parentPlotInitialized(parentPlot0);
}
void PythonQtShell_QCPLayout::selectEvent(QMouseEvent*  event0, bool  additive1, const QVariant&  details2, bool*  selectionStateChanged3)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("selectEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
    void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayout::selectEvent(event0, additive1, details2, selectionStateChanged3);
}
double  PythonQtShell_QCPLayout::selectTest(const QPointF&  pos0, bool  onlySelectable1, QVariant*  details2) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("selectTest");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
      double returnValue;
    void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
        } else {
          returnValue = *((double*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPLayout::selectTest(pos0, onlySelectable1, details2);
}
void PythonQtShell_QCPLayout::simplify()
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("simplify");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={""};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayout::simplify();
}
bool  PythonQtShell_QCPLayout::take(QCPLayoutElement*  element0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("take");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QCPLayoutElement*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      bool returnValue;
    void* args[2] = {NULL, (void*)&element0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("take", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return bool();
}
QCPLayoutElement*  PythonQtShell_QCPLayout::takeAt(int  index0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("takeAt");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QCPLayoutElement*" , "int"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      QCPLayoutElement* returnValue;
    void* args[2] = {NULL, (void*)&index0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("takeAt", methodInfo, result);
        } else {
          returnValue = *((QCPLayoutElement**)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return 0;
}
void PythonQtShell_QCPLayout::timerEvent(QTimerEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("timerEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QTimerEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayout::timerEvent(arg__1);
}
void PythonQtShell_QCPLayout::updateLayout()
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("updateLayout");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={""};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayout::updateLayout();
}
void PythonQtShell_QCPLayout::wheelEvent(QWheelEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("wheelEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QWheelEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayout::wheelEvent(event0);
}
QCPLayout* PythonQtWrapper_QCPLayout::new_QCPLayout()
{ 
return new PythonQtShell_QCPLayout(); }

void PythonQtWrapper_QCPLayout::adoptElement(QCPLayout* theWrappedObject, QCPLayoutElement*  el)
{
  ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_adoptElement(el));
}

void PythonQtWrapper_QCPLayout::clear(QCPLayout* theWrappedObject)
{
  ( theWrappedObject->clear());
}

QCPLayoutElement*  PythonQtWrapper_QCPLayout::elementAt(QCPLayout* theWrappedObject, int  index) const
{
  return ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_elementAt(index));
}

int  PythonQtWrapper_QCPLayout::elementCount(QCPLayout* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_elementCount());
}

QList<QCPLayoutElement* >  PythonQtWrapper_QCPLayout::elements(QCPLayout* theWrappedObject, bool  recursive) const
{
  return ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_elements(recursive));
}

QVector<int >  PythonQtWrapper_QCPLayout::getSectionSizes(QCPLayout* theWrappedObject, QVector<int >  maxSizes, QVector<int >  minSizes, QVector<double >  stretchFactors, int  totalSize) const
{
  return ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_getSectionSizes(maxSizes, minSizes, stretchFactors, totalSize));
}

void PythonQtWrapper_QCPLayout::releaseElement(QCPLayout* theWrappedObject, QCPLayoutElement*  el)
{
  ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_releaseElement(el));
}

bool  PythonQtWrapper_QCPLayout::remove(QCPLayout* theWrappedObject, QCPLayoutElement*  element)
{
  return ( theWrappedObject->remove(element));
}

bool  PythonQtWrapper_QCPLayout::removeAt(QCPLayout* theWrappedObject, int  index)
{
  return ( theWrappedObject->removeAt(index));
}

void PythonQtWrapper_QCPLayout::simplify(QCPLayout* theWrappedObject)
{
  ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_simplify());
}

void PythonQtWrapper_QCPLayout::sizeConstraintsChanged(QCPLayout* theWrappedObject) const
{
  ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_sizeConstraintsChanged());
}

bool  PythonQtWrapper_QCPLayout::take(QCPLayout* theWrappedObject, QCPLayoutElement*  element)
{
  return ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_take(element));
}

QCPLayoutElement*  PythonQtWrapper_QCPLayout::takeAt(QCPLayout* theWrappedObject, int  index)
{
  return ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_takeAt(index));
}

void PythonQtWrapper_QCPLayout::updateLayout(QCPLayout* theWrappedObject)
{
  ( ((PythonQtPublicPromoter_QCPLayout*)theWrappedObject)->promoted_updateLayout());
}



PythonQtShell_QCPLayoutElement::~PythonQtShell_QCPLayoutElement() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QCPLayoutElement::applyDefaultAntialiasingHint(QCPPainter*  painter0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayoutElement::applyDefaultAntialiasingHint(painter0);
}
void PythonQtShell_QCPLayoutElement::childEvent(QChildEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("childEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QChildEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayoutElement::childEvent(arg__1);
}
QRect  PythonQtShell_QCPLayoutElement::clipRect() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("clipRect");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QRect"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QRect returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("clipRect", methodInfo, result);
        } else {
          returnValue = *((QRect*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPLayoutElement::clipRect();
}
void PythonQtShell_QCPLayoutElement::customEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("customEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayoutElement::customEvent(arg__1);
}
void PythonQtShell_QCPLayoutElement::deselectEvent(bool*  selectionStateChanged0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("deselectEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "bool*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&selectionStateChanged0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayoutElement::deselectEvent(selectionStateChanged0);
}
void PythonQtShell_QCPLayoutElement::draw(QCPPainter*  painter0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("draw");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayoutElement::draw(painter0);
}
QList<QCPLayoutElement* >  PythonQtShell_QCPLayoutElement::elements(bool  recursive0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("elements");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QList<QCPLayoutElement* >" , "bool"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      QList<QCPLayoutElement* > returnValue;
    void* args[2] = {NULL, (void*)&recursive0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("elements", methodInfo, result);
        } else {
          returnValue = *((QList<QCPLayoutElement* >*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPLayoutElement::elements(recursive0);
}
bool  PythonQtShell_QCPLayoutElement::event(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("event");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      bool returnValue;
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPLayoutElement::event(arg__1);
}
bool  PythonQtShell_QCPLayoutElement::eventFilter(QObject*  arg__1, QEvent*  arg__2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("eventFilter");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
      bool returnValue;
    void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPLayoutElement::eventFilter(arg__1, arg__2);
}
QSize  PythonQtShell_QCPLayoutElement::maximumSizeHint() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("maximumSizeHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QSize"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QSize returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("maximumSizeHint", methodInfo, result);
        } else {
          returnValue = *((QSize*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPLayoutElement::maximumSizeHint();
}
QSize  PythonQtShell_QCPLayoutElement::minimumSizeHint() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("minimumSizeHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QSize"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QSize returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result);
        } else {
          returnValue = *((QSize*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPLayoutElement::minimumSizeHint();
}
void PythonQtShell_QCPLayoutElement::mouseDoubleClickEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayoutElement::mouseDoubleClickEvent(event0);
}
void PythonQtShell_QCPLayoutElement::mouseMoveEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseMoveEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayoutElement::mouseMoveEvent(event0);
}
void PythonQtShell_QCPLayoutElement::mousePressEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mousePressEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayoutElement::mousePressEvent(event0);
}
void PythonQtShell_QCPLayoutElement::mouseReleaseEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseReleaseEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayoutElement::mouseReleaseEvent(event0);
}
void PythonQtShell_QCPLayoutElement::parentPlotInitialized(QCustomPlot*  parentPlot0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("parentPlotInitialized");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCustomPlot*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&parentPlot0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayoutElement::parentPlotInitialized(parentPlot0);
}
void PythonQtShell_QCPLayoutElement::selectEvent(QMouseEvent*  event0, bool  additive1, const QVariant&  details2, bool*  selectionStateChanged3)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("selectEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
    void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayoutElement::selectEvent(event0, additive1, details2, selectionStateChanged3);
}
double  PythonQtShell_QCPLayoutElement::selectTest(const QPointF&  pos0, bool  onlySelectable1, QVariant*  details2) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("selectTest");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
      double returnValue;
    void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
        } else {
          returnValue = *((double*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPLayoutElement::selectTest(pos0, onlySelectable1, details2);
}
void PythonQtShell_QCPLayoutElement::timerEvent(QTimerEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("timerEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QTimerEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayoutElement::timerEvent(arg__1);
}
void PythonQtShell_QCPLayoutElement::wheelEvent(QWheelEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("wheelEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QWheelEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLayoutElement::wheelEvent(event0);
}
QCPLayoutElement* PythonQtWrapper_QCPLayoutElement::new_QCPLayoutElement(QCustomPlot*  parentPlot)
{ 
return new PythonQtShell_QCPLayoutElement(parentPlot); }

void PythonQtWrapper_QCPLayoutElement::applyDefaultAntialiasingHint(QCPLayoutElement* theWrappedObject, QCPPainter*  painter) const
{
  ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter));
}

void PythonQtWrapper_QCPLayoutElement::draw(QCPLayoutElement* theWrappedObject, QCPPainter*  painter)
{
  ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_draw(painter));
}

QList<QCPLayoutElement* >  PythonQtWrapper_QCPLayoutElement::elements(QCPLayoutElement* theWrappedObject, bool  recursive) const
{
  return ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_elements(recursive));
}

QCPLayout*  PythonQtWrapper_QCPLayoutElement::layout(QCPLayoutElement* theWrappedObject) const
{
  return ( theWrappedObject->layout());
}

QMargins  PythonQtWrapper_QCPLayoutElement::margins(QCPLayoutElement* theWrappedObject) const
{
  return ( theWrappedObject->margins());
}

QSize  PythonQtWrapper_QCPLayoutElement::maximumSize(QCPLayoutElement* theWrappedObject) const
{
  return ( theWrappedObject->maximumSize());
}

QSize  PythonQtWrapper_QCPLayoutElement::maximumSizeHint(QCPLayoutElement* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_maximumSizeHint());
}

QMargins  PythonQtWrapper_QCPLayoutElement::minimumMargins(QCPLayoutElement* theWrappedObject) const
{
  return ( theWrappedObject->minimumMargins());
}

QSize  PythonQtWrapper_QCPLayoutElement::minimumSize(QCPLayoutElement* theWrappedObject) const
{
  return ( theWrappedObject->minimumSize());
}

QSize  PythonQtWrapper_QCPLayoutElement::minimumSizeHint(QCPLayoutElement* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_minimumSizeHint());
}

void PythonQtWrapper_QCPLayoutElement::mouseDoubleClickEvent(QCPLayoutElement* theWrappedObject, QMouseEvent*  event)
{
  ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_mouseDoubleClickEvent(event));
}

void PythonQtWrapper_QCPLayoutElement::mouseMoveEvent(QCPLayoutElement* theWrappedObject, QMouseEvent*  event)
{
  ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_mouseMoveEvent(event));
}

void PythonQtWrapper_QCPLayoutElement::mousePressEvent(QCPLayoutElement* theWrappedObject, QMouseEvent*  event)
{
  ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_mousePressEvent(event));
}

void PythonQtWrapper_QCPLayoutElement::mouseReleaseEvent(QCPLayoutElement* theWrappedObject, QMouseEvent*  event)
{
  ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_mouseReleaseEvent(event));
}

QRect  PythonQtWrapper_QCPLayoutElement::outerRect(QCPLayoutElement* theWrappedObject) const
{
  return ( theWrappedObject->outerRect());
}

void PythonQtWrapper_QCPLayoutElement::parentPlotInitialized(QCPLayoutElement* theWrappedObject, QCustomPlot*  parentPlot)
{
  ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_parentPlotInitialized(parentPlot));
}

QRect  PythonQtWrapper_QCPLayoutElement::rect(QCPLayoutElement* theWrappedObject) const
{
  return ( theWrappedObject->rect());
}

double  PythonQtWrapper_QCPLayoutElement::selectTest(QCPLayoutElement* theWrappedObject, const QPointF&  pos, bool  onlySelectable, QVariant*  details) const
{
  return ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details));
}

void PythonQtWrapper_QCPLayoutElement::setMargins(QCPLayoutElement* theWrappedObject, const QMargins&  margins)
{
  ( theWrappedObject->setMargins(margins));
}

void PythonQtWrapper_QCPLayoutElement::setMaximumSize(QCPLayoutElement* theWrappedObject, const QSize&  size)
{
  ( theWrappedObject->setMaximumSize(size));
}

void PythonQtWrapper_QCPLayoutElement::setMaximumSize(QCPLayoutElement* theWrappedObject, int  width, int  height)
{
  ( theWrappedObject->setMaximumSize(width, height));
}

void PythonQtWrapper_QCPLayoutElement::setMinimumMargins(QCPLayoutElement* theWrappedObject, const QMargins&  margins)
{
  ( theWrappedObject->setMinimumMargins(margins));
}

void PythonQtWrapper_QCPLayoutElement::setMinimumSize(QCPLayoutElement* theWrappedObject, const QSize&  size)
{
  ( theWrappedObject->setMinimumSize(size));
}

void PythonQtWrapper_QCPLayoutElement::setMinimumSize(QCPLayoutElement* theWrappedObject, int  width, int  height)
{
  ( theWrappedObject->setMinimumSize(width, height));
}

void PythonQtWrapper_QCPLayoutElement::setOuterRect(QCPLayoutElement* theWrappedObject, const QRect&  rect)
{
  ( theWrappedObject->setOuterRect(rect));
}

void PythonQtWrapper_QCPLayoutElement::wheelEvent(QCPLayoutElement* theWrappedObject, QWheelEvent*  event)
{
  ( ((PythonQtPublicPromoter_QCPLayoutElement*)theWrappedObject)->promoted_wheelEvent(event));
}



PythonQtShell_QCPLegend::~PythonQtShell_QCPLegend() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QCPLegend::applyDefaultAntialiasingHint(QCPPainter*  painter0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLegend::applyDefaultAntialiasingHint(painter0);
}
void PythonQtShell_QCPLegend::deselectEvent(bool*  selectionStateChanged0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("deselectEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "bool*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&selectionStateChanged0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLegend::deselectEvent(selectionStateChanged0);
}
void PythonQtShell_QCPLegend::draw(QCPPainter*  painter0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("draw");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLegend::draw(painter0);
}
void PythonQtShell_QCPLegend::parentPlotInitialized(QCustomPlot*  parentPlot0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("parentPlotInitialized");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCustomPlot*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&parentPlot0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLegend::parentPlotInitialized(parentPlot0);
}
void PythonQtShell_QCPLegend::selectEvent(QMouseEvent*  event0, bool  additive1, const QVariant&  details2, bool*  selectionStateChanged3)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("selectEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
    void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPLegend::selectEvent(event0, additive1, details2, selectionStateChanged3);
}
double  PythonQtShell_QCPLegend::selectTest(const QPointF&  pos0, bool  onlySelectable1, QVariant*  details2) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("selectTest");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
      double returnValue;
    void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
        } else {
          returnValue = *((double*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPLegend::selectTest(pos0, onlySelectable1, details2);
}
QCPLegend* PythonQtWrapper_QCPLegend::new_QCPLegend()
{ 
return new PythonQtShell_QCPLegend(); }

bool  PythonQtWrapper_QCPLegend::addItem(QCPLegend* theWrappedObject, QCPAbstractLegendItem*  item)
{
  return ( theWrappedObject->addItem(item));
}

void PythonQtWrapper_QCPLegend::applyDefaultAntialiasingHint(QCPLegend* theWrappedObject, QCPPainter*  painter) const
{
  ( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter));
}

QPen  PythonQtWrapper_QCPLegend::borderPen(QCPLegend* theWrappedObject) const
{
  return ( theWrappedObject->borderPen());
}

QBrush  PythonQtWrapper_QCPLegend::brush(QCPLegend* theWrappedObject) const
{
  return ( theWrappedObject->brush());
}

void PythonQtWrapper_QCPLegend::clearItems(QCPLegend* theWrappedObject)
{
  ( theWrappedObject->clearItems());
}

void PythonQtWrapper_QCPLegend::deselectEvent(QCPLegend* theWrappedObject, bool*  selectionStateChanged)
{
  ( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_deselectEvent(selectionStateChanged));
}

void PythonQtWrapper_QCPLegend::draw(QCPLegend* theWrappedObject, QCPPainter*  painter)
{
  ( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_draw(painter));
}

QFont  PythonQtWrapper_QCPLegend::font(QCPLegend* theWrappedObject) const
{
  return ( theWrappedObject->font());
}

QPen  PythonQtWrapper_QCPLegend::getBorderPen(QCPLegend* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_getBorderPen());
}

QBrush  PythonQtWrapper_QCPLegend::getBrush(QCPLegend* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_getBrush());
}

bool  PythonQtWrapper_QCPLegend::hasItem(QCPLegend* theWrappedObject, QCPAbstractLegendItem*  item) const
{
  return ( theWrappedObject->hasItem(item));
}

QPen  PythonQtWrapper_QCPLegend::iconBorderPen(QCPLegend* theWrappedObject) const
{
  return ( theWrappedObject->iconBorderPen());
}

QSize  PythonQtWrapper_QCPLegend::iconSize(QCPLegend* theWrappedObject) const
{
  return ( theWrappedObject->iconSize());
}

int  PythonQtWrapper_QCPLegend::iconTextPadding(QCPLegend* theWrappedObject) const
{
  return ( theWrappedObject->iconTextPadding());
}

QCPAbstractLegendItem*  PythonQtWrapper_QCPLegend::item(QCPLegend* theWrappedObject, int  index) const
{
  return ( theWrappedObject->item(index));
}

int  PythonQtWrapper_QCPLegend::itemCount(QCPLegend* theWrappedObject) const
{
  return ( theWrappedObject->itemCount());
}

void PythonQtWrapper_QCPLegend::parentPlotInitialized(QCPLegend* theWrappedObject, QCustomPlot*  parentPlot)
{
  ( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_parentPlotInitialized(parentPlot));
}

bool  PythonQtWrapper_QCPLegend::removeItem(QCPLegend* theWrappedObject, QCPAbstractLegendItem*  item)
{
  return ( theWrappedObject->removeItem(item));
}

bool  PythonQtWrapper_QCPLegend::removeItem(QCPLegend* theWrappedObject, int  index)
{
  return ( theWrappedObject->removeItem(index));
}

void PythonQtWrapper_QCPLegend::selectEvent(QCPLegend* theWrappedObject, QMouseEvent*  event, bool  additive, const QVariant&  details, bool*  selectionStateChanged)
{
  ( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_selectEvent(event, additive, details, selectionStateChanged));
}

double  PythonQtWrapper_QCPLegend::selectTest(QCPLegend* theWrappedObject, const QPointF&  pos, bool  onlySelectable, QVariant*  details) const
{
  return ( ((PythonQtPublicPromoter_QCPLegend*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details));
}

QPen  PythonQtWrapper_QCPLegend::selectedBorderPen(QCPLegend* theWrappedObject) const
{
  return ( theWrappedObject->selectedBorderPen());
}

QBrush  PythonQtWrapper_QCPLegend::selectedBrush(QCPLegend* theWrappedObject) const
{
  return ( theWrappedObject->selectedBrush());
}

QFont  PythonQtWrapper_QCPLegend::selectedFont(QCPLegend* theWrappedObject) const
{
  return ( theWrappedObject->selectedFont());
}

QPen  PythonQtWrapper_QCPLegend::selectedIconBorderPen(QCPLegend* theWrappedObject) const
{
  return ( theWrappedObject->selectedIconBorderPen());
}

QList<QCPAbstractLegendItem* >  PythonQtWrapper_QCPLegend::selectedItems(QCPLegend* theWrappedObject) const
{
  return ( theWrappedObject->selectedItems());
}

QColor  PythonQtWrapper_QCPLegend::selectedTextColor(QCPLegend* theWrappedObject) const
{
  return ( theWrappedObject->selectedTextColor());
}

void PythonQtWrapper_QCPLegend::setBorderPen(QCPLegend* theWrappedObject, const QPen&  pen)
{
  ( theWrappedObject->setBorderPen(pen));
}

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

void PythonQtWrapper_QCPLegend::setFont(QCPLegend* theWrappedObject, const QFont&  font)
{
  ( theWrappedObject->setFont(font));
}

void PythonQtWrapper_QCPLegend::setIconBorderPen(QCPLegend* theWrappedObject, const QPen&  pen)
{
  ( theWrappedObject->setIconBorderPen(pen));
}

void PythonQtWrapper_QCPLegend::setIconSize(QCPLegend* theWrappedObject, const QSize&  size)
{
  ( theWrappedObject->setIconSize(size));
}

void PythonQtWrapper_QCPLegend::setIconSize(QCPLegend* theWrappedObject, int  width, int  height)
{
  ( theWrappedObject->setIconSize(width, height));
}

void PythonQtWrapper_QCPLegend::setIconTextPadding(QCPLegend* theWrappedObject, int  padding)
{
  ( theWrappedObject->setIconTextPadding(padding));
}

void PythonQtWrapper_QCPLegend::setSelectedBorderPen(QCPLegend* theWrappedObject, const QPen&  pen)
{
  ( theWrappedObject->setSelectedBorderPen(pen));
}

void PythonQtWrapper_QCPLegend::setSelectedBrush(QCPLegend* theWrappedObject, const QBrush&  brush)
{
  ( theWrappedObject->setSelectedBrush(brush));
}

void PythonQtWrapper_QCPLegend::setSelectedFont(QCPLegend* theWrappedObject, const QFont&  font)
{
  ( theWrappedObject->setSelectedFont(font));
}

void PythonQtWrapper_QCPLegend::setSelectedIconBorderPen(QCPLegend* theWrappedObject, const QPen&  pen)
{
  ( theWrappedObject->setSelectedIconBorderPen(pen));
}

void PythonQtWrapper_QCPLegend::setSelectedTextColor(QCPLegend* theWrappedObject, const QColor&  color)
{
  ( theWrappedObject->setSelectedTextColor(color));
}

void PythonQtWrapper_QCPLegend::setTextColor(QCPLegend* theWrappedObject, const QColor&  color)
{
  ( theWrappedObject->setTextColor(color));
}

QColor  PythonQtWrapper_QCPLegend::textColor(QCPLegend* theWrappedObject) const
{
  return ( theWrappedObject->textColor());
}



PythonQtShell_QCPPainter::~PythonQtShell_QCPPainter() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
QCPPainter* PythonQtWrapper_QCPPainter::new_QCPPainter()
{ 
return new PythonQtShell_QCPPainter(); }

QCPPainter* PythonQtWrapper_QCPPainter::new_QCPPainter(QPaintDevice*  device)
{ 
return new PythonQtShell_QCPPainter(device); }

bool  PythonQtWrapper_QCPPainter::antialiasing(QCPPainter* theWrappedObject) const
{
  return ( theWrappedObject->antialiasing());
}

bool  PythonQtWrapper_QCPPainter::begin(QCPPainter* theWrappedObject, QPaintDevice*  device)
{
  return ( theWrappedObject->begin(device));
}

void PythonQtWrapper_QCPPainter::drawLine(QCPPainter* theWrappedObject, const QLineF&  line)
{
  ( theWrappedObject->drawLine(line));
}

void PythonQtWrapper_QCPPainter::drawLine(QCPPainter* theWrappedObject, const QPointF&  p1, const QPointF&  p2)
{
  ( theWrappedObject->drawLine(p1, p2));
}

void PythonQtWrapper_QCPPainter::makeNonCosmetic(QCPPainter* theWrappedObject)
{
  ( theWrappedObject->makeNonCosmetic());
}

void PythonQtWrapper_QCPPainter::restore(QCPPainter* theWrappedObject)
{
  ( theWrappedObject->restore());
}

void PythonQtWrapper_QCPPainter::save(QCPPainter* theWrappedObject)
{
  ( theWrappedObject->save());
}

void PythonQtWrapper_QCPPainter::setAntialiasing(QCPPainter* theWrappedObject, bool  enabled)
{
  ( theWrappedObject->setAntialiasing(enabled));
}

void PythonQtWrapper_QCPPainter::setPen(QCPPainter* theWrappedObject, Qt::PenStyle  penStyle)
{
  ( theWrappedObject->setPen(penStyle));
}

void PythonQtWrapper_QCPPainter::setPen(QCPPainter* theWrappedObject, const QColor&  color)
{
  ( theWrappedObject->setPen(color));
}

void PythonQtWrapper_QCPPainter::setPen(QCPPainter* theWrappedObject, const QPen&  pen)
{
  ( theWrappedObject->setPen(pen));
}



PythonQtShell_QCPPlotTitle::~PythonQtShell_QCPPlotTitle() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QCPPlotTitle::applyDefaultAntialiasingHint(QCPPainter*  painter0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("applyDefaultAntialiasingHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPPlotTitle::applyDefaultAntialiasingHint(painter0);
}
void PythonQtShell_QCPPlotTitle::childEvent(QChildEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("childEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QChildEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPPlotTitle::childEvent(arg__1);
}
QRect  PythonQtShell_QCPPlotTitle::clipRect() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("clipRect");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QRect"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QRect returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("clipRect", methodInfo, result);
        } else {
          returnValue = *((QRect*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPPlotTitle::clipRect();
}
void PythonQtShell_QCPPlotTitle::customEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("customEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPPlotTitle::customEvent(arg__1);
}
void PythonQtShell_QCPPlotTitle::deselectEvent(bool*  selectionStateChanged0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("deselectEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "bool*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&selectionStateChanged0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPPlotTitle::deselectEvent(selectionStateChanged0);
}
void PythonQtShell_QCPPlotTitle::draw(QCPPainter*  painter0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("draw");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPPlotTitle::draw(painter0);
}
QList<QCPLayoutElement* >  PythonQtShell_QCPPlotTitle::elements(bool  recursive0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("elements");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QList<QCPLayoutElement* >" , "bool"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      QList<QCPLayoutElement* > returnValue;
    void* args[2] = {NULL, (void*)&recursive0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("elements", methodInfo, result);
        } else {
          returnValue = *((QList<QCPLayoutElement* >*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPPlotTitle::elements(recursive0);
}
bool  PythonQtShell_QCPPlotTitle::event(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("event");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      bool returnValue;
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPPlotTitle::event(arg__1);
}
bool  PythonQtShell_QCPPlotTitle::eventFilter(QObject*  arg__1, QEvent*  arg__2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("eventFilter");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
      bool returnValue;
    void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPPlotTitle::eventFilter(arg__1, arg__2);
}
QSize  PythonQtShell_QCPPlotTitle::maximumSizeHint() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("maximumSizeHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QSize"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QSize returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("maximumSizeHint", methodInfo, result);
        } else {
          returnValue = *((QSize*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPPlotTitle::maximumSizeHint();
}
QSize  PythonQtShell_QCPPlotTitle::minimumSizeHint() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("minimumSizeHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QSize"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QSize returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result);
        } else {
          returnValue = *((QSize*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPPlotTitle::minimumSizeHint();
}
void PythonQtShell_QCPPlotTitle::mouseDoubleClickEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPPlotTitle::mouseDoubleClickEvent(event0);
}
void PythonQtShell_QCPPlotTitle::mouseMoveEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseMoveEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPPlotTitle::mouseMoveEvent(event0);
}
void PythonQtShell_QCPPlotTitle::mousePressEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mousePressEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPPlotTitle::mousePressEvent(event0);
}
void PythonQtShell_QCPPlotTitle::mouseReleaseEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseReleaseEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPPlotTitle::mouseReleaseEvent(event0);
}
void PythonQtShell_QCPPlotTitle::parentPlotInitialized(QCustomPlot*  parentPlot0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("parentPlotInitialized");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCustomPlot*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&parentPlot0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPPlotTitle::parentPlotInitialized(parentPlot0);
}
void PythonQtShell_QCPPlotTitle::selectEvent(QMouseEvent*  event0, bool  additive1, const QVariant&  details2, bool*  selectionStateChanged3)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("selectEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*" , "bool" , "const QVariant&" , "bool*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(5, argumentList);
    void* args[5] = {NULL, (void*)&event0, (void*)&additive1, (void*)&details2, (void*)&selectionStateChanged3};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPPlotTitle::selectEvent(event0, additive1, details2, selectionStateChanged3);
}
double  PythonQtShell_QCPPlotTitle::selectTest(const QPointF&  pos0, bool  onlySelectable1, QVariant*  details2) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("selectTest");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"double" , "const QPointF&" , "bool" , "QVariant*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
      double returnValue;
    void* args[4] = {NULL, (void*)&pos0, (void*)&onlySelectable1, (void*)&details2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("selectTest", methodInfo, result);
        } else {
          returnValue = *((double*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCPPlotTitle::selectTest(pos0, onlySelectable1, details2);
}
void PythonQtShell_QCPPlotTitle::timerEvent(QTimerEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("timerEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QTimerEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPPlotTitle::timerEvent(arg__1);
}
void PythonQtShell_QCPPlotTitle::wheelEvent(QWheelEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("wheelEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QWheelEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCPPlotTitle::wheelEvent(event0);
}
QCPPlotTitle* PythonQtWrapper_QCPPlotTitle::new_QCPPlotTitle(QCustomPlot*  parentPlot)
{ 
return new PythonQtShell_QCPPlotTitle(parentPlot); }

QCPPlotTitle* PythonQtWrapper_QCPPlotTitle::new_QCPPlotTitle(QCustomPlot*  parentPlot, const QString&  text)
{ 
return new PythonQtShell_QCPPlotTitle(parentPlot, text); }

void PythonQtWrapper_QCPPlotTitle::applyDefaultAntialiasingHint(QCPPlotTitle* theWrappedObject, QCPPainter*  painter) const
{
  ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_applyDefaultAntialiasingHint(painter));
}

void PythonQtWrapper_QCPPlotTitle::deselectEvent(QCPPlotTitle* theWrappedObject, bool*  selectionStateChanged)
{
  ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_deselectEvent(selectionStateChanged));
}

void PythonQtWrapper_QCPPlotTitle::draw(QCPPlotTitle* theWrappedObject, QCPPainter*  painter)
{
  ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_draw(painter));
}

QFont  PythonQtWrapper_QCPPlotTitle::font(QCPPlotTitle* theWrappedObject) const
{
  return ( theWrappedObject->font());
}

QFont  PythonQtWrapper_QCPPlotTitle::mainFont(QCPPlotTitle* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_mainFont());
}

QColor  PythonQtWrapper_QCPPlotTitle::mainTextColor(QCPPlotTitle* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_mainTextColor());
}

QSize  PythonQtWrapper_QCPPlotTitle::maximumSizeHint(QCPPlotTitle* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_maximumSizeHint());
}

QSize  PythonQtWrapper_QCPPlotTitle::minimumSizeHint(QCPPlotTitle* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_minimumSizeHint());
}

void PythonQtWrapper_QCPPlotTitle::selectEvent(QCPPlotTitle* theWrappedObject, QMouseEvent*  event, bool  additive, const QVariant&  details, bool*  selectionStateChanged)
{
  ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_selectEvent(event, additive, details, selectionStateChanged));
}

double  PythonQtWrapper_QCPPlotTitle::selectTest(QCPPlotTitle* theWrappedObject, const QPointF&  pos, bool  onlySelectable, QVariant*  details) const
{
  return ( ((PythonQtPublicPromoter_QCPPlotTitle*)theWrappedObject)->promoted_selectTest(pos, onlySelectable, details));
}

bool  PythonQtWrapper_QCPPlotTitle::selectable(QCPPlotTitle* theWrappedObject) const
{
  return ( theWrappedObject->selectable());
}

bool  PythonQtWrapper_QCPPlotTitle::selected(QCPPlotTitle* theWrappedObject) const
{
  return ( theWrappedObject->selected());
}

QFont  PythonQtWrapper_QCPPlotTitle::selectedFont(QCPPlotTitle* theWrappedObject) const
{
  return ( theWrappedObject->selectedFont());
}

QColor  PythonQtWrapper_QCPPlotTitle::selectedTextColor(QCPPlotTitle* theWrappedObject) const
{
  return ( theWrappedObject->selectedTextColor());
}

void PythonQtWrapper_QCPPlotTitle::setFont(QCPPlotTitle* theWrappedObject, const QFont&  font)
{
  ( theWrappedObject->setFont(font));
}

void PythonQtWrapper_QCPPlotTitle::setSelectable(QCPPlotTitle* theWrappedObject, bool  selectable)
{
  ( theWrappedObject->setSelectable(selectable));
}

void PythonQtWrapper_QCPPlotTitle::setSelected(QCPPlotTitle* theWrappedObject, bool  selected)
{
  ( theWrappedObject->setSelected(selected));
}

void PythonQtWrapper_QCPPlotTitle::setSelectedFont(QCPPlotTitle* theWrappedObject, const QFont&  font)
{
  ( theWrappedObject->setSelectedFont(font));
}

void PythonQtWrapper_QCPPlotTitle::setSelectedTextColor(QCPPlotTitle* theWrappedObject, const QColor&  color)
{
  ( theWrappedObject->setSelectedTextColor(color));
}

void PythonQtWrapper_QCPPlotTitle::setText(QCPPlotTitle* theWrappedObject, const QString&  text)
{
  ( theWrappedObject->setText(text));
}

void PythonQtWrapper_QCPPlotTitle::setTextColor(QCPPlotTitle* theWrappedObject, const QColor&  color)
{
  ( theWrappedObject->setTextColor(color));
}

QString  PythonQtWrapper_QCPPlotTitle::text(QCPPlotTitle* theWrappedObject) const
{
  return ( theWrappedObject->text());
}

QColor  PythonQtWrapper_QCPPlotTitle::textColor(QCPPlotTitle* theWrappedObject) const
{
  return ( theWrappedObject->textColor());
}



PythonQtShell_QCustomPlot::~PythonQtShell_QCustomPlot() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QCustomPlot::actionEvent(QActionEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("actionEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QActionEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::actionEvent(arg__1);
}
void PythonQtShell_QCustomPlot::axisRemoved(QCPAxis*  axis0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("axisRemoved");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPAxis*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&axis0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::axisRemoved(axis0);
}
void PythonQtShell_QCustomPlot::changeEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("changeEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::changeEvent(arg__1);
}
void PythonQtShell_QCustomPlot::childEvent(QChildEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("childEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QChildEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::childEvent(arg__1);
}
void PythonQtShell_QCustomPlot::closeEvent(QCloseEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("closeEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCloseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::closeEvent(arg__1);
}
void PythonQtShell_QCustomPlot::contextMenuEvent(QContextMenuEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("contextMenuEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QContextMenuEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::contextMenuEvent(arg__1);
}
void PythonQtShell_QCustomPlot::customEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("customEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::customEvent(arg__1);
}
int  PythonQtShell_QCustomPlot::devType() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_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] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          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 QCustomPlot::devType();
}
void PythonQtShell_QCustomPlot::dragEnterEvent(QDragEnterEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("dragEnterEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QDragEnterEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::dragEnterEvent(arg__1);
}
void PythonQtShell_QCustomPlot::dragLeaveEvent(QDragLeaveEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("dragLeaveEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::dragLeaveEvent(arg__1);
}
void PythonQtShell_QCustomPlot::dragMoveEvent(QDragMoveEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("dragMoveEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QDragMoveEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::dragMoveEvent(arg__1);
}
void PythonQtShell_QCustomPlot::draw(QCPPainter*  painter0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("draw");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPPainter*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::draw(painter0);
}
void PythonQtShell_QCustomPlot::dropEvent(QDropEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("dropEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QDropEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::dropEvent(arg__1);
}
void PythonQtShell_QCustomPlot::enterEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("enterEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::enterEvent(arg__1);
}
bool  PythonQtShell_QCustomPlot::event(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("event");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      bool returnValue;
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCustomPlot::event(arg__1);
}
bool  PythonQtShell_QCustomPlot::eventFilter(QObject*  arg__1, QEvent*  arg__2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("eventFilter");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
      bool returnValue;
    void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCustomPlot::eventFilter(arg__1, arg__2);
}
void PythonQtShell_QCustomPlot::focusInEvent(QFocusEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("focusInEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QFocusEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::focusInEvent(arg__1);
}
bool  PythonQtShell_QCustomPlot::focusNextPrevChild(bool  next0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("focusNextPrevChild");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "bool"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      bool returnValue;
    void* args[2] = {NULL, (void*)&next0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCustomPlot::focusNextPrevChild(next0);
}
void PythonQtShell_QCustomPlot::focusOutEvent(QFocusEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("focusOutEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QFocusEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::focusOutEvent(arg__1);
}
bool  PythonQtShell_QCustomPlot::hasHeightForWidth() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("hasHeightForWidth");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      bool returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCustomPlot::hasHeightForWidth();
}
int  PythonQtShell_QCustomPlot::heightForWidth(int  arg__1) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("heightForWidth");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"int" , "int"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      int returnValue;
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
        } else {
          returnValue = *((int*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCustomPlot::heightForWidth(arg__1);
}
void PythonQtShell_QCustomPlot::hideEvent(QHideEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("hideEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QHideEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::hideEvent(arg__1);
}
void PythonQtShell_QCustomPlot::initPainter(QPainter*  painter0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_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] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::initPainter(painter0);
}
void PythonQtShell_QCustomPlot::inputMethodEvent(QInputMethodEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("inputMethodEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QInputMethodEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::inputMethodEvent(arg__1);
}
QVariant  PythonQtShell_QCustomPlot::inputMethodQuery(Qt::InputMethodQuery  arg__1) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("inputMethodQuery");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      QVariant returnValue;
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
        } else {
          returnValue = *((QVariant*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCustomPlot::inputMethodQuery(arg__1);
}
void PythonQtShell_QCustomPlot::keyPressEvent(QKeyEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("keyPressEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QKeyEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::keyPressEvent(arg__1);
}
void PythonQtShell_QCustomPlot::keyReleaseEvent(QKeyEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("keyReleaseEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QKeyEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::keyReleaseEvent(arg__1);
}
void PythonQtShell_QCustomPlot::leaveEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("leaveEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::leaveEvent(arg__1);
}
void PythonQtShell_QCustomPlot::legendRemoved(QCPLegend*  legend0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("legendRemoved");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCPLegend*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&legend0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::legendRemoved(legend0);
}
int  PythonQtShell_QCustomPlot::metric(QPaintDevice::PaintDeviceMetric  arg__1) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_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] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          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 QCustomPlot::metric(arg__1);
}
QSize  PythonQtShell_QCustomPlot::minimumSizeHint() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("minimumSizeHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QSize"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QSize returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("minimumSizeHint", methodInfo, result);
        } else {
          returnValue = *((QSize*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCustomPlot::minimumSizeHint();
}
void PythonQtShell_QCustomPlot::mouseDoubleClickEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::mouseDoubleClickEvent(event0);
}
void PythonQtShell_QCustomPlot::mouseMoveEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseMoveEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::mouseMoveEvent(event0);
}
void PythonQtShell_QCustomPlot::mousePressEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mousePressEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::mousePressEvent(event0);
}
void PythonQtShell_QCustomPlot::mouseReleaseEvent(QMouseEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseReleaseEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::mouseReleaseEvent(event0);
}
void PythonQtShell_QCustomPlot::moveEvent(QMoveEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("moveEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMoveEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::moveEvent(arg__1);
}
bool  PythonQtShell_QCustomPlot::nativeEvent(const QByteArray&  eventType0, void*  message1, long*  result2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("nativeEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
      bool returnValue;
    void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCustomPlot::nativeEvent(eventType0, message1, result2);
}
QPaintEngine*  PythonQtShell_QCustomPlot::paintEngine() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_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] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          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 QCustomPlot::paintEngine();
}
void PythonQtShell_QCustomPlot::paintEvent(QPaintEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("paintEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QPaintEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::paintEvent(event0);
}
QPaintDevice*  PythonQtShell_QCustomPlot::redirected(QPoint*  offset0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_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] = {NULL, (void*)&offset0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          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 QCustomPlot::redirected(offset0);
}
void PythonQtShell_QCustomPlot::resizeEvent(QResizeEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("resizeEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QResizeEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::resizeEvent(event0);
}
QPainter*  PythonQtShell_QCustomPlot::sharedPainter() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_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] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          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 QCustomPlot::sharedPainter();
}
void PythonQtShell_QCustomPlot::showEvent(QShowEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("showEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QShowEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::showEvent(arg__1);
}
QSize  PythonQtShell_QCustomPlot::sizeHint() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("sizeHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QSize"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QSize returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("sizeHint", methodInfo, result);
        } else {
          returnValue = *((QSize*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QCustomPlot::sizeHint();
}
void PythonQtShell_QCustomPlot::tabletEvent(QTabletEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("tabletEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QTabletEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::tabletEvent(arg__1);
}
void PythonQtShell_QCustomPlot::timerEvent(QTimerEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("timerEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QTimerEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::timerEvent(arg__1);
}
void PythonQtShell_QCustomPlot::wheelEvent(QWheelEvent*  event0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("wheelEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QWheelEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&event0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QCustomPlot::wheelEvent(event0);
}
QCustomPlot* PythonQtWrapper_QCustomPlot::new_QCustomPlot(QWidget*  parent)
{ 
return new PythonQtShell_QCustomPlot(parent); }

QCPGraph*  PythonQtWrapper_QCustomPlot::addGraph(QCustomPlot* theWrappedObject, QCPAxis*  keyAxis, QCPAxis*  valueAxis)
{
  return ( theWrappedObject->addGraph(keyAxis, valueAxis));
}

bool  PythonQtWrapper_QCustomPlot::addItem(QCustomPlot* theWrappedObject, QCPAbstractItem*  item)
{
  return ( theWrappedObject->addItem(item));
}

bool  PythonQtWrapper_QCustomPlot::autoAddPlottableToLegend(QCustomPlot* theWrappedObject) const
{
  return ( theWrappedObject->autoAddPlottableToLegend());
}

QCPAxisRect*  PythonQtWrapper_QCustomPlot::axisRect(QCustomPlot* theWrappedObject, int  index) const
{
  return ( theWrappedObject->axisRect(index));
}

int  PythonQtWrapper_QCustomPlot::axisRectCount(QCustomPlot* theWrappedObject) const
{
  return ( theWrappedObject->axisRectCount());
}

QList<QCPAxisRect* >  PythonQtWrapper_QCustomPlot::axisRects(QCustomPlot* theWrappedObject) const
{
  return ( theWrappedObject->axisRects());
}

void PythonQtWrapper_QCustomPlot::axisRemoved(QCustomPlot* theWrappedObject, QCPAxis*  axis)
{
  ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_axisRemoved(axis));
}

QPixmap  PythonQtWrapper_QCustomPlot::background(QCustomPlot* theWrappedObject) const
{
  return ( theWrappedObject->background());
}

bool  PythonQtWrapper_QCustomPlot::backgroundScaled(QCustomPlot* theWrappedObject) const
{
  return ( theWrappedObject->backgroundScaled());
}

Qt::AspectRatioMode  PythonQtWrapper_QCustomPlot::backgroundScaledMode(QCustomPlot* theWrappedObject) const
{
  return ( theWrappedObject->backgroundScaledMode());
}

int  PythonQtWrapper_QCustomPlot::clearGraphs(QCustomPlot* theWrappedObject)
{
  return ( theWrappedObject->clearGraphs());
}

int  PythonQtWrapper_QCustomPlot::clearItems(QCustomPlot* theWrappedObject)
{
  return ( theWrappedObject->clearItems());
}

int  PythonQtWrapper_QCustomPlot::clearPlottables(QCustomPlot* theWrappedObject)
{
  return ( theWrappedObject->clearPlottables());
}

QCPLayer*  PythonQtWrapper_QCustomPlot::currentLayer(QCustomPlot* theWrappedObject) const
{
  return ( theWrappedObject->currentLayer());
}

void PythonQtWrapper_QCustomPlot::deselectAll(QCustomPlot* theWrappedObject)
{
  ( theWrappedObject->deselectAll());
}

void PythonQtWrapper_QCustomPlot::draw(QCustomPlot* theWrappedObject, QCPPainter*  painter)
{
  ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_draw(painter));
}

void PythonQtWrapper_QCustomPlot::drawBackground(QCustomPlot* theWrappedObject, QCPPainter*  painter)
{
  ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_drawBackground(painter));
}

QCPGraph*  PythonQtWrapper_QCustomPlot::graph(QCustomPlot* theWrappedObject) const
{
  return ( theWrappedObject->graph());
}

QCPGraph*  PythonQtWrapper_QCustomPlot::graph(QCustomPlot* theWrappedObject, int  index) const
{
  return ( theWrappedObject->graph(index));
}

int  PythonQtWrapper_QCustomPlot::graphCount(QCustomPlot* theWrappedObject) const
{
  return ( theWrappedObject->graphCount());
}

bool  PythonQtWrapper_QCustomPlot::hasItem(QCustomPlot* theWrappedObject, QCPAbstractItem*  item) const
{
  return ( theWrappedObject->hasItem(item));
}

QCPAbstractItem*  PythonQtWrapper_QCustomPlot::item(QCustomPlot* theWrappedObject) const
{
  return ( theWrappedObject->item());
}

QCPAbstractItem*  PythonQtWrapper_QCustomPlot::item(QCustomPlot* theWrappedObject, int  index) const
{
  return ( theWrappedObject->item(index));
}

QCPAbstractItem*  PythonQtWrapper_QCustomPlot::itemAt(QCustomPlot* theWrappedObject, const QPointF&  pos, bool  onlySelectable) const
{
  return ( theWrappedObject->itemAt(pos, onlySelectable));
}

int  PythonQtWrapper_QCustomPlot::itemCount(QCustomPlot* theWrappedObject) const
{
  return ( theWrappedObject->itemCount());
}

QCPLayer*  PythonQtWrapper_QCustomPlot::layer(QCustomPlot* theWrappedObject, const QString&  name) const
{
  return ( theWrappedObject->layer(name));
}

QCPLayer*  PythonQtWrapper_QCustomPlot::layer(QCustomPlot* theWrappedObject, int  index) const
{
  return ( theWrappedObject->layer(index));
}

int  PythonQtWrapper_QCustomPlot::layerCount(QCustomPlot* theWrappedObject) const
{
  return ( theWrappedObject->layerCount());
}

QCPLayerable*  PythonQtWrapper_QCustomPlot::layerableAt(QCustomPlot* theWrappedObject, const QPointF&  pos, bool  onlySelectable, QVariant*  selectionDetails) const
{
  return ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_layerableAt(pos, onlySelectable, selectionDetails));
}

QCPLayoutElement*  PythonQtWrapper_QCustomPlot::layoutElementAt(QCustomPlot* theWrappedObject, const QPointF&  pos) const
{
  return ( theWrappedObject->layoutElementAt(pos));
}

void PythonQtWrapper_QCustomPlot::legendRemoved(QCustomPlot* theWrappedObject, QCPLegend*  legend)
{
  ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_legendRemoved(legend));
}

QSize  PythonQtWrapper_QCustomPlot::minimumSizeHint(QCustomPlot* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_minimumSizeHint());
}

void PythonQtWrapper_QCustomPlot::mouseDoubleClickEvent(QCustomPlot* theWrappedObject, QMouseEvent*  event)
{
  ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_mouseDoubleClickEvent(event));
}

void PythonQtWrapper_QCustomPlot::mouseMoveEvent(QCustomPlot* theWrappedObject, QMouseEvent*  event)
{
  ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_mouseMoveEvent(event));
}

void PythonQtWrapper_QCustomPlot::mousePressEvent(QCustomPlot* theWrappedObject, QMouseEvent*  event)
{
  ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_mousePressEvent(event));
}

void PythonQtWrapper_QCustomPlot::mouseReleaseEvent(QCustomPlot* theWrappedObject, QMouseEvent*  event)
{
  ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_mouseReleaseEvent(event));
}

Qt::KeyboardModifier  PythonQtWrapper_QCustomPlot::multiSelectModifier(QCustomPlot* theWrappedObject) const
{
  return ( theWrappedObject->multiSelectModifier());
}

bool  PythonQtWrapper_QCustomPlot::noAntialiasingOnDrag(QCustomPlot* theWrappedObject) const
{
  return ( theWrappedObject->noAntialiasingOnDrag());
}

void PythonQtWrapper_QCustomPlot::paintEvent(QCustomPlot* theWrappedObject, QPaintEvent*  event)
{
  ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_paintEvent(event));
}

int  PythonQtWrapper_QCustomPlot::plottableCount(QCustomPlot* theWrappedObject) const
{
  return ( theWrappedObject->plottableCount());
}

bool  PythonQtWrapper_QCustomPlot::removeGraph(QCustomPlot* theWrappedObject, QCPGraph*  graph)
{
  return ( theWrappedObject->removeGraph(graph));
}

bool  PythonQtWrapper_QCustomPlot::removeGraph(QCustomPlot* theWrappedObject, int  index)
{
  return ( theWrappedObject->removeGraph(index));
}

bool  PythonQtWrapper_QCustomPlot::removeItem(QCustomPlot* theWrappedObject, QCPAbstractItem*  item)
{
  return ( theWrappedObject->removeItem(item));
}

bool  PythonQtWrapper_QCustomPlot::removeItem(QCustomPlot* theWrappedObject, int  index)
{
  return ( theWrappedObject->removeItem(index));
}

bool  PythonQtWrapper_QCustomPlot::removeLayer(QCustomPlot* theWrappedObject, QCPLayer*  layer)
{
  return ( theWrappedObject->removeLayer(layer));
}

bool  PythonQtWrapper_QCustomPlot::removePlottable(QCustomPlot* theWrappedObject, int  index)
{
  return ( theWrappedObject->removePlottable(index));
}

void PythonQtWrapper_QCustomPlot::rescaleAxes(QCustomPlot* theWrappedObject, bool  onlyVisiblePlottables)
{
  ( theWrappedObject->rescaleAxes(onlyVisiblePlottables));
}

void PythonQtWrapper_QCustomPlot::resizeEvent(QCustomPlot* theWrappedObject, QResizeEvent*  event)
{
  ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_resizeEvent(event));
}

bool  PythonQtWrapper_QCustomPlot::saveBmp(QCustomPlot* theWrappedObject, const QString&  fileName, int  width, int  height, double  scale)
{
  return ( theWrappedObject->saveBmp(fileName, width, height, scale));
}

bool  PythonQtWrapper_QCustomPlot::saveJpg(QCustomPlot* theWrappedObject, const QString&  fileName, int  width, int  height, double  scale, int  quality)
{
  return ( theWrappedObject->saveJpg(fileName, width, height, scale, quality));
}

bool  PythonQtWrapper_QCustomPlot::savePdf(QCustomPlot* theWrappedObject, const QString&  fileName, bool  noCosmeticPen, int  width, int  height, const QString&  pdfCreator, const QString&  pdfTitle)
{
  return ( theWrappedObject->savePdf(fileName, noCosmeticPen, width, height, pdfCreator, pdfTitle));
}

bool  PythonQtWrapper_QCustomPlot::savePng(QCustomPlot* theWrappedObject, const QString&  fileName, int  width, int  height, double  scale, int  quality)
{
  return ( theWrappedObject->savePng(fileName, width, height, scale, quality));
}

bool  PythonQtWrapper_QCustomPlot::saveRastered(QCustomPlot* theWrappedObject, const QString&  fileName, int  width, int  height, double  scale, const char*  format, int  quality)
{
  return ( theWrappedObject->saveRastered(fileName, width, height, scale, format, quality));
}

QList<QCPAxis* >  PythonQtWrapper_QCustomPlot::selectedAxes(QCustomPlot* theWrappedObject) const
{
  return ( theWrappedObject->selectedAxes());
}

QList<QCPGraph* >  PythonQtWrapper_QCustomPlot::selectedGraphs(QCustomPlot* theWrappedObject) const
{
  return ( theWrappedObject->selectedGraphs());
}

QList<QCPAbstractItem* >  PythonQtWrapper_QCustomPlot::selectedItems(QCustomPlot* theWrappedObject) const
{
  return ( theWrappedObject->selectedItems());
}

QList<QCPLegend* >  PythonQtWrapper_QCustomPlot::selectedLegends(QCustomPlot* theWrappedObject) const
{
  return ( theWrappedObject->selectedLegends());
}

int  PythonQtWrapper_QCustomPlot::selectionTolerance(QCustomPlot* theWrappedObject) const
{
  return ( theWrappedObject->selectionTolerance());
}

void PythonQtWrapper_QCustomPlot::setAutoAddPlottableToLegend(QCustomPlot* theWrappedObject, bool  on)
{
  ( theWrappedObject->setAutoAddPlottableToLegend(on));
}

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

void PythonQtWrapper_QCustomPlot::setBackground(QCustomPlot* theWrappedObject, const QPixmap&  pm)
{
  ( theWrappedObject->setBackground(pm));
}

void PythonQtWrapper_QCustomPlot::setBackground(QCustomPlot* theWrappedObject, const QPixmap&  pm, bool  scaled, Qt::AspectRatioMode  mode)
{
  ( theWrappedObject->setBackground(pm, scaled, mode));
}

void PythonQtWrapper_QCustomPlot::setBackgroundScaled(QCustomPlot* theWrappedObject, bool  scaled)
{
  ( theWrappedObject->setBackgroundScaled(scaled));
}

void PythonQtWrapper_QCustomPlot::setBackgroundScaledMode(QCustomPlot* theWrappedObject, Qt::AspectRatioMode  mode)
{
  ( theWrappedObject->setBackgroundScaledMode(mode));
}

bool  PythonQtWrapper_QCustomPlot::setCurrentLayer(QCustomPlot* theWrappedObject, QCPLayer*  layer)
{
  return ( theWrappedObject->setCurrentLayer(layer));
}

bool  PythonQtWrapper_QCustomPlot::setCurrentLayer(QCustomPlot* theWrappedObject, const QString&  name)
{
  return ( theWrappedObject->setCurrentLayer(name));
}

void PythonQtWrapper_QCustomPlot::setMultiSelectModifier(QCustomPlot* theWrappedObject, Qt::KeyboardModifier  modifier)
{
  ( theWrappedObject->setMultiSelectModifier(modifier));
}

void PythonQtWrapper_QCustomPlot::setNoAntialiasingOnDrag(QCustomPlot* theWrappedObject, bool  enabled)
{
  ( theWrappedObject->setNoAntialiasingOnDrag(enabled));
}

void PythonQtWrapper_QCustomPlot::setSelectionTolerance(QCustomPlot* theWrappedObject, int  pixels)
{
  ( theWrappedObject->setSelectionTolerance(pixels));
}

void PythonQtWrapper_QCustomPlot::setViewport(QCustomPlot* theWrappedObject, const QRect&  rect)
{
  ( theWrappedObject->setViewport(rect));
}

QSize  PythonQtWrapper_QCustomPlot::sizeHint(QCustomPlot* theWrappedObject) const
{
  return ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_sizeHint());
}

void PythonQtWrapper_QCustomPlot::toPainter(QCustomPlot* theWrappedObject, QCPPainter*  painter, int  width, int  height)
{
  ( theWrappedObject->toPainter(painter, width, height));
}

QPixmap  PythonQtWrapper_QCustomPlot::toPixmap(QCustomPlot* theWrappedObject, int  width, int  height, double  scale)
{
  return ( theWrappedObject->toPixmap(width, height, scale));
}

void PythonQtWrapper_QCustomPlot::updateLayerIndices(QCustomPlot* theWrappedObject) const
{
  ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_updateLayerIndices());
}

QRect  PythonQtWrapper_QCustomPlot::viewport(QCustomPlot* theWrappedObject) const
{
  return ( theWrappedObject->viewport());
}

void PythonQtWrapper_QCustomPlot::wheelEvent(QCustomPlot* theWrappedObject, QWheelEvent*  event)
{
  ( ((PythonQtPublicPromoter_QCustomPlot*)theWrappedObject)->promoted_wheelEvent(event));
}



PythonQtShell_QLopData::~PythonQtShell_QLopData() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QLopData::childEvent(QChildEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("childEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QChildEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QLopData::childEvent(arg__1);
}
void PythonQtShell_QLopData::customEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("customEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QLopData::customEvent(arg__1);
}
bool  PythonQtShell_QLopData::event(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("event");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      bool returnValue;
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QLopData::event(arg__1);
}
bool  PythonQtShell_QLopData::eventFilter(QObject*  arg__1, QEvent*  arg__2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("eventFilter");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
      bool returnValue;
    void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QLopData::eventFilter(arg__1, arg__2);
}
void PythonQtShell_QLopData::timerEvent(QTimerEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("timerEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QTimerEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QLopData::timerEvent(arg__1);
}
QLopData* PythonQtWrapper_QLopData::new_QLopData(QObject*  parent)
{ 
return new PythonQtShell_QLopData(parent); }



QLopDataList* PythonQtWrapper_QLopDataList::new_QLopDataList()
{ 
return new QLopDataList(); }

QLopDataList* PythonQtWrapper_QLopDataList::new_QLopDataList(const QList<QLopData* >&  l)
{ 
return new QLopDataList(l); }

void PythonQtWrapper_QLopDataList::append(QLopDataList* theWrappedObject, QLopData*  t)
{
  ( theWrappedObject->append(t));
}

void PythonQtWrapper_QLopDataList::append(QLopDataList* theWrappedObject, const QList<QLopData* >&  t)
{
  ( theWrappedObject->append(t));
}

QLopData*  PythonQtWrapper_QLopDataList::at(QLopDataList* theWrappedObject, int  i) const
{
  return ( theWrappedObject->at(i));
}

QLopData*  PythonQtWrapper_QLopDataList::back(QLopDataList* theWrappedObject) const
{
  return ( theWrappedObject->back());
}

void PythonQtWrapper_QLopDataList::clear(QLopDataList* theWrappedObject)
{
  ( theWrappedObject->clear());
}

bool  PythonQtWrapper_QLopDataList::contains(QLopDataList* theWrappedObject, QLopData*  t) const
{
  return ( theWrappedObject->contains(t));
}

int  PythonQtWrapper_QLopDataList::count(QLopDataList* theWrappedObject) const
{
  return ( theWrappedObject->count());
}

int  PythonQtWrapper_QLopDataList::count(QLopDataList* theWrappedObject, QLopData*  t) const
{
  return ( theWrappedObject->count(t));
}

void PythonQtWrapper_QLopDataList::detachShared(QLopDataList* theWrappedObject)
{
  ( theWrappedObject->detachShared());
}

bool  PythonQtWrapper_QLopDataList::empty(QLopDataList* theWrappedObject) const
{
  return ( theWrappedObject->empty());
}

bool  PythonQtWrapper_QLopDataList::endsWith(QLopDataList* theWrappedObject, QLopData*  t) const
{
  return ( theWrappedObject->endsWith(t));
}

QLopData*  PythonQtWrapper_QLopDataList::first(QLopDataList* theWrappedObject) const
{
  return ( theWrappedObject->first());
}

QList<QLopData* >  PythonQtWrapper_QLopDataList::static_QLopDataList_fromVector(const QVector<QLopData* >&  vector)
{
  return (QLopDataList::fromVector(vector));
}

QLopData*  PythonQtWrapper_QLopDataList::front(QLopDataList* theWrappedObject) const
{
  return ( theWrappedObject->front());
}

int  PythonQtWrapper_QLopDataList::indexOf(QLopDataList* theWrappedObject, QLopData*  t, int  from) const
{
  return ( theWrappedObject->indexOf(t, from));
}

bool  PythonQtWrapper_QLopDataList::isEmpty(QLopDataList* theWrappedObject) const
{
  return ( theWrappedObject->isEmpty());
}

bool  PythonQtWrapper_QLopDataList::isSharedWith(QLopDataList* theWrappedObject, const QList<QLopData* >&  other) const
{
  return ( theWrappedObject->isSharedWith(other));
}

QLopData*  PythonQtWrapper_QLopDataList::last(QLopDataList* theWrappedObject) const
{
  return ( theWrappedObject->last());
}

int  PythonQtWrapper_QLopDataList::lastIndexOf(QLopDataList* theWrappedObject, QLopData*  t, int  from) const
{
  return ( theWrappedObject->lastIndexOf(t, from));
}

int  PythonQtWrapper_QLopDataList::length(QLopDataList* theWrappedObject) const
{
  return ( theWrappedObject->length());
}

QList<QLopData* >  PythonQtWrapper_QLopDataList::mid(QLopDataList* theWrappedObject, int  pos, int  length) const
{
  return ( theWrappedObject->mid(pos, length));
}

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

bool  PythonQtWrapper_QLopDataList::__ne__(QLopDataList* theWrappedObject, const QList<QLopData* >&  l) const
{
  return ( (*theWrappedObject)!= l);
}

QList<QLopData* >  PythonQtWrapper_QLopDataList::__add__(QLopDataList* theWrappedObject, const QList<QLopData* >&  l) const
{
  return ( (*theWrappedObject)+ l);
}

QList<QLopData* >*  PythonQtWrapper_QLopDataList::__iadd__(QLopDataList* theWrappedObject, QLopData*  t)
{
  return &( (*theWrappedObject)+= t);
}

QList<QLopData* >*  PythonQtWrapper_QLopDataList::__iadd__(QLopDataList* theWrappedObject, const QList<QLopData* >&  l)
{
  return &( (*theWrappedObject)+= l);
}

QList<QLopData* >*  PythonQtWrapper_QLopDataList::__lshift__(QLopDataList* theWrappedObject, QLopData*  t)
{
  return &( (*theWrappedObject) <<t);
}

QList<QLopData* >*  PythonQtWrapper_QLopDataList::__lshift__(QLopDataList* theWrappedObject, const QList<QLopData* >&  l)
{
  return &( (*theWrappedObject) <<l);
}

bool  PythonQtWrapper_QLopDataList::__eq__(QLopDataList* theWrappedObject, const QList<QLopData* >&  l) const
{
  return ( (*theWrappedObject)== l);
}

void PythonQtWrapper_QLopDataList::pop_back(QLopDataList* theWrappedObject)
{
  ( theWrappedObject->pop_back());
}

void PythonQtWrapper_QLopDataList::pop_front(QLopDataList* theWrappedObject)
{
  ( theWrappedObject->pop_front());
}

void PythonQtWrapper_QLopDataList::prepend(QLopDataList* theWrappedObject, QLopData*  t)
{
  ( theWrappedObject->prepend(t));
}

void PythonQtWrapper_QLopDataList::push_back(QLopDataList* theWrappedObject, QLopData*  t)
{
  ( theWrappedObject->push_back(t));
}

void PythonQtWrapper_QLopDataList::push_front(QLopDataList* theWrappedObject, QLopData*  t)
{
  ( theWrappedObject->push_front(t));
}

int  PythonQtWrapper_QLopDataList::removeAll(QLopDataList* theWrappedObject, QLopData*  t)
{
  return ( theWrappedObject->removeAll(t));
}

void PythonQtWrapper_QLopDataList::removeAt(QLopDataList* theWrappedObject, int  i)
{
  ( theWrappedObject->removeAt(i));
}

void PythonQtWrapper_QLopDataList::removeFirst(QLopDataList* theWrappedObject)
{
  ( theWrappedObject->removeFirst());
}

void PythonQtWrapper_QLopDataList::removeLast(QLopDataList* theWrappedObject)
{
  ( theWrappedObject->removeLast());
}

bool  PythonQtWrapper_QLopDataList::removeOne(QLopDataList* theWrappedObject, QLopData*  t)
{
  return ( theWrappedObject->removeOne(t));
}

void PythonQtWrapper_QLopDataList::replace(QLopDataList* theWrappedObject, int  i, QLopData*  t)
{
  ( theWrappedObject->replace(i, t));
}

void PythonQtWrapper_QLopDataList::reserve(QLopDataList* theWrappedObject, int  size)
{
  ( theWrappedObject->reserve(size));
}

void PythonQtWrapper_QLopDataList::setSharable(QLopDataList* theWrappedObject, bool  sharable)
{
  ( theWrappedObject->setSharable(sharable));
}

int  PythonQtWrapper_QLopDataList::size(QLopDataList* theWrappedObject) const
{
  return ( theWrappedObject->size());
}

bool  PythonQtWrapper_QLopDataList::startsWith(QLopDataList* theWrappedObject, QLopData*  t) const
{
  return ( theWrappedObject->startsWith(t));
}

void PythonQtWrapper_QLopDataList::swap(QLopDataList* theWrappedObject, QList<QLopData* >&  other)
{
  ( theWrappedObject->swap(other));
}

void PythonQtWrapper_QLopDataList::swap(QLopDataList* theWrappedObject, int  i, int  j)
{
  ( theWrappedObject->swap(i, j));
}

QLopData*  PythonQtWrapper_QLopDataList::takeAt(QLopDataList* theWrappedObject, int  i)
{
  return ( theWrappedObject->takeAt(i));
}

QLopData*  PythonQtWrapper_QLopDataList::takeFirst(QLopDataList* theWrappedObject)
{
  return ( theWrappedObject->takeFirst());
}

QLopData*  PythonQtWrapper_QLopDataList::takeLast(QLopDataList* theWrappedObject)
{
  return ( theWrappedObject->takeLast());
}

QVector<QLopData* >  PythonQtWrapper_QLopDataList::toVector(QLopDataList* theWrappedObject) const
{
  return ( theWrappedObject->toVector());
}

QLopData*  PythonQtWrapper_QLopDataList::value(QLopDataList* theWrappedObject, int  i) const
{
  return ( theWrappedObject->value(i));
}

QLopData*  PythonQtWrapper_QLopDataList::value(QLopDataList* theWrappedObject, int  i, QLopData*  defaultValue) const
{
  return ( theWrappedObject->value(i, defaultValue));
}



PythonQtShell_QLopService::~PythonQtShell_QLopService() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_QLopService::childEvent(QChildEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("childEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QChildEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QLopService::childEvent(arg__1);
}
void PythonQtShell_QLopService::customEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("customEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QLopService::customEvent(arg__1);
}
bool  PythonQtShell_QLopService::event(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("event");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      bool returnValue;
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QLopService::event(arg__1);
}
bool  PythonQtShell_QLopService::eventFilter(QObject*  arg__1, QEvent*  arg__2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("eventFilter");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
      bool returnValue;
    void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return QLopService::eventFilter(arg__1, arg__2);
}
QDockWidget*  PythonQtShell_QLopService::getGUI()
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("getGUI");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QDockWidget*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QDockWidget* returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("getGUI", methodInfo, result);
        } else {
          returnValue = *((QDockWidget**)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return 0;
}
const QString&  PythonQtShell_QLopService::serviceName()
{
  return QLopService::serviceName();
}
void PythonQtShell_QLopService::timerEvent(QTimerEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("timerEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QTimerEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  QLopService::timerEvent(arg__1);
}
QLopService* PythonQtWrapper_QLopService::new_QLopService(QObject*  parent)
{ 
return new PythonQtShell_QLopService(parent); }

QDockWidget*  PythonQtWrapper_QLopService::getGUI(QLopService* theWrappedObject)
{
  return ( ((PythonQtPublicPromoter_QLopService*)theWrappedObject)->promoted_getGUI());
}

const QString*  PythonQtWrapper_QLopService::serviceName(QLopService* theWrappedObject)
{
  return &( ((PythonQtPublicPromoter_QLopService*)theWrappedObject)->promoted_serviceName());
}



PythonQtShell_SocExplorerPlot::~PythonQtShell_SocExplorerPlot() {
  PythonQtPrivate* priv = PythonQt::priv();
  if (priv) { priv->shellClassDeleted(this); }
}
void PythonQtShell_SocExplorerPlot::actionEvent(QActionEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("actionEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QActionEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::actionEvent(arg__1);
}
void PythonQtShell_SocExplorerPlot::changeEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("changeEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::changeEvent(arg__1);
}
void PythonQtShell_SocExplorerPlot::childEvent(QChildEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("childEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QChildEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::childEvent(arg__1);
}
void PythonQtShell_SocExplorerPlot::closeEvent(QCloseEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("closeEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QCloseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::closeEvent(arg__1);
}
void PythonQtShell_SocExplorerPlot::contextMenuEvent(QContextMenuEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("contextMenuEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QContextMenuEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::contextMenuEvent(arg__1);
}
void PythonQtShell_SocExplorerPlot::customEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("customEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::customEvent(arg__1);
}
int  PythonQtShell_SocExplorerPlot::devType() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_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] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          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 SocExplorerPlot::devType();
}
void PythonQtShell_SocExplorerPlot::dragEnterEvent(QDragEnterEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("dragEnterEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QDragEnterEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::dragEnterEvent(arg__1);
}
void PythonQtShell_SocExplorerPlot::dragLeaveEvent(QDragLeaveEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("dragLeaveEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QDragLeaveEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::dragLeaveEvent(arg__1);
}
void PythonQtShell_SocExplorerPlot::dragMoveEvent(QDragMoveEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("dragMoveEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QDragMoveEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::dragMoveEvent(arg__1);
}
void PythonQtShell_SocExplorerPlot::dropEvent(QDropEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("dropEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QDropEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::dropEvent(arg__1);
}
void PythonQtShell_SocExplorerPlot::enterEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("enterEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::enterEvent(arg__1);
}
bool  PythonQtShell_SocExplorerPlot::event(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("event");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      bool returnValue;
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("event", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return SocExplorerPlot::event(arg__1);
}
bool  PythonQtShell_SocExplorerPlot::eventFilter(QObject*  arg__1, QEvent*  arg__2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("eventFilter");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "QObject*" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(3, argumentList);
      bool returnValue;
    void* args[3] = {NULL, (void*)&arg__1, (void*)&arg__2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("eventFilter", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return SocExplorerPlot::eventFilter(arg__1, arg__2);
}
void PythonQtShell_SocExplorerPlot::focusInEvent(QFocusEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("focusInEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QFocusEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::focusInEvent(arg__1);
}
bool  PythonQtShell_SocExplorerPlot::focusNextPrevChild(bool  next0)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("focusNextPrevChild");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "bool"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      bool returnValue;
    void* args[2] = {NULL, (void*)&next0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("focusNextPrevChild", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return SocExplorerPlot::focusNextPrevChild(next0);
}
void PythonQtShell_SocExplorerPlot::focusOutEvent(QFocusEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("focusOutEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QFocusEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::focusOutEvent(arg__1);
}
bool  PythonQtShell_SocExplorerPlot::hasHeightForWidth() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("hasHeightForWidth");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      bool returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("hasHeightForWidth", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return SocExplorerPlot::hasHeightForWidth();
}
int  PythonQtShell_SocExplorerPlot::heightForWidth(int  arg__1) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("heightForWidth");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"int" , "int"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      int returnValue;
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("heightForWidth", methodInfo, result);
        } else {
          returnValue = *((int*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return SocExplorerPlot::heightForWidth(arg__1);
}
void PythonQtShell_SocExplorerPlot::hideEvent(QHideEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("hideEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QHideEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::hideEvent(arg__1);
}
void PythonQtShell_SocExplorerPlot::initPainter(QPainter*  painter0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_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] = {NULL, (void*)&painter0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::initPainter(painter0);
}
void PythonQtShell_SocExplorerPlot::inputMethodEvent(QInputMethodEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("inputMethodEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QInputMethodEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::inputMethodEvent(arg__1);
}
QVariant  PythonQtShell_SocExplorerPlot::inputMethodQuery(Qt::InputMethodQuery  arg__1) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("inputMethodQuery");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QVariant" , "Qt::InputMethodQuery"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
      QVariant returnValue;
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("inputMethodQuery", methodInfo, result);
        } else {
          returnValue = *((QVariant*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return SocExplorerPlot::inputMethodQuery(arg__1);
}
void PythonQtShell_SocExplorerPlot::keyPressEvent(QKeyEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("keyPressEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QKeyEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::keyPressEvent(arg__1);
}
void PythonQtShell_SocExplorerPlot::keyReleaseEvent(QKeyEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("keyReleaseEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QKeyEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::keyReleaseEvent(arg__1);
}
void PythonQtShell_SocExplorerPlot::leaveEvent(QEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("leaveEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::leaveEvent(arg__1);
}
int  PythonQtShell_SocExplorerPlot::metric(QPaintDevice::PaintDeviceMetric  arg__1) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_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] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          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 SocExplorerPlot::metric(arg__1);
}
QSize  PythonQtShell_SocExplorerPlot::minimumSizeHint() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("getMinimumSizeHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QSize"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QSize returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("getMinimumSizeHint", methodInfo, result);
        } else {
          returnValue = *((QSize*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return SocExplorerPlot::minimumSizeHint();
}
void PythonQtShell_SocExplorerPlot::mouseDoubleClickEvent(QMouseEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseDoubleClickEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::mouseDoubleClickEvent(arg__1);
}
void PythonQtShell_SocExplorerPlot::mouseMoveEvent(QMouseEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseMoveEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::mouseMoveEvent(arg__1);
}
void PythonQtShell_SocExplorerPlot::mousePressEvent(QMouseEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mousePressEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::mousePressEvent(arg__1);
}
void PythonQtShell_SocExplorerPlot::mouseReleaseEvent(QMouseEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("mouseReleaseEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMouseEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::mouseReleaseEvent(arg__1);
}
void PythonQtShell_SocExplorerPlot::moveEvent(QMoveEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("moveEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QMoveEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::moveEvent(arg__1);
}
bool  PythonQtShell_SocExplorerPlot::nativeEvent(const QByteArray&  eventType0, void*  message1, long*  result2)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("nativeEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"bool" , "const QByteArray&" , "void*" , "long*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(4, argumentList);
      bool returnValue;
    void* args[4] = {NULL, (void*)&eventType0, (void*)&message1, (void*)&result2};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("nativeEvent", methodInfo, result);
        } else {
          returnValue = *((bool*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return SocExplorerPlot::nativeEvent(eventType0, message1, result2);
}
QPaintEngine*  PythonQtShell_SocExplorerPlot::paintEngine() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_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] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          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 SocExplorerPlot::paintEngine();
}
void PythonQtShell_SocExplorerPlot::paintEvent(QPaintEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("paintEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QPaintEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::paintEvent(arg__1);
}
QPaintDevice*  PythonQtShell_SocExplorerPlot::redirected(QPoint*  offset0) const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_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] = {NULL, (void*)&offset0};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          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 SocExplorerPlot::redirected(offset0);
}
void PythonQtShell_SocExplorerPlot::resizeEvent(QResizeEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("resizeEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QResizeEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::resizeEvent(arg__1);
}
QPainter*  PythonQtShell_SocExplorerPlot::sharedPainter() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_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] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          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 SocExplorerPlot::sharedPainter();
}
void PythonQtShell_SocExplorerPlot::showEvent(QShowEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("showEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QShowEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::showEvent(arg__1);
}
QSize  PythonQtShell_SocExplorerPlot::sizeHint() const
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("getSizeHint");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"QSize"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(1, argumentList);
      QSize returnValue;
    void* args[1] = {NULL};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) {
      args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);
      if (args[0]!=&returnValue) {
        if (args[0]==NULL) {
          PythonQt::priv()->handleVirtualOverloadReturnError("getSizeHint", methodInfo, result);
        } else {
          returnValue = *((QSize*)args[0]);
        }
      }
    }
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return returnValue;
  } else {
    PyErr_Clear();
  }
}
  return SocExplorerPlot::sizeHint();
}
void PythonQtShell_SocExplorerPlot::tabletEvent(QTabletEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("tabletEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QTabletEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::tabletEvent(arg__1);
}
void PythonQtShell_SocExplorerPlot::timerEvent(QTimerEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("timerEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QTimerEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::timerEvent(arg__1);
}
void PythonQtShell_SocExplorerPlot::wheelEvent(QWheelEvent*  arg__1)
{
if (_wrapper && (((PyObject*)_wrapper)->ob_refcnt > 0)) {
  static PyObject* name = PyString_FromString("wheelEvent");
  PyObject* obj = PyBaseObject_Type.tp_getattro((PyObject*)_wrapper, name);
  if (obj) {
    static const char* argumentList[] ={"" , "QWheelEvent*"};
    static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(2, argumentList);
    void* args[2] = {NULL, (void*)&arg__1};
    PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);
    if (result) { Py_DECREF(result); } 
    Py_DECREF(obj);
    return;
  } else {
    PyErr_Clear();
  }
}
  SocExplorerPlot::wheelEvent(arg__1);
}
SocExplorerPlot* PythonQtWrapper_SocExplorerPlot::new_SocExplorerPlot(QWidget*  parent)
{ 
return new PythonQtShell_SocExplorerPlot(parent); }

int  PythonQtWrapper_SocExplorerPlot::addGraph(SocExplorerPlot* theWrappedObject)
{
  return ( theWrappedObject->addGraph());
}

void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int  graphIndex, QList<QVariant >  x, QList<QVariant >  y)
{
  ( theWrappedObject->addGraphData(graphIndex, x, y));
}

void PythonQtWrapper_SocExplorerPlot::addGraphData(SocExplorerPlot* theWrappedObject, int  graphIndex, QVariant  x, QVariant  y)
{
  ( theWrappedObject->addGraphData(graphIndex, x, y));
}

void PythonQtWrapper_SocExplorerPlot::exportToPDF(SocExplorerPlot* theWrappedObject, const QString&  fileName)
{
  ( theWrappedObject->exportToPDF(fileName));
}

void PythonQtWrapper_SocExplorerPlot::exportToSVG(SocExplorerPlot* theWrappedObject, const QString&  fileName)
{
  ( theWrappedObject->exportToSVG(fileName));
}

QPen  PythonQtWrapper_SocExplorerPlot::getGraphPen(SocExplorerPlot* theWrappedObject, int  graphIndex)
{
  return ( theWrappedObject->getGraphPen(graphIndex));
}

void PythonQtWrapper_SocExplorerPlot::keyPressEvent(SocExplorerPlot* theWrappedObject, QKeyEvent*  arg__1)
{
  ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyPressEvent(arg__1));
}

void PythonQtWrapper_SocExplorerPlot::keyReleaseEvent(SocExplorerPlot* theWrappedObject, QKeyEvent*  arg__1)
{
  ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_keyReleaseEvent(arg__1));
}

void PythonQtWrapper_SocExplorerPlot::mouseMoveEvent(SocExplorerPlot* theWrappedObject, QMouseEvent*  arg__1)
{
  ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseMoveEvent(arg__1));
}

void PythonQtWrapper_SocExplorerPlot::mousePressEvent(SocExplorerPlot* theWrappedObject, QMouseEvent*  arg__1)
{
  ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mousePressEvent(arg__1));
}

void PythonQtWrapper_SocExplorerPlot::mouseReleaseEvent(SocExplorerPlot* theWrappedObject, QMouseEvent*  arg__1)
{
  ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_mouseReleaseEvent(arg__1));
}

void PythonQtWrapper_SocExplorerPlot::removeAllGraphs(SocExplorerPlot* theWrappedObject)
{
  ( theWrappedObject->removeAllGraphs());
}

bool  PythonQtWrapper_SocExplorerPlot::removeGraph(SocExplorerPlot* theWrappedObject, int  graphIndex)
{
  return ( theWrappedObject->removeGraph(graphIndex));
}

void PythonQtWrapper_SocExplorerPlot::replot(SocExplorerPlot* theWrappedObject)
{
  ( theWrappedObject->replot());
}

void PythonQtWrapper_SocExplorerPlot::rescaleAxis(SocExplorerPlot* theWrappedObject)
{
  ( theWrappedObject->rescaleAxis());
}

void PythonQtWrapper_SocExplorerPlot::setAdaptativeSampling(SocExplorerPlot* theWrappedObject, int  graphIndex, bool  enable)
{
  ( theWrappedObject->setAdaptativeSampling(graphIndex, enable));
}

void PythonQtWrapper_SocExplorerPlot::setGraphData(SocExplorerPlot* theWrappedObject, int  graphIndex, QList<QVariant >  x, QList<QVariant >  y)
{
  ( theWrappedObject->setGraphData(graphIndex, x, y));
}

void PythonQtWrapper_SocExplorerPlot::setGraphLineStyle(SocExplorerPlot* theWrappedObject, int  graphIndex, QString  lineStyle)
{
  ( theWrappedObject->setGraphLineStyle(graphIndex, lineStyle));
}

void PythonQtWrapper_SocExplorerPlot::setGraphName(SocExplorerPlot* theWrappedObject, int  graphIndex, QString  name)
{
  ( theWrappedObject->setGraphName(graphIndex, name));
}

void PythonQtWrapper_SocExplorerPlot::setGraphPen(SocExplorerPlot* theWrappedObject, int  graphIndex, QPen  pen)
{
  ( theWrappedObject->setGraphPen(graphIndex, pen));
}

void PythonQtWrapper_SocExplorerPlot::setGraphScatterStyle(SocExplorerPlot* theWrappedObject, int  graphIndex, QString  scatterStyle)
{
  ( theWrappedObject->setGraphScatterStyle(graphIndex, scatterStyle));
}

void PythonQtWrapper_SocExplorerPlot::setLegendFont(SocExplorerPlot* theWrappedObject, QFont  font)
{
  ( theWrappedObject->setLegendFont(font));
}

void PythonQtWrapper_SocExplorerPlot::setLegendSelectedFont(SocExplorerPlot* theWrappedObject, QFont  font)
{
  ( theWrappedObject->setLegendSelectedFont(font));
}

void PythonQtWrapper_SocExplorerPlot::setTitle(SocExplorerPlot* theWrappedObject, QString  title)
{
  ( theWrappedObject->setTitle(title));
}

void PythonQtWrapper_SocExplorerPlot::setUseFastVector(SocExplorerPlot* theWrappedObject, int  graphIndex, bool  enable)
{
  ( theWrappedObject->setUseFastVector(graphIndex, enable));
}

void PythonQtWrapper_SocExplorerPlot::setXaxisDateTimeFormat(SocExplorerPlot* theWrappedObject, const QString&  format)
{
  ( theWrappedObject->setXaxisDateTimeFormat(format));
}

void PythonQtWrapper_SocExplorerPlot::setXaxisLabel(SocExplorerPlot* theWrappedObject, QString  label)
{
  ( theWrappedObject->setXaxisLabel(label));
}

void PythonQtWrapper_SocExplorerPlot::setXaxisRange(SocExplorerPlot* theWrappedObject, double  lower, double  upper)
{
  ( theWrappedObject->setXaxisRange(lower, upper));
}

void PythonQtWrapper_SocExplorerPlot::setYaxisLabel(SocExplorerPlot* theWrappedObject, QString  label)
{
  ( theWrappedObject->setYaxisLabel(label));
}

void PythonQtWrapper_SocExplorerPlot::setYaxisRange(SocExplorerPlot* theWrappedObject, double  lower, double  upper)
{
  ( theWrappedObject->setYaxisRange(lower, upper));
}

void PythonQtWrapper_SocExplorerPlot::show(SocExplorerPlot* theWrappedObject)
{
  ( theWrappedObject->show());
}

void PythonQtWrapper_SocExplorerPlot::wheelEvent(SocExplorerPlot* theWrappedObject, QWheelEvent*  arg__1)
{
  ( ((PythonQtPublicPromoter_SocExplorerPlot*)theWrappedObject)->promoted_wheelEvent(arg__1));
}