#pragma once
#ifndef MIQT_QT_GEN_QGRAPHICSITEM_H
#define MIQT_QT_GEN_QGRAPHICSITEM_H

#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

#pragma GCC diagnostic ignored "-Wdeprecated-declarations"

#include "../libmiqt/libmiqt.h"

#ifdef __cplusplus
extern "C" {
#endif

#ifdef __cplusplus
class QAbstractGraphicsShapeItem;
class QBrush;
class QChildEvent;
class QColor;
class QCursor;
class QEvent;
class QFocusEvent;
class QFont;
class QGraphicsEffect;
class QGraphicsEllipseItem;
class QGraphicsItem;
class QGraphicsItemGroup;
class QGraphicsLineItem;
class QGraphicsObject;
class QGraphicsPathItem;
class QGraphicsPixmapItem;
class QGraphicsPolygonItem;
class QGraphicsRectItem;
class QGraphicsScene;
class QGraphicsSceneContextMenuEvent;
class QGraphicsSceneDragDropEvent;
class QGraphicsSceneHoverEvent;
class QGraphicsSceneMouseEvent;
class QGraphicsSceneWheelEvent;
class QGraphicsSimpleTextItem;
class QGraphicsTextItem;
class QGraphicsTransform;
class QGraphicsWidget;
class QInputMethodEvent;
class QKeyEvent;
class QLineF;
class QMatrix;
class QMetaMethod;
class QMetaObject;
class QObject;
class QPainter;
class QPainterPath;
class QPen;
class QPixmap;
class QPointF;
class QRectF;
class QRegion;
class QSize;
class QStyleOptionGraphicsItem;
class QTextCursor;
class QTextDocument;
class QTimerEvent;
class QTransform;
class QVariant;
class QWidget;
#else
typedef struct QAbstractGraphicsShapeItem QAbstractGraphicsShapeItem;
typedef struct QBrush QBrush;
typedef struct QChildEvent QChildEvent;
typedef struct QColor QColor;
typedef struct QCursor QCursor;
typedef struct QEvent QEvent;
typedef struct QFocusEvent QFocusEvent;
typedef struct QFont QFont;
typedef struct QGraphicsEffect QGraphicsEffect;
typedef struct QGraphicsEllipseItem QGraphicsEllipseItem;
typedef struct QGraphicsItem QGraphicsItem;
typedef struct QGraphicsItemGroup QGraphicsItemGroup;
typedef struct QGraphicsLineItem QGraphicsLineItem;
typedef struct QGraphicsObject QGraphicsObject;
typedef struct QGraphicsPathItem QGraphicsPathItem;
typedef struct QGraphicsPixmapItem QGraphicsPixmapItem;
typedef struct QGraphicsPolygonItem QGraphicsPolygonItem;
typedef struct QGraphicsRectItem QGraphicsRectItem;
typedef struct QGraphicsScene QGraphicsScene;
typedef struct QGraphicsSceneContextMenuEvent QGraphicsSceneContextMenuEvent;
typedef struct QGraphicsSceneDragDropEvent QGraphicsSceneDragDropEvent;
typedef struct QGraphicsSceneHoverEvent QGraphicsSceneHoverEvent;
typedef struct QGraphicsSceneMouseEvent QGraphicsSceneMouseEvent;
typedef struct QGraphicsSceneWheelEvent QGraphicsSceneWheelEvent;
typedef struct QGraphicsSimpleTextItem QGraphicsSimpleTextItem;
typedef struct QGraphicsTextItem QGraphicsTextItem;
typedef struct QGraphicsTransform QGraphicsTransform;
typedef struct QGraphicsWidget QGraphicsWidget;
typedef struct QInputMethodEvent QInputMethodEvent;
typedef struct QKeyEvent QKeyEvent;
typedef struct QLineF QLineF;
typedef struct QMatrix QMatrix;
typedef struct QMetaMethod QMetaMethod;
typedef struct QMetaObject QMetaObject;
typedef struct QObject QObject;
typedef struct QPainter QPainter;
typedef struct QPainterPath QPainterPath;
typedef struct QPen QPen;
typedef struct QPixmap QPixmap;
typedef struct QPointF QPointF;
typedef struct QRectF QRectF;
typedef struct QRegion QRegion;
typedef struct QSize QSize;
typedef struct QStyleOptionGraphicsItem QStyleOptionGraphicsItem;
typedef struct QTextCursor QTextCursor;
typedef struct QTextDocument QTextDocument;
typedef struct QTimerEvent QTimerEvent;
typedef struct QTransform QTransform;
typedef struct QVariant QVariant;
typedef struct QWidget QWidget;
#endif

QGraphicsItem* QGraphicsItem_new();
QGraphicsItem* QGraphicsItem_new2(QGraphicsItem* parent);
QGraphicsScene* QGraphicsItem_scene(const QGraphicsItem* self);
QGraphicsItem* QGraphicsItem_parentItem(const QGraphicsItem* self);
QGraphicsItem* QGraphicsItem_topLevelItem(const QGraphicsItem* self);
QGraphicsObject* QGraphicsItem_parentObject(const QGraphicsItem* self);
QGraphicsWidget* QGraphicsItem_parentWidget(const QGraphicsItem* self);
QGraphicsWidget* QGraphicsItem_topLevelWidget(const QGraphicsItem* self);
QGraphicsWidget* QGraphicsItem_window(const QGraphicsItem* self);
QGraphicsItem* QGraphicsItem_panel(const QGraphicsItem* self);
void QGraphicsItem_setParentItem(QGraphicsItem* self, QGraphicsItem* parent);
struct miqt_array /* of QGraphicsItem* */  QGraphicsItem_childItems(const QGraphicsItem* self);
bool QGraphicsItem_isWidget(const QGraphicsItem* self);
bool QGraphicsItem_isWindow(const QGraphicsItem* self);
bool QGraphicsItem_isPanel(const QGraphicsItem* self);
QGraphicsObject* QGraphicsItem_toGraphicsObject(QGraphicsItem* self);
QGraphicsObject* QGraphicsItem_toGraphicsObject2(const QGraphicsItem* self);
QGraphicsItemGroup* QGraphicsItem_group(const QGraphicsItem* self);
void QGraphicsItem_setGroup(QGraphicsItem* self, QGraphicsItemGroup* group);
int QGraphicsItem_flags(const QGraphicsItem* self);
void QGraphicsItem_setFlag(QGraphicsItem* self, int flag);
void QGraphicsItem_setFlags(QGraphicsItem* self, int flags);
int QGraphicsItem_cacheMode(const QGraphicsItem* self);
void QGraphicsItem_setCacheMode(QGraphicsItem* self, int mode);
int QGraphicsItem_panelModality(const QGraphicsItem* self);
void QGraphicsItem_setPanelModality(QGraphicsItem* self, int panelModality);
bool QGraphicsItem_isBlockedByModalPanel(const QGraphicsItem* self);
struct miqt_string QGraphicsItem_toolTip(const QGraphicsItem* self);
void QGraphicsItem_setToolTip(QGraphicsItem* self, struct miqt_string toolTip);
QCursor* QGraphicsItem_cursor(const QGraphicsItem* self);
void QGraphicsItem_setCursor(QGraphicsItem* self, QCursor* cursor);
bool QGraphicsItem_hasCursor(const QGraphicsItem* self);
void QGraphicsItem_unsetCursor(QGraphicsItem* self);
bool QGraphicsItem_isVisible(const QGraphicsItem* self);
bool QGraphicsItem_isVisibleTo(const QGraphicsItem* self, QGraphicsItem* parent);
void QGraphicsItem_setVisible(QGraphicsItem* self, bool visible);
void QGraphicsItem_hide(QGraphicsItem* self);
void QGraphicsItem_show(QGraphicsItem* self);
bool QGraphicsItem_isEnabled(const QGraphicsItem* self);
void QGraphicsItem_setEnabled(QGraphicsItem* self, bool enabled);
bool QGraphicsItem_isSelected(const QGraphicsItem* self);
void QGraphicsItem_setSelected(QGraphicsItem* self, bool selected);
bool QGraphicsItem_acceptDrops(const QGraphicsItem* self);
void QGraphicsItem_setAcceptDrops(QGraphicsItem* self, bool on);
double QGraphicsItem_opacity(const QGraphicsItem* self);
double QGraphicsItem_effectiveOpacity(const QGraphicsItem* self);
void QGraphicsItem_setOpacity(QGraphicsItem* self, double opacity);
QGraphicsEffect* QGraphicsItem_graphicsEffect(const QGraphicsItem* self);
void QGraphicsItem_setGraphicsEffect(QGraphicsItem* self, QGraphicsEffect* effect);
int QGraphicsItem_acceptedMouseButtons(const QGraphicsItem* self);
void QGraphicsItem_setAcceptedMouseButtons(QGraphicsItem* self, int buttons);
bool QGraphicsItem_acceptHoverEvents(const QGraphicsItem* self);
void QGraphicsItem_setAcceptHoverEvents(QGraphicsItem* self, bool enabled);
bool QGraphicsItem_acceptTouchEvents(const QGraphicsItem* self);
void QGraphicsItem_setAcceptTouchEvents(QGraphicsItem* self, bool enabled);
bool QGraphicsItem_filtersChildEvents(const QGraphicsItem* self);
void QGraphicsItem_setFiltersChildEvents(QGraphicsItem* self, bool enabled);
bool QGraphicsItem_handlesChildEvents(const QGraphicsItem* self);
void QGraphicsItem_setHandlesChildEvents(QGraphicsItem* self, bool enabled);
bool QGraphicsItem_isActive(const QGraphicsItem* self);
void QGraphicsItem_setActive(QGraphicsItem* self, bool active);
bool QGraphicsItem_hasFocus(const QGraphicsItem* self);
void QGraphicsItem_setFocus(QGraphicsItem* self);
void QGraphicsItem_clearFocus(QGraphicsItem* self);
QGraphicsItem* QGraphicsItem_focusProxy(const QGraphicsItem* self);
void QGraphicsItem_setFocusProxy(QGraphicsItem* self, QGraphicsItem* item);
QGraphicsItem* QGraphicsItem_focusItem(const QGraphicsItem* self);
QGraphicsItem* QGraphicsItem_focusScopeItem(const QGraphicsItem* self);
void QGraphicsItem_grabMouse(QGraphicsItem* self);
void QGraphicsItem_ungrabMouse(QGraphicsItem* self);
void QGraphicsItem_grabKeyboard(QGraphicsItem* self);
void QGraphicsItem_ungrabKeyboard(QGraphicsItem* self);
QPointF* QGraphicsItem_pos(const QGraphicsItem* self);
double QGraphicsItem_x(const QGraphicsItem* self);
void QGraphicsItem_setX(QGraphicsItem* self, double x);
double QGraphicsItem_y(const QGraphicsItem* self);
void QGraphicsItem_setY(QGraphicsItem* self, double y);
QPointF* QGraphicsItem_scenePos(const QGraphicsItem* self);
void QGraphicsItem_setPos(QGraphicsItem* self, QPointF* pos);
void QGraphicsItem_setPos2(QGraphicsItem* self, double x, double y);
void QGraphicsItem_moveBy(QGraphicsItem* self, double dx, double dy);
void QGraphicsItem_ensureVisible(QGraphicsItem* self);
void QGraphicsItem_ensureVisible2(QGraphicsItem* self, double x, double y, double w, double h);
QMatrix* QGraphicsItem_matrix(const QGraphicsItem* self);
QMatrix* QGraphicsItem_sceneMatrix(const QGraphicsItem* self);
void QGraphicsItem_setMatrix(QGraphicsItem* self, QMatrix* matrix);
void QGraphicsItem_resetMatrix(QGraphicsItem* self);
QTransform* QGraphicsItem_transform(const QGraphicsItem* self);
QTransform* QGraphicsItem_sceneTransform(const QGraphicsItem* self);
QTransform* QGraphicsItem_deviceTransform(const QGraphicsItem* self, QTransform* viewportTransform);
QTransform* QGraphicsItem_itemTransform(const QGraphicsItem* self, QGraphicsItem* other);
void QGraphicsItem_setTransform(QGraphicsItem* self, QTransform* matrix);
void QGraphicsItem_resetTransform(QGraphicsItem* self);
void QGraphicsItem_setRotation(QGraphicsItem* self, double angle);
double QGraphicsItem_rotation(const QGraphicsItem* self);
void QGraphicsItem_setScale(QGraphicsItem* self, double scale);
double QGraphicsItem_scale(const QGraphicsItem* self);
struct miqt_array /* of QGraphicsTransform* */  QGraphicsItem_transformations(const QGraphicsItem* self);
void QGraphicsItem_setTransformations(QGraphicsItem* self, struct miqt_array /* of QGraphicsTransform* */  transformations);
QPointF* QGraphicsItem_transformOriginPoint(const QGraphicsItem* self);
void QGraphicsItem_setTransformOriginPoint(QGraphicsItem* self, QPointF* origin);
void QGraphicsItem_setTransformOriginPoint2(QGraphicsItem* self, double ax, double ay);
void QGraphicsItem_advance(QGraphicsItem* self, int phase);
double QGraphicsItem_zValue(const QGraphicsItem* self);
void QGraphicsItem_setZValue(QGraphicsItem* self, double z);
void QGraphicsItem_stackBefore(QGraphicsItem* self, QGraphicsItem* sibling);
QRectF* QGraphicsItem_boundingRect(const QGraphicsItem* self);
QRectF* QGraphicsItem_childrenBoundingRect(const QGraphicsItem* self);
QRectF* QGraphicsItem_sceneBoundingRect(const QGraphicsItem* self);
QPainterPath* QGraphicsItem_shape(const QGraphicsItem* self);
bool QGraphicsItem_isClipped(const QGraphicsItem* self);
QPainterPath* QGraphicsItem_clipPath(const QGraphicsItem* self);
bool QGraphicsItem_contains(const QGraphicsItem* self, QPointF* point);
bool QGraphicsItem_collidesWithItem(const QGraphicsItem* self, QGraphicsItem* other, int mode);
bool QGraphicsItem_collidesWithPath(const QGraphicsItem* self, QPainterPath* path, int mode);
struct miqt_array /* of QGraphicsItem* */  QGraphicsItem_collidingItems(const QGraphicsItem* self);
bool QGraphicsItem_isObscured(const QGraphicsItem* self);
bool QGraphicsItem_isObscured2(const QGraphicsItem* self, double x, double y, double w, double h);
bool QGraphicsItem_isObscuredBy(const QGraphicsItem* self, QGraphicsItem* item);
QPainterPath* QGraphicsItem_opaqueArea(const QGraphicsItem* self);
QRegion* QGraphicsItem_boundingRegion(const QGraphicsItem* self, QTransform* itemToDeviceTransform);
double QGraphicsItem_boundingRegionGranularity(const QGraphicsItem* self);
void QGraphicsItem_setBoundingRegionGranularity(QGraphicsItem* self, double granularity);
void QGraphicsItem_paint(QGraphicsItem* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
void QGraphicsItem_update(QGraphicsItem* self);
void QGraphicsItem_update2(QGraphicsItem* self, double x, double y, double width, double height);
void QGraphicsItem_scroll(QGraphicsItem* self, double dx, double dy);
QPointF* QGraphicsItem_mapToItem(const QGraphicsItem* self, QGraphicsItem* item, QPointF* point);
QPointF* QGraphicsItem_mapToParent(const QGraphicsItem* self, QPointF* point);
QPointF* QGraphicsItem_mapToScene(const QGraphicsItem* self, QPointF* point);
QRectF* QGraphicsItem_mapRectToItem(const QGraphicsItem* self, QGraphicsItem* item, QRectF* rect);
QRectF* QGraphicsItem_mapRectToParent(const QGraphicsItem* self, QRectF* rect);
QRectF* QGraphicsItem_mapRectToScene(const QGraphicsItem* self, QRectF* rect);
QPainterPath* QGraphicsItem_mapToItem4(const QGraphicsItem* self, QGraphicsItem* item, QPainterPath* path);
QPainterPath* QGraphicsItem_mapToParentWithPath(const QGraphicsItem* self, QPainterPath* path);
QPainterPath* QGraphicsItem_mapToSceneWithPath(const QGraphicsItem* self, QPainterPath* path);
QPointF* QGraphicsItem_mapFromItem(const QGraphicsItem* self, QGraphicsItem* item, QPointF* point);
QPointF* QGraphicsItem_mapFromParent(const QGraphicsItem* self, QPointF* point);
QPointF* QGraphicsItem_mapFromScene(const QGraphicsItem* self, QPointF* point);
QRectF* QGraphicsItem_mapRectFromItem(const QGraphicsItem* self, QGraphicsItem* item, QRectF* rect);
QRectF* QGraphicsItem_mapRectFromParent(const QGraphicsItem* self, QRectF* rect);
QRectF* QGraphicsItem_mapRectFromScene(const QGraphicsItem* self, QRectF* rect);
QPainterPath* QGraphicsItem_mapFromItem4(const QGraphicsItem* self, QGraphicsItem* item, QPainterPath* path);
QPainterPath* QGraphicsItem_mapFromParentWithPath(const QGraphicsItem* self, QPainterPath* path);
QPainterPath* QGraphicsItem_mapFromSceneWithPath(const QGraphicsItem* self, QPainterPath* path);
QPointF* QGraphicsItem_mapToItem5(const QGraphicsItem* self, QGraphicsItem* item, double x, double y);
QPointF* QGraphicsItem_mapToParent2(const QGraphicsItem* self, double x, double y);
QPointF* QGraphicsItem_mapToScene2(const QGraphicsItem* self, double x, double y);
QRectF* QGraphicsItem_mapRectToItem2(const QGraphicsItem* self, QGraphicsItem* item, double x, double y, double w, double h);
QRectF* QGraphicsItem_mapRectToParent2(const QGraphicsItem* self, double x, double y, double w, double h);
QRectF* QGraphicsItem_mapRectToScene2(const QGraphicsItem* self, double x, double y, double w, double h);
QPointF* QGraphicsItem_mapFromItem5(const QGraphicsItem* self, QGraphicsItem* item, double x, double y);
QPointF* QGraphicsItem_mapFromParent2(const QGraphicsItem* self, double x, double y);
QPointF* QGraphicsItem_mapFromScene2(const QGraphicsItem* self, double x, double y);
QRectF* QGraphicsItem_mapRectFromItem2(const QGraphicsItem* self, QGraphicsItem* item, double x, double y, double w, double h);
QRectF* QGraphicsItem_mapRectFromParent2(const QGraphicsItem* self, double x, double y, double w, double h);
QRectF* QGraphicsItem_mapRectFromScene2(const QGraphicsItem* self, double x, double y, double w, double h);
bool QGraphicsItem_isAncestorOf(const QGraphicsItem* self, QGraphicsItem* child);
QGraphicsItem* QGraphicsItem_commonAncestorItem(const QGraphicsItem* self, QGraphicsItem* other);
bool QGraphicsItem_isUnderMouse(const QGraphicsItem* self);
QVariant* QGraphicsItem_data(const QGraphicsItem* self, int key);
void QGraphicsItem_setData(QGraphicsItem* self, int key, QVariant* value);
int QGraphicsItem_inputMethodHints(const QGraphicsItem* self);
void QGraphicsItem_setInputMethodHints(QGraphicsItem* self, int hints);
int QGraphicsItem_type(const QGraphicsItem* self);
void QGraphicsItem_installSceneEventFilter(QGraphicsItem* self, QGraphicsItem* filterItem);
void QGraphicsItem_removeSceneEventFilter(QGraphicsItem* self, QGraphicsItem* filterItem);
bool QGraphicsItem_sceneEventFilter(QGraphicsItem* self, QGraphicsItem* watched, QEvent* event);
bool QGraphicsItem_sceneEvent(QGraphicsItem* self, QEvent* event);
void QGraphicsItem_contextMenuEvent(QGraphicsItem* self, QGraphicsSceneContextMenuEvent* event);
void QGraphicsItem_dragEnterEvent(QGraphicsItem* self, QGraphicsSceneDragDropEvent* event);
void QGraphicsItem_dragLeaveEvent(QGraphicsItem* self, QGraphicsSceneDragDropEvent* event);
void QGraphicsItem_dragMoveEvent(QGraphicsItem* self, QGraphicsSceneDragDropEvent* event);
void QGraphicsItem_dropEvent(QGraphicsItem* self, QGraphicsSceneDragDropEvent* event);
void QGraphicsItem_focusInEvent(QGraphicsItem* self, QFocusEvent* event);
void QGraphicsItem_focusOutEvent(QGraphicsItem* self, QFocusEvent* event);
void QGraphicsItem_hoverEnterEvent(QGraphicsItem* self, QGraphicsSceneHoverEvent* event);
void QGraphicsItem_hoverMoveEvent(QGraphicsItem* self, QGraphicsSceneHoverEvent* event);
void QGraphicsItem_hoverLeaveEvent(QGraphicsItem* self, QGraphicsSceneHoverEvent* event);
void QGraphicsItem_keyPressEvent(QGraphicsItem* self, QKeyEvent* event);
void QGraphicsItem_keyReleaseEvent(QGraphicsItem* self, QKeyEvent* event);
void QGraphicsItem_mousePressEvent(QGraphicsItem* self, QGraphicsSceneMouseEvent* event);
void QGraphicsItem_mouseMoveEvent(QGraphicsItem* self, QGraphicsSceneMouseEvent* event);
void QGraphicsItem_mouseReleaseEvent(QGraphicsItem* self, QGraphicsSceneMouseEvent* event);
void QGraphicsItem_mouseDoubleClickEvent(QGraphicsItem* self, QGraphicsSceneMouseEvent* event);
void QGraphicsItem_wheelEvent(QGraphicsItem* self, QGraphicsSceneWheelEvent* event);
void QGraphicsItem_inputMethodEvent(QGraphicsItem* self, QInputMethodEvent* event);
QVariant* QGraphicsItem_inputMethodQuery(const QGraphicsItem* self, int query);
QVariant* QGraphicsItem_itemChange(QGraphicsItem* self, int change, QVariant* value);
bool QGraphicsItem_supportsExtension(const QGraphicsItem* self, int extension);
void QGraphicsItem_setExtension(QGraphicsItem* self, int extension, QVariant* variant);
QVariant* QGraphicsItem_extension(const QGraphicsItem* self, QVariant* variant);
void QGraphicsItem_setFlag2(QGraphicsItem* self, int flag, bool enabled);
void QGraphicsItem_setCacheMode2(QGraphicsItem* self, int mode, QSize* cacheSize);
void QGraphicsItem_setFocus1(QGraphicsItem* self, int focusReason);
void QGraphicsItem_ensureVisible1(QGraphicsItem* self, QRectF* rect);
void QGraphicsItem_ensureVisible22(QGraphicsItem* self, QRectF* rect, int xmargin);
void QGraphicsItem_ensureVisible3(QGraphicsItem* self, QRectF* rect, int xmargin, int ymargin);
void QGraphicsItem_ensureVisible5(QGraphicsItem* self, double x, double y, double w, double h, int xmargin);
void QGraphicsItem_ensureVisible6(QGraphicsItem* self, double x, double y, double w, double h, int xmargin, int ymargin);
void QGraphicsItem_setMatrix2(QGraphicsItem* self, QMatrix* matrix, bool combine);
QTransform* QGraphicsItem_itemTransform2(const QGraphicsItem* self, QGraphicsItem* other, bool* ok);
void QGraphicsItem_setTransform2(QGraphicsItem* self, QTransform* matrix, bool combine);
struct miqt_array /* of QGraphicsItem* */  QGraphicsItem_collidingItems1(const QGraphicsItem* self, int mode);
bool QGraphicsItem_isObscured1(const QGraphicsItem* self, QRectF* rect);
void QGraphicsItem_update1(QGraphicsItem* self, QRectF* rect);
void QGraphicsItem_scroll3(QGraphicsItem* self, double dx, double dy, QRectF* rect);
bool QGraphicsItem_override_virtual_advance(void* self, intptr_t slot);
void QGraphicsItem_virtualbase_advance(void* self, int phase);
bool QGraphicsItem_override_virtual_boundingRect(void* self, intptr_t slot);
QRectF* QGraphicsItem_virtualbase_boundingRect(const void* self);
bool QGraphicsItem_override_virtual_shape(void* self, intptr_t slot);
QPainterPath* QGraphicsItem_virtualbase_shape(const void* self);
bool QGraphicsItem_override_virtual_contains(void* self, intptr_t slot);
bool QGraphicsItem_virtualbase_contains(const void* self, QPointF* point);
bool QGraphicsItem_override_virtual_collidesWithItem(void* self, intptr_t slot);
bool QGraphicsItem_virtualbase_collidesWithItem(const void* self, QGraphicsItem* other, int mode);
bool QGraphicsItem_override_virtual_collidesWithPath(void* self, intptr_t slot);
bool QGraphicsItem_virtualbase_collidesWithPath(const void* self, QPainterPath* path, int mode);
bool QGraphicsItem_override_virtual_isObscuredBy(void* self, intptr_t slot);
bool QGraphicsItem_virtualbase_isObscuredBy(const void* self, QGraphicsItem* item);
bool QGraphicsItem_override_virtual_opaqueArea(void* self, intptr_t slot);
QPainterPath* QGraphicsItem_virtualbase_opaqueArea(const void* self);
bool QGraphicsItem_override_virtual_paint(void* self, intptr_t slot);
void QGraphicsItem_virtualbase_paint(void* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
bool QGraphicsItem_override_virtual_type(void* self, intptr_t slot);
int QGraphicsItem_virtualbase_type(const void* self);
bool QGraphicsItem_override_virtual_sceneEventFilter(void* self, intptr_t slot);
bool QGraphicsItem_virtualbase_sceneEventFilter(void* self, QGraphicsItem* watched, QEvent* event);
bool QGraphicsItem_override_virtual_sceneEvent(void* self, intptr_t slot);
bool QGraphicsItem_virtualbase_sceneEvent(void* self, QEvent* event);
bool QGraphicsItem_override_virtual_contextMenuEvent(void* self, intptr_t slot);
void QGraphicsItem_virtualbase_contextMenuEvent(void* self, QGraphicsSceneContextMenuEvent* event);
bool QGraphicsItem_override_virtual_dragEnterEvent(void* self, intptr_t slot);
void QGraphicsItem_virtualbase_dragEnterEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsItem_override_virtual_dragLeaveEvent(void* self, intptr_t slot);
void QGraphicsItem_virtualbase_dragLeaveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsItem_override_virtual_dragMoveEvent(void* self, intptr_t slot);
void QGraphicsItem_virtualbase_dragMoveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsItem_override_virtual_dropEvent(void* self, intptr_t slot);
void QGraphicsItem_virtualbase_dropEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsItem_override_virtual_focusInEvent(void* self, intptr_t slot);
void QGraphicsItem_virtualbase_focusInEvent(void* self, QFocusEvent* event);
bool QGraphicsItem_override_virtual_focusOutEvent(void* self, intptr_t slot);
void QGraphicsItem_virtualbase_focusOutEvent(void* self, QFocusEvent* event);
bool QGraphicsItem_override_virtual_hoverEnterEvent(void* self, intptr_t slot);
void QGraphicsItem_virtualbase_hoverEnterEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsItem_override_virtual_hoverMoveEvent(void* self, intptr_t slot);
void QGraphicsItem_virtualbase_hoverMoveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsItem_override_virtual_hoverLeaveEvent(void* self, intptr_t slot);
void QGraphicsItem_virtualbase_hoverLeaveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsItem_override_virtual_keyPressEvent(void* self, intptr_t slot);
void QGraphicsItem_virtualbase_keyPressEvent(void* self, QKeyEvent* event);
bool QGraphicsItem_override_virtual_keyReleaseEvent(void* self, intptr_t slot);
void QGraphicsItem_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event);
bool QGraphicsItem_override_virtual_mousePressEvent(void* self, intptr_t slot);
void QGraphicsItem_virtualbase_mousePressEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsItem_override_virtual_mouseMoveEvent(void* self, intptr_t slot);
void QGraphicsItem_virtualbase_mouseMoveEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsItem_override_virtual_mouseReleaseEvent(void* self, intptr_t slot);
void QGraphicsItem_virtualbase_mouseReleaseEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsItem_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot);
void QGraphicsItem_virtualbase_mouseDoubleClickEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsItem_override_virtual_wheelEvent(void* self, intptr_t slot);
void QGraphicsItem_virtualbase_wheelEvent(void* self, QGraphicsSceneWheelEvent* event);
bool QGraphicsItem_override_virtual_inputMethodEvent(void* self, intptr_t slot);
void QGraphicsItem_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* event);
bool QGraphicsItem_override_virtual_inputMethodQuery(void* self, intptr_t slot);
QVariant* QGraphicsItem_virtualbase_inputMethodQuery(const void* self, int query);
bool QGraphicsItem_override_virtual_itemChange(void* self, intptr_t slot);
QVariant* QGraphicsItem_virtualbase_itemChange(void* self, int change, QVariant* value);
bool QGraphicsItem_override_virtual_supportsExtension(void* self, intptr_t slot);
bool QGraphicsItem_virtualbase_supportsExtension(const void* self, int extension);
bool QGraphicsItem_override_virtual_setExtension(void* self, intptr_t slot);
void QGraphicsItem_virtualbase_setExtension(void* self, int extension, QVariant* variant);
bool QGraphicsItem_override_virtual_extension(void* self, intptr_t slot);
QVariant* QGraphicsItem_virtualbase_extension(const void* self, QVariant* variant);
void QGraphicsItem_delete(QGraphicsItem* self);

