pylab_ml.misc.iasvg.SvgItem

class SvgItem(id, renderer, parent=None, element=None)[source]

Bases: QGraphicsSvgItem

SvgItem is a QGraphicsSvgItem with some additional functions for interactivity.

__init__(id, renderer, parent=None, element=None)[source]

Constructor for the SvgItem.

Parameters:

id (string) – id from the svg element.
renderer (QSvgRenderer) – The SVG renderer to use for this item.
parent (TYPE, optional) – The parent item. The default is None.
element (TYPE, optional) – The SVG element associated with this item. The default is None.

Methods

`__init__`(id, renderer[, parent, element])	Constructor for the SvgItem.
`acceptDrops`(self)
`acceptHoverEvents`(self)
`acceptTouchEvents`(self)
`acceptedMouseButtons`(self)
`advance`(self, phase)
`blockSignals`(self, b)
`boundingRect`(self)
`boundingRegion`(self, itemToDeviceTransform)
`boundingRegionGranularity`(self)
`cacheMode`(self)
`childEvent`(self, a0)
`childItems`(self)
`children`(self)
`childrenBoundingRect`(self)
`clearFocus`(self)
`clipPath`(self)
`collidesWithItem`(self, other[, mode])
`collidesWithPath`(self, path[, mode])
`collidingItems`(self[, mode])
`commonAncestorItem`(self, other)
`connectNotify`(self, signal)
`contains`(self, point)
`contextMenuEvent`(self, event)
`cursor`(self)
`customEvent`(self, a0)
`data`(self, key)
`deleteLater`(self)
`deviceTransform`(self, viewportTransform)
`disconnect`(-> bool)
`disconnectNotify`(self, signal)
`dragEnterEvent`(self, event)
`dragLeaveEvent`(self, event)
`dragMoveEvent`(self, event)
`dropEvent`(self, event)
`dumpObjectInfo`(self)
`dumpObjectTree`(self)
`dynamicPropertyNames`(self)
`effectiveOpacity`(self)
`elementId`(self)
`ensureVisible`(, xMargin, yMargin)
`event`(self, ev)
`eventFilter`(obj, event)	Set an event Filter.
`filtersChildEvents`(self)
`findChild`(-> QObjectT)
`findChildren`(...)
`flags`(self)
`focusInEvent`(self, event)
`focusItem`(self)
`focusOutEvent`(self, event)
`focusProxy`(self)
`grabGesture`(self, type[, flags])
`grabKeyboard`(self)
`grabMouse`(self)
`graphicsEffect`(self)
`group`(self)
`hasCursor`(self)
`hasFocus`(self)
`hide`(self)
`hoverEnterEvent`(self, event)
`hoverLeaveEvent`(self, event)
`hoverMoveEvent`(self, event)
`inherits`(self, classname)
`inputMethodEvent`(self, event)
`inputMethodHints`(self)
`inputMethodQuery`(self, query)
`installEventFilter`(self, a0)
`installSceneEventFilter`(self, filterItem)
`isActive`(self)
`isAncestorOf`(self, child)
`isBlockedByModalPanel`(self)
`isClipped`(self)
`isEnabled`(self)
`isObscured`() -> bool)
`isObscuredBy`(self, item)
`isPanel`(self)
`isSelected`(self)
`isSignalConnected`(self, signal)
`isUnderMouse`(self)
`isVisible`(self)
`isVisibleTo`(self, parent)
`isWidget`(self)
`isWidgetType`(self)
`isWindow`(self)
`isWindowType`(self)
`itemChange`(self, change, value)
`itemTransform`(self, other)
`keyPressEvent`(self, event)
`keyReleaseEvent`(self, event)
`killTimer`(self, id)
`mapFromItem`(...)
`mapFromParent`(...)
`mapFromScene`(...)
`mapRectFromItem`(-> QRectF)
`mapRectFromParent`(-> QRectF)
`mapRectFromScene`(-> QRectF)
`mapRectToItem`(-> QRectF)
`mapRectToParent`(-> QRectF)
`mapRectToScene`(-> QRectF)
`mapToItem`(...)
`mapToParent`(...)
`mapToScene`(...)
`maximumCacheSize`(self)
`metaObject`(self)
`mouseDoubleClickEvent`(self, event)
`mouseMoveEvent`(self, event)
`mousePressEvent`(event)	Overwrite the mousePressEvent from QGraphicsSvgItem.
`mouseReleaseEvent`(self, event)
`moveBy`(self, dx, dy)
`moveToThread`(self, thread)
`objectName`(self)
`opacity`(self)
`opaqueArea`(self)
`paint`(painter, option[, widget])	Overwerite the paint-function from QGraphicsSvgItem.
`panel`(self)
`panelModality`(self)
`parent`(self)
`parentItem`(self)
`parentObject`(self)
`parentWidget`(self)
`pos`(self)
`prepareGeometryChange`(self)
`property`(self, name)
`pyqtConfigure`(...)	Each keyword argument is either the name of a Qt property or a Qt signal.
`receivers`(self, signal)
`removeEventFilter`(self, a0)
`removeSceneEventFilter`(self, filterItem)
`renderer`(self)
`resetTransform`(self)
`rotation`(self)
`scale`(self)
`scene`(self)
`sceneBoundingRect`(self)
`sceneEvent`(self, event)
`sceneEventFilter`(self, watched, event)
`scenePos`(self)
`sceneTransform`(self)
`scroll`(self, dx, dy[, rect])
`sender`(self)
`senderSignalIndex`(self)
`setAcceptDrops`(self, on)
`setAcceptHoverEvents`(self, enabled)
`setAcceptTouchEvents`(self, enabled)
`setAcceptedMouseButtons`(self, buttons)
`setActive`(self, active)
`setBoundingRegionGranularity`(self, granularity)
`setCacheMode`(self, mode[, logicalCacheSize])
`setCursor`(self, cursor)
`setData`(self, key, value)
`setElementId`(self, id)
`setEnabled`(self, enabled)
`setFiltersChildEvents`(self, enabled)
`setFlag`(self, flag[, enabled])
`setFlags`(self, flags)
`setFocus`(self[, focusReason])
`setFocusProxy`(self, item)
`setGraphicsEffect`(self, effect)
`setGroup`(self, group)
`setInputMethodHints`(self, hints)
`setMaximumCacheSize`(self, size)
`setObjectName`(self, name)
`setOpacity`(self, opacity)
`setPanelModality`(self, panelModality)
`setParent`(self, a0)
`setParentItem`(self, parent)
`setPos`()
`setProperty`(self, name, value)
`setRotation`(self, angle)
`setScale`(self, scale)
`setSelected`(self, selected)
`setSharedRenderer`(self, renderer)
`setToolTip`(self, toolTip)
`setTransform`(self, matrix[, combine])
`setTransformOriginPoint`()
`setTransformations`(self, transformations)
`setVisible`(self, visible)
`setX`(self, x)
`setY`(self, y)
`setZValue`(self, z)
`shape`(self)
`show`(self)
`signalsBlocked`(self)
`stackBefore`(self, sibling)
`startTimer`(self, interval[, timerType])
`thread`(self)
`timerEvent`(self, a0)
`toGraphicsObject`(self)
`toolTip`(self)
`topLevelItem`(self)
`topLevelWidget`(self)
`tr`(self, sourceText[, disambiguation, n])
`transform`(self)
`transformOriginPoint`(self)
`transformations`(self)
`type`(self)
`ungrabGesture`(self, type)
`ungrabKeyboard`(self)
`ungrabMouse`(self)
`unsetCursor`(self)
`update`())
`updateMicroFocus`(self)
`wheelEvent`(self, event)
`window`(self)
`x`(self)
`y`(self)
`zValue`(self)

