GIT_REPOSITORIES/LPP/PythonQt Commit - r15:ae998290bf19

- added hasOwner method to manage ownership more nicely...

florianlink -

r15:ae998290bf19

parent child

Context file:

r15:ae998290bf19

Collapse all files

generated_cpp/com_trolltech_qt_gui/PythonQtWrapper_QGraphicsItem.h +2 0

             #ifndef PYTHONQTWRAPPER_QGRAPHICSITEM_H
             #define PYTHONQTWRAPPER_QGRAPHICSITEM_H
             #include <qgraphicsitem.h>
             #include <QObject>
             #include <QVariant>
             #include <qcoreevent.h>
             #include <qcursor.h>
             #include <qevent.h>
             #include <qgraphicsitem.h>
             #include <qgraphicsscene.h>
             #include <qgraphicssceneevent.h>
             #include <qgraphicswidget.h>
             #include <qlist.h>
             #include <qpainter.h>
             #include <qpainterpath.h>
             #include <qpoint.h>
             #include <qpolygon.h>
             #include <qrect.h>
             #include <qregion.h>
             #include <qsize.h>
             #include <qstyleoption.h>
             #include <qtransform.h>
             #include <qwidget.h>
             class PythonQtWrapper_QGraphicsItem : public QObject
             { Q_OBJECT
             public:
             Q_ENUMS(CacheMode enum_1 GraphicsItemFlag GraphicsItemChange )
             enum CacheMode{
               NoCache = QGraphicsItem::NoCache,   ItemCoordinateCache = QGraphicsItem::ItemCoordinateCache,   DeviceCoordinateCache = QGraphicsItem::DeviceCoordinateCache};
             enum enum_1{
               Type = QGraphicsItem::Type,   UserType = QGraphicsItem::UserType};
             enum GraphicsItemFlag{
               ItemIsMovable = QGraphicsItem::ItemIsMovable,   ItemIsSelectable = QGraphicsItem::ItemIsSelectable,   ItemIsFocusable = QGraphicsItem::ItemIsFocusable,   ItemClipsToShape = QGraphicsItem::ItemClipsToShape,   ItemClipsChildrenToShape = QGraphicsItem::ItemClipsChildrenToShape,   ItemIgnoresTransformations = QGraphicsItem::ItemIgnoresTransformations};
             enum GraphicsItemChange{
               ItemPositionChange = QGraphicsItem::ItemPositionChange,   ItemMatrixChange = QGraphicsItem::ItemMatrixChange,   ItemVisibleChange = QGraphicsItem::ItemVisibleChange,   ItemEnabledChange = QGraphicsItem::ItemEnabledChange,   ItemSelectedChange = QGraphicsItem::ItemSelectedChange,   ItemParentChange = QGraphicsItem::ItemParentChange,   ItemChildAddedChange = QGraphicsItem::ItemChildAddedChange,   ItemChildRemovedChange = QGraphicsItem::ItemChildRemovedChange,   ItemTransformChange = QGraphicsItem::ItemTransformChange,   ItemPositionHasChanged = QGraphicsItem::ItemPositionHasChanged,   ItemTransformHasChanged = QGraphicsItem::ItemTransformHasChanged,   ItemSceneChange = QGraphicsItem::ItemSceneChange,   ItemVisibleHasChanged = QGraphicsItem::ItemVisibleHasChanged,   ItemEnabledHasChanged = QGraphicsItem::ItemEnabledHasChanged,   ItemSelectedHasChanged = QGraphicsItem::ItemSelectedHasChanged,   ItemParentHasChanged = QGraphicsItem::ItemParentHasChanged,   ItemSceneHasChanged = QGraphicsItem::ItemSceneHasChanged,   ItemCursorChange = QGraphicsItem::ItemCursorChange,   ItemCursorHasChanged = QGraphicsItem::ItemCursorHasChanged,   ItemToolTipChange = QGraphicsItem::ItemToolTipChange,   ItemToolTipHasChanged = QGraphicsItem::ItemToolTipHasChanged,   ItemFlagsChange = QGraphicsItem::ItemFlagsChange,   ItemFlagsHaveChanged = QGraphicsItem::ItemFlagsHaveChanged,   ItemZValueChange = QGraphicsItem::ItemZValueChange,   ItemZValueHasChanged = QGraphicsItem::ItemZValueHasChanged};
             public slots:
+              bool hasOwner(QGraphicsItem* theWrappedObject) { return theWrappedObject->scene()!=NULL || theWrappedObject->parentItem()!=NULL; }
             void delete_QGraphicsItem(QGraphicsItem* obj) { delete obj; }
                bool  acceptDrops(QGraphicsItem* theWrappedObject) const;
                bool  acceptHoverEvents(QGraphicsItem* theWrappedObject) const;
                Qt::MouseButtons  acceptedMouseButtons(QGraphicsItem* theWrappedObject) const;
                bool  acceptsHoverEvents(QGraphicsItem* theWrappedObject) const;
                void advance(QGraphicsItem* theWrappedObject, int  phase);
                QRectF  boundingRect(QGraphicsItem* theWrappedObject) const;
                QRegion  boundingRegion(QGraphicsItem* theWrappedObject, const QTransform&  itemToDeviceTransform) const;
                qreal  boundingRegionGranularity(QGraphicsItem* theWrappedObject) const;
                QGraphicsItem::CacheMode  cacheMode(QGraphicsItem* theWrappedObject) const;
                QList<QGraphicsItem* >  childItems(QGraphicsItem* theWrappedObject) const;
                QRectF  childrenBoundingRect(QGraphicsItem* theWrappedObject) const;
                void clearFocus(QGraphicsItem* theWrappedObject);
                bool  collidesWithItem(QGraphicsItem* theWrappedObject, const QGraphicsItem*  other, Qt::ItemSelectionMode  mode = Qt::IntersectsItemShape) const;
                bool  collidesWithPath(QGraphicsItem* theWrappedObject, const QPainterPath&  path, Qt::ItemSelectionMode  mode = Qt::IntersectsItemShape) const;
                QList<QGraphicsItem* >  collidingItems(QGraphicsItem* theWrappedObject, Qt::ItemSelectionMode  mode = Qt::IntersectsItemShape) const;
                QGraphicsItem*  commonAncestorItem(QGraphicsItem* theWrappedObject, const QGraphicsItem*  other) const;
                bool  contains(QGraphicsItem* theWrappedObject, const QPointF&  point) const;
                QCursor  cursor(QGraphicsItem* theWrappedObject) const;
                QVariant  data(QGraphicsItem* theWrappedObject, int  key) const;
                QTransform  deviceTransform(QGraphicsItem* theWrappedObject, const QTransform&  viewportTransform) const;
                void ensureVisible(QGraphicsItem* theWrappedObject, const QRectF&  rect = QRectF(), int  xmargin = 50, int  ymargin = 50);
                void ensureVisible(QGraphicsItem* theWrappedObject, qreal  x, qreal  y, qreal  w, qreal  h, int  xmargin = 50, int  ymargin = 50);
                QGraphicsItem::GraphicsItemFlags  flags(QGraphicsItem* theWrappedObject) const;
                void grabKeyboard(QGraphicsItem* theWrappedObject);
                void grabMouse(QGraphicsItem* theWrappedObject);
                QGraphicsItemGroup*  group(QGraphicsItem* theWrappedObject) const;
                bool  handlesChildEvents(QGraphicsItem* theWrappedObject) const;
                bool  hasCursor(QGraphicsItem* theWrappedObject) const;
                bool  hasFocus(QGraphicsItem* theWrappedObject) const;
                void hide(QGraphicsItem* theWrappedObject);
                void installSceneEventFilter(QGraphicsItem* theWrappedObject, QGraphicsItem*  filterItem);
                bool  isAncestorOf(QGraphicsItem* theWrappedObject, const QGraphicsItem*  child) const;
                bool  isEnabled(QGraphicsItem* theWrappedObject) const;
                bool  isObscured(QGraphicsItem* theWrappedObject) const;
                bool  isObscured(QGraphicsItem* theWrappedObject, const QRectF&  rect) const;
                bool  isObscured(QGraphicsItem* theWrappedObject, qreal  x, qreal  y, qreal  w, qreal  h) const;
                bool  isObscuredBy(QGraphicsItem* theWrappedObject, const QGraphicsItem*  item) const;
                bool  isSelected(QGraphicsItem* theWrappedObject) const;
                bool  isUnderMouse(QGraphicsItem* theWrappedObject) const;
                bool  isVisible(QGraphicsItem* theWrappedObject) const;
                bool  isVisibleTo(QGraphicsItem* theWrappedObject, const QGraphicsItem*  parent) const;
                bool  isWidget(QGraphicsItem* theWrappedObject) const;
                bool  isWindow(QGraphicsItem* theWrappedObject) const;
                QPainterPath  mapFromItem(QGraphicsItem* theWrappedObject, const QGraphicsItem*  item, const QPainterPath&  path) const;
                QPointF  mapFromItem(QGraphicsItem* theWrappedObject, const QGraphicsItem*  item, const QPointF&  point) const;
                QPolygonF  mapFromItem(QGraphicsItem* theWrappedObject, const QGraphicsItem*  item, const QPolygonF&  polygon) const;
                QPolygonF  mapFromItem(QGraphicsItem* theWrappedObject, const QGraphicsItem*  item, const QRectF&  rect) const;
                QPointF  mapFromItem(QGraphicsItem* theWrappedObject, const QGraphicsItem*  item, qreal  x, qreal  y) const;
                QPolygonF  mapFromItem(QGraphicsItem* theWrappedObject, const QGraphicsItem*  item, qreal  x, qreal  y, qreal  w, qreal  h) const;
                QPainterPath  mapFromParent(QGraphicsItem* theWrappedObject, const QPainterPath&  path) const;
                QPointF  mapFromParent(QGraphicsItem* theWrappedObject, const QPointF&  point) const;
                QPolygonF  mapFromParent(QGraphicsItem* theWrappedObject, const QPolygonF&  polygon) const;
                QPolygonF  mapFromParent(QGraphicsItem* theWrappedObject, const QRectF&  rect) const;
                QPointF  mapFromParent(QGraphicsItem* theWrappedObject, qreal  x, qreal  y) const;
                QPolygonF  mapFromParent(QGraphicsItem* theWrappedObject, qreal  x, qreal  y, qreal  w, qreal  h) const;
                QPainterPath  mapFromScene(QGraphicsItem* theWrappedObject, const QPainterPath&  path) const;
                QPointF  mapFromScene(QGraphicsItem* theWrappedObject, const QPointF&  point) const;
                QPolygonF  mapFromScene(QGraphicsItem* theWrappedObject, const QPolygonF&  polygon) const;
                QPolygonF  mapFromScene(QGraphicsItem* theWrappedObject, const QRectF&  rect) const;
                QPointF  mapFromScene(QGraphicsItem* theWrappedObject, qreal  x, qreal  y) const;
                QPolygonF  mapFromScene(QGraphicsItem* theWrappedObject, qreal  x, qreal  y, qreal  w, qreal  h) const;
                QPainterPath  mapToItem(QGraphicsItem* theWrappedObject, const QGraphicsItem*  item, const QPainterPath&  path) const;
                QPointF  mapToItem(QGraphicsItem* theWrappedObject, const QGraphicsItem*  item, const QPointF&  point) const;
                QPolygonF  mapToItem(QGraphicsItem* theWrappedObject, const QGraphicsItem*  item, const QPolygonF&  polygon) const;
                QPolygonF  mapToItem(QGraphicsItem* theWrappedObject, const QGraphicsItem*  item, const QRectF&  rect) const;
                QPointF  mapToItem(QGraphicsItem* theWrappedObject, const QGraphicsItem*  item, qreal  x, qreal  y) const;
                QPolygonF  mapToItem(QGraphicsItem* theWrappedObject, const QGraphicsItem*  item, qreal  x, qreal  y, qreal  w, qreal  h) const;
                QPainterPath  mapToParent(QGraphicsItem* theWrappedObject, const QPainterPath&  path) const;
                QPointF  mapToParent(QGraphicsItem* theWrappedObject, const QPointF&  point) const;
                QPolygonF  mapToParent(QGraphicsItem* theWrappedObject, const QPolygonF&  polygon) const;
                QPolygonF  mapToParent(QGraphicsItem* theWrappedObject, const QRectF&  rect) const;
                QPointF  mapToParent(QGraphicsItem* theWrappedObject, qreal  x, qreal  y) const;
                QPolygonF  mapToParent(QGraphicsItem* theWrappedObject, qreal  x, qreal  y, qreal  w, qreal  h) const;
                QPainterPath  mapToScene(QGraphicsItem* theWrappedObject, const QPainterPath&  path) const;
                QPointF  mapToScene(QGraphicsItem* theWrappedObject, const QPointF&  point) const;
                QPolygonF  mapToScene(QGraphicsItem* theWrappedObject, const QPolygonF&  polygon) const;
                QPolygonF  mapToScene(QGraphicsItem* theWrappedObject, const QRectF&  rect) const;
                QPointF  mapToScene(QGraphicsItem* theWrappedObject, qreal  x, qreal  y) const;
                QPolygonF  mapToScene(QGraphicsItem* theWrappedObject, qreal  x, qreal  y, qreal  w, qreal  h) const;
                void moveBy(QGraphicsItem* theWrappedObject, qreal  dx, qreal  dy);
                QPainterPath  opaqueArea(QGraphicsItem* theWrappedObject) const;
                void paint(QGraphicsItem* theWrappedObject, QPainter*  painter, const QStyleOptionGraphicsItem*  option, QWidget*  widget = 0);
                QGraphicsItem*  parentItem(QGraphicsItem* theWrappedObject) const;
                QGraphicsWidget*  parentWidget(QGraphicsItem* theWrappedObject) const;
                QPointF  pos(QGraphicsItem* theWrappedObject) const;
                void removeSceneEventFilter(QGraphicsItem* theWrappedObject, QGraphicsItem*  filterItem);
                void resetTransform(QGraphicsItem* theWrappedObject);
                void rotate(QGraphicsItem* theWrappedObject, qreal  angle);
                void scale(QGraphicsItem* theWrappedObject, qreal  sx, qreal  sy);
                QGraphicsScene*  scene(QGraphicsItem* theWrappedObject) const;
                QRectF  sceneBoundingRect(QGraphicsItem* theWrappedObject) const;
                QPointF  scenePos(QGraphicsItem* theWrappedObject) const;
                QTransform  sceneTransform(QGraphicsItem* theWrappedObject) const;
                void scroll(QGraphicsItem* theWrappedObject, qreal  dx, qreal  dy, const QRectF&  rect = QRectF());
                void setAcceptDrops(QGraphicsItem* theWrappedObject, bool  on);
                void setAcceptHoverEvents(QGraphicsItem* theWrappedObject, bool  enabled);
                void setAcceptedMouseButtons(QGraphicsItem* theWrappedObject, Qt::MouseButtons  buttons);
                void setAcceptsHoverEvents(QGraphicsItem* theWrappedObject, bool  enabled);
                void setBoundingRegionGranularity(QGraphicsItem* theWrappedObject, qreal  granularity);
                void setCacheMode(QGraphicsItem* theWrappedObject, QGraphicsItem::CacheMode  mode, const QSize&  cacheSize = QSize());
                void setCursor(QGraphicsItem* theWrappedObject, const QCursor&  cursor);
                void setData(QGraphicsItem* theWrappedObject, int  key, const QVariant&  value);
                void setEnabled(QGraphicsItem* theWrappedObject, bool  enabled);
                void setFlag(QGraphicsItem* theWrappedObject, QGraphicsItem::GraphicsItemFlag  flag, bool  enabled = true);
                void setFlags(QGraphicsItem* theWrappedObject, QGraphicsItem::GraphicsItemFlags  flags);
                void setFocus(QGraphicsItem* theWrappedObject, Qt::FocusReason  focusReason = Qt::OtherFocusReason);
                void setGroup(QGraphicsItem* theWrappedObject, QGraphicsItemGroup*  group);
                void setHandlesChildEvents(QGraphicsItem* theWrappedObject, bool  enabled);
                void setParentItem(QGraphicsItem* theWrappedObject, QGraphicsItem*  parent);
                void setPos(QGraphicsItem* theWrappedObject, const QPointF&  pos);
                void setPos(QGraphicsItem* theWrappedObject, qreal  x, qreal  y);
                void setSelected(QGraphicsItem* theWrappedObject, bool  selected);
                void setToolTip(QGraphicsItem* theWrappedObject, const QString&  toolTip);
                void setTransform(QGraphicsItem* theWrappedObject, const QTransform&  matrix, bool  combine = false);
                void setVisible(QGraphicsItem* theWrappedObject, bool  visible);
                void setZValue(QGraphicsItem* theWrappedObject, qreal  z);
                QPainterPath  shape(QGraphicsItem* theWrappedObject) const;
                void shear(QGraphicsItem* theWrappedObject, qreal  sh, qreal  sv);
                void show(QGraphicsItem* theWrappedObject);
                QString  toolTip(QGraphicsItem* theWrappedObject) const;
                QGraphicsItem*  topLevelItem(QGraphicsItem* theWrappedObject) const;
                QGraphicsWidget*  topLevelWidget(QGraphicsItem* theWrappedObject) const;
                QTransform  transform(QGraphicsItem* theWrappedObject) const;
                void translate(QGraphicsItem* theWrappedObject, qreal  dx, qreal  dy);
                int  type(QGraphicsItem* theWrappedObject) const;
                void ungrabKeyboard(QGraphicsItem* theWrappedObject);
                void ungrabMouse(QGraphicsItem* theWrappedObject);
                void unsetCursor(QGraphicsItem* theWrappedObject);
                void update(QGraphicsItem* theWrappedObject, const QRectF&  rect = QRectF());
                void update(QGraphicsItem* theWrappedObject, qreal  x, qreal  y, qreal  width, qreal  height);
                QGraphicsWidget*  window(QGraphicsItem* theWrappedObject) const;
                qreal  x(QGraphicsItem* theWrappedObject) const;
                qreal  y(QGraphicsItem* theWrappedObject) const;
                qreal  zValue(QGraphicsItem* theWrappedObject) const;
             };
             #endif // PYTHONQTWRAPPER_QGRAPHICSITEM_H

