public void AddItem(IQGraphicsItem item)
 {
     interceptor.Invoke("addItem#", "addItem(QGraphicsItem*)", typeof(void), typeof(IQGraphicsItem), item);
 }

 public QPolygonF MapToItem(IQGraphicsItem item, double x, double y, double w, double h)
 {
     return (QPolygonF) interceptor.Invoke("mapToItem#$$$$", "mapToItem(const QGraphicsItem*, qreal, qreal, qreal, qreal) const", typeof(QPolygonF), typeof(IQGraphicsItem), item, typeof(double), x, typeof(double), y, typeof(double), w, typeof(double), h);
 }

 public void RemoveSceneEventFilter(IQGraphicsItem filterItem)
 {
     interceptor.Invoke("removeSceneEventFilter#", "removeSceneEventFilter(QGraphicsItem*)", typeof(void), typeof(IQGraphicsItem), filterItem);
 }

 public QRectF MapRectToItem(IQGraphicsItem item, QRectF rect)
 {
     return (QRectF) interceptor.Invoke("mapRectToItem##", "mapRectToItem(const QGraphicsItem*, const QRectF&) const", typeof(QRectF), typeof(IQGraphicsItem), item, typeof(QRectF), rect);
 }

 public QTransform ItemTransform(IQGraphicsItem other, ref bool ok)
 {
     StackItem[] stack = new StackItem[3];
     #if DEBUG
     stack[1].s_class = (IntPtr) DebugGCHandle.Alloc(other);
     #else
     stack[1].s_class = (IntPtr) GCHandle.Alloc(other);
     #endif
     stack[2].s_bool = ok;
     interceptor.Invoke("itemTransform#$", "itemTransform(const QGraphicsItem*, bool*) const", stack);
     #if DEBUG
     DebugGCHandle.Free((GCHandle) stack[1].s_class);
     #else
     ((GCHandle) stack[1].s_class).SynchronizedFree();
     #endif
     ok = stack[2].s_bool;
     object returnValue = ((GCHandle) stack[0].s_class).Target;
     #if DEBUG
     DebugGCHandle.Free((GCHandle) stack[0].s_class);
     #else
     ((GCHandle) stack[0].s_class).SynchronizedFree();
     #endif
     return (QTransform) returnValue;
 }

 public QPointF MapFromItem(IQGraphicsItem item, QPointF point)
 {
     return (QPointF) interceptor.Invoke("mapFromItem##", "mapFromItem(const QGraphicsItem*, const QPointF&) const", typeof(QPointF), typeof(IQGraphicsItem), item, typeof(QPointF), point);
 }

 public void SetFocusItem(IQGraphicsItem item, Qt.FocusReason focusReason)
 {
     interceptor.Invoke("setFocusItem#$", "setFocusItem(QGraphicsItem*, Qt::FocusReason)", typeof(void), typeof(IQGraphicsItem), item, typeof(Qt.FocusReason), focusReason);
 }

 public bool SendEvent(IQGraphicsItem item, QEvent arg2)
 {
     return (bool) interceptor.Invoke("sendEvent##", "sendEvent(QGraphicsItem*, QEvent*)", typeof(bool), typeof(IQGraphicsItem), item, typeof(QEvent), arg2);
 }

 public void SetActivePanel(IQGraphicsItem item)
 {
     interceptor.Invoke("setActivePanel#", "setActivePanel(QGraphicsItem*)", typeof(void), typeof(IQGraphicsItem), item);
 }

 public void RemoveItem(IQGraphicsItem item)
 {
     interceptor.Invoke("removeItem#", "removeItem(QGraphicsItem*)", typeof(void), typeof(IQGraphicsItem), item);
 }

 public List<IQGraphicsItem> CollidingItems(IQGraphicsItem item)
 {
     return (List<IQGraphicsItem>) interceptor.Invoke("collidingItems#", "collidingItems(const QGraphicsItem*) const", typeof(List<IQGraphicsItem>), typeof(IQGraphicsItem), item);
 }

 // QGraphicsItem* QGraphicsItem(QGraphicsItemPrivate& arg1,QGraphicsItem* arg2,QGraphicsScene* arg3); >>>> NOT CONVERTED
 public QGraphicsTextItem(IQGraphicsItem parent, QGraphicsScene scene)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("QGraphicsTextItem##", "QGraphicsTextItem(QGraphicsItem*, QGraphicsScene*)", typeof(void), typeof(IQGraphicsItem), parent, typeof(QGraphicsScene), scene);
 }

 protected virtual bool SceneEventFilter(IQGraphicsItem watched, QEvent arg2)
 {
     return (bool) interceptor.Invoke("sceneEventFilter##", "sceneEventFilter(QGraphicsItem*, QEvent*)", typeof(bool), typeof(IQGraphicsItem), watched, typeof(QEvent), arg2);
 }

 public bool IsVisibleTo(IQGraphicsItem parent)
 {
     return (bool) interceptor.Invoke("isVisibleTo#", "isVisibleTo(const QGraphicsItem*) const", typeof(bool), typeof(IQGraphicsItem), parent);
 }

 public virtual bool CollidesWithItem(IQGraphicsItem other, Qt.ItemSelectionMode mode)
 {
     return (bool) interceptor.Invoke("collidesWithItem#$", "collidesWithItem(const QGraphicsItem*, Qt::ItemSelectionMode) const", typeof(bool), typeof(IQGraphicsItem), other, typeof(Qt.ItemSelectionMode), mode);
 }

 public IQGraphicsItem CommonAncestorItem(IQGraphicsItem other)
 {
     return (IQGraphicsItem) interceptor.Invoke("commonAncestorItem#", "commonAncestorItem(const QGraphicsItem*) const", typeof(IQGraphicsItem), typeof(IQGraphicsItem), other);
 }

 public void InstallSceneEventFilter(IQGraphicsItem filterItem)
 {
     interceptor.Invoke("installSceneEventFilter#", "installSceneEventFilter(QGraphicsItem*)", typeof(void), typeof(IQGraphicsItem), filterItem);
 }

 public bool IsAncestorOf(IQGraphicsItem child)
 {
     return (bool) interceptor.Invoke("isAncestorOf#", "isAncestorOf(const QGraphicsItem*) const", typeof(bool), typeof(IQGraphicsItem), child);
 }

 public virtual bool IsObscuredBy(IQGraphicsItem item)
 {
     return (bool) interceptor.Invoke("isObscuredBy#", "isObscuredBy(const QGraphicsItem*) const", typeof(bool), typeof(IQGraphicsItem), item);
 }

 public void SetParentItem(IQGraphicsItem parent)
 {
     interceptor.Invoke("setParentItem#", "setParentItem(QGraphicsItem*)", typeof(void), typeof(IQGraphicsItem), parent);
 }