Attributes

`DeviceCoordinateCache`
`ItemAcceptsInputMethod`
`ItemChildAddedChange`
`ItemChildRemovedChange`
`ItemClipsChildrenToShape`
`ItemClipsToShape`
`ItemContainsChildrenInShape`
`ItemCoordinateCache`
`ItemCursorChange`
`ItemCursorHasChanged`
`ItemDoesntPropagateOpacityToChildren`
`ItemEnabledChange`
`ItemEnabledHasChanged`
`ItemFlagsChange`
`ItemFlagsHaveChanged`
`ItemHasNoContents`
`ItemIgnoresParentOpacity`
`ItemIgnoresTransformations`
`ItemIsFocusable`
`ItemIsMovable`
`ItemIsPanel`
`ItemIsSelectable`
`ItemMatrixChange`
`ItemNegativeZStacksBehindParent`
`ItemOpacityChange`
`ItemOpacityHasChanged`
`ItemParentChange`
`ItemParentHasChanged`
`ItemPositionChange`
`ItemPositionHasChanged`
`ItemRotationChange`
`ItemRotationHasChanged`
`ItemScaleChange`
`ItemScaleHasChanged`
`ItemSceneChange`
`ItemSceneHasChanged`
`ItemScenePositionHasChanged`
`ItemSelectedChange`
`ItemSelectedHasChanged`
`ItemSendsGeometryChanges`
`ItemSendsScenePositionChanges`
`ItemStacksBehindParent`
`ItemToolTipChange`
`ItemToolTipHasChanged`
`ItemTransformChange`
`ItemTransformHasChanged`
`ItemTransformOriginPointChange`
`ItemTransformOriginPointHasChanged`
`ItemUsesExtendedStyleOption`
`ItemVisibleChange`
`ItemVisibleHasChanged`
`ItemZValueChange`
`ItemZValueHasChanged`
`NoCache`
`NonModal`
`PanelModal`
`SceneModal`
`Type`
`UserType`
`clickBox`
`clickHelpBox`
`destroyed`	Optional[QObject] = None) [signal]
`enabledChanged`	enabledChanged(self) [signal]
`objectNameChanged`	Optional[str]) [signal]
`opacityChanged`	opacityChanged(self) [signal]
`parentChanged`	parentChanged(self) [signal]
`rotationChanged`	rotationChanged(self) [signal]
`scaleChanged`	scaleChanged(self) [signal]
`staticMetaObject`
`visibleChanged`	visibleChanged(self) [signal]
`xChanged`	xChanged(self) [signal]
`yChanged`	yChanged(self) [signal]
`zChanged`	zChanged(self) [signal]