generated_cpp/com_trolltech_qt_gui/PythonQtWrapper_QTreeWidgetItem.h +2 0

             #ifndef PYTHONQTWRAPPER_QTREEWIDGETITEM_H
             #define PYTHONQTWRAPPER_QTREEWIDGETITEM_H
             #include <qtreewidget.h>
             #include <QObject>
             #include <QVariant>
             #include <qbrush.h>
             #include <qdatastream.h>
             #include <qfont.h>
             #include <qicon.h>
             #include <qlist.h>
             #include <qsize.h>
             #include <qstringlist.h>
             #include <qtreewidget.h>
             class PythonQtWrapper_QTreeWidgetItem : public QObject
             { Q_OBJECT
             public:
             Q_ENUMS(ItemType ChildIndicatorPolicy )
             enum ItemType{
               Type = QTreeWidgetItem::Type,   UserType = QTreeWidgetItem::UserType};
             enum ChildIndicatorPolicy{
               ShowIndicator = QTreeWidgetItem::ShowIndicator,   DontShowIndicator = QTreeWidgetItem::DontShowIndicator,   DontShowIndicatorWhenChildless = QTreeWidgetItem::DontShowIndicatorWhenChildless};
             public slots:
+              bool hasOwner(QTreeWidgetItem* theWrappedObject) { return theWrappedObject->treeWidget()!=NULL || theWrappedObject->parent()!=NULL; }
             QTreeWidgetItem* new_QTreeWidgetItem(QTreeWidget*  view, QTreeWidgetItem*  after, int  type = Type);
             QTreeWidgetItem* new_QTreeWidgetItem(QTreeWidget*  view, const QStringList&  strings, int  type = Type);
             QTreeWidgetItem* new_QTreeWidgetItem(QTreeWidget*  view, int  type = Type);
             QTreeWidgetItem* new_QTreeWidgetItem(QTreeWidgetItem*  parent, QTreeWidgetItem*  after, int  type = Type);
             QTreeWidgetItem* new_QTreeWidgetItem(QTreeWidgetItem*  parent, const QStringList&  strings, int  type = Type);
             QTreeWidgetItem* new_QTreeWidgetItem(QTreeWidgetItem*  parent, int  type = Type);
             QTreeWidgetItem* new_QTreeWidgetItem(const QStringList&  strings, int  type = Type);
             QTreeWidgetItem* new_QTreeWidgetItem(int  type = Type);
             void delete_QTreeWidgetItem(QTreeWidgetItem* obj) { delete obj; }
                void addChild(QTreeWidgetItem* theWrappedObject, QTreeWidgetItem*  child);
                void addChildren(QTreeWidgetItem* theWrappedObject, const QList<QTreeWidgetItem* >&  children);
                QBrush  background(QTreeWidgetItem* theWrappedObject, int  column) const;
                Qt::CheckState  checkState(QTreeWidgetItem* theWrappedObject, int  column) const;
                QTreeWidgetItem*  child(QTreeWidgetItem* theWrappedObject, int  index) const;
                int  childCount(QTreeWidgetItem* theWrappedObject) const;
                QTreeWidgetItem::ChildIndicatorPolicy  childIndicatorPolicy(QTreeWidgetItem* theWrappedObject) const;
                QTreeWidgetItem*  clone(QTreeWidgetItem* theWrappedObject) const;
                int  columnCount(QTreeWidgetItem* theWrappedObject) const;
                QVariant  data(QTreeWidgetItem* theWrappedObject, int  column, int  role) const;
                Qt::ItemFlags  flags(QTreeWidgetItem* theWrappedObject) const;
                QFont  font(QTreeWidgetItem* theWrappedObject, int  column) const;
                QBrush  foreground(QTreeWidgetItem* theWrappedObject, int  column) const;
                QIcon  icon(QTreeWidgetItem* theWrappedObject, int  column) const;
                int  indexOfChild(QTreeWidgetItem* theWrappedObject, QTreeWidgetItem*  child) const;
                void insertChild(QTreeWidgetItem* theWrappedObject, int  index, QTreeWidgetItem*  child);
                void insertChildren(QTreeWidgetItem* theWrappedObject, int  index, const QList<QTreeWidgetItem* >&  children);
                bool  isDisabled(QTreeWidgetItem* theWrappedObject) const;
                bool  isExpanded(QTreeWidgetItem* theWrappedObject) const;
                bool  isFirstColumnSpanned(QTreeWidgetItem* theWrappedObject) const;
                bool  isHidden(QTreeWidgetItem* theWrappedObject) const;
                bool  isSelected(QTreeWidgetItem* theWrappedObject) const;
                void writeTo(QTreeWidgetItem* theWrappedObject, QDataStream&  out);
                void readFrom(QTreeWidgetItem* theWrappedObject, QDataStream&  in);
                QTreeWidgetItem*  parent(QTreeWidgetItem* theWrappedObject) const;
                void removeChild(QTreeWidgetItem* theWrappedObject, QTreeWidgetItem*  child);
                void setBackground(QTreeWidgetItem* theWrappedObject, int  column, const QBrush&  brush);
                void setCheckState(QTreeWidgetItem* theWrappedObject, int  column, Qt::CheckState  state);
                void setChildIndicatorPolicy(QTreeWidgetItem* theWrappedObject, QTreeWidgetItem::ChildIndicatorPolicy  policy);
                void setData(QTreeWidgetItem* theWrappedObject, int  column, int  role, const QVariant&  value);
                void setDisabled(QTreeWidgetItem* theWrappedObject, bool  disabled);
                void setExpanded(QTreeWidgetItem* theWrappedObject, bool  expand);
                void setFirstColumnSpanned(QTreeWidgetItem* theWrappedObject, bool  span);
                void setFlags(QTreeWidgetItem* theWrappedObject, Qt::ItemFlags  flags);
                void setFont(QTreeWidgetItem* theWrappedObject, int  column, const QFont&  font);
                void setForeground(QTreeWidgetItem* theWrappedObject, int  column, const QBrush&  brush);
                void setHidden(QTreeWidgetItem* theWrappedObject, bool  hide);
                void setIcon(QTreeWidgetItem* theWrappedObject, int  column, const QIcon&  icon);
                void setSelected(QTreeWidgetItem* theWrappedObject, bool  select);
                void setSizeHint(QTreeWidgetItem* theWrappedObject, int  column, const QSize&  size);
                void setStatusTip(QTreeWidgetItem* theWrappedObject, int  column, const QString&  statusTip);
                void setText(QTreeWidgetItem* theWrappedObject, int  column, const QString&  text);
                void setTextAlignment(QTreeWidgetItem* theWrappedObject, int  column, int  alignment);
                void setToolTip(QTreeWidgetItem* theWrappedObject, int  column, const QString&  toolTip);
                void setWhatsThis(QTreeWidgetItem* theWrappedObject, int  column, const QString&  whatsThis);
                QSize  sizeHint(QTreeWidgetItem* theWrappedObject, int  column) const;
                void sortChildren(QTreeWidgetItem* theWrappedObject, int  column, Qt::SortOrder  order);
                QString  statusTip(QTreeWidgetItem* theWrappedObject, int  column) const;
                QTreeWidgetItem*  takeChild(QTreeWidgetItem* theWrappedObject, int  index);
                QList<QTreeWidgetItem* >  takeChildren(QTreeWidgetItem* theWrappedObject);
                QString  text(QTreeWidgetItem* theWrappedObject, int  column) const;
                int  textAlignment(QTreeWidgetItem* theWrappedObject, int  column) const;
                QString  toolTip(QTreeWidgetItem* theWrappedObject, int  column) const;
                QTreeWidget*  treeWidget(QTreeWidgetItem* theWrappedObject) const;
                int  type(QTreeWidgetItem* theWrappedObject) const;
                QString  whatsThis(QTreeWidgetItem* theWrappedObject, int  column) const;
             };
             #endif // PYTHONQTWRAPPER_QTREEWIDGETITEM_H