QGraphicsObject* QGraphicsObject_new();
QGraphicsObject* QGraphicsObject_new2(QGraphicsItem* parent);
void QGraphicsObject_virtbase(QGraphicsObject* src, QObject** outptr_QObject, QGraphicsItem** outptr_QGraphicsItem);
QMetaObject* QGraphicsObject_metaObject(const QGraphicsObject* self);
void* QGraphicsObject_metacast(QGraphicsObject* self, const char* param1);
struct miqt_string QGraphicsObject_tr(const char* s);
struct miqt_string QGraphicsObject_trUtf8(const char* s);
void QGraphicsObject_grabGesture(QGraphicsObject* self, int type);
void QGraphicsObject_ungrabGesture(QGraphicsObject* self, int type);
void QGraphicsObject_parentChanged(QGraphicsObject* self);
void QGraphicsObject_connect_parentChanged(QGraphicsObject* self, intptr_t slot);
void QGraphicsObject_opacityChanged(QGraphicsObject* self);
void QGraphicsObject_connect_opacityChanged(QGraphicsObject* self, intptr_t slot);
void QGraphicsObject_visibleChanged(QGraphicsObject* self);
void QGraphicsObject_connect_visibleChanged(QGraphicsObject* self, intptr_t slot);
void QGraphicsObject_enabledChanged(QGraphicsObject* self);
void QGraphicsObject_connect_enabledChanged(QGraphicsObject* self, intptr_t slot);
void QGraphicsObject_xChanged(QGraphicsObject* self);
void QGraphicsObject_connect_xChanged(QGraphicsObject* self, intptr_t slot);
void QGraphicsObject_yChanged(QGraphicsObject* self);
void QGraphicsObject_connect_yChanged(QGraphicsObject* self, intptr_t slot);
void QGraphicsObject_zChanged(QGraphicsObject* self);
void QGraphicsObject_connect_zChanged(QGraphicsObject* self, intptr_t slot);
void QGraphicsObject_rotationChanged(QGraphicsObject* self);
void QGraphicsObject_connect_rotationChanged(QGraphicsObject* self, intptr_t slot);
void QGraphicsObject_scaleChanged(QGraphicsObject* self);
void QGraphicsObject_connect_scaleChanged(QGraphicsObject* self, intptr_t slot);
void QGraphicsObject_childrenChanged(QGraphicsObject* self);
void QGraphicsObject_connect_childrenChanged(QGraphicsObject* self, intptr_t slot);
void QGraphicsObject_widthChanged(QGraphicsObject* self);
void QGraphicsObject_connect_widthChanged(QGraphicsObject* self, intptr_t slot);
void QGraphicsObject_heightChanged(QGraphicsObject* self);
void QGraphicsObject_connect_heightChanged(QGraphicsObject* self, intptr_t slot);
bool QGraphicsObject_event(QGraphicsObject* self, QEvent* ev);
struct miqt_string QGraphicsObject_tr2(const char* s, const char* c);
struct miqt_string QGraphicsObject_tr3(const char* s, const char* c, int n);
struct miqt_string QGraphicsObject_trUtf82(const char* s, const char* c);
struct miqt_string QGraphicsObject_trUtf83(const char* s, const char* c, int n);
void QGraphicsObject_grabGesture2(QGraphicsObject* self, int type, int flags);
bool QGraphicsObject_override_virtual_event(void* self, intptr_t slot);
bool QGraphicsObject_virtualbase_event(void* self, QEvent* ev);
bool QGraphicsObject_override_virtual_eventFilter(void* self, intptr_t slot);
bool QGraphicsObject_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
bool QGraphicsObject_override_virtual_timerEvent(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_timerEvent(void* self, QTimerEvent* event);
bool QGraphicsObject_override_virtual_childEvent(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_childEvent(void* self, QChildEvent* event);
bool QGraphicsObject_override_virtual_customEvent(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_customEvent(void* self, QEvent* event);
bool QGraphicsObject_override_virtual_connectNotify(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_connectNotify(void* self, QMetaMethod* signal);
bool QGraphicsObject_override_virtual_disconnectNotify(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
bool QGraphicsObject_override_virtual_advance(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_advance(void* self, int phase);
bool QGraphicsObject_override_virtual_boundingRect(void* self, intptr_t slot);
QRectF* QGraphicsObject_virtualbase_boundingRect(const void* self);
bool QGraphicsObject_override_virtual_shape(void* self, intptr_t slot);
QPainterPath* QGraphicsObject_virtualbase_shape(const void* self);
bool QGraphicsObject_override_virtual_contains(void* self, intptr_t slot);
bool QGraphicsObject_virtualbase_contains(const void* self, QPointF* point);
bool QGraphicsObject_override_virtual_collidesWithItem(void* self, intptr_t slot);
bool QGraphicsObject_virtualbase_collidesWithItem(const void* self, QGraphicsItem* other, int mode);
bool QGraphicsObject_override_virtual_collidesWithPath(void* self, intptr_t slot);
bool QGraphicsObject_virtualbase_collidesWithPath(const void* self, QPainterPath* path, int mode);
bool QGraphicsObject_override_virtual_isObscuredBy(void* self, intptr_t slot);
bool QGraphicsObject_virtualbase_isObscuredBy(const void* self, QGraphicsItem* item);
bool QGraphicsObject_override_virtual_opaqueArea(void* self, intptr_t slot);
QPainterPath* QGraphicsObject_virtualbase_opaqueArea(const void* self);
bool QGraphicsObject_override_virtual_paint(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_paint(void* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
bool QGraphicsObject_override_virtual_type(void* self, intptr_t slot);
int QGraphicsObject_virtualbase_type(const void* self);
bool QGraphicsObject_override_virtual_sceneEventFilter(void* self, intptr_t slot);
bool QGraphicsObject_virtualbase_sceneEventFilter(void* self, QGraphicsItem* watched, QEvent* event);
bool QGraphicsObject_override_virtual_sceneEvent(void* self, intptr_t slot);
bool QGraphicsObject_virtualbase_sceneEvent(void* self, QEvent* event);
bool QGraphicsObject_override_virtual_contextMenuEvent(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_contextMenuEvent(void* self, QGraphicsSceneContextMenuEvent* event);
bool QGraphicsObject_override_virtual_dragEnterEvent(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_dragEnterEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsObject_override_virtual_dragLeaveEvent(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_dragLeaveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsObject_override_virtual_dragMoveEvent(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_dragMoveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsObject_override_virtual_dropEvent(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_dropEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsObject_override_virtual_focusInEvent(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_focusInEvent(void* self, QFocusEvent* event);
bool QGraphicsObject_override_virtual_focusOutEvent(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_focusOutEvent(void* self, QFocusEvent* event);
bool QGraphicsObject_override_virtual_hoverEnterEvent(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_hoverEnterEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsObject_override_virtual_hoverMoveEvent(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_hoverMoveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsObject_override_virtual_hoverLeaveEvent(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_hoverLeaveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsObject_override_virtual_keyPressEvent(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_keyPressEvent(void* self, QKeyEvent* event);
bool QGraphicsObject_override_virtual_keyReleaseEvent(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event);
bool QGraphicsObject_override_virtual_mousePressEvent(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_mousePressEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsObject_override_virtual_mouseMoveEvent(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_mouseMoveEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsObject_override_virtual_mouseReleaseEvent(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_mouseReleaseEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsObject_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_mouseDoubleClickEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsObject_override_virtual_wheelEvent(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_wheelEvent(void* self, QGraphicsSceneWheelEvent* event);
bool QGraphicsObject_override_virtual_inputMethodEvent(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* event);
bool QGraphicsObject_override_virtual_inputMethodQuery(void* self, intptr_t slot);
QVariant* QGraphicsObject_virtualbase_inputMethodQuery(const void* self, int query);
bool QGraphicsObject_override_virtual_itemChange(void* self, intptr_t slot);
QVariant* QGraphicsObject_virtualbase_itemChange(void* self, int change, QVariant* value);
bool QGraphicsObject_override_virtual_supportsExtension(void* self, intptr_t slot);
bool QGraphicsObject_virtualbase_supportsExtension(const void* self, int extension);
bool QGraphicsObject_override_virtual_setExtension(void* self, intptr_t slot);
void QGraphicsObject_virtualbase_setExtension(void* self, int extension, QVariant* variant);
bool QGraphicsObject_override_virtual_extension(void* self, intptr_t slot);
QVariant* QGraphicsObject_virtualbase_extension(const void* self, QVariant* variant);
void QGraphicsObject_delete(QGraphicsObject* self);

QAbstractGraphicsShapeItem* QAbstractGraphicsShapeItem_new();
QAbstractGraphicsShapeItem* QAbstractGraphicsShapeItem_new2(QGraphicsItem* parent);
void QAbstractGraphicsShapeItem_virtbase(QAbstractGraphicsShapeItem* src, QGraphicsItem** outptr_QGraphicsItem);
QPen* QAbstractGraphicsShapeItem_pen(const QAbstractGraphicsShapeItem* self);
void QAbstractGraphicsShapeItem_setPen(QAbstractGraphicsShapeItem* self, QPen* pen);
QBrush* QAbstractGraphicsShapeItem_brush(const QAbstractGraphicsShapeItem* self);
void QAbstractGraphicsShapeItem_setBrush(QAbstractGraphicsShapeItem* self, QBrush* brush);
bool QAbstractGraphicsShapeItem_isObscuredBy(const QAbstractGraphicsShapeItem* self, QGraphicsItem* item);
QPainterPath* QAbstractGraphicsShapeItem_opaqueArea(const QAbstractGraphicsShapeItem* self);
bool QAbstractGraphicsShapeItem_override_virtual_isObscuredBy(void* self, intptr_t slot);
bool QAbstractGraphicsShapeItem_virtualbase_isObscuredBy(const void* self, QGraphicsItem* item);
bool QAbstractGraphicsShapeItem_override_virtual_opaqueArea(void* self, intptr_t slot);
QPainterPath* QAbstractGraphicsShapeItem_virtualbase_opaqueArea(const void* self);
bool QAbstractGraphicsShapeItem_override_virtual_advance(void* self, intptr_t slot);
void QAbstractGraphicsShapeItem_virtualbase_advance(void* self, int phase);
bool QAbstractGraphicsShapeItem_override_virtual_boundingRect(void* self, intptr_t slot);
QRectF* QAbstractGraphicsShapeItem_virtualbase_boundingRect(const void* self);
bool QAbstractGraphicsShapeItem_override_virtual_shape(void* self, intptr_t slot);
QPainterPath* QAbstractGraphicsShapeItem_virtualbase_shape(const void* self);
bool QAbstractGraphicsShapeItem_override_virtual_contains(void* self, intptr_t slot);
bool QAbstractGraphicsShapeItem_virtualbase_contains(const void* self, QPointF* point);
bool QAbstractGraphicsShapeItem_override_virtual_collidesWithItem(void* self, intptr_t slot);
bool QAbstractGraphicsShapeItem_virtualbase_collidesWithItem(const void* self, QGraphicsItem* other, int mode);
bool QAbstractGraphicsShapeItem_override_virtual_collidesWithPath(void* self, intptr_t slot);
bool QAbstractGraphicsShapeItem_virtualbase_collidesWithPath(const void* self, QPainterPath* path, int mode);
bool QAbstractGraphicsShapeItem_override_virtual_paint(void* self, intptr_t slot);
void QAbstractGraphicsShapeItem_virtualbase_paint(void* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
bool QAbstractGraphicsShapeItem_override_virtual_type(void* self, intptr_t slot);
int QAbstractGraphicsShapeItem_virtualbase_type(const void* self);
bool QAbstractGraphicsShapeItem_override_virtual_sceneEventFilter(void* self, intptr_t slot);
bool QAbstractGraphicsShapeItem_virtualbase_sceneEventFilter(void* self, QGraphicsItem* watched, QEvent* event);
bool QAbstractGraphicsShapeItem_override_virtual_sceneEvent(void* self, intptr_t slot);
bool QAbstractGraphicsShapeItem_virtualbase_sceneEvent(void* self, QEvent* event);
bool QAbstractGraphicsShapeItem_override_virtual_contextMenuEvent(void* self, intptr_t slot);
void QAbstractGraphicsShapeItem_virtualbase_contextMenuEvent(void* self, QGraphicsSceneContextMenuEvent* event);
bool QAbstractGraphicsShapeItem_override_virtual_dragEnterEvent(void* self, intptr_t slot);
void QAbstractGraphicsShapeItem_virtualbase_dragEnterEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QAbstractGraphicsShapeItem_override_virtual_dragLeaveEvent(void* self, intptr_t slot);
void QAbstractGraphicsShapeItem_virtualbase_dragLeaveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QAbstractGraphicsShapeItem_override_virtual_dragMoveEvent(void* self, intptr_t slot);
void QAbstractGraphicsShapeItem_virtualbase_dragMoveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QAbstractGraphicsShapeItem_override_virtual_dropEvent(void* self, intptr_t slot);
void QAbstractGraphicsShapeItem_virtualbase_dropEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QAbstractGraphicsShapeItem_override_virtual_focusInEvent(void* self, intptr_t slot);
void QAbstractGraphicsShapeItem_virtualbase_focusInEvent(void* self, QFocusEvent* event);
bool QAbstractGraphicsShapeItem_override_virtual_focusOutEvent(void* self, intptr_t slot);
void QAbstractGraphicsShapeItem_virtualbase_focusOutEvent(void* self, QFocusEvent* event);
bool QAbstractGraphicsShapeItem_override_virtual_hoverEnterEvent(void* self, intptr_t slot);
void QAbstractGraphicsShapeItem_virtualbase_hoverEnterEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QAbstractGraphicsShapeItem_override_virtual_hoverMoveEvent(void* self, intptr_t slot);
void QAbstractGraphicsShapeItem_virtualbase_hoverMoveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QAbstractGraphicsShapeItem_override_virtual_hoverLeaveEvent(void* self, intptr_t slot);
void QAbstractGraphicsShapeItem_virtualbase_hoverLeaveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QAbstractGraphicsShapeItem_override_virtual_keyPressEvent(void* self, intptr_t slot);
void QAbstractGraphicsShapeItem_virtualbase_keyPressEvent(void* self, QKeyEvent* event);
bool QAbstractGraphicsShapeItem_override_virtual_keyReleaseEvent(void* self, intptr_t slot);
void QAbstractGraphicsShapeItem_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event);
bool QAbstractGraphicsShapeItem_override_virtual_mousePressEvent(void* self, intptr_t slot);
void QAbstractGraphicsShapeItem_virtualbase_mousePressEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QAbstractGraphicsShapeItem_override_virtual_mouseMoveEvent(void* self, intptr_t slot);
void QAbstractGraphicsShapeItem_virtualbase_mouseMoveEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QAbstractGraphicsShapeItem_override_virtual_mouseReleaseEvent(void* self, intptr_t slot);
void QAbstractGraphicsShapeItem_virtualbase_mouseReleaseEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QAbstractGraphicsShapeItem_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot);
void QAbstractGraphicsShapeItem_virtualbase_mouseDoubleClickEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QAbstractGraphicsShapeItem_override_virtual_wheelEvent(void* self, intptr_t slot);
void QAbstractGraphicsShapeItem_virtualbase_wheelEvent(void* self, QGraphicsSceneWheelEvent* event);
bool QAbstractGraphicsShapeItem_override_virtual_inputMethodEvent(void* self, intptr_t slot);
void QAbstractGraphicsShapeItem_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* event);
bool QAbstractGraphicsShapeItem_override_virtual_inputMethodQuery(void* self, intptr_t slot);
QVariant* QAbstractGraphicsShapeItem_virtualbase_inputMethodQuery(const void* self, int query);
bool QAbstractGraphicsShapeItem_override_virtual_itemChange(void* self, intptr_t slot);
QVariant* QAbstractGraphicsShapeItem_virtualbase_itemChange(void* self, int change, QVariant* value);
bool QAbstractGraphicsShapeItem_override_virtual_supportsExtension(void* self, intptr_t slot);
bool QAbstractGraphicsShapeItem_virtualbase_supportsExtension(const void* self, int extension);
bool QAbstractGraphicsShapeItem_override_virtual_setExtension(void* self, intptr_t slot);
void QAbstractGraphicsShapeItem_virtualbase_setExtension(void* self, int extension, QVariant* variant);
bool QAbstractGraphicsShapeItem_override_virtual_extension(void* self, intptr_t slot);
QVariant* QAbstractGraphicsShapeItem_virtualbase_extension(const void* self, QVariant* variant);
void QAbstractGraphicsShapeItem_delete(QAbstractGraphicsShapeItem* self);

QGraphicsPathItem* QGraphicsPathItem_new();
QGraphicsPathItem* QGraphicsPathItem_new2(QPainterPath* path);
QGraphicsPathItem* QGraphicsPathItem_new3(QGraphicsItem* parent);
QGraphicsPathItem* QGraphicsPathItem_new4(QPainterPath* path, QGraphicsItem* parent);
void QGraphicsPathItem_virtbase(QGraphicsPathItem* src, QAbstractGraphicsShapeItem** outptr_QAbstractGraphicsShapeItem);
QPainterPath* QGraphicsPathItem_path(const QGraphicsPathItem* self);
void QGraphicsPathItem_setPath(QGraphicsPathItem* self, QPainterPath* path);
QRectF* QGraphicsPathItem_boundingRect(const QGraphicsPathItem* self);
QPainterPath* QGraphicsPathItem_shape(const QGraphicsPathItem* self);
bool QGraphicsPathItem_contains(const QGraphicsPathItem* self, QPointF* point);
void QGraphicsPathItem_paint(QGraphicsPathItem* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
bool QGraphicsPathItem_isObscuredBy(const QGraphicsPathItem* self, QGraphicsItem* item);
QPainterPath* QGraphicsPathItem_opaqueArea(const QGraphicsPathItem* self);
int QGraphicsPathItem_type(const QGraphicsPathItem* self);
bool QGraphicsPathItem_supportsExtension(const QGraphicsPathItem* self, int extension);
void QGraphicsPathItem_setExtension(QGraphicsPathItem* self, int extension, QVariant* variant);
QVariant* QGraphicsPathItem_extension(const QGraphicsPathItem* self, QVariant* variant);
bool QGraphicsPathItem_override_virtual_boundingRect(void* self, intptr_t slot);
QRectF* QGraphicsPathItem_virtualbase_boundingRect(const void* self);
bool QGraphicsPathItem_override_virtual_shape(void* self, intptr_t slot);
QPainterPath* QGraphicsPathItem_virtualbase_shape(const void* self);
bool QGraphicsPathItem_override_virtual_contains(void* self, intptr_t slot);
bool QGraphicsPathItem_virtualbase_contains(const void* self, QPointF* point);
bool QGraphicsPathItem_override_virtual_paint(void* self, intptr_t slot);
void QGraphicsPathItem_virtualbase_paint(void* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
bool QGraphicsPathItem_override_virtual_isObscuredBy(void* self, intptr_t slot);
bool QGraphicsPathItem_virtualbase_isObscuredBy(const void* self, QGraphicsItem* item);
bool QGraphicsPathItem_override_virtual_opaqueArea(void* self, intptr_t slot);
QPainterPath* QGraphicsPathItem_virtualbase_opaqueArea(const void* self);
bool QGraphicsPathItem_override_virtual_type(void* self, intptr_t slot);
int QGraphicsPathItem_virtualbase_type(const void* self);
bool QGraphicsPathItem_override_virtual_supportsExtension(void* self, intptr_t slot);
bool QGraphicsPathItem_virtualbase_supportsExtension(const void* self, int extension);
bool QGraphicsPathItem_override_virtual_setExtension(void* self, intptr_t slot);
void QGraphicsPathItem_virtualbase_setExtension(void* self, int extension, QVariant* variant);
bool QGraphicsPathItem_override_virtual_extension(void* self, intptr_t slot);
QVariant* QGraphicsPathItem_virtualbase_extension(const void* self, QVariant* variant);
bool QGraphicsPathItem_override_virtual_advance(void* self, intptr_t slot);
void QGraphicsPathItem_virtualbase_advance(void* self, int phase);
bool QGraphicsPathItem_override_virtual_collidesWithItem(void* self, intptr_t slot);
bool QGraphicsPathItem_virtualbase_collidesWithItem(const void* self, QGraphicsItem* other, int mode);
bool QGraphicsPathItem_override_virtual_collidesWithPath(void* self, intptr_t slot);
bool QGraphicsPathItem_virtualbase_collidesWithPath(const void* self, QPainterPath* path, int mode);
bool QGraphicsPathItem_override_virtual_sceneEventFilter(void* self, intptr_t slot);
bool QGraphicsPathItem_virtualbase_sceneEventFilter(void* self, QGraphicsItem* watched, QEvent* event);
bool QGraphicsPathItem_override_virtual_sceneEvent(void* self, intptr_t slot);
bool QGraphicsPathItem_virtualbase_sceneEvent(void* self, QEvent* event);
bool QGraphicsPathItem_override_virtual_contextMenuEvent(void* self, intptr_t slot);
void QGraphicsPathItem_virtualbase_contextMenuEvent(void* self, QGraphicsSceneContextMenuEvent* event);
bool QGraphicsPathItem_override_virtual_dragEnterEvent(void* self, intptr_t slot);
void QGraphicsPathItem_virtualbase_dragEnterEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsPathItem_override_virtual_dragLeaveEvent(void* self, intptr_t slot);
void QGraphicsPathItem_virtualbase_dragLeaveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsPathItem_override_virtual_dragMoveEvent(void* self, intptr_t slot);
void QGraphicsPathItem_virtualbase_dragMoveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsPathItem_override_virtual_dropEvent(void* self, intptr_t slot);
void QGraphicsPathItem_virtualbase_dropEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsPathItem_override_virtual_focusInEvent(void* self, intptr_t slot);
void QGraphicsPathItem_virtualbase_focusInEvent(void* self, QFocusEvent* event);
bool QGraphicsPathItem_override_virtual_focusOutEvent(void* self, intptr_t slot);
void QGraphicsPathItem_virtualbase_focusOutEvent(void* self, QFocusEvent* event);
bool QGraphicsPathItem_override_virtual_hoverEnterEvent(void* self, intptr_t slot);
void QGraphicsPathItem_virtualbase_hoverEnterEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsPathItem_override_virtual_hoverMoveEvent(void* self, intptr_t slot);
void QGraphicsPathItem_virtualbase_hoverMoveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsPathItem_override_virtual_hoverLeaveEvent(void* self, intptr_t slot);
void QGraphicsPathItem_virtualbase_hoverLeaveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsPathItem_override_virtual_keyPressEvent(void* self, intptr_t slot);
void QGraphicsPathItem_virtualbase_keyPressEvent(void* self, QKeyEvent* event);
bool QGraphicsPathItem_override_virtual_keyReleaseEvent(void* self, intptr_t slot);
void QGraphicsPathItem_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event);
bool QGraphicsPathItem_override_virtual_mousePressEvent(void* self, intptr_t slot);
void QGraphicsPathItem_virtualbase_mousePressEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsPathItem_override_virtual_mouseMoveEvent(void* self, intptr_t slot);
void QGraphicsPathItem_virtualbase_mouseMoveEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsPathItem_override_virtual_mouseReleaseEvent(void* self, intptr_t slot);
void QGraphicsPathItem_virtualbase_mouseReleaseEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsPathItem_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot);
void QGraphicsPathItem_virtualbase_mouseDoubleClickEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsPathItem_override_virtual_wheelEvent(void* self, intptr_t slot);
void QGraphicsPathItem_virtualbase_wheelEvent(void* self, QGraphicsSceneWheelEvent* event);
bool QGraphicsPathItem_override_virtual_inputMethodEvent(void* self, intptr_t slot);
void QGraphicsPathItem_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* event);
bool QGraphicsPathItem_override_virtual_inputMethodQuery(void* self, intptr_t slot);
QVariant* QGraphicsPathItem_virtualbase_inputMethodQuery(const void* self, int query);
bool QGraphicsPathItem_override_virtual_itemChange(void* self, intptr_t slot);
QVariant* QGraphicsPathItem_virtualbase_itemChange(void* self, int change, QVariant* value);
void QGraphicsPathItem_delete(QGraphicsPathItem* self);

QGraphicsRectItem* QGraphicsRectItem_new();
QGraphicsRectItem* QGraphicsRectItem_new2(QRectF* rect);
QGraphicsRectItem* QGraphicsRectItem_new3(double x, double y, double w, double h);
QGraphicsRectItem* QGraphicsRectItem_new4(QGraphicsItem* parent);
QGraphicsRectItem* QGraphicsRectItem_new5(QRectF* rect, QGraphicsItem* parent);
QGraphicsRectItem* QGraphicsRectItem_new6(double x, double y, double w, double h, QGraphicsItem* parent);
void QGraphicsRectItem_virtbase(QGraphicsRectItem* src, QAbstractGraphicsShapeItem** outptr_QAbstractGraphicsShapeItem);
QRectF* QGraphicsRectItem_rect(const QGraphicsRectItem* self);
void QGraphicsRectItem_setRect(QGraphicsRectItem* self, QRectF* rect);
void QGraphicsRectItem_setRect2(QGraphicsRectItem* self, double x, double y, double w, double h);
QRectF* QGraphicsRectItem_boundingRect(const QGraphicsRectItem* self);
QPainterPath* QGraphicsRectItem_shape(const QGraphicsRectItem* self);
bool QGraphicsRectItem_contains(const QGraphicsRectItem* self, QPointF* point);
void QGraphicsRectItem_paint(QGraphicsRectItem* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
bool QGraphicsRectItem_isObscuredBy(const QGraphicsRectItem* self, QGraphicsItem* item);
QPainterPath* QGraphicsRectItem_opaqueArea(const QGraphicsRectItem* self);
int QGraphicsRectItem_type(const QGraphicsRectItem* self);
bool QGraphicsRectItem_supportsExtension(const QGraphicsRectItem* self, int extension);
void QGraphicsRectItem_setExtension(QGraphicsRectItem* self, int extension, QVariant* variant);
QVariant* QGraphicsRectItem_extension(const QGraphicsRectItem* self, QVariant* variant);
bool QGraphicsRectItem_override_virtual_boundingRect(void* self, intptr_t slot);
QRectF* QGraphicsRectItem_virtualbase_boundingRect(const void* self);
bool QGraphicsRectItem_override_virtual_shape(void* self, intptr_t slot);
QPainterPath* QGraphicsRectItem_virtualbase_shape(const void* self);
bool QGraphicsRectItem_override_virtual_contains(void* self, intptr_t slot);
bool QGraphicsRectItem_virtualbase_contains(const void* self, QPointF* point);
bool QGraphicsRectItem_override_virtual_paint(void* self, intptr_t slot);
void QGraphicsRectItem_virtualbase_paint(void* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
bool QGraphicsRectItem_override_virtual_isObscuredBy(void* self, intptr_t slot);
bool QGraphicsRectItem_virtualbase_isObscuredBy(const void* self, QGraphicsItem* item);
bool QGraphicsRectItem_override_virtual_opaqueArea(void* self, intptr_t slot);
QPainterPath* QGraphicsRectItem_virtualbase_opaqueArea(const void* self);
bool QGraphicsRectItem_override_virtual_type(void* self, intptr_t slot);
int QGraphicsRectItem_virtualbase_type(const void* self);
bool QGraphicsRectItem_override_virtual_supportsExtension(void* self, intptr_t slot);
bool QGraphicsRectItem_virtualbase_supportsExtension(const void* self, int extension);
bool QGraphicsRectItem_override_virtual_setExtension(void* self, intptr_t slot);
void QGraphicsRectItem_virtualbase_setExtension(void* self, int extension, QVariant* variant);
bool QGraphicsRectItem_override_virtual_extension(void* self, intptr_t slot);
QVariant* QGraphicsRectItem_virtualbase_extension(const void* self, QVariant* variant);
bool QGraphicsRectItem_override_virtual_advance(void* self, intptr_t slot);
void QGraphicsRectItem_virtualbase_advance(void* self, int phase);
bool QGraphicsRectItem_override_virtual_collidesWithItem(void* self, intptr_t slot);
bool QGraphicsRectItem_virtualbase_collidesWithItem(const void* self, QGraphicsItem* other, int mode);
bool QGraphicsRectItem_override_virtual_collidesWithPath(void* self, intptr_t slot);
bool QGraphicsRectItem_virtualbase_collidesWithPath(const void* self, QPainterPath* path, int mode);
bool QGraphicsRectItem_override_virtual_sceneEventFilter(void* self, intptr_t slot);
bool QGraphicsRectItem_virtualbase_sceneEventFilter(void* self, QGraphicsItem* watched, QEvent* event);
bool QGraphicsRectItem_override_virtual_sceneEvent(void* self, intptr_t slot);
bool QGraphicsRectItem_virtualbase_sceneEvent(void* self, QEvent* event);
bool QGraphicsRectItem_override_virtual_contextMenuEvent(void* self, intptr_t slot);
void QGraphicsRectItem_virtualbase_contextMenuEvent(void* self, QGraphicsSceneContextMenuEvent* event);
bool QGraphicsRectItem_override_virtual_dragEnterEvent(void* self, intptr_t slot);
void QGraphicsRectItem_virtualbase_dragEnterEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsRectItem_override_virtual_dragLeaveEvent(void* self, intptr_t slot);
void QGraphicsRectItem_virtualbase_dragLeaveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsRectItem_override_virtual_dragMoveEvent(void* self, intptr_t slot);
void QGraphicsRectItem_virtualbase_dragMoveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsRectItem_override_virtual_dropEvent(void* self, intptr_t slot);
void QGraphicsRectItem_virtualbase_dropEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsRectItem_override_virtual_focusInEvent(void* self, intptr_t slot);
void QGraphicsRectItem_virtualbase_focusInEvent(void* self, QFocusEvent* event);
bool QGraphicsRectItem_override_virtual_focusOutEvent(void* self, intptr_t slot);
void QGraphicsRectItem_virtualbase_focusOutEvent(void* self, QFocusEvent* event);
bool QGraphicsRectItem_override_virtual_hoverEnterEvent(void* self, intptr_t slot);
void QGraphicsRectItem_virtualbase_hoverEnterEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsRectItem_override_virtual_hoverMoveEvent(void* self, intptr_t slot);
void QGraphicsRectItem_virtualbase_hoverMoveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsRectItem_override_virtual_hoverLeaveEvent(void* self, intptr_t slot);
void QGraphicsRectItem_virtualbase_hoverLeaveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsRectItem_override_virtual_keyPressEvent(void* self, intptr_t slot);
void QGraphicsRectItem_virtualbase_keyPressEvent(void* self, QKeyEvent* event);
bool QGraphicsRectItem_override_virtual_keyReleaseEvent(void* self, intptr_t slot);
void QGraphicsRectItem_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event);
bool QGraphicsRectItem_override_virtual_mousePressEvent(void* self, intptr_t slot);
void QGraphicsRectItem_virtualbase_mousePressEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsRectItem_override_virtual_mouseMoveEvent(void* self, intptr_t slot);
void QGraphicsRectItem_virtualbase_mouseMoveEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsRectItem_override_virtual_mouseReleaseEvent(void* self, intptr_t slot);
void QGraphicsRectItem_virtualbase_mouseReleaseEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsRectItem_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot);
void QGraphicsRectItem_virtualbase_mouseDoubleClickEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsRectItem_override_virtual_wheelEvent(void* self, intptr_t slot);
void QGraphicsRectItem_virtualbase_wheelEvent(void* self, QGraphicsSceneWheelEvent* event);
bool QGraphicsRectItem_override_virtual_inputMethodEvent(void* self, intptr_t slot);
void QGraphicsRectItem_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* event);
bool QGraphicsRectItem_override_virtual_inputMethodQuery(void* self, intptr_t slot);
QVariant* QGraphicsRectItem_virtualbase_inputMethodQuery(const void* self, int query);
bool QGraphicsRectItem_override_virtual_itemChange(void* self, intptr_t slot);
QVariant* QGraphicsRectItem_virtualbase_itemChange(void* self, int change, QVariant* value);
void QGraphicsRectItem_delete(QGraphicsRectItem* self);

QGraphicsEllipseItem* QGraphicsEllipseItem_new();
QGraphicsEllipseItem* QGraphicsEllipseItem_new2(QRectF* rect);
QGraphicsEllipseItem* QGraphicsEllipseItem_new3(double x, double y, double w, double h);
QGraphicsEllipseItem* QGraphicsEllipseItem_new4(QGraphicsItem* parent);
QGraphicsEllipseItem* QGraphicsEllipseItem_new5(QRectF* rect, QGraphicsItem* parent);
QGraphicsEllipseItem* QGraphicsEllipseItem_new6(double x, double y, double w, double h, QGraphicsItem* parent);
void QGraphicsEllipseItem_virtbase(QGraphicsEllipseItem* src, QAbstractGraphicsShapeItem** outptr_QAbstractGraphicsShapeItem);
QRectF* QGraphicsEllipseItem_rect(const QGraphicsEllipseItem* self);
void QGraphicsEllipseItem_setRect(QGraphicsEllipseItem* self, QRectF* rect);
void QGraphicsEllipseItem_setRect2(QGraphicsEllipseItem* self, double x, double y, double w, double h);
int QGraphicsEllipseItem_startAngle(const QGraphicsEllipseItem* self);
void QGraphicsEllipseItem_setStartAngle(QGraphicsEllipseItem* self, int angle);
int QGraphicsEllipseItem_spanAngle(const QGraphicsEllipseItem* self);
void QGraphicsEllipseItem_setSpanAngle(QGraphicsEllipseItem* self, int angle);
QRectF* QGraphicsEllipseItem_boundingRect(const QGraphicsEllipseItem* self);
QPainterPath* QGraphicsEllipseItem_shape(const QGraphicsEllipseItem* self);
bool QGraphicsEllipseItem_contains(const QGraphicsEllipseItem* self, QPointF* point);
void QGraphicsEllipseItem_paint(QGraphicsEllipseItem* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
bool QGraphicsEllipseItem_isObscuredBy(const QGraphicsEllipseItem* self, QGraphicsItem* item);
QPainterPath* QGraphicsEllipseItem_opaqueArea(const QGraphicsEllipseItem* self);
int QGraphicsEllipseItem_type(const QGraphicsEllipseItem* self);
bool QGraphicsEllipseItem_supportsExtension(const QGraphicsEllipseItem* self, int extension);
void QGraphicsEllipseItem_setExtension(QGraphicsEllipseItem* self, int extension, QVariant* variant);
QVariant* QGraphicsEllipseItem_extension(const QGraphicsEllipseItem* self, QVariant* variant);
bool QGraphicsEllipseItem_override_virtual_boundingRect(void* self, intptr_t slot);
QRectF* QGraphicsEllipseItem_virtualbase_boundingRect(const void* self);
bool QGraphicsEllipseItem_override_virtual_shape(void* self, intptr_t slot);
QPainterPath* QGraphicsEllipseItem_virtualbase_shape(const void* self);
bool QGraphicsEllipseItem_override_virtual_contains(void* self, intptr_t slot);
bool QGraphicsEllipseItem_virtualbase_contains(const void* self, QPointF* point);
bool QGraphicsEllipseItem_override_virtual_paint(void* self, intptr_t slot);
void QGraphicsEllipseItem_virtualbase_paint(void* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
bool QGraphicsEllipseItem_override_virtual_isObscuredBy(void* self, intptr_t slot);
bool QGraphicsEllipseItem_virtualbase_isObscuredBy(const void* self, QGraphicsItem* item);
bool QGraphicsEllipseItem_override_virtual_opaqueArea(void* self, intptr_t slot);
QPainterPath* QGraphicsEllipseItem_virtualbase_opaqueArea(const void* self);
bool QGraphicsEllipseItem_override_virtual_type(void* self, intptr_t slot);
int QGraphicsEllipseItem_virtualbase_type(const void* self);
bool QGraphicsEllipseItem_override_virtual_supportsExtension(void* self, intptr_t slot);
bool QGraphicsEllipseItem_virtualbase_supportsExtension(const void* self, int extension);
bool QGraphicsEllipseItem_override_virtual_setExtension(void* self, intptr_t slot);
void QGraphicsEllipseItem_virtualbase_setExtension(void* self, int extension, QVariant* variant);
bool QGraphicsEllipseItem_override_virtual_extension(void* self, intptr_t slot);
QVariant* QGraphicsEllipseItem_virtualbase_extension(const void* self, QVariant* variant);
bool QGraphicsEllipseItem_override_virtual_advance(void* self, intptr_t slot);
void QGraphicsEllipseItem_virtualbase_advance(void* self, int phase);
bool QGraphicsEllipseItem_override_virtual_collidesWithItem(void* self, intptr_t slot);
bool QGraphicsEllipseItem_virtualbase_collidesWithItem(const void* self, QGraphicsItem* other, int mode);
bool QGraphicsEllipseItem_override_virtual_collidesWithPath(void* self, intptr_t slot);
bool QGraphicsEllipseItem_virtualbase_collidesWithPath(const void* self, QPainterPath* path, int mode);
bool QGraphicsEllipseItem_override_virtual_sceneEventFilter(void* self, intptr_t slot);
bool QGraphicsEllipseItem_virtualbase_sceneEventFilter(void* self, QGraphicsItem* watched, QEvent* event);
bool QGraphicsEllipseItem_override_virtual_sceneEvent(void* self, intptr_t slot);
bool QGraphicsEllipseItem_virtualbase_sceneEvent(void* self, QEvent* event);
bool QGraphicsEllipseItem_override_virtual_contextMenuEvent(void* self, intptr_t slot);
void QGraphicsEllipseItem_virtualbase_contextMenuEvent(void* self, QGraphicsSceneContextMenuEvent* event);
bool QGraphicsEllipseItem_override_virtual_dragEnterEvent(void* self, intptr_t slot);
void QGraphicsEllipseItem_virtualbase_dragEnterEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsEllipseItem_override_virtual_dragLeaveEvent(void* self, intptr_t slot);
void QGraphicsEllipseItem_virtualbase_dragLeaveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsEllipseItem_override_virtual_dragMoveEvent(void* self, intptr_t slot);
void QGraphicsEllipseItem_virtualbase_dragMoveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsEllipseItem_override_virtual_dropEvent(void* self, intptr_t slot);
void QGraphicsEllipseItem_virtualbase_dropEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsEllipseItem_override_virtual_focusInEvent(void* self, intptr_t slot);
void QGraphicsEllipseItem_virtualbase_focusInEvent(void* self, QFocusEvent* event);
bool QGraphicsEllipseItem_override_virtual_focusOutEvent(void* self, intptr_t slot);
void QGraphicsEllipseItem_virtualbase_focusOutEvent(void* self, QFocusEvent* event);
bool QGraphicsEllipseItem_override_virtual_hoverEnterEvent(void* self, intptr_t slot);
void QGraphicsEllipseItem_virtualbase_hoverEnterEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsEllipseItem_override_virtual_hoverMoveEvent(void* self, intptr_t slot);
void QGraphicsEllipseItem_virtualbase_hoverMoveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsEllipseItem_override_virtual_hoverLeaveEvent(void* self, intptr_t slot);
void QGraphicsEllipseItem_virtualbase_hoverLeaveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsEllipseItem_override_virtual_keyPressEvent(void* self, intptr_t slot);
void QGraphicsEllipseItem_virtualbase_keyPressEvent(void* self, QKeyEvent* event);
bool QGraphicsEllipseItem_override_virtual_keyReleaseEvent(void* self, intptr_t slot);
void QGraphicsEllipseItem_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event);
bool QGraphicsEllipseItem_override_virtual_mousePressEvent(void* self, intptr_t slot);
void QGraphicsEllipseItem_virtualbase_mousePressEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsEllipseItem_override_virtual_mouseMoveEvent(void* self, intptr_t slot);
void QGraphicsEllipseItem_virtualbase_mouseMoveEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsEllipseItem_override_virtual_mouseReleaseEvent(void* self, intptr_t slot);
void QGraphicsEllipseItem_virtualbase_mouseReleaseEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsEllipseItem_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot);
void QGraphicsEllipseItem_virtualbase_mouseDoubleClickEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsEllipseItem_override_virtual_wheelEvent(void* self, intptr_t slot);
void QGraphicsEllipseItem_virtualbase_wheelEvent(void* self, QGraphicsSceneWheelEvent* event);
bool QGraphicsEllipseItem_override_virtual_inputMethodEvent(void* self, intptr_t slot);
void QGraphicsEllipseItem_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* event);
bool QGraphicsEllipseItem_override_virtual_inputMethodQuery(void* self, intptr_t slot);
QVariant* QGraphicsEllipseItem_virtualbase_inputMethodQuery(const void* self, int query);
bool QGraphicsEllipseItem_override_virtual_itemChange(void* self, intptr_t slot);
QVariant* QGraphicsEllipseItem_virtualbase_itemChange(void* self, int change, QVariant* value);
void QGraphicsEllipseItem_delete(QGraphicsEllipseItem* self);

QGraphicsPolygonItem* QGraphicsPolygonItem_new();
QGraphicsPolygonItem* QGraphicsPolygonItem_new2(QGraphicsItem* parent);
void QGraphicsPolygonItem_virtbase(QGraphicsPolygonItem* src, QAbstractGraphicsShapeItem** outptr_QAbstractGraphicsShapeItem);
int QGraphicsPolygonItem_fillRule(const QGraphicsPolygonItem* self);
void QGraphicsPolygonItem_setFillRule(QGraphicsPolygonItem* self, int rule);
QRectF* QGraphicsPolygonItem_boundingRect(const QGraphicsPolygonItem* self);
QPainterPath* QGraphicsPolygonItem_shape(const QGraphicsPolygonItem* self);
bool QGraphicsPolygonItem_contains(const QGraphicsPolygonItem* self, QPointF* point);
void QGraphicsPolygonItem_paint(QGraphicsPolygonItem* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
bool QGraphicsPolygonItem_isObscuredBy(const QGraphicsPolygonItem* self, QGraphicsItem* item);
QPainterPath* QGraphicsPolygonItem_opaqueArea(const QGraphicsPolygonItem* self);
int QGraphicsPolygonItem_type(const QGraphicsPolygonItem* self);
bool QGraphicsPolygonItem_supportsExtension(const QGraphicsPolygonItem* self, int extension);
void QGraphicsPolygonItem_setExtension(QGraphicsPolygonItem* self, int extension, QVariant* variant);
QVariant* QGraphicsPolygonItem_extension(const QGraphicsPolygonItem* self, QVariant* variant);
bool QGraphicsPolygonItem_override_virtual_boundingRect(void* self, intptr_t slot);
QRectF* QGraphicsPolygonItem_virtualbase_boundingRect(const void* self);
bool QGraphicsPolygonItem_override_virtual_shape(void* self, intptr_t slot);
QPainterPath* QGraphicsPolygonItem_virtualbase_shape(const void* self);
bool QGraphicsPolygonItem_override_virtual_contains(void* self, intptr_t slot);
bool QGraphicsPolygonItem_virtualbase_contains(const void* self, QPointF* point);
bool QGraphicsPolygonItem_override_virtual_paint(void* self, intptr_t slot);
void QGraphicsPolygonItem_virtualbase_paint(void* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
bool QGraphicsPolygonItem_override_virtual_isObscuredBy(void* self, intptr_t slot);
bool QGraphicsPolygonItem_virtualbase_isObscuredBy(const void* self, QGraphicsItem* item);
bool QGraphicsPolygonItem_override_virtual_opaqueArea(void* self, intptr_t slot);
QPainterPath* QGraphicsPolygonItem_virtualbase_opaqueArea(const void* self);
bool QGraphicsPolygonItem_override_virtual_type(void* self, intptr_t slot);
int QGraphicsPolygonItem_virtualbase_type(const void* self);
bool QGraphicsPolygonItem_override_virtual_supportsExtension(void* self, intptr_t slot);
bool QGraphicsPolygonItem_virtualbase_supportsExtension(const void* self, int extension);
bool QGraphicsPolygonItem_override_virtual_setExtension(void* self, intptr_t slot);
void QGraphicsPolygonItem_virtualbase_setExtension(void* self, int extension, QVariant* variant);
bool QGraphicsPolygonItem_override_virtual_extension(void* self, intptr_t slot);
QVariant* QGraphicsPolygonItem_virtualbase_extension(const void* self, QVariant* variant);
bool QGraphicsPolygonItem_override_virtual_advance(void* self, intptr_t slot);
void QGraphicsPolygonItem_virtualbase_advance(void* self, int phase);
bool QGraphicsPolygonItem_override_virtual_collidesWithItem(void* self, intptr_t slot);
bool QGraphicsPolygonItem_virtualbase_collidesWithItem(const void* self, QGraphicsItem* other, int mode);
bool QGraphicsPolygonItem_override_virtual_collidesWithPath(void* self, intptr_t slot);
bool QGraphicsPolygonItem_virtualbase_collidesWithPath(const void* self, QPainterPath* path, int mode);
bool QGraphicsPolygonItem_override_virtual_sceneEventFilter(void* self, intptr_t slot);
bool QGraphicsPolygonItem_virtualbase_sceneEventFilter(void* self, QGraphicsItem* watched, QEvent* event);
bool QGraphicsPolygonItem_override_virtual_sceneEvent(void* self, intptr_t slot);
bool QGraphicsPolygonItem_virtualbase_sceneEvent(void* self, QEvent* event);
bool QGraphicsPolygonItem_override_virtual_contextMenuEvent(void* self, intptr_t slot);
void QGraphicsPolygonItem_virtualbase_contextMenuEvent(void* self, QGraphicsSceneContextMenuEvent* event);
bool QGraphicsPolygonItem_override_virtual_dragEnterEvent(void* self, intptr_t slot);
void QGraphicsPolygonItem_virtualbase_dragEnterEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsPolygonItem_override_virtual_dragLeaveEvent(void* self, intptr_t slot);
void QGraphicsPolygonItem_virtualbase_dragLeaveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsPolygonItem_override_virtual_dragMoveEvent(void* self, intptr_t slot);
void QGraphicsPolygonItem_virtualbase_dragMoveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsPolygonItem_override_virtual_dropEvent(void* self, intptr_t slot);
void QGraphicsPolygonItem_virtualbase_dropEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsPolygonItem_override_virtual_focusInEvent(void* self, intptr_t slot);
void QGraphicsPolygonItem_virtualbase_focusInEvent(void* self, QFocusEvent* event);
bool QGraphicsPolygonItem_override_virtual_focusOutEvent(void* self, intptr_t slot);
void QGraphicsPolygonItem_virtualbase_focusOutEvent(void* self, QFocusEvent* event);
bool QGraphicsPolygonItem_override_virtual_hoverEnterEvent(void* self, intptr_t slot);
void QGraphicsPolygonItem_virtualbase_hoverEnterEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsPolygonItem_override_virtual_hoverMoveEvent(void* self, intptr_t slot);
void QGraphicsPolygonItem_virtualbase_hoverMoveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsPolygonItem_override_virtual_hoverLeaveEvent(void* self, intptr_t slot);
void QGraphicsPolygonItem_virtualbase_hoverLeaveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsPolygonItem_override_virtual_keyPressEvent(void* self, intptr_t slot);
void QGraphicsPolygonItem_virtualbase_keyPressEvent(void* self, QKeyEvent* event);
bool QGraphicsPolygonItem_override_virtual_keyReleaseEvent(void* self, intptr_t slot);
void QGraphicsPolygonItem_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event);
bool QGraphicsPolygonItem_override_virtual_mousePressEvent(void* self, intptr_t slot);
void QGraphicsPolygonItem_virtualbase_mousePressEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsPolygonItem_override_virtual_mouseMoveEvent(void* self, intptr_t slot);
void QGraphicsPolygonItem_virtualbase_mouseMoveEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsPolygonItem_override_virtual_mouseReleaseEvent(void* self, intptr_t slot);
void QGraphicsPolygonItem_virtualbase_mouseReleaseEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsPolygonItem_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot);
void QGraphicsPolygonItem_virtualbase_mouseDoubleClickEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsPolygonItem_override_virtual_wheelEvent(void* self, intptr_t slot);
void QGraphicsPolygonItem_virtualbase_wheelEvent(void* self, QGraphicsSceneWheelEvent* event);
bool QGraphicsPolygonItem_override_virtual_inputMethodEvent(void* self, intptr_t slot);
void QGraphicsPolygonItem_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* event);
bool QGraphicsPolygonItem_override_virtual_inputMethodQuery(void* self, intptr_t slot);
QVariant* QGraphicsPolygonItem_virtualbase_inputMethodQuery(const void* self, int query);
bool QGraphicsPolygonItem_override_virtual_itemChange(void* self, intptr_t slot);
QVariant* QGraphicsPolygonItem_virtualbase_itemChange(void* self, int change, QVariant* value);
void QGraphicsPolygonItem_delete(QGraphicsPolygonItem* self);

QGraphicsLineItem* QGraphicsLineItem_new();
QGraphicsLineItem* QGraphicsLineItem_new2(QLineF* line);
QGraphicsLineItem* QGraphicsLineItem_new3(double x1, double y1, double x2, double y2);
QGraphicsLineItem* QGraphicsLineItem_new4(QGraphicsItem* parent);
QGraphicsLineItem* QGraphicsLineItem_new5(QLineF* line, QGraphicsItem* parent);
QGraphicsLineItem* QGraphicsLineItem_new6(double x1, double y1, double x2, double y2, QGraphicsItem* parent);
void QGraphicsLineItem_virtbase(QGraphicsLineItem* src, QGraphicsItem** outptr_QGraphicsItem);
QPen* QGraphicsLineItem_pen(const QGraphicsLineItem* self);
void QGraphicsLineItem_setPen(QGraphicsLineItem* self, QPen* pen);
QLineF* QGraphicsLineItem_line(const QGraphicsLineItem* self);
void QGraphicsLineItem_setLine(QGraphicsLineItem* self, QLineF* line);
void QGraphicsLineItem_setLine2(QGraphicsLineItem* self, double x1, double y1, double x2, double y2);
QRectF* QGraphicsLineItem_boundingRect(const QGraphicsLineItem* self);
QPainterPath* QGraphicsLineItem_shape(const QGraphicsLineItem* self);
bool QGraphicsLineItem_contains(const QGraphicsLineItem* self, QPointF* point);
void QGraphicsLineItem_paint(QGraphicsLineItem* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
bool QGraphicsLineItem_isObscuredBy(const QGraphicsLineItem* self, QGraphicsItem* item);
QPainterPath* QGraphicsLineItem_opaqueArea(const QGraphicsLineItem* self);
int QGraphicsLineItem_type(const QGraphicsLineItem* self);
bool QGraphicsLineItem_supportsExtension(const QGraphicsLineItem* self, int extension);
void QGraphicsLineItem_setExtension(QGraphicsLineItem* self, int extension, QVariant* variant);
QVariant* QGraphicsLineItem_extension(const QGraphicsLineItem* self, QVariant* variant);
bool QGraphicsLineItem_override_virtual_boundingRect(void* self, intptr_t slot);
QRectF* QGraphicsLineItem_virtualbase_boundingRect(const void* self);
bool QGraphicsLineItem_override_virtual_shape(void* self, intptr_t slot);
QPainterPath* QGraphicsLineItem_virtualbase_shape(const void* self);
bool QGraphicsLineItem_override_virtual_contains(void* self, intptr_t slot);
bool QGraphicsLineItem_virtualbase_contains(const void* self, QPointF* point);
bool QGraphicsLineItem_override_virtual_paint(void* self, intptr_t slot);
void QGraphicsLineItem_virtualbase_paint(void* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
bool QGraphicsLineItem_override_virtual_isObscuredBy(void* self, intptr_t slot);
bool QGraphicsLineItem_virtualbase_isObscuredBy(const void* self, QGraphicsItem* item);
bool QGraphicsLineItem_override_virtual_opaqueArea(void* self, intptr_t slot);
QPainterPath* QGraphicsLineItem_virtualbase_opaqueArea(const void* self);
bool QGraphicsLineItem_override_virtual_type(void* self, intptr_t slot);
int QGraphicsLineItem_virtualbase_type(const void* self);
bool QGraphicsLineItem_override_virtual_supportsExtension(void* self, intptr_t slot);
bool QGraphicsLineItem_virtualbase_supportsExtension(const void* self, int extension);
bool QGraphicsLineItem_override_virtual_setExtension(void* self, intptr_t slot);
void QGraphicsLineItem_virtualbase_setExtension(void* self, int extension, QVariant* variant);
bool QGraphicsLineItem_override_virtual_extension(void* self, intptr_t slot);
QVariant* QGraphicsLineItem_virtualbase_extension(const void* self, QVariant* variant);
bool QGraphicsLineItem_override_virtual_advance(void* self, intptr_t slot);
void QGraphicsLineItem_virtualbase_advance(void* self, int phase);
bool QGraphicsLineItem_override_virtual_collidesWithItem(void* self, intptr_t slot);
bool QGraphicsLineItem_virtualbase_collidesWithItem(const void* self, QGraphicsItem* other, int mode);
bool QGraphicsLineItem_override_virtual_collidesWithPath(void* self, intptr_t slot);
bool QGraphicsLineItem_virtualbase_collidesWithPath(const void* self, QPainterPath* path, int mode);
bool QGraphicsLineItem_override_virtual_sceneEventFilter(void* self, intptr_t slot);
bool QGraphicsLineItem_virtualbase_sceneEventFilter(void* self, QGraphicsItem* watched, QEvent* event);
bool QGraphicsLineItem_override_virtual_sceneEvent(void* self, intptr_t slot);
bool QGraphicsLineItem_virtualbase_sceneEvent(void* self, QEvent* event);
bool QGraphicsLineItem_override_virtual_contextMenuEvent(void* self, intptr_t slot);
void QGraphicsLineItem_virtualbase_contextMenuEvent(void* self, QGraphicsSceneContextMenuEvent* event);
bool QGraphicsLineItem_override_virtual_dragEnterEvent(void* self, intptr_t slot);
void QGraphicsLineItem_virtualbase_dragEnterEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsLineItem_override_virtual_dragLeaveEvent(void* self, intptr_t slot);
void QGraphicsLineItem_virtualbase_dragLeaveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsLineItem_override_virtual_dragMoveEvent(void* self, intptr_t slot);
void QGraphicsLineItem_virtualbase_dragMoveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsLineItem_override_virtual_dropEvent(void* self, intptr_t slot);
void QGraphicsLineItem_virtualbase_dropEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsLineItem_override_virtual_focusInEvent(void* self, intptr_t slot);
void QGraphicsLineItem_virtualbase_focusInEvent(void* self, QFocusEvent* event);
bool QGraphicsLineItem_override_virtual_focusOutEvent(void* self, intptr_t slot);
void QGraphicsLineItem_virtualbase_focusOutEvent(void* self, QFocusEvent* event);
bool QGraphicsLineItem_override_virtual_hoverEnterEvent(void* self, intptr_t slot);
void QGraphicsLineItem_virtualbase_hoverEnterEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsLineItem_override_virtual_hoverMoveEvent(void* self, intptr_t slot);
void QGraphicsLineItem_virtualbase_hoverMoveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsLineItem_override_virtual_hoverLeaveEvent(void* self, intptr_t slot);
void QGraphicsLineItem_virtualbase_hoverLeaveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsLineItem_override_virtual_keyPressEvent(void* self, intptr_t slot);
void QGraphicsLineItem_virtualbase_keyPressEvent(void* self, QKeyEvent* event);
bool QGraphicsLineItem_override_virtual_keyReleaseEvent(void* self, intptr_t slot);
void QGraphicsLineItem_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event);
bool QGraphicsLineItem_override_virtual_mousePressEvent(void* self, intptr_t slot);
void QGraphicsLineItem_virtualbase_mousePressEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsLineItem_override_virtual_mouseMoveEvent(void* self, intptr_t slot);
void QGraphicsLineItem_virtualbase_mouseMoveEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsLineItem_override_virtual_mouseReleaseEvent(void* self, intptr_t slot);
void QGraphicsLineItem_virtualbase_mouseReleaseEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsLineItem_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot);
void QGraphicsLineItem_virtualbase_mouseDoubleClickEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsLineItem_override_virtual_wheelEvent(void* self, intptr_t slot);
void QGraphicsLineItem_virtualbase_wheelEvent(void* self, QGraphicsSceneWheelEvent* event);
bool QGraphicsLineItem_override_virtual_inputMethodEvent(void* self, intptr_t slot);
void QGraphicsLineItem_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* event);
bool QGraphicsLineItem_override_virtual_inputMethodQuery(void* self, intptr_t slot);
QVariant* QGraphicsLineItem_virtualbase_inputMethodQuery(const void* self, int query);
bool QGraphicsLineItem_override_virtual_itemChange(void* self, intptr_t slot);
QVariant* QGraphicsLineItem_virtualbase_itemChange(void* self, int change, QVariant* value);
void QGraphicsLineItem_delete(QGraphicsLineItem* self);

QGraphicsPixmapItem* QGraphicsPixmapItem_new();
QGraphicsPixmapItem* QGraphicsPixmapItem_new2(QPixmap* pixmap);
QGraphicsPixmapItem* QGraphicsPixmapItem_new3(QGraphicsItem* parent);
QGraphicsPixmapItem* QGraphicsPixmapItem_new4(QPixmap* pixmap, QGraphicsItem* parent);
void QGraphicsPixmapItem_virtbase(QGraphicsPixmapItem* src, QGraphicsItem** outptr_QGraphicsItem);
QPixmap* QGraphicsPixmapItem_pixmap(const QGraphicsPixmapItem* self);
void QGraphicsPixmapItem_setPixmap(QGraphicsPixmapItem* self, QPixmap* pixmap);
int QGraphicsPixmapItem_transformationMode(const QGraphicsPixmapItem* self);
void QGraphicsPixmapItem_setTransformationMode(QGraphicsPixmapItem* self, int mode);
QPointF* QGraphicsPixmapItem_offset(const QGraphicsPixmapItem* self);
void QGraphicsPixmapItem_setOffset(QGraphicsPixmapItem* self, QPointF* offset);
void QGraphicsPixmapItem_setOffset2(QGraphicsPixmapItem* self, double x, double y);
QRectF* QGraphicsPixmapItem_boundingRect(const QGraphicsPixmapItem* self);
QPainterPath* QGraphicsPixmapItem_shape(const QGraphicsPixmapItem* self);
bool QGraphicsPixmapItem_contains(const QGraphicsPixmapItem* self, QPointF* point);
void QGraphicsPixmapItem_paint(QGraphicsPixmapItem* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
bool QGraphicsPixmapItem_isObscuredBy(const QGraphicsPixmapItem* self, QGraphicsItem* item);
QPainterPath* QGraphicsPixmapItem_opaqueArea(const QGraphicsPixmapItem* self);
int QGraphicsPixmapItem_type(const QGraphicsPixmapItem* self);
int QGraphicsPixmapItem_shapeMode(const QGraphicsPixmapItem* self);
void QGraphicsPixmapItem_setShapeMode(QGraphicsPixmapItem* self, int mode);
bool QGraphicsPixmapItem_supportsExtension(const QGraphicsPixmapItem* self, int extension);
void QGraphicsPixmapItem_setExtension(QGraphicsPixmapItem* self, int extension, QVariant* variant);
QVariant* QGraphicsPixmapItem_extension(const QGraphicsPixmapItem* self, QVariant* variant);
bool QGraphicsPixmapItem_override_virtual_boundingRect(void* self, intptr_t slot);
QRectF* QGraphicsPixmapItem_virtualbase_boundingRect(const void* self);
bool QGraphicsPixmapItem_override_virtual_shape(void* self, intptr_t slot);
QPainterPath* QGraphicsPixmapItem_virtualbase_shape(const void* self);
bool QGraphicsPixmapItem_override_virtual_contains(void* self, intptr_t slot);
bool QGraphicsPixmapItem_virtualbase_contains(const void* self, QPointF* point);
bool QGraphicsPixmapItem_override_virtual_paint(void* self, intptr_t slot);
void QGraphicsPixmapItem_virtualbase_paint(void* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
bool QGraphicsPixmapItem_override_virtual_isObscuredBy(void* self, intptr_t slot);
bool QGraphicsPixmapItem_virtualbase_isObscuredBy(const void* self, QGraphicsItem* item);
bool QGraphicsPixmapItem_override_virtual_opaqueArea(void* self, intptr_t slot);
QPainterPath* QGraphicsPixmapItem_virtualbase_opaqueArea(const void* self);
bool QGraphicsPixmapItem_override_virtual_type(void* self, intptr_t slot);
int QGraphicsPixmapItem_virtualbase_type(const void* self);
bool QGraphicsPixmapItem_override_virtual_supportsExtension(void* self, intptr_t slot);
bool QGraphicsPixmapItem_virtualbase_supportsExtension(const void* self, int extension);
bool QGraphicsPixmapItem_override_virtual_setExtension(void* self, intptr_t slot);
void QGraphicsPixmapItem_virtualbase_setExtension(void* self, int extension, QVariant* variant);
bool QGraphicsPixmapItem_override_virtual_extension(void* self, intptr_t slot);
QVariant* QGraphicsPixmapItem_virtualbase_extension(const void* self, QVariant* variant);
bool QGraphicsPixmapItem_override_virtual_advance(void* self, intptr_t slot);
void QGraphicsPixmapItem_virtualbase_advance(void* self, int phase);
bool QGraphicsPixmapItem_override_virtual_collidesWithItem(void* self, intptr_t slot);
bool QGraphicsPixmapItem_virtualbase_collidesWithItem(const void* self, QGraphicsItem* other, int mode);
bool QGraphicsPixmapItem_override_virtual_collidesWithPath(void* self, intptr_t slot);
bool QGraphicsPixmapItem_virtualbase_collidesWithPath(const void* self, QPainterPath* path, int mode);
bool QGraphicsPixmapItem_override_virtual_sceneEventFilter(void* self, intptr_t slot);
bool QGraphicsPixmapItem_virtualbase_sceneEventFilter(void* self, QGraphicsItem* watched, QEvent* event);
bool QGraphicsPixmapItem_override_virtual_sceneEvent(void* self, intptr_t slot);
bool QGraphicsPixmapItem_virtualbase_sceneEvent(void* self, QEvent* event);
bool QGraphicsPixmapItem_override_virtual_contextMenuEvent(void* self, intptr_t slot);
void QGraphicsPixmapItem_virtualbase_contextMenuEvent(void* self, QGraphicsSceneContextMenuEvent* event);
bool QGraphicsPixmapItem_override_virtual_dragEnterEvent(void* self, intptr_t slot);
void QGraphicsPixmapItem_virtualbase_dragEnterEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsPixmapItem_override_virtual_dragLeaveEvent(void* self, intptr_t slot);
void QGraphicsPixmapItem_virtualbase_dragLeaveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsPixmapItem_override_virtual_dragMoveEvent(void* self, intptr_t slot);
void QGraphicsPixmapItem_virtualbase_dragMoveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsPixmapItem_override_virtual_dropEvent(void* self, intptr_t slot);
void QGraphicsPixmapItem_virtualbase_dropEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsPixmapItem_override_virtual_focusInEvent(void* self, intptr_t slot);
void QGraphicsPixmapItem_virtualbase_focusInEvent(void* self, QFocusEvent* event);
bool QGraphicsPixmapItem_override_virtual_focusOutEvent(void* self, intptr_t slot);
void QGraphicsPixmapItem_virtualbase_focusOutEvent(void* self, QFocusEvent* event);
bool QGraphicsPixmapItem_override_virtual_hoverEnterEvent(void* self, intptr_t slot);
void QGraphicsPixmapItem_virtualbase_hoverEnterEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsPixmapItem_override_virtual_hoverMoveEvent(void* self, intptr_t slot);
void QGraphicsPixmapItem_virtualbase_hoverMoveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsPixmapItem_override_virtual_hoverLeaveEvent(void* self, intptr_t slot);
void QGraphicsPixmapItem_virtualbase_hoverLeaveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsPixmapItem_override_virtual_keyPressEvent(void* self, intptr_t slot);
void QGraphicsPixmapItem_virtualbase_keyPressEvent(void* self, QKeyEvent* event);
bool QGraphicsPixmapItem_override_virtual_keyReleaseEvent(void* self, intptr_t slot);
void QGraphicsPixmapItem_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event);
bool QGraphicsPixmapItem_override_virtual_mousePressEvent(void* self, intptr_t slot);
void QGraphicsPixmapItem_virtualbase_mousePressEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsPixmapItem_override_virtual_mouseMoveEvent(void* self, intptr_t slot);
void QGraphicsPixmapItem_virtualbase_mouseMoveEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsPixmapItem_override_virtual_mouseReleaseEvent(void* self, intptr_t slot);
void QGraphicsPixmapItem_virtualbase_mouseReleaseEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsPixmapItem_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot);
void QGraphicsPixmapItem_virtualbase_mouseDoubleClickEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsPixmapItem_override_virtual_wheelEvent(void* self, intptr_t slot);
void QGraphicsPixmapItem_virtualbase_wheelEvent(void* self, QGraphicsSceneWheelEvent* event);
bool QGraphicsPixmapItem_override_virtual_inputMethodEvent(void* self, intptr_t slot);
void QGraphicsPixmapItem_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* event);
bool QGraphicsPixmapItem_override_virtual_inputMethodQuery(void* self, intptr_t slot);
QVariant* QGraphicsPixmapItem_virtualbase_inputMethodQuery(const void* self, int query);
bool QGraphicsPixmapItem_override_virtual_itemChange(void* self, intptr_t slot);
QVariant* QGraphicsPixmapItem_virtualbase_itemChange(void* self, int change, QVariant* value);
void QGraphicsPixmapItem_delete(QGraphicsPixmapItem* self);

QGraphicsTextItem* QGraphicsTextItem_new();
QGraphicsTextItem* QGraphicsTextItem_new2(struct miqt_string text);
QGraphicsTextItem* QGraphicsTextItem_new3(QGraphicsItem* parent);
QGraphicsTextItem* QGraphicsTextItem_new4(struct miqt_string text, QGraphicsItem* parent);
void QGraphicsTextItem_virtbase(QGraphicsTextItem* src, QGraphicsObject** outptr_QGraphicsObject);
QMetaObject* QGraphicsTextItem_metaObject(const QGraphicsTextItem* self);
void* QGraphicsTextItem_metacast(QGraphicsTextItem* self, const char* param1);
struct miqt_string QGraphicsTextItem_tr(const char* s);
struct miqt_string QGraphicsTextItem_trUtf8(const char* s);
struct miqt_string QGraphicsTextItem_toHtml(const QGraphicsTextItem* self);
void QGraphicsTextItem_setHtml(QGraphicsTextItem* self, struct miqt_string html);
struct miqt_string QGraphicsTextItem_toPlainText(const QGraphicsTextItem* self);
void QGraphicsTextItem_setPlainText(QGraphicsTextItem* self, struct miqt_string text);
QFont* QGraphicsTextItem_font(const QGraphicsTextItem* self);
void QGraphicsTextItem_setFont(QGraphicsTextItem* self, QFont* font);
void QGraphicsTextItem_setDefaultTextColor(QGraphicsTextItem* self, QColor* c);
QColor* QGraphicsTextItem_defaultTextColor(const QGraphicsTextItem* self);
QRectF* QGraphicsTextItem_boundingRect(const QGraphicsTextItem* self);
QPainterPath* QGraphicsTextItem_shape(const QGraphicsTextItem* self);
bool QGraphicsTextItem_contains(const QGraphicsTextItem* self, QPointF* point);
void QGraphicsTextItem_paint(QGraphicsTextItem* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
bool QGraphicsTextItem_isObscuredBy(const QGraphicsTextItem* self, QGraphicsItem* item);
QPainterPath* QGraphicsTextItem_opaqueArea(const QGraphicsTextItem* self);
int QGraphicsTextItem_type(const QGraphicsTextItem* self);
void QGraphicsTextItem_setTextWidth(QGraphicsTextItem* self, double width);
double QGraphicsTextItem_textWidth(const QGraphicsTextItem* self);
void QGraphicsTextItem_adjustSize(QGraphicsTextItem* self);
void QGraphicsTextItem_setDocument(QGraphicsTextItem* self, QTextDocument* document);
QTextDocument* QGraphicsTextItem_document(const QGraphicsTextItem* self);
void QGraphicsTextItem_setTextInteractionFlags(QGraphicsTextItem* self, int flags);
int QGraphicsTextItem_textInteractionFlags(const QGraphicsTextItem* self);
void QGraphicsTextItem_setTabChangesFocus(QGraphicsTextItem* self, bool b);
bool QGraphicsTextItem_tabChangesFocus(const QGraphicsTextItem* self);
void QGraphicsTextItem_setOpenExternalLinks(QGraphicsTextItem* self, bool open);
bool QGraphicsTextItem_openExternalLinks(const QGraphicsTextItem* self);
void QGraphicsTextItem_setTextCursor(QGraphicsTextItem* self, QTextCursor* cursor);
QTextCursor* QGraphicsTextItem_textCursor(const QGraphicsTextItem* self);
void QGraphicsTextItem_linkActivated(QGraphicsTextItem* self, struct miqt_string param1);
void QGraphicsTextItem_connect_linkActivated(QGraphicsTextItem* self, intptr_t slot);
void QGraphicsTextItem_linkHovered(QGraphicsTextItem* self, struct miqt_string param1);
void QGraphicsTextItem_connect_linkHovered(QGraphicsTextItem* self, intptr_t slot);
bool QGraphicsTextItem_sceneEvent(QGraphicsTextItem* self, QEvent* event);
void QGraphicsTextItem_mousePressEvent(QGraphicsTextItem* self, QGraphicsSceneMouseEvent* event);
void QGraphicsTextItem_mouseMoveEvent(QGraphicsTextItem* self, QGraphicsSceneMouseEvent* event);
void QGraphicsTextItem_mouseReleaseEvent(QGraphicsTextItem* self, QGraphicsSceneMouseEvent* event);
void QGraphicsTextItem_mouseDoubleClickEvent(QGraphicsTextItem* self, QGraphicsSceneMouseEvent* event);
void QGraphicsTextItem_contextMenuEvent(QGraphicsTextItem* self, QGraphicsSceneContextMenuEvent* event);
void QGraphicsTextItem_keyPressEvent(QGraphicsTextItem* self, QKeyEvent* event);
void QGraphicsTextItem_keyReleaseEvent(QGraphicsTextItem* self, QKeyEvent* event);
void QGraphicsTextItem_focusInEvent(QGraphicsTextItem* self, QFocusEvent* event);
void QGraphicsTextItem_focusOutEvent(QGraphicsTextItem* self, QFocusEvent* event);
void QGraphicsTextItem_dragEnterEvent(QGraphicsTextItem* self, QGraphicsSceneDragDropEvent* event);
void QGraphicsTextItem_dragLeaveEvent(QGraphicsTextItem* self, QGraphicsSceneDragDropEvent* event);
void QGraphicsTextItem_dragMoveEvent(QGraphicsTextItem* self, QGraphicsSceneDragDropEvent* event);
void QGraphicsTextItem_dropEvent(QGraphicsTextItem* self, QGraphicsSceneDragDropEvent* event);
void QGraphicsTextItem_inputMethodEvent(QGraphicsTextItem* self, QInputMethodEvent* event);
void QGraphicsTextItem_hoverEnterEvent(QGraphicsTextItem* self, QGraphicsSceneHoverEvent* event);
void QGraphicsTextItem_hoverMoveEvent(QGraphicsTextItem* self, QGraphicsSceneHoverEvent* event);
void QGraphicsTextItem_hoverLeaveEvent(QGraphicsTextItem* self, QGraphicsSceneHoverEvent* event);
QVariant* QGraphicsTextItem_inputMethodQuery(const QGraphicsTextItem* self, int query);
bool QGraphicsTextItem_supportsExtension(const QGraphicsTextItem* self, int extension);
void QGraphicsTextItem_setExtension(QGraphicsTextItem* self, int extension, QVariant* variant);
QVariant* QGraphicsTextItem_extension(const QGraphicsTextItem* self, QVariant* variant);
struct miqt_string QGraphicsTextItem_tr2(const char* s, const char* c);
struct miqt_string QGraphicsTextItem_tr3(const char* s, const char* c, int n);
struct miqt_string QGraphicsTextItem_trUtf82(const char* s, const char* c);
struct miqt_string QGraphicsTextItem_trUtf83(const char* s, const char* c, int n);
bool QGraphicsTextItem_override_virtual_boundingRect(void* self, intptr_t slot);
QRectF* QGraphicsTextItem_virtualbase_boundingRect(const void* self);
bool QGraphicsTextItem_override_virtual_shape(void* self, intptr_t slot);
QPainterPath* QGraphicsTextItem_virtualbase_shape(const void* self);
bool QGraphicsTextItem_override_virtual_contains(void* self, intptr_t slot);
bool QGraphicsTextItem_virtualbase_contains(const void* self, QPointF* point);
bool QGraphicsTextItem_override_virtual_paint(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_paint(void* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
bool QGraphicsTextItem_override_virtual_isObscuredBy(void* self, intptr_t slot);
bool QGraphicsTextItem_virtualbase_isObscuredBy(const void* self, QGraphicsItem* item);
bool QGraphicsTextItem_override_virtual_opaqueArea(void* self, intptr_t slot);
QPainterPath* QGraphicsTextItem_virtualbase_opaqueArea(const void* self);
bool QGraphicsTextItem_override_virtual_type(void* self, intptr_t slot);
int QGraphicsTextItem_virtualbase_type(const void* self);
bool QGraphicsTextItem_override_virtual_sceneEvent(void* self, intptr_t slot);
bool QGraphicsTextItem_virtualbase_sceneEvent(void* self, QEvent* event);
bool QGraphicsTextItem_override_virtual_mousePressEvent(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_mousePressEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsTextItem_override_virtual_mouseMoveEvent(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_mouseMoveEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsTextItem_override_virtual_mouseReleaseEvent(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_mouseReleaseEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsTextItem_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_mouseDoubleClickEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsTextItem_override_virtual_contextMenuEvent(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_contextMenuEvent(void* self, QGraphicsSceneContextMenuEvent* event);
bool QGraphicsTextItem_override_virtual_keyPressEvent(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_keyPressEvent(void* self, QKeyEvent* event);
bool QGraphicsTextItem_override_virtual_keyReleaseEvent(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event);
bool QGraphicsTextItem_override_virtual_focusInEvent(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_focusInEvent(void* self, QFocusEvent* event);
bool QGraphicsTextItem_override_virtual_focusOutEvent(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_focusOutEvent(void* self, QFocusEvent* event);
bool QGraphicsTextItem_override_virtual_dragEnterEvent(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_dragEnterEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsTextItem_override_virtual_dragLeaveEvent(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_dragLeaveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsTextItem_override_virtual_dragMoveEvent(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_dragMoveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsTextItem_override_virtual_dropEvent(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_dropEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsTextItem_override_virtual_inputMethodEvent(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* event);
bool QGraphicsTextItem_override_virtual_hoverEnterEvent(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_hoverEnterEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsTextItem_override_virtual_hoverMoveEvent(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_hoverMoveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsTextItem_override_virtual_hoverLeaveEvent(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_hoverLeaveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsTextItem_override_virtual_inputMethodQuery(void* self, intptr_t slot);
QVariant* QGraphicsTextItem_virtualbase_inputMethodQuery(const void* self, int query);
bool QGraphicsTextItem_override_virtual_supportsExtension(void* self, intptr_t slot);
bool QGraphicsTextItem_virtualbase_supportsExtension(const void* self, int extension);
bool QGraphicsTextItem_override_virtual_setExtension(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_setExtension(void* self, int extension, QVariant* variant);
bool QGraphicsTextItem_override_virtual_extension(void* self, intptr_t slot);
QVariant* QGraphicsTextItem_virtualbase_extension(const void* self, QVariant* variant);
bool QGraphicsTextItem_override_virtual_event(void* self, intptr_t slot);
bool QGraphicsTextItem_virtualbase_event(void* self, QEvent* ev);
bool QGraphicsTextItem_override_virtual_eventFilter(void* self, intptr_t slot);
bool QGraphicsTextItem_virtualbase_eventFilter(void* self, QObject* watched, QEvent* event);
bool QGraphicsTextItem_override_virtual_timerEvent(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_timerEvent(void* self, QTimerEvent* event);
bool QGraphicsTextItem_override_virtual_childEvent(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_childEvent(void* self, QChildEvent* event);
bool QGraphicsTextItem_override_virtual_customEvent(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_customEvent(void* self, QEvent* event);
bool QGraphicsTextItem_override_virtual_connectNotify(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_connectNotify(void* self, QMetaMethod* signal);
bool QGraphicsTextItem_override_virtual_disconnectNotify(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_disconnectNotify(void* self, QMetaMethod* signal);
bool QGraphicsTextItem_override_virtual_advance(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_advance(void* self, int phase);
bool QGraphicsTextItem_override_virtual_collidesWithItem(void* self, intptr_t slot);
bool QGraphicsTextItem_virtualbase_collidesWithItem(const void* self, QGraphicsItem* other, int mode);
bool QGraphicsTextItem_override_virtual_collidesWithPath(void* self, intptr_t slot);
bool QGraphicsTextItem_virtualbase_collidesWithPath(const void* self, QPainterPath* path, int mode);
bool QGraphicsTextItem_override_virtual_sceneEventFilter(void* self, intptr_t slot);
bool QGraphicsTextItem_virtualbase_sceneEventFilter(void* self, QGraphicsItem* watched, QEvent* event);
bool QGraphicsTextItem_override_virtual_wheelEvent(void* self, intptr_t slot);
void QGraphicsTextItem_virtualbase_wheelEvent(void* self, QGraphicsSceneWheelEvent* event);
bool QGraphicsTextItem_override_virtual_itemChange(void* self, intptr_t slot);
QVariant* QGraphicsTextItem_virtualbase_itemChange(void* self, int change, QVariant* value);
void QGraphicsTextItem_delete(QGraphicsTextItem* self);

QGraphicsSimpleTextItem* QGraphicsSimpleTextItem_new();
QGraphicsSimpleTextItem* QGraphicsSimpleTextItem_new2(struct miqt_string text);
QGraphicsSimpleTextItem* QGraphicsSimpleTextItem_new3(QGraphicsItem* parent);
QGraphicsSimpleTextItem* QGraphicsSimpleTextItem_new4(struct miqt_string text, QGraphicsItem* parent);
void QGraphicsSimpleTextItem_virtbase(QGraphicsSimpleTextItem* src, QAbstractGraphicsShapeItem** outptr_QAbstractGraphicsShapeItem);
void QGraphicsSimpleTextItem_setText(QGraphicsSimpleTextItem* self, struct miqt_string text);
struct miqt_string QGraphicsSimpleTextItem_text(const QGraphicsSimpleTextItem* self);
void QGraphicsSimpleTextItem_setFont(QGraphicsSimpleTextItem* self, QFont* font);
QFont* QGraphicsSimpleTextItem_font(const QGraphicsSimpleTextItem* self);
QRectF* QGraphicsSimpleTextItem_boundingRect(const QGraphicsSimpleTextItem* self);
QPainterPath* QGraphicsSimpleTextItem_shape(const QGraphicsSimpleTextItem* self);
bool QGraphicsSimpleTextItem_contains(const QGraphicsSimpleTextItem* self, QPointF* point);
void QGraphicsSimpleTextItem_paint(QGraphicsSimpleTextItem* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
bool QGraphicsSimpleTextItem_isObscuredBy(const QGraphicsSimpleTextItem* self, QGraphicsItem* item);
QPainterPath* QGraphicsSimpleTextItem_opaqueArea(const QGraphicsSimpleTextItem* self);
int QGraphicsSimpleTextItem_type(const QGraphicsSimpleTextItem* self);
bool QGraphicsSimpleTextItem_supportsExtension(const QGraphicsSimpleTextItem* self, int extension);
void QGraphicsSimpleTextItem_setExtension(QGraphicsSimpleTextItem* self, int extension, QVariant* variant);
QVariant* QGraphicsSimpleTextItem_extension(const QGraphicsSimpleTextItem* self, QVariant* variant);
bool QGraphicsSimpleTextItem_override_virtual_boundingRect(void* self, intptr_t slot);
QRectF* QGraphicsSimpleTextItem_virtualbase_boundingRect(const void* self);
bool QGraphicsSimpleTextItem_override_virtual_shape(void* self, intptr_t slot);
QPainterPath* QGraphicsSimpleTextItem_virtualbase_shape(const void* self);
bool QGraphicsSimpleTextItem_override_virtual_contains(void* self, intptr_t slot);
bool QGraphicsSimpleTextItem_virtualbase_contains(const void* self, QPointF* point);
bool QGraphicsSimpleTextItem_override_virtual_paint(void* self, intptr_t slot);
void QGraphicsSimpleTextItem_virtualbase_paint(void* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
bool QGraphicsSimpleTextItem_override_virtual_isObscuredBy(void* self, intptr_t slot);
bool QGraphicsSimpleTextItem_virtualbase_isObscuredBy(const void* self, QGraphicsItem* item);
bool QGraphicsSimpleTextItem_override_virtual_opaqueArea(void* self, intptr_t slot);
QPainterPath* QGraphicsSimpleTextItem_virtualbase_opaqueArea(const void* self);
bool QGraphicsSimpleTextItem_override_virtual_type(void* self, intptr_t slot);
int QGraphicsSimpleTextItem_virtualbase_type(const void* self);
bool QGraphicsSimpleTextItem_override_virtual_supportsExtension(void* self, intptr_t slot);
bool QGraphicsSimpleTextItem_virtualbase_supportsExtension(const void* self, int extension);
bool QGraphicsSimpleTextItem_override_virtual_setExtension(void* self, intptr_t slot);
void QGraphicsSimpleTextItem_virtualbase_setExtension(void* self, int extension, QVariant* variant);
bool QGraphicsSimpleTextItem_override_virtual_extension(void* self, intptr_t slot);
QVariant* QGraphicsSimpleTextItem_virtualbase_extension(const void* self, QVariant* variant);
bool QGraphicsSimpleTextItem_override_virtual_advance(void* self, intptr_t slot);
void QGraphicsSimpleTextItem_virtualbase_advance(void* self, int phase);
bool QGraphicsSimpleTextItem_override_virtual_collidesWithItem(void* self, intptr_t slot);
bool QGraphicsSimpleTextItem_virtualbase_collidesWithItem(const void* self, QGraphicsItem* other, int mode);
bool QGraphicsSimpleTextItem_override_virtual_collidesWithPath(void* self, intptr_t slot);
bool QGraphicsSimpleTextItem_virtualbase_collidesWithPath(const void* self, QPainterPath* path, int mode);
bool QGraphicsSimpleTextItem_override_virtual_sceneEventFilter(void* self, intptr_t slot);
bool QGraphicsSimpleTextItem_virtualbase_sceneEventFilter(void* self, QGraphicsItem* watched, QEvent* event);
bool QGraphicsSimpleTextItem_override_virtual_sceneEvent(void* self, intptr_t slot);
bool QGraphicsSimpleTextItem_virtualbase_sceneEvent(void* self, QEvent* event);
bool QGraphicsSimpleTextItem_override_virtual_contextMenuEvent(void* self, intptr_t slot);
void QGraphicsSimpleTextItem_virtualbase_contextMenuEvent(void* self, QGraphicsSceneContextMenuEvent* event);
bool QGraphicsSimpleTextItem_override_virtual_dragEnterEvent(void* self, intptr_t slot);
void QGraphicsSimpleTextItem_virtualbase_dragEnterEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsSimpleTextItem_override_virtual_dragLeaveEvent(void* self, intptr_t slot);
void QGraphicsSimpleTextItem_virtualbase_dragLeaveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsSimpleTextItem_override_virtual_dragMoveEvent(void* self, intptr_t slot);
void QGraphicsSimpleTextItem_virtualbase_dragMoveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsSimpleTextItem_override_virtual_dropEvent(void* self, intptr_t slot);
void QGraphicsSimpleTextItem_virtualbase_dropEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsSimpleTextItem_override_virtual_focusInEvent(void* self, intptr_t slot);
void QGraphicsSimpleTextItem_virtualbase_focusInEvent(void* self, QFocusEvent* event);
bool QGraphicsSimpleTextItem_override_virtual_focusOutEvent(void* self, intptr_t slot);
void QGraphicsSimpleTextItem_virtualbase_focusOutEvent(void* self, QFocusEvent* event);
bool QGraphicsSimpleTextItem_override_virtual_hoverEnterEvent(void* self, intptr_t slot);
void QGraphicsSimpleTextItem_virtualbase_hoverEnterEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsSimpleTextItem_override_virtual_hoverMoveEvent(void* self, intptr_t slot);
void QGraphicsSimpleTextItem_virtualbase_hoverMoveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsSimpleTextItem_override_virtual_hoverLeaveEvent(void* self, intptr_t slot);
void QGraphicsSimpleTextItem_virtualbase_hoverLeaveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsSimpleTextItem_override_virtual_keyPressEvent(void* self, intptr_t slot);
void QGraphicsSimpleTextItem_virtualbase_keyPressEvent(void* self, QKeyEvent* event);
bool QGraphicsSimpleTextItem_override_virtual_keyReleaseEvent(void* self, intptr_t slot);
void QGraphicsSimpleTextItem_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event);
bool QGraphicsSimpleTextItem_override_virtual_mousePressEvent(void* self, intptr_t slot);
void QGraphicsSimpleTextItem_virtualbase_mousePressEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsSimpleTextItem_override_virtual_mouseMoveEvent(void* self, intptr_t slot);
void QGraphicsSimpleTextItem_virtualbase_mouseMoveEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsSimpleTextItem_override_virtual_mouseReleaseEvent(void* self, intptr_t slot);
void QGraphicsSimpleTextItem_virtualbase_mouseReleaseEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsSimpleTextItem_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot);
void QGraphicsSimpleTextItem_virtualbase_mouseDoubleClickEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsSimpleTextItem_override_virtual_wheelEvent(void* self, intptr_t slot);
void QGraphicsSimpleTextItem_virtualbase_wheelEvent(void* self, QGraphicsSceneWheelEvent* event);
bool QGraphicsSimpleTextItem_override_virtual_inputMethodEvent(void* self, intptr_t slot);
void QGraphicsSimpleTextItem_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* event);
bool QGraphicsSimpleTextItem_override_virtual_inputMethodQuery(void* self, intptr_t slot);
QVariant* QGraphicsSimpleTextItem_virtualbase_inputMethodQuery(const void* self, int query);
bool QGraphicsSimpleTextItem_override_virtual_itemChange(void* self, intptr_t slot);
QVariant* QGraphicsSimpleTextItem_virtualbase_itemChange(void* self, int change, QVariant* value);
void QGraphicsSimpleTextItem_delete(QGraphicsSimpleTextItem* self);

QGraphicsItemGroup* QGraphicsItemGroup_new();
QGraphicsItemGroup* QGraphicsItemGroup_new2(QGraphicsItem* parent);
void QGraphicsItemGroup_virtbase(QGraphicsItemGroup* src, QGraphicsItem** outptr_QGraphicsItem);
void QGraphicsItemGroup_addToGroup(QGraphicsItemGroup* self, QGraphicsItem* item);
void QGraphicsItemGroup_removeFromGroup(QGraphicsItemGroup* self, QGraphicsItem* item);
QRectF* QGraphicsItemGroup_boundingRect(const QGraphicsItemGroup* self);
void QGraphicsItemGroup_paint(QGraphicsItemGroup* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
bool QGraphicsItemGroup_isObscuredBy(const QGraphicsItemGroup* self, QGraphicsItem* item);
QPainterPath* QGraphicsItemGroup_opaqueArea(const QGraphicsItemGroup* self);
int QGraphicsItemGroup_type(const QGraphicsItemGroup* self);
bool QGraphicsItemGroup_override_virtual_boundingRect(void* self, intptr_t slot);
QRectF* QGraphicsItemGroup_virtualbase_boundingRect(const void* self);
bool QGraphicsItemGroup_override_virtual_paint(void* self, intptr_t slot);
void QGraphicsItemGroup_virtualbase_paint(void* self, QPainter* painter, QStyleOptionGraphicsItem* option, QWidget* widget);
bool QGraphicsItemGroup_override_virtual_isObscuredBy(void* self, intptr_t slot);
bool QGraphicsItemGroup_virtualbase_isObscuredBy(const void* self, QGraphicsItem* item);
bool QGraphicsItemGroup_override_virtual_opaqueArea(void* self, intptr_t slot);
QPainterPath* QGraphicsItemGroup_virtualbase_opaqueArea(const void* self);
bool QGraphicsItemGroup_override_virtual_type(void* self, intptr_t slot);
int QGraphicsItemGroup_virtualbase_type(const void* self);
bool QGraphicsItemGroup_override_virtual_advance(void* self, intptr_t slot);
void QGraphicsItemGroup_virtualbase_advance(void* self, int phase);
bool QGraphicsItemGroup_override_virtual_shape(void* self, intptr_t slot);
QPainterPath* QGraphicsItemGroup_virtualbase_shape(const void* self);
bool QGraphicsItemGroup_override_virtual_contains(void* self, intptr_t slot);
bool QGraphicsItemGroup_virtualbase_contains(const void* self, QPointF* point);
bool QGraphicsItemGroup_override_virtual_collidesWithItem(void* self, intptr_t slot);
bool QGraphicsItemGroup_virtualbase_collidesWithItem(const void* self, QGraphicsItem* other, int mode);
bool QGraphicsItemGroup_override_virtual_collidesWithPath(void* self, intptr_t slot);
bool QGraphicsItemGroup_virtualbase_collidesWithPath(const void* self, QPainterPath* path, int mode);
bool QGraphicsItemGroup_override_virtual_sceneEventFilter(void* self, intptr_t slot);
bool QGraphicsItemGroup_virtualbase_sceneEventFilter(void* self, QGraphicsItem* watched, QEvent* event);
bool QGraphicsItemGroup_override_virtual_sceneEvent(void* self, intptr_t slot);
bool QGraphicsItemGroup_virtualbase_sceneEvent(void* self, QEvent* event);
bool QGraphicsItemGroup_override_virtual_contextMenuEvent(void* self, intptr_t slot);
void QGraphicsItemGroup_virtualbase_contextMenuEvent(void* self, QGraphicsSceneContextMenuEvent* event);
bool QGraphicsItemGroup_override_virtual_dragEnterEvent(void* self, intptr_t slot);
void QGraphicsItemGroup_virtualbase_dragEnterEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsItemGroup_override_virtual_dragLeaveEvent(void* self, intptr_t slot);
void QGraphicsItemGroup_virtualbase_dragLeaveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsItemGroup_override_virtual_dragMoveEvent(void* self, intptr_t slot);
void QGraphicsItemGroup_virtualbase_dragMoveEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsItemGroup_override_virtual_dropEvent(void* self, intptr_t slot);
void QGraphicsItemGroup_virtualbase_dropEvent(void* self, QGraphicsSceneDragDropEvent* event);
bool QGraphicsItemGroup_override_virtual_focusInEvent(void* self, intptr_t slot);
void QGraphicsItemGroup_virtualbase_focusInEvent(void* self, QFocusEvent* event);
bool QGraphicsItemGroup_override_virtual_focusOutEvent(void* self, intptr_t slot);
void QGraphicsItemGroup_virtualbase_focusOutEvent(void* self, QFocusEvent* event);
bool QGraphicsItemGroup_override_virtual_hoverEnterEvent(void* self, intptr_t slot);
void QGraphicsItemGroup_virtualbase_hoverEnterEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsItemGroup_override_virtual_hoverMoveEvent(void* self, intptr_t slot);
void QGraphicsItemGroup_virtualbase_hoverMoveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsItemGroup_override_virtual_hoverLeaveEvent(void* self, intptr_t slot);
void QGraphicsItemGroup_virtualbase_hoverLeaveEvent(void* self, QGraphicsSceneHoverEvent* event);
bool QGraphicsItemGroup_override_virtual_keyPressEvent(void* self, intptr_t slot);
void QGraphicsItemGroup_virtualbase_keyPressEvent(void* self, QKeyEvent* event);
bool QGraphicsItemGroup_override_virtual_keyReleaseEvent(void* self, intptr_t slot);
void QGraphicsItemGroup_virtualbase_keyReleaseEvent(void* self, QKeyEvent* event);
bool QGraphicsItemGroup_override_virtual_mousePressEvent(void* self, intptr_t slot);
void QGraphicsItemGroup_virtualbase_mousePressEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsItemGroup_override_virtual_mouseMoveEvent(void* self, intptr_t slot);
void QGraphicsItemGroup_virtualbase_mouseMoveEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsItemGroup_override_virtual_mouseReleaseEvent(void* self, intptr_t slot);
void QGraphicsItemGroup_virtualbase_mouseReleaseEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsItemGroup_override_virtual_mouseDoubleClickEvent(void* self, intptr_t slot);
void QGraphicsItemGroup_virtualbase_mouseDoubleClickEvent(void* self, QGraphicsSceneMouseEvent* event);
bool QGraphicsItemGroup_override_virtual_wheelEvent(void* self, intptr_t slot);
void QGraphicsItemGroup_virtualbase_wheelEvent(void* self, QGraphicsSceneWheelEvent* event);
bool QGraphicsItemGroup_override_virtual_inputMethodEvent(void* self, intptr_t slot);
void QGraphicsItemGroup_virtualbase_inputMethodEvent(void* self, QInputMethodEvent* event);
bool QGraphicsItemGroup_override_virtual_inputMethodQuery(void* self, intptr_t slot);
QVariant* QGraphicsItemGroup_virtualbase_inputMethodQuery(const void* self, int query);
bool QGraphicsItemGroup_override_virtual_itemChange(void* self, intptr_t slot);
QVariant* QGraphicsItemGroup_virtualbase_itemChange(void* self, int change, QVariant* value);
bool QGraphicsItemGroup_override_virtual_supportsExtension(void* self, intptr_t slot);
bool QGraphicsItemGroup_virtualbase_supportsExtension(const void* self, int extension);
bool QGraphicsItemGroup_override_virtual_setExtension(void* self, intptr_t slot);
void QGraphicsItemGroup_virtualbase_setExtension(void* self, int extension, QVariant* variant);
bool QGraphicsItemGroup_override_virtual_extension(void* self, intptr_t slot);
QVariant* QGraphicsItemGroup_virtualbase_extension(const void* self, QVariant* variant);
void QGraphicsItemGroup_delete(QGraphicsItemGroup* self);

#ifdef __cplusplus
} /* extern C */
#endif

#endif