class CacheMode: Bases: int

class GraphicsItemChange: Bases: int

class GraphicsItemFlag: Bases: int

class GraphicsItemFlags
class GraphicsItemFlags(f: QGraphicsItem.GraphicsItemFlags | QGraphicsItem.GraphicsItemFlag)
class GraphicsItemFlags(a0: QGraphicsItem.GraphicsItemFlags): Bases: simplewrapper

class PanelModality: Bases: int

acceptDrops(self) → bool

acceptHoverEvents(self) → bool

acceptTouchEvents(self) → bool

acceptedMouseButtons(self) → Qt.MouseButtons

advance(self, phase: int)

blockSignals(self, b: bool) → bool

boundingRect(self) → QRectF

boundingRegion(self, itemToDeviceTransform: QTransform) → QRegion

boundingRegionGranularity(self) → float

cacheMode(self) → QGraphicsItem.CacheMode

childEvent(self, a0: QChildEvent | None)

childItems(self) → List[QGraphicsItem]

children(self) → List[QObject]

childrenBoundingRect(self) → QRectF

clearFocus(self)

clipPath(self) → QPainterPath

collidesWithItem(self, other: QGraphicsItem | None, mode: Qt.ItemSelectionMode = Qt.IntersectsItemShape) → bool

collidesWithPath(self, path: QPainterPath, mode: Qt.ItemSelectionMode = Qt.IntersectsItemShape) → bool

collidingItems(self, mode: Qt.ItemSelectionMode = Qt.IntersectsItemShape) → List[QGraphicsItem]

commonAncestorItem(self, other: QGraphicsItem | None) → QGraphicsItem | None

connectNotify(self, signal: QMetaMethod)

contains(self, point: QPointF | QPoint) → bool

contextMenuEvent(self, event: QGraphicsSceneContextMenuEvent | None)

cursor(self) → QCursor

customEvent(self, a0: QEvent | None)

data(self, key: int) → Any

deleteLater(self)

destroyed

Optional[QObject] = None) [signal]

Type:: destroyed(self, object

deviceTransform(self, viewportTransform: QTransform) → QTransform

disconnect(a0: QMetaObject.Connection) → bool
disconnect(self) → None

disconnectNotify(self, signal: QMetaMethod)

dragEnterEvent(self, event: QGraphicsSceneDragDropEvent | None)

dragLeaveEvent(self, event: QGraphicsSceneDragDropEvent | None)

dragMoveEvent(self, event: QGraphicsSceneDragDropEvent | None)

dropEvent(self, event: QGraphicsSceneDragDropEvent | None)

dumpObjectInfo(self)

dumpObjectTree(self)

dynamicPropertyNames(self) → List[QByteArray]

effectiveOpacity(self) → float

elementId(self) → str

enabledChanged: enabledChanged(self) [signal]

ensureVisible(self, rect: QRectF = QRectF(), xMargin: int = 50, yMargin: int = 50)
ensureVisible(self, x: float, y: float, w: float, h: float, xMargin: int = 50, yMargin: int = 50) → None

event(self, ev: QEvent | None) → bool

eventFilter(obj, event)[source]

Set an event Filter.

Parameters:

obj (QObject) – The object that is being filtered.
event (QEvent) – The event that is being filtered.

Returns:

True if the event should be filtered out, False otherwise.

Return type:

bool

filtersChildEvents(self) → bool

findChild(self, type: Type[QObjectT], name: str | None = '', options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → QObjectT
findChild(self, types: Tuple[Type[QObjectT], ...], name: str | None = '', options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → QObjectT

findChildren(self, type: Type[QObjectT], name: str | None = '', options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObjectT]
findChildren(self, types: Tuple[Type[QObjectT], ...], name: str | None = '', options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObjectT]
findChildren(self, type: Type[QObjectT], regExp: QRegExp, options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObjectT]
findChildren(self, types: Tuple[Type[QObjectT], ...], regExp: QRegExp, options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObjectT]
findChildren(self, type: Type[QObjectT], re: QRegularExpression, options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObjectT]
findChildren(self, types: Tuple[Type[QObjectT], ...], re: QRegularExpression, options: Qt.FindChildOptions | Qt.FindChildOption = Qt.FindChildrenRecursively) → List[QObjectT]

flags(self) → QGraphicsItem.GraphicsItemFlags

focusInEvent(self, event: QFocusEvent | None)

focusItem(self) → QGraphicsItem | None

focusOutEvent(self, event: QFocusEvent | None)

focusProxy(self) → QGraphicsItem | None

grabGesture(self, type: Qt.GestureType, flags: Qt.GestureFlags | Qt.GestureFlag = Qt.GestureFlags())

grabKeyboard(self)

grabMouse(self)

graphicsEffect(self) → QGraphicsEffect | None

group(self) → QGraphicsItemGroup | None

hasCursor(self) → bool

hasFocus(self) → bool

hide(self)

hoverEnterEvent(self, event: QGraphicsSceneHoverEvent | None)

hoverLeaveEvent(self, event: QGraphicsSceneHoverEvent | None)

hoverMoveEvent(self, event: QGraphicsSceneHoverEvent | None)

inherits(self, classname: str | None) → bool

inputMethodEvent(self, event: QInputMethodEvent | None)

inputMethodHints(self) → Qt.InputMethodHints

inputMethodQuery(self, query: Qt.InputMethodQuery) → Any

installEventFilter(self, a0: QObject | None)

installSceneEventFilter(self, filterItem: QGraphicsItem | None)

isActive(self) → bool

isAncestorOf(self, child: QGraphicsItem | None) → bool

isBlockedByModalPanel(self)

isClipped(self) → bool

isEnabled(self) → bool

isObscured(self, rect: QRectF = QRectF()) → bool
isObscured(self, ax: float, ay: float, w: float, h: float) → bool

isObscuredBy(self, item: QGraphicsItem | None) → bool

isPanel(self) → bool

isSelected(self) → bool

isSignalConnected(self, signal: QMetaMethod) → bool

isUnderMouse(self) → bool

isVisible(self) → bool

isVisibleTo(self, parent: QGraphicsItem | None) → bool

isWidget(self) → bool

isWidgetType(self) → bool

isWindow(self) → bool

isWindowType(self) → bool

itemChange(self, change: QGraphicsItem.GraphicsItemChange, value: Any) → Any

itemTransform(self, other: QGraphicsItem | None)

keyPressEvent(self, event: QKeyEvent | None)

keyReleaseEvent(self, event: QKeyEvent | None)

killTimer(self, id: int)

mapFromItem(self, item: QGraphicsItem | None, point: QPointF | QPoint) → QPointF
mapFromItem(self, item: QGraphicsItem | None, rect: QRectF) → QPolygonF
mapFromItem(self, item: QGraphicsItem | None, polygon: QPolygonF) → QPolygonF
mapFromItem(self, item: QGraphicsItem | None, path: QPainterPath) → QPainterPath
mapFromItem(self, item: QGraphicsItem | None, ax: float, ay: float) → QPointF
mapFromItem(self, item: QGraphicsItem | None, ax: float, ay: float, w: float, h: float) → QPolygonF

mapFromParent(self, point: QPointF | QPoint) → QPointF
mapFromParent(self, rect: QRectF) → QPolygonF
mapFromParent(self, polygon: QPolygonF) → QPolygonF
mapFromParent(self, path: QPainterPath) → QPainterPath
mapFromParent(self, ax: float, ay: float) → QPointF
mapFromParent(self, ax: float, ay: float, w: float, h: float) → QPolygonF

mapFromScene(self, point: QPointF | QPoint) → QPointF
mapFromScene(self, rect: QRectF) → QPolygonF
mapFromScene(self, polygon: QPolygonF) → QPolygonF
mapFromScene(self, path: QPainterPath) → QPainterPath
mapFromScene(self, ax: float, ay: float) → QPointF
mapFromScene(self, ax: float, ay: float, w: float, h: float) → QPolygonF

mapRectFromItem(self, item: QGraphicsItem | None, rect: QRectF) → QRectF
mapRectFromItem(self, item: QGraphicsItem | None, ax: float, ay: float, w: float, h: float) → QRectF

mapRectFromParent(self, rect: QRectF) → QRectF
mapRectFromParent(self, ax: float, ay: float, w: float, h: float) → QRectF

mapRectFromScene(self, rect: QRectF) → QRectF
mapRectFromScene(self, ax: float, ay: float, w: float, h: float) → QRectF

mapRectToItem(self, item: QGraphicsItem | None, rect: QRectF) → QRectF
mapRectToItem(self, item: QGraphicsItem | None, ax: float, ay: float, w: float, h: float) → QRectF

mapRectToParent(self, rect: QRectF) → QRectF
mapRectToParent(self, ax: float, ay: float, w: float, h: float) → QRectF

mapRectToScene(self, rect: QRectF) → QRectF
mapRectToScene(self, ax: float, ay: float, w: float, h: float) → QRectF

mapToItem(self, item: QGraphicsItem | None, point: QPointF | QPoint) → QPointF
mapToItem(self, item: QGraphicsItem | None, rect: QRectF) → QPolygonF
mapToItem(self, item: QGraphicsItem | None, polygon: QPolygonF) → QPolygonF
mapToItem(self, item: QGraphicsItem | None, path: QPainterPath) → QPainterPath
mapToItem(self, item: QGraphicsItem | None, ax: float, ay: float) → QPointF
mapToItem(self, item: QGraphicsItem | None, ax: float, ay: float, w: float, h: float) → QPolygonF

mapToParent(self, point: QPointF | QPoint) → QPointF
mapToParent(self, rect: QRectF) → QPolygonF
mapToParent(self, polygon: QPolygonF) → QPolygonF
mapToParent(self, path: QPainterPath) → QPainterPath
mapToParent(self, ax: float, ay: float) → QPointF
mapToParent(self, ax: float, ay: float, w: float, h: float) → QPolygonF

mapToScene(self, point: QPointF | QPoint) → QPointF
mapToScene(self, rect: QRectF) → QPolygonF
mapToScene(self, polygon: QPolygonF) → QPolygonF
mapToScene(self, path: QPainterPath) → QPainterPath
mapToScene(self, ax: float, ay: float) → QPointF
mapToScene(self, ax: float, ay: float, w: float, h: float) → QPolygonF

maximumCacheSize(self) → QSize

metaObject(self) → QMetaObject | None

mouseDoubleClickEvent(self, event: QGraphicsSceneMouseEvent | None)

mouseMoveEvent(self, event: QGraphicsSceneMouseEvent | None)

mousePressEvent(event: QGraphicsSceneMouseEvent)[source]

Overwrite the mousePressEvent from QGraphicsSvgItem.

Send the clickBox or clickHelpBox Signal with the name from the element and the coordinates.

Parameters:: event ('QtWidgets.QGraphicsSceneMouseEvent') – The mouse event that triggered the function.
Return type:: None.

mouseReleaseEvent(self, event: QGraphicsSceneMouseEvent | None)

moveBy(self, dx: float, dy: float)

moveToThread(self, thread: QThread | None)

objectName(self) → str

objectNameChanged

Optional[str]) [signal]

Type:: objectNameChanged(self, objectName

opacity(self) → float

opacityChanged: opacityChanged(self) [signal]

opaqueArea(self) → QPainterPath

paint(painter, option, widget=None)[source]

Overwerite the paint-function from QGraphicsSvgItem.

Parameters:

painter (QPainter) – The painter to use for drawing the item.
option (QStyleOptionGraphicsItem) – The style options for the item.
widget (QWidget, optional) – The widget that is being painted on. The default is None.

Return type:

None.

panel(self) → QGraphicsItem | None

panelModality(self) → QGraphicsItem.PanelModality

parent(self) → QObject | None

parentChanged: parentChanged(self) [signal]

parentItem(self) → QGraphicsItem | None

parentObject(self) → QGraphicsObject | None

parentWidget(self) → QGraphicsWidget | None

pos(self) → QPointF

prepareGeometryChange(self)

property(self, name: str | None) → Any

pyqtConfigure(...): Each keyword argument is either the name of a Qt property or a Qt signal. For properties the property is set to the given value which should be of an appropriate type. For signals the signal is connected to the given value which should be a callable.

receivers(self, signal: PYQT_SIGNAL) → int

removeEventFilter(self, a0: QObject | None)

removeSceneEventFilter(self, filterItem: QGraphicsItem | None)

renderer(self) → QSvgRenderer | None

resetTransform(self)

rotation(self) → float

rotationChanged: rotationChanged(self) [signal]

scale(self) → float

scaleChanged: scaleChanged(self) [signal]

scene(self) → QGraphicsScene | None

sceneBoundingRect(self) → QRectF

sceneEvent(self, event: QEvent | None) → bool

sceneEventFilter(self, watched: QGraphicsItem | None, event: QEvent | None) → bool

scenePos(self) → QPointF

sceneTransform(self) → QTransform

scroll(self, dx: float, dy: float, rect: QRectF = QRectF())

sender(self) → QObject | None

senderSignalIndex(self) → int

setAcceptDrops(self, on: bool)

setAcceptHoverEvents(self, enabled: bool)

setAcceptTouchEvents(self, enabled: bool)

setAcceptedMouseButtons(self, buttons: Qt.MouseButtons | Qt.MouseButton)

setActive(self, active: bool)

setBoundingRegionGranularity(self, granularity: float)

setCacheMode(self, mode: QGraphicsItem.CacheMode, logicalCacheSize: QSize = QSize())

setCursor(self, cursor: QCursor | Qt.CursorShape)

setData(self, key: int, value: Any)

setElementId(self, id: str | None)

setEnabled(self, enabled: bool)

setFiltersChildEvents(self, enabled: bool)

setFlag(self, flag: QGraphicsItem.GraphicsItemFlag, enabled: bool = True)

setFlags(self, flags: QGraphicsItem.GraphicsItemFlags | QGraphicsItem.GraphicsItemFlag)

setFocus(self, focusReason: Qt.FocusReason = Qt.OtherFocusReason)

setFocusProxy(self, item: QGraphicsItem | None)

setGraphicsEffect(self, effect: QGraphicsEffect | None)

setGroup(self, group: QGraphicsItemGroup | None)

setInputMethodHints(self, hints: Qt.InputMethodHints | Qt.InputMethodHint)

setMaximumCacheSize(self, size: QSize)

setObjectName(self, name: str | None)

setOpacity(self, opacity: float)

setPanelModality(self, panelModality: QGraphicsItem.PanelModality)

setParent(self, a0: QObject | None)

setParentItem(self, parent: QGraphicsItem | None)

setPos(self, pos: QPointF | QPoint)
setPos(self, ax: float, ay: float) → None

setProperty(self, name: str | None, value: Any) → bool

setRotation(self, angle: float)

setScale(self, scale: float)

setSelected(self, selected: bool)

setSharedRenderer(self, renderer: QSvgRenderer | None)

setToolTip(self, toolTip: str | None)

setTransform(self, matrix: QTransform, combine: bool = False)

setTransformOriginPoint(self, origin: QPointF | QPoint)
setTransformOriginPoint(self, ax: float, ay: float) → None

setTransformations(self, transformations: Iterable[QGraphicsTransform])

setVisible(self, visible: bool)

setX(self, x: float)

setY(self, y: float)

setZValue(self, z: float)

shape(self) → QPainterPath

show(self)

signalsBlocked(self) → bool

stackBefore(self, sibling: QGraphicsItem | None)

startTimer(self, interval: int, timerType: Qt.TimerType = Qt.CoarseTimer) → int

thread(self) → QThread | None

timerEvent(self, a0: QTimerEvent | None)

toGraphicsObject(self) → QGraphicsObject | None

toolTip(self) → str

topLevelItem(self) → QGraphicsItem | None

topLevelWidget(self) → QGraphicsWidget | None

tr(self, sourceText: str | None, disambiguation: str | None = None, n: int = -1) → str

transform(self) → QTransform

transformOriginPoint(self) → QPointF

transformations(self) → List[QGraphicsTransform]

type(self) → int

ungrabGesture(self, type: Qt.GestureType)

ungrabKeyboard(self)

ungrabMouse(self)

unsetCursor(self)

update(self, rect: QRectF = QRectF())
update(self, ax: float, ay: float, width: float, height: float) → None

updateMicroFocus(self)

visibleChanged: visibleChanged(self) [signal]

wheelEvent(self, event: QGraphicsSceneWheelEvent | None)

window(self) → QGraphicsWidget | None

x(self) → float

xChanged: xChanged(self) [signal]

y(self) → float

yChanged: yChanged(self) [signal]

zChanged: zChanged(self) [signal]

zValue(self) → float