generator/shellheadergenerator.cpp +5 0

             /****************************************************************************
             **
             ** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
             **
             ** This file is part of the Qt Script Generator project on Trolltech Labs.
             **
             ** This file may be used under the terms of the GNU General Public
             ** License version 2.0 as published by the Free Software Foundation
             ** and appearing in the file LICENSE.GPL included in the packaging of
             ** this file.  Please review the following information to ensure GNU
             ** General Public Licensing requirements will be met:
             ** http://www.trolltech.com/products/qt/opensource.html
             **
             ** If you are unsure which license is appropriate for your use, please
             ** review the following information:
             ** http://www.trolltech.com/products/qt/licensing.html or contact the
             ** sales department at sales@trolltech.com.
             **
             ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
             ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
             **
             ****************************************************************************/
             #include "shellheadergenerator.h"
             #include "fileout.h"
             #include "classgenerator.h"
             #include <QtCore/QDir>
             #include <qdebug.h>
             QString ShellHeaderGenerator::fileNameForClass(const AbstractMetaClass *meta_class) const
             {
                 return QString("PythonQtWrapper_%1.h").arg(meta_class->name());
             }
             void writeQtScriptQtBindingsLicense(QTextStream &stream);
             void ShellHeaderGenerator::write(QTextStream &s, const AbstractMetaClass *meta_class)
             {
               setupGenerator->addClass(meta_class);
               if (FileOut::license)
                     writeQtScriptQtBindingsLicense(s);
                 QString include_block = "PYTHONQTWRAPPER_" + meta_class->name().toUpper() + "_H";
                 s << "#ifndef " << include_block << endl
                   << "#define " << include_block << endl << endl;
                 Include inc = meta_class->typeEntry()->include();
                 ClassGenerator::writeInclude(s, inc);
               s << "#include <QObject>" << endl << endl;
               IncludeList list = meta_class->typeEntry()->extraIncludes();
               qSort(list.begin(), list.end());
               foreach (const Include &inc, list) {
                 ClassGenerator::writeInclude(s, inc);
               }
               s << endl;
                 QString pro_file_name = meta_class->package().replace(".", "_") + "/" + meta_class->package().replace(".", "_") + ".pri";
             //    if (!meta_class->generateShellClass()) {
             //        s << "#endif" << endl << endl;
             //        priGenerator->addHeader(pro_file_name, fileNameForClass(meta_class));
             //        return ;
             //    }
                 s << "class " << shellClassName(meta_class)
                   << " : public QObject" << endl
                   << "{ Q_OBJECT" << endl;
                 s << "public:" << endl;
                 AbstractMetaEnumList enums1 = meta_class->enums();
                 AbstractMetaEnumList enums;
                 foreach(AbstractMetaEnum* enum1, enums1) {
                   if (enum1->isPublic() && !enum1->hasQEnumsDeclaration()) {
                     enums << enum1;
                   }
                 }
               if (enums.count()) {
                 s << "Q_ENUMS(";
                 foreach(AbstractMetaEnum* enum1, enums) {
                   s << enum1->name() << " ";
                 }
                 s << ")" << endl;
                 foreach(AbstractMetaEnum* enum1, enums) {
                   s << "enum " << enum1->name() << "{" << endl;
                   bool first = true;
                   foreach(AbstractMetaEnumValue* value, enum1->values()) {
                     if (first) { first = false; }
                     else { s << ", "; }
                     s << "  " << value->name() << " = " << meta_class->qualifiedCppName() << "::" << value->name();
                   }
                   s << "};" << endl;
                 }
               }
                 s << "public slots:" << endl;
               if (!meta_class->isAbstract()) {
                 AbstractMetaFunctionList ctors;
                 ctors = meta_class->queryFunctions(AbstractMetaClass::Constructors
                                                    | AbstractMetaClass::WasVisible
                                                    | AbstractMetaClass::NotRemovedFromTargetLang);
                 foreach (const AbstractMetaFunction *function, ctors) {
                   if (!function->isPublic() || function->isAbstract()) { continue; }
                         s << meta_class->qualifiedCppName() << "* ";
                         writeFunctionSignature(s, function, 0, "new_",
                                                Option(IncludeDefaultExpression | OriginalName | ShowStatic));
                         s << ";" << endl;
                 }
               }
               if (meta_class->hasPublicDestructor() && !meta_class->isNamespace()) {
                 s << "void delete_" << meta_class->name() << "(" << meta_class->qualifiedCppName() << "* obj) { delete obj; } ";
                 s << endl;
               }
+              if (meta_class->name()=="QTreeWidgetItem") {
+                s << "bool hasOwner(QTreeWidgetItem* theWrappedObject) { return theWrappedObject->treeWidget()!=NULL || theWrappedObject->parent()!=NULL; }" << endl;
+              } else if (meta_class->name()=="QGraphicsItem") {
+                s << "bool hasOwner(QGraphicsItem* theWrappedObject) { return theWrappedObject->scene()!=NULL || theWrappedObject->parentItem()!=NULL; }" << endl;
+              }
                 AbstractMetaFunctionList functions = meta_class->queryFunctions(
                     AbstractMetaClass::NormalFunctions | AbstractMetaClass::WasVisible | AbstractMetaClass::WasPublic
                     | AbstractMetaClass::NotRemovedFromTargetLang | AbstractMetaClass::ClassImplements
                     );
                 foreach (const AbstractMetaFunction *function, functions) {
                   if (!function->isSlot()) {
                     s << "   ";
                     writeFunctionSignature(s, function, 0, QString(),
                                            Option(IncludeDefaultExpression | OriginalName | ShowStatic | UnderscoreSpaces));
                     s << ";" << endl;
                   }
                 }
             //    writeInjectedCode(s, meta_class);
               //  s  << endl << "    QScriptValue __qtscript_self;" << endl;
                 s  << "};" << endl << endl
                    << "#endif // " << include_block << endl;
               if (!ClassGenerator::isBuiltIn(meta_class->name())) {
                 priGenerator->addHeader(pro_file_name, fileNameForClass(meta_class));
               }
             }
             void ShellHeaderGenerator::writeInjectedCode(QTextStream &s, const AbstractMetaClass *meta_class)
             {
                 CodeSnipList code_snips = meta_class->typeEntry()->codeSnips();
                 foreach (const CodeSnip &cs, code_snips) {
                     if (cs.language == TypeSystem::ShellDeclaration) {
                         s << cs.code() << endl;
                     }
                 }
             }

src/PythonQtClassInfo.cpp +16 0

             /*
             *
             *  Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
             *
             *  This library is free software; you can redistribute it and/or
             *  modify it under the terms of the GNU Lesser General Public
             *  License as published by the Free Software Foundation; either
             *  version 2.1 of the License, or (at your option) any later version.
             *
             *  This library is distributed in the hope that it will be useful,
             *  but WITHOUT ANY WARRANTY; without even the implied warranty of
             *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
             *  Lesser General Public License for more details.
             *
             *  Further, this software is distributed without any warranty that it is
             *  free of the rightful claim of any third person regarding infringement
             *  or the like.  Any license provided herein, whether implied or
             *  otherwise, applies only to this software file.  Patent licenses, if
             *  any, provided herein do not apply to combinations of this program with
             *  other software, or any other product whatsoever.
             *
             *  You should have received a copy of the GNU Lesser General Public
             *  License along with this library; if not, write to the Free Software
             *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             *
             *  Contact information: MeVis Research GmbH, Universitaetsallee 29,
             *  28359 Bremen, Germany or:
             *
             *  http://www.mevis.de
             *
             */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQt.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtClassInfo.h"
             #include "PythonQtMethodInfo.h"
             #include "PythonQt.h"
             #include <QMetaMethod>
             QHash<QByteArray, int> PythonQtMethodInfo::_parameterTypeDict;
             PythonQtClassInfo::PythonQtClassInfo(const QMetaObject* meta, const QByteArray& wrappedClassName) {
               _meta = meta;
               _wrappedClassName = wrappedClassName;
               _constructors = NULL;
               _parentClassInfo = NULL;
               _parentClassInfoResolved = false;
               _decoratorProvider = NULL;
               _decoratorProviderCB = NULL;
               if (wrappedClassName.isEmpty()) {
                 _metaTypeId = -1;
               } else {
                 _metaTypeId = QMetaType::type(wrappedClassName);
               }
             }
             PythonQtClassInfo::~PythonQtClassInfo()
             {
               clearCachedMembers();
             }
             void PythonQtClassInfo::clearCachedMembers()
             {
               QHashIterator<QByteArray, PythonQtMemberInfo> i(_cachedMembers);
               while (i.hasNext()) {
                 PythonQtMemberInfo member = i.next().value();
                 if (member._type== PythonQtMemberInfo::Slot) {
                   PythonQtSlotInfo* info = member._slot;
                   while (info) {
                     PythonQtSlotInfo* next = info->nextInfo();
                     delete info;
                     info = next;
                   }
                 }
               }
             }
             void PythonQtClassInfo::resolveParentClassInfo()
             {
               if (!_parentClassInfoResolved) {
                 _parentClassInfoResolved = true;
                 if (isCPPWrapper()) {
                   if (!_wrappedClassName.isEmpty()) {
                     _parentClassInfo = PythonQt::priv()->getClassInfo(_wrappedParentClassName);
                   }
                 } else {
                   if (_meta->superClass()) {
                     _parentClassInfo = PythonQt::priv()->getClassInfo(_meta->superClass());
                   }
                 }
               }
             }
             int PythonQtClassInfo::findCharOffset(const char* sigStart, char someChar)
             {
               const char* sigEnd = sigStart;
               char c;
               do {
                 c = *sigEnd++;
               } while (c!=someChar && c!=0);
               return sigEnd-sigStart-1;
             }
             bool PythonQtClassInfo::lookForPropertyAndCache(const char* memberName)
             {
               bool found = false;
               bool nameMapped = false;
               const char* attributeName = memberName;
               // look for properties
               int i = _meta->indexOfProperty(attributeName);
               if (i==-1) {
                 // try to map name to objectName
                 if (qstrcmp(attributeName, "name")==0) {
                   attributeName = "objectName";
                   nameMapped = true;
                   i = _meta->indexOfProperty(attributeName);
                 }
               }
               if (i!=-1) {
                 PythonQtMemberInfo newInfo(_meta->property(i));
                 _cachedMembers.insert(attributeName, newInfo);
                 if (nameMapped) {
                   _cachedMembers.insert(memberName, newInfo);
                 }
               #ifdef PYTHONQT_DEBUG
                 std::cout << "caching property " << memberName << " on " << _meta->className() << std::endl;
               #endif
                 found = true;
               }
               return found;
             }
             PythonQtSlotInfo* PythonQtClassInfo::findDecoratorSlotsFromDecoratorProvider(const char* memberName, PythonQtSlotInfo* tail, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache) {
               QObject* decoratorProvider = decorator();
               if (decoratorProvider) {
                 const QMetaObject* meta = decoratorProvider->metaObject();
                 int memberNameLen = strlen(memberName);
                 int numMethods = meta->methodCount();
                 int startFrom = QObject::staticMetaObject.methodCount();
                 for (int i = startFrom; i < numMethods; i++) {
                   QMetaMethod m = meta->method(i);
                   if ((m.methodType() == QMetaMethod::Method ||
                        m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
                     const char* sigStart = m.signature();
                     bool isClassDeco = false;
                     if (qstrncmp(sigStart, "static_", 7)==0) {
                       // skip the static_classname_ part of the string
                       sigStart += 7 + 1 + strlen(className());
                       isClassDeco = true;
                     } else if (qstrncmp(sigStart, "new_", 4)==0) {
                       isClassDeco = true;
                     } else if (qstrncmp(sigStart, "delete_", 7)==0) {
                       isClassDeco = true;
                     }
                     // find the first '('
                     int offset = findCharOffset(sigStart, '(');
                     // XXX no checking is currently done if the slots have correct first argument or not...
                     // check if same length and same name
                     if (memberNameLen == offset && qstrncmp(memberName, sigStart, offset)==0) {
                       found = true;
                       PythonQtSlotInfo* info = new PythonQtSlotInfo(m, i, decoratorProvider, isClassDeco?PythonQtSlotInfo::ClassDecorator:PythonQtSlotInfo::InstanceDecorator);
                       if (tail) {
                         tail->setNextInfo(info);
                       } else {
                         PythonQtMemberInfo newInfo(info);
                         memberCache.insert(memberName, newInfo);
                       }
                       tail = info;
                     }
                   }
                 }
               }
               return tail;
             }
             bool PythonQtClassInfo::lookForMethodAndCache(const char* memberName)
             {
               bool found = false;
               int memberNameLen = strlen(memberName);
               PythonQtSlotInfo* tail = NULL;
               if (_meta) {
                 int numMethods = _meta->methodCount();
                 for (int i = 0; i < numMethods; i++) {
                   QMetaMethod m = _meta->method(i);
                   if ((m.methodType() == QMetaMethod::Method ||
                        m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
                     const char* sigStart = m.signature();
                     // find the first '('
                     int offset = findCharOffset(sigStart, '(');
                     // check if same length and same name
                     if (memberNameLen == offset && qstrncmp(memberName, sigStart, offset)==0) {
                       found = true;
                       PythonQtSlotInfo* info = new PythonQtSlotInfo(m, i);
                       if (tail) {
                         tail->setNextInfo(info);
                       } else {
                         PythonQtMemberInfo newInfo(info);
                         _cachedMembers.insert(memberName, newInfo);
                       }
                       tail = info;
                     }
                   }
                 }
               }
               // look for dynamic decorators in this class and in derived classes
               PythonQtClassInfo* info = this;
               while (info) {
                 tail = info->findDecoratorSlotsFromDecoratorProvider(memberName, tail, found, _cachedMembers);
                 if (!info->_parentClassInfoResolved) {
                   info->resolveParentClassInfo();
                 }
                 info = info->_parentClassInfo;
               }
               // look for decorators
               if (!_wrappedClassName.isEmpty()) {
                 tail = findDecoratorSlots(_wrappedClassName.constData(), memberName, memberNameLen, tail, found);
               }
               const QMetaObject* meta = _meta;
               while (meta) {
                 tail = findDecoratorSlots(meta->className(), memberName, memberNameLen, tail, found);
                 meta = meta->superClass();
               }
               return found;
             }
             bool PythonQtClassInfo::lookForEnumAndCache(const QMetaObject* meta, const char* memberName)
             {
               bool found = false;
               // look for enum values
               int enumCount = meta->enumeratorCount();
               for (int i=0;i<enumCount; i++) {
                 QMetaEnum e = meta->enumerator(i);
                 for (int j=0; j < e.keyCount(); j++) {
                   if (qstrcmp(e.key(j), memberName)==0) {
                     PythonQtMemberInfo newInfo(e.value(j));
                     _cachedMembers.insert(memberName, newInfo);
               #ifdef PYTHONQT_DEBUG
                     std::cout << "caching enum " << memberName << " on " << meta->className() << std::endl;
               #endif
                     found = true;
                   }
                 }
               }
               return found;
             }
             PythonQtMemberInfo PythonQtClassInfo::member(const char* memberName)
             {
               PythonQtMemberInfo info = _cachedMembers.value(memberName);
               if (info._type != PythonQtMemberInfo::Invalid) {
                 return info;
               } else {
                 bool found = false;
                 found = lookForPropertyAndCache(memberName);
                 if (!found) {
                   found = lookForMethodAndCache(memberName);
                 }
                 if (!found) {
                   if (_meta) {
                     // check enums in our meta object directly
                     found = lookForEnumAndCache(_meta, memberName);
                   }
                   if (!found) {
                     // check enums in the class hierachy of CPP classes
                     // look for dynamic decorators in this class and in derived classes
                     PythonQtClassInfo* info = this;
                     while (info && !found) {
                       QObject* deco = info->decorator();
                       if (deco) {
                         // call on ourself for caching, but with different metaObject():
                         found = lookForEnumAndCache(deco->metaObject(), memberName);
                       }
                       if (!info->_parentClassInfoResolved) {
                         info->resolveParentClassInfo();
                       }
                       info = info->_parentClassInfo;
                     }
                   }
                 }
                 if (!found) {
                   // we store a NotFound member, so that we get a quick result for non existing members (e.g. operator_equal lookup)
                   info._type = PythonQtMemberInfo::NotFound;
                   _cachedMembers.insert(memberName, info);
                 }
               }
               return _cachedMembers.value(memberName);
             }
             PythonQtSlotInfo* PythonQtClassInfo::findDecoratorSlots(const char* classname, const char* memberName, int memberNameLen, PythonQtSlotInfo* tail, bool& found)
             {
               QListIterator<PythonQtSlotInfo*> it(PythonQt::priv()->getDecoratorSlots(classname));
               while (it.hasNext()) {
                 PythonQtSlotInfo* infoOrig = it.next();
                 const char* sigStart = infoOrig->metaMethod()->signature();
                 if (qstrncmp("static_", sigStart, 7)==0) {
                   sigStart += 7;
                   sigStart += findCharOffset(sigStart, '_')+1;
                 }
                 int offset = findCharOffset(sigStart, '(');
                 if (memberNameLen == offset && qstrncmp(memberName, sigStart, offset)==0) {
                   //make a copy, otherwise we will have trouble on overloads!
                   PythonQtSlotInfo* info = new PythonQtSlotInfo(*infoOrig);
                   found = true;
                   if (tail) {
                     tail->setNextInfo(info);
                   } else {
                     PythonQtMemberInfo newInfo(info);
                     _cachedMembers.insert(memberName, newInfo);
                   }
                   tail = info;
                 }
               }
               return tail;
             }
             void PythonQtClassInfo::listDecoratorSlotsFromDecoratorProvider(QStringList& list, bool metaOnly) {
               QObject* decoratorProvider = decorator();
               if (decoratorProvider) {
                 const QMetaObject* meta = decoratorProvider->metaObject();
                 int numMethods = meta->methodCount();
                 int startFrom = QObject::staticMetaObject.methodCount();
                 for (int i = startFrom; i < numMethods; i++) {
                   QMetaMethod m = meta->method(i);
                   if ((m.methodType() == QMetaMethod::Method ||
                        m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
                     const char* sigStart = m.signature();
                     bool isClassDeco = false;
                     if (qstrncmp(sigStart, "static_", 7)==0) {
                       // skip the static_classname_ part of the string
                       sigStart += 7 + 1 + strlen(className());
                       isClassDeco = true;
                     } else if (qstrncmp(sigStart, "new_", 4)==0) {
                       sigStart += 4 + 1 + strlen(className());
                       isClassDeco = true;
                     } else if (qstrncmp(sigStart, "delete_", 7)==0) {
                       sigStart += 7 + 1 + strlen(className());
                       isClassDeco = true;
                     }
                     // find the first '('
                     int offset = findCharOffset(sigStart, '(');
                     // XXX no checking is currently done if the slots have correct first argument or not...
                     if (!metaOnly || isClassDeco) {
                       list << QString::fromLatin1(sigStart, offset);
                     }
                   }
                 }
               }
             }
             QStringList PythonQtClassInfo::memberList(bool metaOnly)
             {
               resolveParentClassInfo();
               decorator();
               QStringList l;
               QString h;
               if (_wrappedClassName.isEmpty() && _meta) {
                 int i;
                 int numProperties = _meta->propertyCount();
                 for (i = 0; i < numProperties; i++) {
                   QMetaProperty p = _meta->property(i);
                   l << QString(p.name());
                 }
               }
               // normal slots of QObject (or wrapper QObject)
               if (!metaOnly && _meta) {
                 int numMethods = _meta->methodCount();
                 bool skipQObj = !_wrappedClassName.isEmpty();
                 for (int i = skipQObj?QObject::staticMetaObject.methodCount():0; i < numMethods; i++) {
                   QMetaMethod m = _meta->method(i);
                   if ((m.methodType() == QMetaMethod::Method ||
                     m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
                     QByteArray signa(m.signature());
                     if (signa.startsWith("new_")) continue;
                     if (signa.startsWith("delete_")) continue;
                     if (signa.startsWith("static_")) continue;
                     PythonQtSlotInfo slot(m, i);
                     l << slot.slotName();
                   }
                 }
               }
               {
                 // look for dynamic decorators in this class and in derived classes
                 PythonQtClassInfo* info = this;
                 while (info) {
                   info->listDecoratorSlotsFromDecoratorProvider(l, metaOnly);
                   if (!info->_parentClassInfoResolved) {
                     info->resolveParentClassInfo();
                   }
                   info = info->_parentClassInfo;
                 }
               }
               // look for decorators
               QList<const char*> names;
               if (!_wrappedClassName.isEmpty()) {
                 // CPP wrapper case:
                 names << _wrappedClassName.constData();
                 // for CPP classes which are wrapped, we do not want to look for decorators of the wrapping qobjects, since they
                 // would require a different pointer on the decorator slot call
               } else {
                 // QObject case:
                 const QMetaObject* meta = _meta;
                 while (meta) {
                   if (meta==&QObject::staticMetaObject && !_wrappedClassName.isEmpty()) break;
                   names << meta->className();
                   meta = meta->superClass();
                 }
               }
               QListIterator<const char*> nameIt(names);
               while (nameIt.hasNext()) {
                 QListIterator<PythonQtSlotInfo*> it(PythonQt::priv()->getDecoratorSlots(nameIt.next()));
                 while (it.hasNext()) {
                   PythonQtSlotInfo* slot = it.next();
                   if (metaOnly) {
                     if (slot->isClassDecorator()) {
                       QByteArray first = slot->slotName();
                       if (first.startsWith("static_")) {
                         int idx = first.indexOf('_');
                         idx = first.indexOf('_', idx+1);
                         first = first.mid(idx+1);
                       }
                       l << first;
                     }
                   } else {
                     l << slot->slotName();
                   }
                 }
               }
               // List enumerator keys...
               QList<const QMetaObject*> enumMetaObjects;
               if (_meta) {
                 enumMetaObjects << _meta;
               }
               // check enums in the class hierachy of CPP classes
               PythonQtClassInfo* info = this;
               while (info) {
                 QObject* deco = info->decorator();
                 if (deco) {
                   enumMetaObjects << deco->metaObject();
                 }
                 if (!info->_parentClassInfoResolved) {
                   info->resolveParentClassInfo();
                 }
                 info = info->_parentClassInfo;
               }
               foreach(const QMetaObject* meta, enumMetaObjects) {
                 for (int i = 0; i<meta->enumeratorCount(); i++) {
                   QMetaEnum e = meta->enumerator(i);
                   for (int j=0; j < e.keyCount(); j++) {
                     l << QString(e.key(j));
                   }
                 }
               }
               return l;
             }
             const char* PythonQtClassInfo::className()
             {
               if (!_wrappedClassName.isEmpty()) {
                 return _wrappedClassName.constData();
               } else {
                 return _meta->className();
               }
             }
             bool PythonQtClassInfo::inherits(const char* name)
             {
               resolveParentClassInfo();
               if (isCPPWrapper()) {
                 PythonQtClassInfo* info = this;
                 while (info) {
                   if (_wrappedClassName == name) {
                     return true;
                   }
                   if (!info->_parentClassInfoResolved) {
                     info->resolveParentClassInfo();
                   }
                   info = info->_parentClassInfo;
                 }
               } else {
                 const QMetaObject* m = _meta;
                 while (m) {
                   if (strcmp(name, m->className())==0) {
                     return true;
                   }
                   m = m->superClass();
                 }
               }
               return false;
             }
             QString PythonQtClassInfo::help()
             {
               resolveParentClassInfo();
               decorator();
               QString h;
               h += QString("--- ") + QString(className()) + QString(" ---\n");
               if (_wrappedClassName.isEmpty()) {
                 h += "Properties:\n";
                 int i;
                 int numProperties = _meta->propertyCount();
                 for (i = 0; i < numProperties; i++) {
                   QMetaProperty p = _meta->property(i);
                   h += QString(p.name()) + " (" + QString(p.typeName()) + " )\n";
                 }
               }
               if (constructors()) {
                 h += "Constructors:\n";
                 PythonQtSlotInfo* constr = constructors();
                 while (constr) {
                   h += constr->fullSignature(false) + "\n";
                   constr = constr->nextInfo();
                 }
               }
               h += "Slots:\n";
               h += "QString help()\n";
               h += "QString className()\n";
               if (_meta) {
                 int numMethods = _meta->methodCount();
                 for (int i = 0; i < numMethods; i++) {
                   QMetaMethod m = _meta->method(i);
                   if ((m.methodType() == QMetaMethod::Method ||
                     m.methodType() == QMetaMethod::Slot) && m.access() == QMetaMethod::Public) {
                     QByteArray signa(m.signature());
                     if (signa.startsWith("new_")) continue;
                     if (signa.startsWith("delete_")) continue;
                     if (signa.startsWith("static_")) continue;
                     PythonQtSlotInfo slot(m, i);
                     h += slot.fullSignature(false)+ "\n";
                   }
                 }
               }
               // TODO xxx : decorators and enums from decorator() are missing...
               // maybe we can reuse memberlist()?
               // look for decorators
               QList<const char*> names;
               if (!_wrappedClassName.isEmpty()) {
                 names << _wrappedClassName.constData();
               }
               const QMetaObject* meta = _meta;
               while (meta) {
                 names << meta->className();
                 meta = meta->superClass();
               }
               QListIterator<const char*> nameIt(names);
               while (nameIt.hasNext()) {
                 QListIterator<PythonQtSlotInfo*> it(PythonQt::priv()->getDecoratorSlots(nameIt.next()));
                 while (it.hasNext()) {
                   PythonQtSlotInfo* slot = it.next();
                   h += slot->fullSignature(slot->isInstanceDecorator()) + "\n";
                 }
               }
               if (_meta && _meta->enumeratorCount()) {
                 h += "Enums:\n";
                 for (int i = 0; i<_meta->enumeratorCount(); i++) {
                   QMetaEnum e = _meta->enumerator(i);
                   h += QString(e.name()) + " {";
                   for (int j=0; j < e.keyCount(); j++) {
                     if (j) { h+= ", "; }
                     h += e.key(j);
                   }
                   h += " }\n";
                 }
               }
               if (_wrappedClassName.isEmpty() && _meta) {
                 int numMethods = _meta->methodCount();
                 if (numMethods>0) {
                   h += "Signals:\n";
                   for (int i = 0; i < numMethods; i++) {
                     QMetaMethod m = _meta->method(i);
                     if (m.methodType() == QMetaMethod::Signal) {
                       h += QString(m.signature()) + "\n";
                     }
                   }
                 }
               }
               return h;
             }
             PythonQtSlotInfo* PythonQtClassInfo::constructors()
             {
               if (!_constructors) {
                 // force creation of lazy decorator, which will register the decorators
                 decorator();
                 _constructors = PythonQt::priv()->getConstructorSlot(!_wrappedClassName.isEmpty()?_wrappedClassName:QByteArray(_meta->className()));
               }
               return _constructors;
             }
             void PythonQtClassInfo::setMetaObject(const QMetaObject* meta)
             {
               _meta = meta;
               clearCachedMembers();
             }
             QObject* PythonQtClassInfo::decorator()
             {
               if (!_decoratorProvider && _decoratorProviderCB) {
                 _decoratorProvider = (*_decoratorProviderCB)();
                 if (_decoratorProvider) {
                   _decoratorProvider->setParent(PythonQt::priv());
                   PythonQt::priv()->addDecorators(_decoratorProvider, PythonQtPrivate::ConstructorDecorator | PythonQtPrivate::DestructorDecorator);
                 }
               }
               return _decoratorProvider;
             }
+            bool PythonQtClassInfo::hasOwnerMethodButNoOwner(void* object)
+            {
+              PythonQtMemberInfo info = member("hasOwner");
+              if (info._type == PythonQtMemberInfo::Slot) {
+                void* obj = object;
+                bool result = false;
+                void* args[2];
+                args[0] = &result;
+                args[1] = &obj;
+                info._slot->decorator()->qt_metacall(QMetaObject::InvokeMetaMethod, info._slot->slotIndex(), args);
+                return !result;
+              } else {
+                return false;
+              }
+            }

src/PythonQtClassInfo.h +3 0

             #ifndef _PYTHONQTCLASSINFO_H
             #define _PYTHONQTCLASSINFO_H
             /*
              *
              *  Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
              *
              *  This library is free software; you can redistribute it and/or
              *  modify it under the terms of the GNU Lesser General Public
              *  License as published by the Free Software Foundation; either
              *  version 2.1 of the License, or (at your option) any later version.
              *
              *  This library is distributed in the hope that it will be useful,
              *  but WITHOUT ANY WARRANTY; without even the implied warranty of
              *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
              *  Lesser General Public License for more details.
              *
              *  Further, this software is distributed without any warranty that it is
              *  free of the rightful claim of any third person regarding infringement
              *  or the like.  Any license provided herein, whether implied or
              *  otherwise, applies only to this software file.  Patent licenses, if
              *  any, provided herein do not apply to combinations of this program with
              *  other software, or any other product whatsoever.
              *
              *  You should have received a copy of the GNU Lesser General Public
              *  License along with this library; if not, write to the Free Software
              *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
              *
              *  Contact information: MeVis Research GmbH, Universitaetsallee 29,
              *  28359 Bremen, Germany or:
              *
              *  http://www.mevis.de
              *
              */
             #include <QMetaObject>
             #include <QMetaMethod>
             #include <QHash>
             #include <QByteArray>
             #include <QList>
             #include "PythonQt.h"
             class PythonQtSlotInfo;
             struct PythonQtMemberInfo {
               enum Type {
                 Invalid, Slot, EnumValue, Property, NotFound
               };
               PythonQtMemberInfo():_slot(NULL),_enumValue(0),_type(Invalid) { }
               PythonQtMemberInfo(PythonQtSlotInfo* info) {
                 _type = Slot;
                 _slot = info;
                 _enumValue = 0;
               }
               PythonQtMemberInfo(unsigned int enumValue) {
                 _type = EnumValue;
                 _slot = NULL;
                 _enumValue = enumValue;
               }
               PythonQtMemberInfo(const QMetaProperty& prop) {
                 _type = Property;
                 _slot = NULL;
                 _enumValue = 0;
                 _property = prop;
               }
               PythonQtSlotInfo* _slot;
               unsigned int      _enumValue;
               QMetaProperty     _property;
               Type              _type;
             };
             //! a class that stores all required information about a Qt object (and an optional associated C++ class name)
             /*! for fast lookup of slots when calling the object from Python
             */
             class PythonQtClassInfo {
             public:
               PythonQtClassInfo(const QMetaObject* meta, const QByteArray& wrappedClassName = QByteArray());
               ~PythonQtClassInfo();
               //! get the Python method definition for a given slot name (without return type and signature)
               PythonQtMemberInfo member(const char* member);
               PythonQtSlotInfo* constructors();
               //! get the classname (either of the QObject or of the wrapped CPP object)
               const char* className();
               //! returns if the object is a CPP wrapper
               bool isCPPWrapper() { return !_wrappedClassName.isEmpty(); }
               //! get the meta object
               const QMetaObject* metaObject() { return _meta; }
               //! set the meta object, this will reset the caching
               void setMetaObject(const QMetaObject* meta);
               //! returns if the meta object inherits the given classname
               bool inherits(const char* name);
               //! get help string for the metaobject
               QString help();
               //! get list of all members
               QStringList memberList(bool metaOnly = false);
               //! get the meta type id of this class (only valid for isCPPWrapper() == true)
               int metaTypeId() { return _metaTypeId; }
               //! set an additional decorator provider that offers additional decorator slots for this class
               void setDecoratorProvider(PythonQtQObjectCreatorFunctionCB* cb) { _decoratorProviderCB = cb; _decoratorProvider = NULL; }
               //! get the decorator qobject instance
               QObject* decorator();
               //! set the parent class name of a wrapped CPP pointer
               void setWrappedParentClassName(const QByteArray& name) { _wrappedParentClassName = name; _parentClassInfo = NULL; _parentClassInfoResolved = false; }
+              //! check if the special method "hasOwner" is implemented and if it returns false, which means that the object may be destroyed
+              bool hasOwnerMethodButNoOwner(void* object);
             private:
               //! resolve the parent class from either meta object or cpp parent class name
               void resolveParentClassInfo();
               //! clear all cached members
               void clearCachedMembers();
               PythonQtSlotInfo* findDecoratorSlotsFromDecoratorProvider(const char* memberName, PythonQtSlotInfo* inputInfo, bool &found, QHash<QByteArray, PythonQtMemberInfo>& memberCache);
               void listDecoratorSlotsFromDecoratorProvider(QStringList& list, bool metaOnly);
               bool lookForPropertyAndCache(const char* memberName);
               bool lookForMethodAndCache(const char* memberName);
               bool lookForEnumAndCache(const QMetaObject* m, const char* memberName);
               PythonQtSlotInfo* findDecoratorSlots(const char* classname, const char* memberName, int memberNameLen, PythonQtSlotInfo* tail, bool &found);
               int findCharOffset(const char* sigStart, char someChar);
               QHash<QByteArray, PythonQtMemberInfo> _cachedMembers;
               PythonQtSlotInfo*                    _constructors;
               const QMetaObject*                   _meta;
               QByteArray                           _wrappedClassName;
               QByteArray                           _wrappedParentClassName;
               QObject*                             _decoratorProvider;
               PythonQtQObjectCreatorFunctionCB*    _decoratorProviderCB;
               PythonQtClassInfo*                   _parentClassInfo;
               bool                                 _parentClassInfoResolved;
               int                                  _metaTypeId;
             };
             //---------------------------------------------------------------
             #endif

src/PythonQtWrapper.cpp +7 -6

             /*
             *
             *  Copyright (C) 2006 MeVis Research GmbH All Rights Reserved.
             *
             *  This library is free software; you can redistribute it and/or
             *  modify it under the terms of the GNU Lesser General Public
             *  License as published by the Free Software Foundation; either
             *  version 2.1 of the License, or (at your option) any later version.
             *
             *  This library is distributed in the hope that it will be useful,
             *  but WITHOUT ANY WARRANTY; without even the implied warranty of
             *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
             *  Lesser General Public License for more details.
             *
             *  Further, this software is distributed without any warranty that it is
             *  free of the rightful claim of any third person regarding infringement
             *  or the like.  Any license provided herein, whether implied or
             *  otherwise, applies only to this software file.  Patent licenses, if
             *  any, provided herein do not apply to combinations of this program with
             *  other software, or any other product whatsoever.
             *
             *  You should have received a copy of the GNU Lesser General Public
             *  License along with this library; if not, write to the Free Software
             *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
             *
             *  Contact information: MeVis Research GmbH, Universitaetsallee 29,
             *  28359 Bremen, Germany or:
             *
             *  http://www.mevis.de
             *
             */
             //----------------------------------------------------------------------------------
             /*!
             // \file    PythonQtWrapper.cpp
             // \author  Florian Link
             // \author  Last changed by $Author: florian $
             // \date    2006-05
             */
             //----------------------------------------------------------------------------------
             #include "PythonQtWrapper.h"
             #include <QObject>
             #include "PythonQt.h"
             #include "PythonQtSlot.h"
             #include "PythonQtClassInfo.h"
             #include "PythonQtConversion.h"
-            static void PythonQtWrapper_deleteObject(PythonQtWrapper* self) {
+            static void PythonQtWrapper_deleteObject(PythonQtWrapper* self, bool force = false) {
+              // is this a C++ wrapper?
               if (self->_wrappedPtr) {
                 //mlabDebugConst("Python","c++ wrapper removed " << self->_wrappedPtr << " " << self->_obj->className() << " " << self->_info->wrappedClassName().latin1());
                 PythonQt::priv()->removeWrapperPointer(self->_wrappedPtr);
                 // we own our qobject, so we delete it now:
                 delete self->_obj;
                 self->_obj = NULL;
-                if (self->_ownedByPythonQt) {
+                if (force || self->_info->hasOwnerMethodButNoOwner(self->_wrappedPtr) || self->_ownedByPythonQt) {
                   int type = self->_info->metaTypeId();
                   if (self->_useQMetaTypeDestroy && type>=0) {
                     // use QMetaType to destroy the object
                     QMetaType::destroy(type, self->_wrappedPtr);
                   } else {
                     PythonQtSlotInfo* slot = PythonQt::priv()->getDestructorSlot(self->_info->className());
                     if (slot) {
                       void* args[2];
                       args[0] = NULL;
                       args[1] = &self->_wrappedPtr;
                       slot->decorator()->qt_metacall(QMetaObject::InvokeMetaMethod, slot->slotIndex(), args);
                       self->_wrappedPtr = NULL;
                     } else {
                       if (type>=0) {
                         // use QMetaType to destroy the object
                         QMetaType::destroy(type, self->_wrappedPtr);
                       } else {
                         // TODO: warn about not being able to destroy the object?
                       }
                     }
                   }
                 }
               } else {
                 //mlabDebugConst("Python","qobject wrapper removed " << self->_obj->className() << " " << self->_info->wrappedClassName().latin1());
                 if (self->_objPointerCopy) {
                   PythonQt::priv()->removeWrapperPointer(self->_objPointerCopy);
                 }
                 if (self->_obj) {
-                  if (self->_ownedByPythonQt) {
+                  if (force || self->_ownedByPythonQt) {
-                    if (!self->_obj->parent()) {
+                    if (force || !self->_obj->parent()) {
                       delete self->_obj;
                     }
                   } else {
                     if (self->_obj->parent()==NULL) {
                       // tell someone who is interested that the qobject is no longer wrapped, if it has no parent
                       PythonQt::qObjectNoLongerWrappedCB(self->_obj);
                     }
                   }
                 }
               }
               self->_obj = NULL;
             }
             static void PythonQtWrapper_dealloc(PythonQtWrapper* self)
             {
               PythonQtWrapper_deleteObject(self);
               self->_obj.~QPointer<QObject>();
               self->ob_type->tp_free((PyObject*)self);
             }
             static PyObject* PythonQtWrapper_new(PyTypeObject *type, PyObject * /*args*/, PyObject * /*kwds*/)
             {
               PythonQtWrapper *self;
               self = (PythonQtWrapper *)type->tp_alloc(type, 0);
               if (self != NULL) {
                 self->_info = NULL;
                 new (&self->_obj) QPointer<QObject>();
                 self->_wrappedPtr = NULL;
                 self->_ownedByPythonQt = false;
                 self->_useQMetaTypeDestroy = false;
               }
               return (PyObject *)self;
             }
             static int PythonQtWrapper_init(PythonQtWrapper * /*self*/, PyObject * /*args*/, PyObject * /*kwds*/)
             {
               return 0;
             }
             static PyObject *PythonQtWrapper_classname(PythonQtWrapper* type)
             {
               return PyString_FromString(type->_info->className());
             }
             static PyObject *PythonQtWrapper_help(PythonQtWrapper* type)
             {
               return PythonQt::self()->helpCalled(type->_info);
             }
             static PyObject *PythonQtWrapper_delete(PythonQtWrapper * self)
             {
-              PythonQtWrapper_deleteObject(self);
+              PythonQtWrapper_deleteObject(self, true);
               Py_INCREF(Py_None);
               return Py_None;
             }
             static PyMethodDef PythonQtWrapper_methods[] = {
                 {"className", (PyCFunction)PythonQtWrapper_classname, METH_NOARGS,
                  "Return the classname of the object"
                 },
                 {"help", (PyCFunction)PythonQtWrapper_help, METH_NOARGS,
                 "Shows the help of available methods for this class"
                 },
                 {"delete", (PyCFunction)PythonQtWrapper_delete, METH_NOARGS,
                 "Deletes the C++ object (at your own risk, my friend!)"
                 },
             {NULL, NULL, 0, NULL}  /* Sentinel */
             };
             static PyObject *PythonQtWrapper_getattro(PyObject *obj,PyObject *name)
             {
               const char *attributeName;
               PythonQtWrapper *wt = (PythonQtWrapper *)obj;
               if ((attributeName = PyString_AsString(name)) == NULL) {
                 return NULL;
               }
               if (!wt->_obj && !wt->_wrappedPtr) {
                 QString error = QString("Trying to read attribute '") + attributeName + "' from a destroyed " + wt->_info->className() + " object";
                 PyErr_SetString(PyExc_ValueError, error.toLatin1().data());
                 return NULL;
               }
               //  mlabDebugConst("Python","get " << attributeName);
               // TODO: dynamic properties are missing
               PythonQtMemberInfo member = wt->_info->member(attributeName);
               switch (member._type) {
               case PythonQtMemberInfo::Property:
                 if (wt->_obj) {
                   return PythonQtConv::QVariantToPyObject(member._property.read(wt->_obj));
                 }
                 break;
               case PythonQtMemberInfo::Slot:
                 return PythonQtSlotFunction_New(member._slot, obj, NULL);
                 break;
               case PythonQtMemberInfo::EnumValue:
                 return PyInt_FromLong(member._enumValue);
                 break;
                 default:
                   // is an invalid type, go on
                 break;
               }
               // look for the interal methods (className(), help())
               PyObject* internalMethod = Py_FindMethod( PythonQtWrapper_methods, obj, (char*)attributeName);
               if (internalMethod) {
                 return internalMethod;
               }
               PyErr_Clear();
               if (wt->_obj) {
                 // look for a child
                 QObjectList children = wt->_obj->children();
                 for (int i = 0; i < children.count(); i++) {
                   QObject *child = children.at(i);
                   if (child->objectName() == attributeName) {
                     return PythonQt::self()->priv()->wrapQObject(child);
                   }
                 }
               }
               if (qstrcmp(attributeName, "__dict__")==0) {
                 QStringList l = wt->_info->memberList(false);
                 PyObject* dict = PyDict_New();
                 foreach (QString name, l) {
                   //PyObject* o = PyObject_GetAttrString(obj, name.toLatin1().data());
                   PyDict_SetItemString(dict, name.toLatin1().data(), Py_None);
                   //Py_DECREF(o);
                 }
                 // Note: we do not put children into the dict, is would look confusing?!
                 return dict;
               }
               QString error = QString(wt->_info->className()) + " has no attribute named '" + QString(attributeName) + "'";
               PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
               return NULL;
             }
             static int PythonQtWrapper_setattro(PyObject *obj,PyObject *name,PyObject *value)
             {
               QString error;
               char *attributeName;
               PythonQtWrapper *wt = (PythonQtWrapper *)obj;
               if ((attributeName = PyString_AsString(name)) == NULL)
                 return -1;
               if (!wt->_obj) {
                 error = QString("Trying to set attribute '") + attributeName + "' on a destroyed " + wt->_info->className() + " object";
                 PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
                 return -1;
               }
               PythonQtMemberInfo member = wt->_info->member(attributeName);
               if (member._type == PythonQtMemberInfo::Property) {
                 QMetaProperty prop = member._property;
                 if (prop.isWritable()) {
                   QVariant v;
                   if (prop.isEnumType()) {
                     // this will give us either a string or an int, everything else will probably be an error
                     v = PythonQtConv::PyObjToQVariant(value);
                   } else {
                     int t = prop.userType();
                     v = PythonQtConv::PyObjToQVariant(value, t);
                   }
                   bool success = false;
                   if (v.isValid()) {
                     success = prop.write(wt->_obj, v);
                   }
                   if (success) {
                     return 0;
                   } else {
                     error = QString("Property '") + attributeName + "' of type '" +
                       prop.typeName() + "' does not accept an object of type "
                       + QString(value->ob_type->tp_name) + " (" + PythonQtConv::PyObjGetRepresentation(value) + ")";
                   }
                 } else {
                   error = QString("Property '") + attributeName + "' of " + wt->_info->className() + " object is not writable";
                 }
               } else {
                 if (member._type == PythonQtMemberInfo::Slot) {
                   error = QString("Slot '") + attributeName + "' can not be overwritten on " + wt->_info->className() + " object";
                 } else if (member._type == PythonQtMemberInfo::EnumValue) {
                   error = QString("EnumValue '") + attributeName + "' can not be overwritten on " + wt->_info->className() + " object";
                 }
               }
               PyErr_SetString(PyExc_AttributeError, error.toLatin1().data());
               return -1;
             }
             static PyObject * PythonQtWrapper_str(PyObject * obj)
             {
               PythonQtWrapper* wt = (PythonQtWrapper*)obj;
               QObject *qobj = wt->_obj;
               if (wt->_wrappedPtr) {
                 QString str = PythonQtConv::CPPObjectToString(wt->_info->metaTypeId(), wt->_wrappedPtr);
                 if (!str.isEmpty()) {
                   return PyString_FromFormat("%s", str.toLatin1().constData());
                 } else
                 if (wt->_obj) {
                   return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", wt->_info->className(), wt->_wrappedPtr, wt->_obj->metaObject()->className(), qobj);
                 } else {
                   return PyString_FromFormat("%s (C++ Object %p)", wt->_info->className(), wt->_wrappedPtr);
                 }
               } else {
                 return PyString_FromFormat("%s (QObject %p)", wt->_info->className(), qobj);
               }
             }
             static PyObject * PythonQtWrapper_repr(PyObject * obj)
             {
               PythonQtWrapper* wt = (PythonQtWrapper*)obj;
               QObject *qobj = wt->_obj;
               if (wt->_wrappedPtr) {
                 QString str = PythonQtConv::CPPObjectToString(wt->_info->metaTypeId(), wt->_wrappedPtr);
                 if (!str.isEmpty()) {
                   return PyString_FromFormat("%s(%s, %p)", QMetaType::typeName(wt->_info->metaTypeId()), str.toLatin1().constData(), wt->_wrappedPtr);
                 } else
                 if (wt->_obj) {
                   return PyString_FromFormat("%s (C++ Object %p wrapped by %s %p))", wt->_info->className(), wt->_wrappedPtr, wt->_obj->metaObject()->className(), qobj);
                 } else {
                   return PyString_FromFormat("%s (C++ Object %p)", wt->_info->className(), wt->_wrappedPtr);
                 }
               } else {
                 return PyString_FromFormat("%s (QObject %p)", wt->_info->className(), qobj);
               }
             }
             static int PythonQtWrapper_compare(PyObject * obj1, PyObject * obj2)
             {
               if (obj1->ob_type == &PythonQtWrapper_Type &&
                 obj2->ob_type == &PythonQtWrapper_Type) {
                 PythonQtWrapper* w1 = (PythonQtWrapper*)obj1;
                 PythonQtWrapper* w2 = (PythonQtWrapper*)obj2;
                 // check pointers directly first:
                 if (w1->_wrappedPtr != NULL) {
                   if (w1->_wrappedPtr == w2->_wrappedPtr) {
                     return 0;
                   }
                 } else if (w1->_obj == w2->_obj) {
                   return 0;
                 }
                 const char* class1 = w1->_info->className();
                 const char* class2 = w2->_info->className();
                 if (strcmp(class1, class2) == 0) {
                   // same class names, so we can try the operator_equal
                   PythonQtMemberInfo info = w1->_info->member("operator_equal");
                   if (info._type == PythonQtMemberInfo::Slot) {
                     bool result = false;
                     void* obj1 = w1->_wrappedPtr;
                     if (!obj1) {
                       obj1 = w1->_obj;
                     }
                     if (!obj1) { return -1; }
                     void* obj2 = w2->_wrappedPtr;
                     if (!obj2) {
                       obj2 = w2->_obj;
                     }
                     if (!obj2) { return -1; }
                     if (info._slot->isInstanceDecorator()) {
                       // call on decorator QObject
                       void* args[3];
                       args[0] = &result;
                       args[1] = &obj1; // this is a pointer, so it needs a pointer to a pointer
                       args[2] = obj2;  // this is a reference, so it needs the direct pointer
                       info._slot->decorator()->qt_metacall(QMetaObject::InvokeMetaMethod, info._slot->slotIndex(), args);
                       return result?0:-1;
                     } else {
                       // call directly on QObject
                       if (w1->_obj && w2->_obj) {
                         void* args[2];
                         args[0] = &result;
                         args[2] = obj2;  // this is a reference, so it needs the direct pointer
                         w1->_obj->qt_metacall(QMetaObject::InvokeMetaMethod, info._slot->slotIndex(), args);
                       }
                     }
                   }
                 }
               }
               return -1;
             }
             static int PythonQtWrapper_nonzero(PyObject *obj)
             {
               PythonQtWrapper* wt = (PythonQtWrapper*)obj;
               return (wt->_wrappedPtr == NULL && wt->_obj == NULL)?0:1;
             }
             static long PythonQtWrapper_hash(PythonQtWrapper *obj)
             {
               if (obj->_wrappedPtr != NULL) {
                 return reinterpret_cast<long>(obj->_wrappedPtr);
               } else {
                 QObject* qobj = obj->_obj; // get pointer from QPointer wrapper
                 return reinterpret_cast<long>(qobj);
               }
             }
             // we override nb_nonzero, so that one can do 'if' expressions to test for a NULL ptr
             static PyNumberMethods PythonQtWrapper_as_number = {
 ,      /* nb_add */
 ,      /* nb_subtract */
 ,      /* nb_multiply */
 ,      /* nb_divide */
 ,      /* nb_remainder */
 ,      /* nb_divmod */
 ,      /* nb_power */
 ,      /* nb_negative */
 ,      /* nb_positive */
 ,      /* nb_absolute */
                 PythonQtWrapper_nonzero,      /* nb_nonzero */
 ,      /* nb_invert */
 ,      /* nb_lshift */
 ,      /* nb_rshift */
 ,    /* nb_and */
 ,    /* nb_xor */
 ,    /* nb_or */
 ,      /* nb_coerce */
 ,      /* nb_int */
 ,      /* nb_long */
 ,      /* nb_float */
 ,      /* nb_oct */
 ,      /* nb_hex */
 ,      /* nb_inplace_add */
 ,      /* nb_inplace_subtract */
 ,      /* nb_inplace_multiply */
 ,      /* nb_inplace_divide */
 ,      /* nb_inplace_remainder */
 ,      /* nb_inplace_power */
 ,      /* nb_inplace_lshift */
 ,      /* nb_inplace_rshift */
 ,      /* nb_inplace_and */
 ,      /* nb_inplace_xor */
 ,      /* nb_inplace_or */
 ,      /* nb_floor_divide */
 ,      /* nb_true_divide */
 ,      /* nb_inplace_floor_divide */
 ,      /* nb_inplace_true_divide */
             };
             PyTypeObject PythonQtWrapper_Type = {
               PyObject_HEAD_INIT(NULL)
 ,                         /*ob_size*/
                 "PythonQt.PythonQtWrapper",             /*tp_name*/
                 sizeof(PythonQtWrapper),             /*tp_basicsize*/
 ,                         /*tp_itemsize*/
                 (destructor)PythonQtWrapper_dealloc, /*tp_dealloc*/
 ,                         /*tp_print*/
 ,                         /*tp_getattr*/
 ,                         /*tp_setattr*/
                 PythonQtWrapper_compare,         /*tp_compare*/
                 PythonQtWrapper_repr,            /*tp_repr*/
                 &PythonQtWrapper_as_number,                         /*tp_as_number*/
 ,                         /*tp_as_sequence*/
 ,                         /*tp_as_mapping*/
                 (hashfunc)PythonQtWrapper_hash,                         /*tp_hash */
 ,                         /*tp_call*/
                 PythonQtWrapper_str,      /*tp_str*/
                 PythonQtWrapper_getattro,                         /*tp_getattro*/
                 PythonQtWrapper_setattro,                         /*tp_setattro*/
 ,                         /*tp_as_buffer*/
                 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/
                 "PythonQtWrapper object",           /* tp_doc */
 ,                   /* tp_traverse */
 ,                   /* tp_clear */
 ,                   /* tp_richcompare */
 ,                   /* tp_weaklistoffset */
 ,                   /* tp_iter */
 ,                   /* tp_iternext */
 ,             /* tp_methods */
 ,             /* tp_members */
 ,                         /* tp_getset */
 ,                         /* tp_base */
 ,                         /* tp_dict */
 ,                         /* tp_descr_get */
 ,                         /* tp_descr_set */
 ,                         /* tp_dictoffset */
                 (initproc)PythonQtWrapper_init,      /* tp_init */
 ,                         /* tp_alloc */
                 PythonQtWrapper_new,                 /* tp_new */
             };
             //-------------------------------------------------------

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages