QT 笔记 QGraphicsItem 介绍

介绍

QGraphicsItem是Qt中用于在图形视图框架中表示可视图形项的基类。在Qt的图形视图框架中，你可以使用QGraphicsItem及其派生类来创建可在图形场景中显示的图形元素。下面是关于QGraphicsItem的一些重要信息：

• 作用：QGraphicsItem是所有在图形场景中可视的图形项的基类，用于表示图形元素。
• 功能：QGraphicsItem提供了一种方法来管理图形项的位置、外观、交互等属性，使其能够在图形视图框架中进行显示和交互。
• 常用功能：
  • 设置和获取图形项的位置和尺寸。
  • 控制图形项的外观，如颜色、笔刷、边框等。
  • 处理图形项的交互事件，如鼠标点击、拖动等。
  • 实现图形项的碰撞检测、坐标转换等功能。

判断相关函数

isActive() 否处于活动状态

项是否处于活动状态。仅当场景处于活动状态时，项才能处于活动状态。只有活动项才能获得输入焦点。

isAncestorOf 是否是孩子的祖先

isAncestorOf(const QGraphicsItem *child)
1

如果当前项是参数项的祖先则返回true。

isBlockedByModalPanel 是否被模态面板阻

isBlockedByModalPanel(QGraphicsItem **blockingPanel = nullptr)
1

如果当前项被模态面板阻止，则返回true，否则返回false。如果blockingPanel不为nullptr，则将blockingPanel设置为阻止此项的模态面板。如果此项未被阻止，则此功能将不会设置blockingPanel。对于不在场景中的项，此函数始终返回false。

isClipped() 是否被裁剪

如果项被裁剪，则返回true。如果项设置了ItemClipsToShape标志，或其任何祖先设置了ItemClipsChildrenToShape标志，则该项将被裁剪。

isEnabled() 是否启用

判断是否启用

isObscured 是否被上方矩形完全遮盖

isObscured(const QRectF &rect = QRectF()) 	
isObscured(qreal x, qreal y, qreal w, qreal h) 	
1
2

如果rect被其上方任何碰撞项的不透明形状完全遮盖（即，Z值高于当前项），则返回true。（实用）

isObscuredBy 是否被上方的项完全遮盖

isObscuredBy(const QGraphicsItem *item) 	
1

如果当前项的边界矩形完全被参数中的项的不透明形状遮盖，则返回true。基本实现将项的opaqueArea()映射到该项的坐标系，然后检查该项的boundingRect()是否完全包含在映射的形状中。可以重新实现此功能，以提供一种自定义算法来确定该项是否被项遮盖。

isPanel() 是否是面板

项是否是面板。

isSelected() 是否被选中

项是否被选中

isUnderMouse() 是否位于鼠标下方

当前项是否位于一个视图鼠标光标的下方。（实用）

isVisible() 是否对父项可见

当前项是否对参数中的父项可见（即使isVisible()为true，也可能对其祖先不可见。即使isVisible()为false，它的祖先也可能可见）。参数parent可以为空的情况下，此函数将返回当前项对于场景是否可见。如果任何祖先被隐藏，则项本身将被隐式隐藏，在这种情况下，此函数将返回false。

isVisibleTo(const QGraphicsItem *parent)

当前项是否对参数中的父项可见（即使isVisible()为true，也可能对其祖先不可见。即使isVisible()为false，它的祖先也可能可见）。参数parent可以为空的情况下，此函数将返回当前项对于场景是否可见。如果任何祖先被隐藏，则项本身将被隐式隐藏，在这种情况下，此函数将返回false。

isWidget() 是否是QGraphicsWidget

当前项是否是QGraphicsWidget。

isWindow() 是否是QGraphicsWidget窗口

当前项是否是QGraphicsWidget窗口。（QGraphicsWidget对象设置了 windowFlags为Qt::Window）

设置相关函数

setAcceptDrops 接受拖放事件

setAcceptDrops(bool on)  
1

如果on为true，则此项目将接受拖放事件;否则，它对拖放事件是透明的。默认情况下，项不接受拖放事件。

setAcceptHoverEvents 接受悬停事件

setAcceptHoverEvents(bool enabled)
1

如果enabled为true，此项目将接受悬停事件;否则，它将忽略它们。默认情况下，项目不接受悬停事件。

setAcceptTouchEvents 接受触摸事件

setAcceptTouchEvents(bool enabled)
1

如果enabled为true，此项目将接受触摸事件;否则，它将忽略它们。默认情况下，项目不接受触摸事件。

setAcceptedMouseButtons 接受鼠标事件

setAcceptedMouseButtons(Qt::MouseButtons buttons)
1

设置此项接受鼠标事件的鼠标按钮

setActive

setActive(bool active) 活动状态
1

如果active为true，并且场景处于活动状态，则此项目的面板将被激活。否则，表示未激活面板。

setBoundingRegionGranularity 将边界区域粒度设置为粒度

setBoundingRegionGranularity(qreal granularity)
1

将边界区域粒度设置为粒度;介于0和1之间且包括0和1的值。默认值为0(即，最低粒度，其中边界区域对应于项目的边界矩形)。

setCacheMode 缓存模式

setCacheMode(QGraphicsItem::CacheMode mode, const QSize &logicalCacheSize = QSize())
1

将项的缓存模式设置为mode。

setCursor 鼠标光标形状

setCursor(const QCursor &cursor)
为光标项设置当前光标形状。鼠标光标在该项上时将呈现此形状。有关一系列有用的形状，请参阅预定义光标对象列表。

setData 设置键值

setData(int key, const QVariant &value)
1

为键key设置该项的自定义数据为value。

setEnabled 启用状态

setEnabled(bool enabled)
1

如果enabled为true，则启用该项;否则，禁用。
禁用的项是可见的，但它们不接收任何事件，不能成为焦点也不能被选中。鼠标事件被丢弃;除非项目也是不可见的，或者它不接受鼠标事件(参见acceptedMouseButtons())，否则它们不会传播。一个被禁用的项目不能成为鼠标抓取器，因此，如果一个项目在抓取鼠标时被禁用，它就会失去抓取器，就像它在被禁用时有焦点，它就会失去焦点一样。
禁用项通常使用灰色绘制(参见QPalette::Disabled)。
如果禁用父项，则其所有子项也将禁用。如果你启用一个父项，所有的子项都将被启用，除非它们已经被显式禁用(即，如果你在一个子项上调用setEnabled(false)，如果它的父项被禁用，它将不会被重新启用，然后再次启用)。
默认情况下，项是启用的。
注意:如果您安装了事件过滤器，您仍然可以在事件传递给项目之前拦截事件;此机制忽略项的启用状态。

setFiltersChildEvents 过滤事件

setFiltersChildEvents(bool enabled)
1

如果enabled为true，则将此项目设置为过滤所有子项目的所有事件(即，针对其任何子项目的所有事件都被发送到此项目);否则，如果enabled为false，则此项将只处理其自己的事件。默认值为false。

setFlag 设置标志

setFlag(QGraphicsItem::GraphicsItemFlag flag, bool enabled = true)
1

如果enabled为true，则项目标志flag为启用;否则，禁用。

setFlags 设置标志

setFlags(QGraphicsItem::GraphicsItemFlags flags)
1

将项标志设置为flags。flags中的所有标志都是启用的;所有不在标志中的标志都被禁用。
如果项目有焦点，并且flags没有启用ItemIsFocusable，则该项目将由于调用该函数而失去焦点。类似地，如果项目已被选中，并且flags未启用ItemIsSelectable，则该项目将自动取消选中。
缺省情况下，不启用任何标志。(QGraphicsWidget默认启用ItemSendsGeometryChanges标志，以便跟踪位置变化。)

setFocus 键盘输入焦点

setFocus(Qt::FocusReason focusReason = Qt::OtherFocusReason)
1

为该项目提供键盘输入焦点。focusReason参数将被传递到这个函数生成的任何焦点事件中;它用来解释是什么导致了该项目的焦点。
只有设置了ItemIsFocusable标志的启用项才能接受键盘焦点。
如果此项目不可见、不活动或不与场景关联，则它将不会获得即时输入焦点。然而，它将被注册为它的子树的首选焦点项，如果它以后变得可见的话。
作为调用这个函数的结果，这个项目将通过focusReason接收一个焦点事件。如果另一个项目已经有了焦点，那么该项目将首先收到一个焦点输出事件，表明它已经失去了输入焦点。

setFocusProxy 焦点代理

setFocusProxy(QGraphicsItem *item)
1

将项的焦点代理设置为item。
如果项目具有焦点代理，则焦点代理将在项目获得输入焦点时接收输入焦点。项目本身仍然具有焦点(即，hasFocus()将返回true)，但是只有焦点代理将接收键盘输入。
焦点代理本身可以有一个焦点代理，以此类推。在这种情况下，键盘输入将由最外层的焦点代理处理。
焦点代理项必须与此项属于同一场景。

setGraphicsEffect 设置效果

setGraphicsEffect(QGraphicsEffect *effect)
1

将effect设置为项目的效果。如果此项目上已经安装了效果，QGraphicsItem将在安装新效果之前删除现有效果。您可以通过调用setgraphicseeffect (nullptr)来删除现有的效果。
如果effect是安装在其他项目上的效果，setGraphicsEffect()将从项目中删除效果并将其安装在该项目上。
QGraphicsItem拥有所有权。
注意:此函数将对其自身及其所有子函数应用此效果。

setGroup 设置组

setGroup(QGraphicsItemGroup *group)
1

将此项目添加到项目组组中。如果group为nullptr，则该项将从任何当前组中删除，并作为前一个组的父组的子组添加。

setInputMethodHints 设置提示

setInputMethodHints(Qt::InputMethodHints hints)
1

将该项的当前输入法提示设置为提示。

setOpacity 透明度

setOpacity(qreal opacity)
1

设置该项的局部不透明度，介于0.0(透明)和1.0(不透明)之间。项目的局部不透明度与父不透明度和父不透明度结合到effectiveOpacity()中。
默认情况下，不透明度从父节点传播到子节点，所以如果父节点的不透明度为0.5，子节点的不透明度也为0.5，那么子节点的有效不透明度将为0.25。
不透明度属性决定了传递给paint()函数的绘制器的状态。如果项被缓存，即ItemCoordinateCache或DeviceCoordinateCache，则在呈现项时将有效属性应用于项的缓存。
有两个项目标志会影响项目的不透明度与父项目的组合方式:ItemIgnoresParentOpacity和ItemDoesntPropagateOpacityToChildren。
注意:将项目的不透明度设置为0不会使项目不可见(根据isVisible())，但该项目将被视为不可见的项目。有关更多信息，请参阅setVisible()的文档。

setPanelModality 设置模态

setPanelModality(QGraphicsItem::PanelModality panelModality)
1

将该项的模态设置为panelModality。
更改可见项的模态会立即生效。

setParentItem 设置父项

setParentItem(QGraphicsItem *newParent)
1

将该项的父项设置为newParent。如果此项已经有父项，则首先将其从前一个父项中删除。如果newParent为0，则此项将成为顶级项。
注意，这将隐式地将该图形项添加到父场景中。你不应该自己将物品添加到场景中。
在newParent的祖先项上调用此函数时的行为是未定义的。

setPos 设置位置

setPos(const QPointF &pos)
setPos(qreal x, qreal y)
1
2

将项目的位置设置为pos，它位于父坐标中。对于没有父项的项目，pos在场景坐标中。
项目的位置在父坐标中描述了它的原点(本地坐标(0,0))。

setRotation 设置旋转角度

setRotation(qreal angle)
1

设置绕Z轴的顺时针旋转角度(以度为单位)。默认值为0(即，不旋转项目)。赋负值将使项目逆时针旋转。通常情况下，旋转角度在(- 360,360)范围内，但也有可能在这个范围之外赋值(例如，旋转370度与旋转10度相同)。
项目围绕其转换原点旋转，默认情况下为(0,0)。您可以通过调用setTransformOriginPoint()来选择不同的转换原点。
旋转与项目的scale()、transform()和transforms()相结合，将项目的坐标系统映射到父项目。

setScale

setScale(qreal factor)
1

设置项目的比例因子。默认的比例因子是1.0(即，项目没有缩放)。比例系数为0.0将把项目折叠为单个点。如果您提供负比例因子，则项目将被翻转和镜像(即旋转180度)。
项目围绕其转换原点缩放，默认值为(0,0)。您可以通过调用setTransformOriginPoint()来选择不同的转换原点。
比例与项目的rotation()、transform()和transformations()相结合，将项目的坐标系统映射到父项目。

setSelected 是否可选

setSelected(bool selected)
1

如果selected为真值并且此项目是可选择的，则选中此项目;否则，未选中。
如果项目在一个组中，则通过此功能切换整个组的选择状态。如果选中该组，则选中该组中的所有项目;如果未选中该组，则不选中该组中的任何项目。
只能选择可见的、启用的、可选择的项目。如果selected为true，并且该项不可见或禁用或不可选，则此函数不执行任何操作。
缺省情况下，不允许选择项目。要启用选择，请设置ItemIsSelectable标志。
提供此功能是为了方便，允许单独切换项目的选定状态。然而，更常见的选择项目的方法是调用QGraphicsScene::setSelectionArea()，它将为场景中指定区域内的所有可见、启用和可选择的项目调用此函数。

setToolTip 设置工具提示

setToolTip(const QString &toolTip)
1

将项目的工具提示设置为toolTip。如果toolTip为空，则清除该项目的工具提示。

setTransform 设置变换矩阵

setTransform(const QTransform &matrix, bool combine = false)
1

将项目的当前变换矩阵设置为matrix。
如果combine为真，则矩阵与当前矩阵组合;否则，矩阵替换当前矩阵。Combine默认为false。
为了使用转换后的视图简化与项的交互，QGraphicsItem提供了mapTo…和mapFrom……可以在物品和场景坐标之间进行转换的功能。例如，你可以调用mapToScene()将项目坐标映射到场景坐标，或者调用mapFromScene()将场景坐标映射到项目坐标。
转换矩阵与项目的rotation(), scale() 和transformations()组合成一个组合转换，将项目的坐标系映射到它的父坐标系。

setTransformOriginPoint 设置转换原点

setTransformOriginPoint(const QPointF &origin)
setTransformOriginPoint(qreal x, qreal y)
1
2

在项坐标中设置转换的原点。

setTransformations 设置图形转换列表

setTransformations(const QList<QGraphicsTransform *> &transformations)
1

设置当前应用于此项的图形转换列表(qgraphicstrtransform)。
如果你想旋转或缩放一个项目，你应该调用setRotation()或setScale()。如果您想在一个项目上设置任意的转换，您可以调用setTransform()。
QGraphicsTransform 用于应用和控制项目上的单个转换操作链。它在动画中特别有用，其中每个转换操作需要独立或不同地插值。
这些转换与项目的rotation()、scale()和transform()相结合，将项目的坐标系统映射到父项目。

setVisible 设置是否可见

setVisible(bool visible)
1

如果visible为true，则使项目可见。否则，该项将不可见。不可见的物品不会被绘制，也不会收到任何事件。特别是，鼠标事件直接通过不可见的项目，并传递给任何可能在后面的项目。不可见的项目也是不可选择的，它们不能作为输入焦点，也不能被QGraphicsScene的项目定位函数检测到。
如果一个项目在抓取鼠标时变得不可见(即，当它正在接收鼠标事件时)，它将自动失去鼠标抓取，并且不会通过使项目再次可见而重新获得抓取;它必须接受一个新的鼠标按压来重新获得鼠标抓取。
同样地，不可见的道具也不能有焦点，所以如果道具在变得不可见的时候有焦点，它就会失去焦点，并且不能通过让道具再次可见来恢复焦点。
如果隐藏父项，则它的所有子项也将被隐藏。如果你显示父项，所有的子项都会显示，除非它们被显式地隐藏(也就是说，如果你在一个子项上调用setVisible(false)，即使它的父项被隐藏，它也不会被重新显示，然后再次显示)。
默认情况下，项是可见的;不需要在新项上调用setVisible()。
注意:不透明度设置为0的项仍然被认为是可见的，尽管它将被视为不可见的项:鼠标事件将通过它，它将不包括在QGraphicsView::items()返回的项中，等等。但是，该项目将保留焦点。

setX 位置的x坐标

setX(qreal x)
1

设置项目位置的x坐标。相当于调用setPos(x, y())。

setY 位置的y坐标

setY(qreal y)
1

设置项目位置的y坐标。相当于调用setPos(x()， y)。

setZValue 设置z值

setZValue(qreal z)
将项目的z值设置为z。z值决定兄弟(相邻)项目的堆叠顺序。高Z值的兄弟项目将始终绘制在Z值较低的兄弟项目的顶部。
如果恢复Z值，则项目的插入顺序将决定其堆叠顺序。
z值不会以任何方式影响项目的大小。
默认z值为0。

其他函数或属性

acceptDrops属性

在Qt中，acceptDrops是一个用于控制一个窗口部件（widget）是否接受拖放操作的属性。当acceptDrops属性被设置为true时，窗口部件将接受拖放操作；当设置为false时，窗口部件将拒绝拖放操作。

• 作用：acceptDrops属性用于指示窗口部件是否接受拖放操作。
• 类型：布尔类型，可以设置为true或false。
• 默认值：通常情况下，acceptDrops的默认值是false，即窗口部件默认不接受拖放操作。
• 设置方法：你可以通过调用setAcceptDrops(true)或setAcceptDrops(false)来设置窗口部件的acceptDrops属性。

使用示例

// 在一个自定义的QWidget中启用拖放功能
class MyWidget : public QWidget {
public:
    MyWidget(QWidget *parent = nullptr) : QWidget(parent) {
        setAcceptDrops(true); // 启用拖放功能
    }

    // 实现拖放事件的处理函数
    void dragEnterEvent(QDragEnterEvent *event) override {
        // 处理拖放进入事件
        event->acceptProposedAction();
    }

    void dropEvent(QDropEvent *event) override {
        // 处理拖放释放事件
        event->acceptProposedAction();
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在上面的示例中，我们创建了一个自定义的QWidget子类MyWidget，在构造函数中设置了acceptDrops属性为true，启用了拖放功能。同时，我们重写了dragEnterEvent和dropEvent函数来处理拖放事件。

注意事项

• 在使用拖放功能时，除了设置窗口部件的acceptDrops属性外，还需要实现相应的事件处理函数来处理拖放事件，如dragEnterEvent、dropEvent等。
• 通过设置窗口部件的acceptDrops属性为true，你可以实现在窗口部件上进行拖放操作，从而实现更加灵活的用户交互体验。

通过设置窗口部件的acceptDrops属性为true，你可以方便地启用拖放功能，让用户可以通过拖放操作在应用程序中进行数据交互和操作。

acceptHoverEvents属性

在Qt中，acceptHoverEvents是一个用于控制窗口部件（widget）是否接受鼠标悬停事件的属性。当acceptHoverEvents属性被设置为true时，窗口部件将接受鼠标悬停事件；当设置为false时，窗口部件将不接受鼠标悬停事件。

• 作用：acceptHoverEvents属性用于指示窗口部件是否接受鼠标悬停事件。
• 类型：布尔类型，可以设置为true或false。
• 默认值：通常情况下，acceptHoverEvents的默认值是false，即窗口部件默认不接受鼠标悬停事件。
• 设置方法：你可以通过调用setAcceptHoverEvents(true)或setAcceptHoverEvents(false)来设置窗口部件的acceptHoverEvents属性。

使用示例

// 在一个自定义的QWidget中启用鼠标悬停事件
class MyWidget : public QWidget {
public:
    MyWidget(QWidget *parent = nullptr) : QWidget(parent) {
        setAcceptHoverEvents(true); // 启用鼠标悬停事件
    }

    // 实现鼠标悬停事件的处理函数
    void hoverEnterEvent(QHoverEvent *event) override {
        // 处理鼠标悬停进入事件
    }

    void hoverLeaveEvent(QHoverEvent *event) override {
        // 处理鼠标悬停离开事件
    }

    void hoverMoveEvent(QHoverEvent *event) override {
        // 处理鼠标悬停移动事件
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在上面的示例中，我们创建了一个自定义的QWidget子类MyWidget，在构造函数中设置了acceptHoverEvents属性为true，启用了鼠标悬停事件。同时，我们重写了hoverEnterEvent、hoverLeaveEvent和hoverMoveEvent函数来处理鼠标悬停事件。

注意事项

• 在使用鼠标悬停事件时，除了设置窗口部件的acceptHoverEvents属性外，还需要实现相应的事件处理函数来处理鼠标悬停事件，如hoverEnterEvent、hoverLeaveEvent、hoverMoveEvent等。
• 通过设置窗口部件的acceptHoverEvents属性为true，你可以让窗口部件接受鼠标悬停事件，从而实现更加灵活的用户交互体验。

通过设置窗口部件的acceptHoverEvents属性为true，你可以方便地启用鼠标悬停事件，让用户可以通过鼠标悬停在窗口部件上时触发相应的交互效果或操作。

acceptTouchEvents属性

在Qt中，acceptTouchEvents是一个用于控制窗口部件（widget）是否接受触摸事件的属性。当acceptTouchEvents属性被设置为true时，窗口部件将接受触摸事件；当设置为false时，窗口部件将不接受触摸事件。

• 作用：acceptTouchEvents属性用于指示窗口部件是否接受触摸事件。
• 类型：布尔类型，可以设置为true或false。
• 默认值：通常情况下，acceptTouchEvents的默认值是false，即窗口部件默认不接受触摸事件。
• 设置方法：你可以通过调用setAcceptTouchEvents(true)或setAcceptTouchEvents(false)来设置窗口部件的acceptTouchEvents属性。

使用示例

// 在一个自定义的QWidget中启用触摸事件
class MyWidget : public QWidget {
public:
    MyWidget(QWidget *parent = nullptr) : QWidget(parent) {
        setAcceptTouchEvents(true); // 启用触摸事件
    }

    // 实现触摸事件的处理函数
    bool event(QEvent *event) override {
        if (event->type() == QEvent::TouchBegin) {
            // 处理触摸开始事件
            return true;
        } else if (event->type() == QEvent::TouchUpdate) {
            // 处理触摸更新事件
            return true;
        } else if (event->type() == QEvent::TouchEnd) {
            // 处理触摸结束事件
            return true;
        }
        
        return QWidget::event(event);
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

在上面的示例中，我们创建了一个自定义的QWidget子类MyWidget，在构造函数中设置了acceptTouchEvents属性为true，启用了触摸事件。同时，我们重写了event函数来处理触摸事件，根据不同的事件类型（如TouchBegin、TouchUpdate、TouchEnd）来执行相应的操作。

注意事项

• 在使用触摸事件时，除了设置窗口部件的acceptTouchEvents属性外，还需要实现相应的事件处理函数来处理触摸事件，如重写event函数并根据事件类型来处理触摸事件。
• 通过设置窗口部件的acceptTouchEvents属性为true，你可以让窗口部件接受触摸事件，从而实现支持触摸屏的用户交互体验。

通过设置窗口部件的acceptTouchEvents属性为true，你可以方便地启用触摸事件，让用户可以通过触摸屏在窗口部件上进行交互操作。

acceptedMouseButtons 属性

acceptedMouseButtons 是 Qt 中用于指定窗口部件（widget）接受哪些鼠标按钮事件的属性。通过设置 acceptedMouseButtons，你可以限制窗口部件只接受特定的鼠标按钮事件。

• 作用：acceptedMouseButtons 属性用于指定窗口部件接受哪些鼠标按钮事件。
• 类型：Qt::MouseButtons 枚举类型，可以设置为一个或多个鼠标按钮的组合。
• 默认值：通常情况下，acceptedMouseButtons 的默认值是 Qt::AllButtons，表示窗口部件接受所有鼠标按钮事件。
• 设置方法：你可以通过调用 setAcceptedMouseButtons(Qt::MouseButtons buttons) 来设置窗口部件的 acceptedMouseButtons 属性。

使用示例

// 在一个自定义的 QWidget 中设置接受特定鼠标按钮事件
class MyWidget : public QWidget {
public:
    MyWidget(QWidget *parent = nullptr) : QWidget(parent) {
        setAcceptedMouseButtons(Qt::LeftButton | Qt::RightButton); // 只接受左键和右键的鼠标按钮事件
    }

    // 实现鼠标事件的处理函数
    void mousePressEvent(QMouseEvent *event) override {
        if (event->button() == Qt::LeftButton) {
            // 处理左键点击事件
        } else if (event->button() == Qt::RightButton) {
            // 处理右键点击事件
        }
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在上面的示例中，我们创建了一个自定义的 QWidget 子类 MyWidget，在构造函数中设置了 acceptedMouseButtons 属性为 Qt::LeftButton | Qt::RightButton，表示窗口部件只接受左键和右键的鼠标按钮事件。同时，我们重写了 mousePressEvent 函数来处理鼠标按钮事件，并根据不同的按钮类型执行相应的操作。

注意事项

• 通过设置窗口部件的 acceptedMouseButtons 属性，你可以限制窗口部件只接受特定的鼠标按钮事件，从而控制用户与窗口部件的交互行为。
• 在实现鼠标事件处理函数时，记得根据 acceptedMouseButtons 的设置来判断具体的鼠标按钮事件，并执行相应的操作。

通过设置 acceptedMouseButtons 属性，你可以灵活地控制窗口部件接受哪些鼠标按钮事件，从而定制窗口部件的交互行为，以满足特定的用户需求。

advance() 函数

在Qt中，advance() 是一个用于告知窗口部件（widget）在下一个绘图更新时需要执行的函数。当调用 advance() 函数时，它会通知窗口部件，告知其需要在下一个绘图更新时执行额外的操作，比如更新动画、处理特定事件等。

• 作用：advance() 函数用于通知窗口部件在下一个绘图更新时需要执行额外的操作。
• 调用时机：通常情况下，你可以在需要进行额外操作的地方调用 advance() 函数，比如在处理动画、特定事件等情况下。
• 使用方法：直接调用窗口部件的 advance() 函数即可。

示例

// 在一个自定义的 QWidget 中使用 advance() 函数
class MyWidget : public QWidget {
public:
    MyWidget(QWidget *parent = nullptr) : QWidget(parent) {
        // 其他初始化操作
    }

    // 在某个需要执行额外操作的地方调用 advance()
    void someFunction() {
        // 执行一些操作
        advance(); // 调用 advance() 函数通知窗口部件在下一个绘图更新时执行额外操作
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13

在上面的示例中，我们创建了一个自定义的 QWidget 子类 MyWidget，在 someFunction() 函数中调用了 advance() 函数，通知窗口部件在下一个绘图更新时执行额外的操作。

注意事项

• 调用 advance() 函数会触发 QEvent::UpdateRequest 事件，告知窗口部件在下一个绘图更新时需要执行额外的操作。
• 在调用 advance() 函数后，窗口部件会在下一个绘图更新时进行相应的操作，这可以用于实现一些需要在特定时机执行的逻辑，比如更新动画状态、处理特定事件等。

通过调用 advance() 函数，你可以灵活地通知窗口部件在下一个绘图更新时执行额外的操作，从而实现更加定制化和交互性的窗口部件行为。

boundingRect 函数

在Qt中，boundingRect 是一个用于返回图形项（Graphics Item）边界矩形的函数。这个函数通常在自定义的图形项类中被重写，用于指定图形项的边界矩形，以便正确地进行绘制和碰撞检测。

• 作用：boundingRect 函数用于返回图形项的边界矩形，即该图形项占据的矩形区域。
• 返回类型：QRectF，表示一个浮点精度的矩形区域。
• 使用方法：在自定义的图形项类中重写 boundingRect 函数，根据图形项的实际形状和位置来计算并返回边界矩形。

示例

// 自定义的图形项类，重写 boundingRect 函数
class CustomGraphicsItem : public QGraphicsItem {
public:
    QRectF boundingRect() const override {
        // 返回图形项的边界矩形，这里假设图形项位于原点，宽度为100，高度为50
        return QRectF(0, 0, 100, 50);
    }

    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr) override {
        // 在 paint 函数中绘制图形项的内容
        painter->drawRect(boundingRect()); // 绘制边界矩形
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13

在上面的示例中，我们创建了一个自定义的图形项类 CustomGraphicsItem，并重写了 boundingRect 函数以及 paint 函数。在 boundingRect 函数中，我们返回了一个矩形区域作为图形项的边界矩形，这里假设图形项位于原点，宽度为100，高度为50。在 paint 函数中，我们使用 painter 绘制了图形项的内容，包括绘制了边界矩形。

注意事项

• boundingRect 函数的返回值应该准确地描述图形项的边界矩形，以确保正确的绘制和碰撞检测。
• 在重写 boundingRect 函数时，应根据图形项的实际形状和位置来计算边界矩形，避免返回过大或过小的矩形，以提高性能和准确性。

通过重写 boundingRect 函数，你可以指定图形项的边界矩形，从而确保正确的绘制和碰撞检测，提升图形项的可视化效果和交互性。

boundingRegionGranularity 属性

boundingRegionGranularity 是用于指定绘图的粒度或精度的属性，通常用于优化绘图性能。在Qt中，这个属性通常用于控制绘图引擎在绘制图形项时的精细程度。

• 作用：boundingRegionGranularity 属性用于指定绘图引擎在计算图形项的边界矩形时的粒度或精度。通过调整这个属性，可以在绘图性能和绘制质量之间进行权衡。
• 类型：通常是一个整数值，用于表示粒度的程度。
• 默认值：具体的默认值取决于Qt的版本和具体的图形项类。

示例

// 设置 boundingRegionGranularity 属性
myGraphicsItem->setFlag(QGraphicsItem::ItemUsesExtendedStyleOption);
myGraphicsItem->setBoundingRegionGranularity(0.5);
1
2
3

在上面的示例中，我们展示了如何为一个图形项 myGraphicsItem 设置 boundingRegionGranularity 属性。通过调整这个属性，可以控制绘图引擎在计算图形项的边界矩形时的粒度，从而影响绘图性能和绘制质量。

注意事项

• 调整 boundingRegionGranularity 属性可以在一定程度上优化绘图性能，特别是当有大量复杂的图形项需要绘制时。
• 但是需要注意，过高的粒度可能会导致绘图性能下降，因为绘图引擎需要更多的计算来确定精细的边界矩形。

通过了解和调整 boundingRegionGranularity 属性，你可以在绘图性能和绘制质量之间找到一个平衡点，以获得最佳的绘图效果。如果你有任何其他问题或需要进一步的帮助，请随时告诉我。

cacheMode 属性

在Qt中，cacheMode 是用于设置图形项的缓存模式的属性。通过设置不同的缓存模式，可以优化图形项的绘制性能，特别是在需要频繁重绘的情况下。

• 作用：cacheMode 属性用于指定图形项的缓存模式，以优化绘图性能。
• 类型：枚举类型，表示不同的缓存模式选项。
• 默认值：具体的默认值取决于Qt的版本和具体的图形项类。

常见的 cacheMode 值

1. QGraphicsItem::NoCache：不使用缓存，每次绘制都重新计算。
2. QGraphicsItem::ItemCoordinateCache：使用局部坐标系缓存，适用于不经常变化的图形项。
3. QGraphicsItem::DeviceCoordinateCache：使用设备坐标系缓存，适用于频繁变化但不需要重新计算坐标转换的图形项。
4. QGraphicsItem::ItemCoordinateCache：使用局部坐标系缓存，适用于不经常变化的图形项。

示例

// 设置 cacheMode 属性
myGraphicsItem->setCacheMode(QGraphicsItem::DeviceCoordinateCache);
1
2

在上面的示例中，我们展示了如何为一个图形项 myGraphicsItem 设置 cacheMode 属性。通过调整这个属性，可以根据图形项的特性和需要优化绘图性能。

注意事项

• 使用适当的 cacheMode 可以显著提高图形项的绘制性能，尤其是在需要频繁重绘或者复杂图形项的情况下。
• 需要根据具体的应用场景和图形项的特性来选择合适的缓存模式，以获得最佳的性能表现。

通过了解和设置 cacheMode 属性，你可以有效地优化图形项的绘制性能，提升应用程序的用户体验。

childItems 函数

在Qt中，childItems 是一个函数，用于获取一个图形项的所有子图形项。当你在Qt中使用图形项来构建复杂的图形场景时，childItems 函数可以帮助你管理和操作图形项的层次结构。

• 作用：获取一个图形项的所有子图形项。
• 返回值：一个 QList<QGraphicsItem*> 类型的列表，包含了该图形项的所有子图形项。
• 示例：

  QList<QGraphicsItem*> items = parentItem->childItems();
  1

示例代码

假设你有一个父图形项 parentItem，它包含了多个子图形项。你可以使用 childItems 函数来获取这些子图形项，然后对它们进行操作，比如移动、隐藏或删除。

QList<QGraphicsItem*> items = parentItem->childItems();
for (QGraphicsItem* item : items) {
    // 对每个子图形项进行操作
    item->setPos(item->pos() + QPointF(10, 10)); // 移动子图形项
    item->setVisible(false); // 隐藏子图形项
    // 其他操作...
}
1
2
3
4
5
6
7

注意事项

• 使用 childItems 函数可以方便地遍历父图形项的所有子图形项，从而对它们进行批量操作。
• 当你需要对图形场景中的多个图形项进行统一处理时，childItems 函数是一个很有用的工具。

通过使用 childItems 函数，你可以更加方便地管理复杂的图形场景中的图形项，从而实现更灵活和高效的图形界面交互。

childrenBoundingRect() 函数

在Qt中，childrenBoundingRect() 是一个函数，用于返回一个图形项的所有子图形项的边界矩形。这个函数返回的矩形是包围所有子图形项的最小矩形，可以帮助你确定父图形项的大小和位置，以便正确显示所有子图形项。

• 作用：返回一个矩形，该矩形包围了图形项的所有子图形项。
• 返回值：一个 QRectF 类型的矩形，表示所有子图形项的边界矩形。
• 示例：

  QRectF boundingRect = parentItem->childrenBoundingRect();
  1

示例代码

假设你有一个父图形项 parentItem，它包含了多个子图形项。你可以使用 childrenBoundingRect() 函数来获取一个矩形，该矩形包围了所有子图形项的边界，从而可以根据这个矩形来确定父图形项的大小和位置。

QRectF boundingRect = parentItem->childrenBoundingRect();
parentItem->setPos(-boundingRect.width() / 2, -boundingRect.height() / 2);
parentItem->setSize(boundingRect.size());
1
2
3

在上面的示例中，我们获取了父图形项的所有子图形项的边界矩形，并根据这个矩形来设置父图形项的位置和大小，以确保所有子图形项都能正确显示在父图形项内部。

注意事项

• 使用 childrenBoundingRect() 函数可以帮助你更好地管理和布局包含多个子图形项的父图形项。
• 这个函数对于动态调整父图形项的大小和位置以适应子图形项的情况非常有用。

通过使用 childrenBoundingRect() 函数，你可以更好地控制父图形项与其子图形项之间的布局关系，从而实现更灵活和精确的图形界面设计。

clearFocus() 函数

在Qt中，clearFocus() 是一个函数，用于清除当前拥有焦点的部件（widget）的焦点。当一个部件（如按钮、文本框等）获得焦点时，它会响应键盘事件。通过调用 clearFocus() 函数，你可以将焦点从当前部件移除，使其不再响应键盘事件。

• 作用：清除当前拥有焦点的部件的焦点。
• 示例：

  QWidget *currentFocusWidget = QApplication::focusWidget();
  if (currentFocusWidget) {
      currentFocusWidget->clearFocus();
  }
  1
  2
  3
  4

示例代码

以下是一个简单的示例代码，演示如何使用 clearFocus() 函数来清除当前拥有焦点的部件的焦点：

// 获取当前拥有焦点的部件
QWidget *currentFocusWidget = QApplication::focusWidget();

// 如果存在拥有焦点的部件，则清除其焦点
if (currentFocusWidget) {
    currentFocusWidget->clearFocus();
}
1
2
3
4
5
6
7

在上面的示例中，我们首先获取当前拥有焦点的部件，然后调用 clearFocus() 函数来清除它的焦点。这可以用于在特定情况下，例如用户执行某个操作后，希望将焦点从当前部件移除。

注意事项

• clearFocus() 函数可以帮助你管理部件的焦点，确保正确的部件响应键盘事件。
• 当你需要在程序中控制焦点的转移或清除时，可以使用这个函数来实现。

通过使用 clearFocus() 函数，你可以灵活地控制部件之间焦点的转移，从而提高用户界面的交互性和用户体验。

clipPath 进行裁剪

在Qt中，clipPath 是用于设置图形项（QGraphicsItem）裁剪路径的属性。裁剪路径可以用来限制图形项的绘制区域，只有在裁剪路径范围内的内容才会被显示，超出裁剪路径范围的内容将被隐藏。
在Qt中，你可以通过以下步骤来使用 clipPath 进行裁剪：

1. 创建一个裁剪路径（QPainterPath）。
2. 将裁剪路径设置为图形项的 clipPath 属性。

下面是一个简单的示例代码，演示了如何使用 clipPath 进行裁剪：

// 创建一个裁剪路径
QPainterPath clipPath;
clipPath.addRect(0, 0, 100, 100); // 在(0, 0)位置创建一个100x100的矩形裁剪区域

// 将裁剪路径设置为图形项的clipPath属性
yourGraphicsItem->setClipPath(clipPath);
1
2
3
4
5
6

在上面的示例中，我们首先创建了一个矩形裁剪路径，然后将其设置为图形项 yourGraphicsItem 的 clipPath 属性。这样，只有在矩形裁剪区域内的内容才会被显示，超出裁剪区域的内容将被隐藏。

注意事项

• 使用 clipPath 可以帮助你限制图形项的绘制区域，实现特定区域的显示效果。
• 裁剪路径可以是任何形状，不仅限于矩形，你可以根据需要创建不同形状的裁剪路径。

通过使用 clipPath 属性，你可以灵活地控制图形项的显示范围，实现各种有趣的视觉效果。如果你有任何其他问题或需要进一步的帮助，请随时告诉我。

collidesWithItem 函数

在Qt中，collidesWithItem 是一个用于检测两个图形项（QGraphicsItem）是否相交的函数。它可以帮助你判断一个图形项是否与另一个图形项发生了碰撞。
collidesWithItem 函数有两个重载版本：

1. bool QGraphicsItem::collidesWithItem(const QGraphicsItem *other, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const：检测当前图形项是否与指定的其他图形项相交。

2. bool QGraphicsItem::collidesWithItem(const QGraphicsItem *other, Qt::ItemSelectionMode mode, const QPointF &scenePoint)：检测当前图形项是否与指定的其他图形项相交，并指定场景中的点。

示例代码

以下是一个简单的示例代码，演示了如何使用 collidesWithItem 函数来检测两个图形项是否相交：

QGraphicsItem *item1 = ...; // 第一个图形项
QGraphicsItem *item2 = ...; // 第二个图形项

if (item1->collidesWithItem(item2)) {
    // 两个图形项发生了碰撞
    // 可以在这里处理碰撞事件
}
1
2
3
4
5
6
7

在这个示例中，我们首先获取了两个图形项 item1 和 item2，然后使用 collidesWithItem 函数检测它们是否相交。如果它们相交，我们可以在相交的情况下执行特定的操作，比如处理碰撞事件或者改变它们的状态。

注意事项

• collidesWithItem 函数可以帮助你检测图形项之间的碰撞，以便在需要时采取相应的行动。
• 可以根据需要选择合适的重载版本，并根据返回值来判断是否发生了碰撞。

通过使用 collidesWithItem 函数，你可以在Qt中方便地检测图形项之间是否发生了碰撞，从而实现更加交互性和动态性的图形界面。

collidingItems()函数的功能：

collidingItems()函数是QGraphicsItem类中的一个非常有用的函数，用于获取与当前图形项发生碰撞的其他图形项列表。当您需要在Qt中实现碰撞检测时，这个函数可以帮助您快速找到与当前图形项碰撞的其他图形项，从而执行相应的操作。

• 功能：获取与当前图形项发生碰撞的其他图形项列表。
• 返回值：QList<QGraphicsItem*>，包含与当前图形项发生碰撞的其他图形项。

使用示例：

下面是一个简单的示例，演示了如何使用collidingItems()函数来获取与给定QGraphicsItem发生碰撞的其他图形项并输出其信息：

#include <QGraphicsItem>

// 获取与给定图形项item发生碰撞的其他图形项列表
QList<QGraphicsItem*> getCollidingItems(QGraphicsItem* item)
{
    QList<QGraphicsItem*> collidingItems = item->collidingItems();

    // 输出碰撞的图形项信息
    for (QGraphicsItem* collidingItem : collidingItems) {
        qDebug() << "Colliding with item:" << collidingItem;
    }

    return collidingItems;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这个示例中，getCollidingItems函数接受一个QGraphicsItem指针作为参数，并使用collidingItems()函数来获取与该图形项发生碰撞的其他图形项列表。然后，它遍历并输出碰撞的图形项信息。

通过使用collidingItems()函数，您可以轻松地实现碰撞检测逻辑，并在需要时处理碰撞事件。

collidesWithPath()函数的功能：

在Qt中，QGraphicsItem类还提供了一个名为collidesWithPath()的函数，用于检查图形项是否与给定的QPainterPath对象相交。该函数可以用于执行更复杂的碰撞检测，例如检查图形项是否与指定路径相交，而不仅仅是与其他图形项发生碰撞。

• 功能：检查图形项是否与给定的QPainterPath对象相交。
• 参数：QPainterPath对象，用于检查与图形项的碰撞。
• 返回值：true表示相交，false表示不相交。

使用示例：

下面是一个简单的示例，演示了如何使用collidesWithPath()函数来检查一个QGraphicsItem对象是否与一个QPainterPath对象相交：

#include <QGraphicsItem>
#include <QPainterPath>

// 检查图形项item是否与给定路径path相交
bool checkCollisionWithPath(QGraphicsItem* item, const QPainterPath& path)
{
    return item->collidesWithPath(path);
}
1
2
3
4
5
6
7
8

在这个示例中，checkCollisionWithPath函数接受一个QGraphicsItem指针和一个QPainterPath对象作为参数，并使用collidesWithPath()函数来检查图形项是否与给定路径相交。函数将返回true表示相交，false表示不相交。

使用collidesWithPath()函数可以帮助您执行更灵活和复杂的碰撞检测，从而实现更多样化的图形项交互和处理逻辑。

commonAncestorItem()函数的功能：

用于查找两个QGraphicsItem对象的共同祖先（common ancestor）。共同祖先是指两个图形项在场景中的层次结构中共同的最近的祖先图形项。

• 功能：查找两个QGraphicsItem对象的共同祖先。
• 参数：另一个QGraphicsItem对象。
• 返回值：返回两个图形项的共同祖先QGraphicsItem对象。

使用示例：

下面是一个简单的示例，演示了如何使用commonAncestorItem()函数来查找两个QGraphicsItem对象的共同祖先：

#include <QGraphicsItem>

// 查找两个图形项item1和item2的共同祖先
QGraphicsItem* findCommonAncestorItem(QGraphicsItem* item1, QGraphicsItem* item2)
{
    QGraphicsItem* commonAncestor = item1->commonAncestorItem(item2);

    return commonAncestor;
}
1
2
3
4
5
6
7
8
9

在这个示例中，findCommonAncestorItem函数接受两个QGraphicsItem指针作为参数，并使用commonAncestorItem()函数来查找这两个图形项的共同祖先。函数将返回一个QGraphicsItem指针，指向这两个图形项的共同祖先。

通过使用commonAncestorItem()函数，您可以轻松地查找两个图形项在场景中的层次结构中的共同祖先，这对于处理图形项之间的关系和交互非常有用。

contains()函数的功能：

用于检查指定的点是否在图形项的边界框内部。这个函数通常用于判断鼠标点击是否在图形项上，从而实现交互功能。

• 功能：检查指定的点是否在图形项的边界框内部。
• 参数：QPointF类型的点坐标。
• 返回值：如果点在图形项的边界框内部，则返回true；否则返回false。

使用示例：

下面是一个简单的示例，演示了如何使用contains()函数来检查一个点是否在图形项的边界框内部：

#include <QGraphicsItem>
#include <QPointF>

// 检查点point是否在图形项item的边界框内部
bool checkPointInItem(QGraphicsItem* item, const QPointF& point)
{
    return item->contains(point);
}
1
2
3
4
5
6
7
8

在这个示例中，checkPointInItem函数接受一个QGraphicsItem指针和一个QPointF类型的点坐标作为参数，并使用contains()函数来检查这个点是否在图形项的边界框内部。函数将返回true表示点在边界框内部，返回false表示点不在边界框内部。

通过使用contains()函数，您可以实现对图形项的点击检测，以便根据用户的交互来执行相应的操作。

data()函数的功能：

用于存储和检索与图形项相关联的用户自定义数据。这个函数是一个灵活的方式，可以让您为图形项存储额外的信息，以便在需要时检索并使用。

• 功能：存储和检索与图形项相关联的用户自定义数据。
• 参数：int类型的角色（Role）值，用于区分不同类型的数据。
• 返回值：存储在指定角色下的数据，以QVariant类型返回。

使用示例：

下面是一个简单的示例，演示了如何使用data()函数来为图形项存储和检索自定义数据：

#include <QGraphicsItem>
#include <QVariant>

// 设置图形项item的自定义数据
void setCustomData(QGraphicsItem* item)
{
    int customRole = Qt::UserRole + 1; // 定义一个自定义角色
    item->setData(customRole, QVariant("CustomDataValue"));
}

// 获取图形项item的自定义数据
void getCustomData(QGraphicsItem* item)
{
    int customRole = Qt::UserRole + 1; // 自定义角色
    QVariant data = item->data(customRole);
    
    if (data.isValid())
    {
        QString customDataValue = data.toString();
        qDebug() << "Custom Data Value: " << customDataValue;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在这个示例中，setCustomData函数演示了如何为图形项设置自定义数据，它使用自定义的角色值（Qt::UserRole + 1）来存储一个字符串类型的数据。getCustomData函数演示了如何检索这个自定义数据，并将其打印输出。

通过使用data()函数，您可以为图形项存储各种类型的数据，以满足您的需求。这种方式对于需要在图形项之间共享数据或者在图形项上存储额外信息的情况非常有用。

deviceTransform()函数的功能：

用于获取与图形项相关联的设备变换。设备变换描述了如何将图形项的本地坐标映射到场景中的像素坐标。这对于绘制和渲染图形项在视图中的位置和大小非常有用。

• 功能：获取与图形项相关联的设备变换。
• 返回值：QTransform类型，表示图形项的设备变换。

使用示例：

下面是一个简单的示例，演示了如何使用deviceTransform()函数来获取图形项的设备变换：

#include <QGraphicsItem>
#include <QTransform>

// 获取图形项item的设备变换
void getDeviceTransform(QGraphicsItem* item)
{
    QTransform deviceTransform = item->deviceTransform(QTransform(), 0);
    
    // 打印设备变换矩阵的内容
    qDebug() << "Device Transform Matrix:";
    qDebug() << deviceTransform.m11() << " " << deviceTransform.m12() << " " << deviceTransform.m13();
    qDebug() << deviceTransform.m21() << " " << deviceTransform.m22() << " " << deviceTransform.m23();
    qDebug() << deviceTransform.m31() << " " << deviceTransform.m32() << " " << deviceTransform.m33();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

在这个示例中，getDeviceTransform函数演示了如何获取图形项的设备变换，并打印了设备变换矩阵的内容。设备变换矩阵描述了如何将图形项的本地坐标映射到场景中的像素坐标。

通过使用deviceTransform()函数，您可以获得有关图形项如何在场景中呈现的重要信息。这对于处理图形项的绘制和渲染非常有用。

effectiveOpacity()函数的功能：

用于获取图形项的有效不透明度。有效不透明度是指图形项在场景中实际显示时的不透明度，考虑了其父项的不透明度。

• 功能：获取图形项的有效不透明度。
• 返回值：qreal类型，表示图形项的有效不透明度，范围为0.0（完全透明）到1.0（完全不透明）。

使用示例：

下面是一个简单的示例，演示了如何使用effectiveOpacity()函数来获取图形项的有效不透明度：

#include <QGraphicsItem>

// 获取图形项item的有效不透明度
qreal getEffectiveOpacity(QGraphicsItem* item)
{
    qreal opacity = item->effectiveOpacity();
    
    // 打印有效不透明度
    qDebug() << "Effective Opacity: " << opacity;
    
    return opacity;
}
1
2
3
4
5
6
7
8
9
10
11
12

在这个示例中，getEffectiveOpacity函数演示了如何获取图形项的有效不透明度，并打印了该值。有效不透明度考虑了图形项的不透明度以及其父项的不透明度，因此它表示了图形项在场景中实际显示时的不透明度。

通过使用effectiveOpacity()函数，您可以获取有关图形项在场景中显示时的不透明度信息，这对于处理图形项的可视化效果非常有用。

ensureVisible()函数的功能：

用于确保指定的图形项在视图中可见。这个函数可以用于滚动视图以确保特定的图形项在视图中可见。

• 功能：确保指定的图形项在视图中可见。
• 参数：可以传递一个x和y的QRectF参数，用于指定图形项在视图中的可见区域。
• 返回值：无。

使用示例：

下面是一个简单的示例，演示了如何使用ensureVisible()函数来确保指定的图形项在视图中可见：

#include <QGraphicsView>
#include <QGraphicsItem>

// 确保图形项item在视图view中可见
void ensureItemVisible(QGraphicsView* view, QGraphicsItem* item)
{
    view->ensureVisible(item);
}
1
2
3
4
5
6
7
8

在这个示例中，ensureItemVisible函数演示了如何使用ensureVisible()函数确保指定的图形项在视图中可见。这对于在视图中自动滚动以使特定图形项可见非常有用。

通过使用ensureVisible()函数，您可以在处理大型场景并确保特定图形项可见时提供方便。

filtersChildEvents函数的功能：

用于指定是否过滤子对象的事件。当filtersChildEvents设置为true时，表示该对象会过滤其子对象的事件，而不会将这些事件传递给子对象进行处理。

• 功能：指定是否过滤子对象的事件。
• 参数：bool filter，表示是否过滤子对象的事件。
• 返回值：无。

使用示例：

下面是一个简单的示例，演示了如何使用filtersChildEvents函数来设置是否过滤子对象的事件：

#include <QObject>

// 设置对象obj是否过滤子对象的事件
void setFilterChildEvents(QObject* obj, bool filter)
{
    obj->setFiltersChildEvents(filter);
}
1
2
3
4
5
6
7

在这个示例中，setFilterChildEvents函数演示了如何使用filtersChildEvents函数来设置对象是否过滤其子对象的事件。通过设置filtersChildEvents为true，可以阻止子对象接收事件，从而在父对象层面处理这些事件。

这个函数对于在事件处理过程中控制事件传递和处理非常有用。

flags函数的功能：

用于获取图形项的标志（flags）。这些标志描述了图形项的各种属性和行为，例如是否可以移动、是否可以选择等。

• 功能：获取图形项的标志（flags）。
• 返回值：QGraphicsItem::GraphicsItemFlags，表示图形项的各种属性和行为。

使用示例：

下面是一个简单的示例，演示了如何使用flags函数来获取图形项的标志：

#include <QGraphicsItem>

// 获取图形项item的标志
QGraphicsItem::GraphicsItemFlags getItemFlags(QGraphicsItem* item)
{
    return item->flags();
}
1
2
3
4
5
6
7

在这个示例中，getItemFlags函数演示了如何使用flags函数来获取图形项的标志。通过检查图形项的标志，您可以了解图形项的属性和行为，以便根据需要进行相应的操作。

使用flags函数可以帮助您在处理图形项时了解其属性，例如是否可以移动、是否可以选择等。

focusProxy功能和用法：

focusProxy是一个属性，用于设置或获取QGraphicsItem对象的焦点代理。焦点代理是用于处理焦点的对象，当QGraphicsItem对象无法直接获得焦点时，焦点会被传递给焦点代理对象。

• 功能：focusProxy属性用于设置或获取QGraphicsItem对象的焦点代理。
• 类型：QGraphicsItem*。
• 默认值：nullptr，表示没有焦点代理。
• 作用：当QGraphicsItem对象无法直接获得焦点时，焦点会被传递给焦点代理对象。

示例：

下面是一个简单的示例，演示了如何在Qt中使用focusProxy属性来设置焦点代理：

#include <QGraphicsItem>

// 创建两个自定义的 QGraphicsItem 对象
QGraphicsItem *item1 = new QGraphicsItem;
QGraphicsItem *item2 = new QGraphicsItem;

// 将 item2 设置为 item1 的焦点代理
item1->setFocusProxy(item2);

// 检查 item1 的焦点代理是否为 item2
if (item1->focusProxy() == item2) {
    // 焦点代理设置成功
}
1
2
3
4
5
6
7
8
9
10
11
12
13

在这个示例中，我们创建了两个自定义的QGraphicsItem对象item1和item2。然后，通过调用setFocusProxy函数，我们将item2设置为item1的焦点代理。最后，我们检查了item1的焦点代理是否为item2，以确认焦点代理设置成功。

通过设置焦点代理，您可以实现在QGraphicsItem对象之间传递焦点，从而更灵活地管理焦点控制。

grabKeyboard函数的功能：

在Qt中，grabKeyboard是一个函数，用于将键盘输入捕获到特定的QGraphicsItem对象，而不是普通的QWidget窗口部件。

• 功能：将键盘输入捕获到特定的QGraphicsItem对象。
• 参数：无。
• 返回值：void。

使用示例：

下面是一个简单的示例，演示了如何在Qt中使用QGraphicsItem::grabKeyboard函数将键盘输入捕获到一个QGraphicsItem对象：

#include <QGraphicsItem>

// 创建一个自定义的 QGraphicsItem 类
class CustomGraphicsItem : public QGraphicsItem {
public:
    CustomGraphicsItem() {}

    // 重写 QGraphicsItem 的 keyPressEvent 函数
    void keyPressEvent(QKeyEvent *event) override {
        // 处理键盘事件
    }
};

// 创建一个 CustomGraphicsItem 对象
CustomGraphicsItem *customItem = new CustomGraphicsItem;

// 将键盘输入捕获到这个 CustomGraphicsItem 对象
customItem->grabKeyboard();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

在这个示例中，我们首先创建了一个自定义的QGraphicsItem类CustomGraphicsItem，并重写了其中的keyPressEvent函数来处理键盘事件。然后创建了一个CustomGraphicsItem对象customItem，并调用了grabKeyboard函数将键盘输入捕获到该对象。

通过使用grabKeyboard函数，您可以实现在QGraphicsItem对象中处理键盘事件，从而实现更复杂的图形交互逻辑。请注意，与普通的QWidget窗口部件类似，在某个QGraphicsItem对象调用了grabKeyboard函数后，确保在适当的时机调用ungrabKeyboard函数来释放键盘捕获。

grabMouse函数的功能：

在Qt中，grabMouse是一个函数，用于将鼠标输入捕获到特定的QGraphicsItem对象，而不是普通的QWidget窗口部件。

• 功能：将鼠标输入捕获到特定的QGraphicsItem对象。
• 参数：无。
• 返回值：void。

使用示例：

下面是一个简单的示例，演示了如何在Qt中使用QGraphicsItem::grabMouse函数将键盘输入捕获到一个QGraphicsItem对象：

#include <QGraphicsItem>

// 创建一个自定义的 QGraphicsItem 类
class CustomGraphicsItem : public QGraphicsItem {
public:
    CustomGraphicsItem() : QGraphicsItem() {
        isMouseGrabbed = false;
    }

    // 重写 mousePressEvent 函数来处理鼠标抓取
    void mousePressEvent(QGraphicsSceneMouseEvent *event) override {
        // 捕获鼠标
        isMouseGrabbed = true;
        // 处理鼠标事件
    }

    // 重写 mouseReleaseEvent 函数来释放鼠标
    void mouseReleaseEvent(QGraphicsSceneMouseEvent *event) override {
        // 释放鼠标
        isMouseGrabbed = false;
};

// 创建一个 CustomGraphicsItem 对象
CustomGraphicsItem *customItem = new CustomGraphicsItem;

// 将鼠标输入捕获到这个 CustomGraphicsItem 对象
customItem->grabMouse();
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

在这个示例中，我们首先创建了一个自定义的QGraphicsItem类CustomGraphicsItem，并重写了其中的keyPressEvent函数来处理键盘事件。然后创建了一个CustomGraphicsItem对象customItem，并调用了grabKeyboard函数将键盘输入捕获到该对象。

通过使用grabKeyboard函数，您可以实现在QGraphicsItem对象中处理键盘事件，从而实现更复杂的图形交互逻辑。请注意，与普通的QWidget窗口部件类似，在某个QGraphicsItem对象调用了grabKeyboard函数后，确保在适当的时机调用ungrabKeyboard函数来释放键盘捕获。

QGraphicsEffect函数

QGraphicsItem::graphicsEffect()函数用于获取应用于QGraphicsItem的QGraphicsEffect对象。如果QGraphicsItem没有应用任何效果，该函数将返回nullptr。

以下是一个简单的示例，演示如何使用QGraphicsItem::graphicsEffect()函数来获取应用于QGraphicsItem的效果对象：

#include <QGraphicsItem>
#include <QGraphicsEffect>
#include <QDebug>

// 假设有一个CustomGraphicsItem类继承自QGraphicsItem
class CustomGraphicsItem : public QGraphicsItem {
public:
    CustomGraphicsItem() : QGraphicsItem() {
        // 在构造函数中为CustomGraphicsItem应用一个效果
        QGraphicsDropShadowEffect *shadowEffect = new QGraphicsDropShadowEffect;
        shadowEffect->setBlurRadius(10);
        shadowEffect->setOffset(5, 5);
        
        setGraphicsEffect(shadowEffect);
    }
};

// 在某处获取CustomGraphicsItem对象的效果
CustomGraphicsItem item;
QGraphicsEffect *effect = item.graphicsEffect();

if (effect) {
    qDebug() << "Graphics effect found!";
} else {
    qDebug() << "No graphics effect applied.";
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

在这个示例中，我们创建了一个自定义的QGraphicsItem子类CustomGraphicsItem，在其构造函数中应用了一个阴影效果。然后，我们使用graphicsEffect()函数来获取应用于CustomGraphicsItem的效果对象，并根据返回结果输出相应的消息。

通过使用QGraphicsItem::graphicsEffect()函数，您可以轻松地获取应用于QGraphicsItem的效果对象，并进一步操作或修改这些效果。

group()函数

用于获取与QGraphicsItem相关联的QGraphicsItemGroup对象。如果QGraphicsItem没有被添加到任何组中，该函数将返回nullptr。

QGraphicsItemGroup是一个用于将多个QGraphicsItem对象组合在一起的类。通过将多个图形项添加到QGraphicsItemGroup中，您可以对它们进行集体操作，例如移动、旋转或删除。

以下是一个简单的示例，演示如何使用QGraphicsItem::group()函数来获取与QGraphicsItem相关联的QGraphicsItemGroup对象：

#include <QGraphicsItem>
#include <QGraphicsItemGroup>
#include <QDebug>

// 假设有一个CustomGraphicsItem类继承自QGraphicsItem
class CustomGraphicsItem : public QGraphicsItem {
public:
    CustomGraphicsItem() : QGraphicsItem() {
        // 在构造函数中创建CustomGraphicsItem对象
    }
};

// 创建一个QGraphicsItemGroup并将CustomGraphicsItem添加到组中
QGraphicsItemGroup group;
CustomGraphicsItem item1;
CustomGraphicsItem item2;

group.addToGroup(&item1);
group.addToGroup(&item2);

// 获取与CustomGraphicsItem相关联的组
QGraphicsItemGroup *itemGroup = item1.group();

if (itemGroup) {
    qDebug() << "Item is part of a group.";
} else {
    qDebug() << "Item is not part of any group.";
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

在这个示例中，我们创建了两个自定义的QGraphicsItem对象item1和item2，然后将它们添加到一个QGraphicsItemGroup对象group中。接着，我们使用group()函数来获取item1所属的组，并根据返回结果输出相应的消息。

通过使用QGraphicsItem::group()函数，您可以轻松地获取与QGraphicsItem相关联的组对象，从而实现对组中所有图形项的集体操作。

hide 函数

QGraphicsItem::hide()是一个函数，用于隐藏QGraphicsItem对象。当调用hide()函数时，QGraphicsItem对象将不再在QGraphicsScene中可见，但仍然存在于场景中，只是不再被绘制。

使用示例

下面是一个简单的示例，演示如何使用hide()函数隐藏一个QGraphicsItem对象：

#include <QGraphicsItem>
#include <QGraphicsScene>
#include <QGraphicsView>
#include <QApplication>

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);

    // 创建一个场景
    QGraphicsScene scene;

    // 创建一个矩形项
    QGraphicsRectItem *rectItem = new QGraphicsRectItem(0, 0, 100, 100);
    rectItem->setPos(100, 100);
    scene.addItem(rectItem);

    // 显示场景
    QGraphicsView view(&scene);
    view.show();

    // 隐藏矩形项
    rectItem->hide();

    return app.exec();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

在这个示例中，我们首先创建了一个QGraphicsScene对象scene，然后创建了一个矩形项rectItem并将其添加到场景中。接着，我们显示了包含这个场景的QGraphicsView对象view。最后，我们调用hide()函数来隐藏矩形项rectItem，使其在场景中不可见。

请注意，隐藏一个QGraphicsItem对象并不会从场景中移除它，只是让它不可见。如果您希望完全移除一个QGraphicsItem对象，可以使用QGraphicsScene::removeItem()函数将其从场景中移除。
在Qt中，inputMethodHints是QGraphicsItem类的一个属性，用于指定输入法相关的提示。这个属性通常用于指示输入法如何处理文本输入和显示。

inputMethodHints属性

inputMethodHints属性可以在QGraphicsItem对象上设置，以影响与输入法相关的行为。以下是一些常见的inputMethodHints值及其含义：

• Qt::ImhNone: 没有特定的输入法提示。
• Qt::ImhHiddenText: 输入法应该隐藏输入文本。
• Qt::ImhSensitiveData: 输入法应该处理敏感数据。
• Qt::ImhNoAutoUppercase: 不要自动将输入转换为大写。
• Qt::ImhPreferNumbers: 输入法应该优先显示数字键盘。

您可以通过调用setInputMethodHints()函数来设置inputMethodHints属性，例如：

myGraphicsItem->setInputMethodHints(Qt::ImhHiddenText);
1

这将在myGraphicsItem上设置inputMethodHints属性为隐藏输入文本，告诉输入法应该隐藏用户输入的文本。

请注意，inputMethodHints属性通常与文本输入相关，用于指导输入法如何处理文本输入。如果您的QGraphicsItem对象不涉及文本输入，您可能不需要设置这个属性。

itemTransform函数

itemTransform是QGraphicsItem类中的一个函数，用于获取或设置与该图形项相关联的变换矩阵。这个函数允许您检索或更改应用于图形项的转换，例如平移、旋转和缩放。

在Qt中，QGraphicsItem类提供了许多与图形项变换相关的函数，其中itemTransform是其中之一。通过itemTransform函数，您可以获取或设置与特定图形项关联的变换矩阵。这个变换矩阵描述了如何将图形项的局部坐标系映射到其父项的坐标系中。

示例：

// 获取与图形项关联的变换矩阵
QTransform QGraphicsItem::itemTransform() const;

// 设置与图形项关联的变换矩阵
void QGraphicsItem::setItemTransform(const QTransform &matrix, bool combine = false);
1
2
3
4
5

• itemTransform()函数返回一个QTransform对象，表示与该图形项关联的变换矩阵。
• setItemTransform(const QTransform &matrix, bool combine = false)函数用于设置与该图形项关联的变换矩阵。参数matrix是要应用的新变换矩阵，combine参数指示是否应将新矩阵与当前变换矩阵组合。

通过使用itemTransform函数，您可以在QGraphicsItem对象上执行各种变换操作，从而实现平移、旋转、缩放等效果。

mapFromItem函数

mapFromItem是QGraphicsItem类中用于将另一个图形项的坐标映射到当前图形项坐标系中的函数。这个函数可以帮助您在不同图形项之间进行坐标转换，特别是在处理图形项嵌套或组合的情况下非常有用。

mapFromItem函数的语法

QPointF QGraphicsItem::mapFromItem(const QGraphicsItem *item, const QPointF &point)
QPolygonF QGraphicsItem::mapFromItem(const QGraphicsItem *item, const QRectF &rect)
QPolygonF QGraphicsItem::mapFromItem(const QGraphicsItem *item, const QPolygonF &polygon)
QPainterPath QGraphicsItem::mapFromItem(const QGraphicsItem *item, const QPainterPath &path)
QPointF QGraphicsItem::mapFromItem(const QGraphicsItem *item, qreal x, qreal y)
QPolygonF QGraphicsItem::mapFromItem(const QGraphicsItem *item, qreal x, qreal y, qreal w, qreal h)
1
2
3
4
5
6

• mapFromItem函数接受两个参数：item是要映射坐标的源图形项，要映射的图像或点。
• mapFromItem函数返回源图形项中给定点或矩形在当前图形项坐标系中的坐标。

示例用法

QGraphicsItem *sourceItem = ...; // 源图形项
QGraphicsItem *targetItem = ...; // 目标图形项

QPointF sourcePoint(10, 10);
QPointF mappedPoint = targetItem->mapFromItem(sourceItem, sourcePoint);
1
2
3
4
5

在上面的示例中，mappedPoint将包含sourceItem中sourcePoint在targetItem坐标系中的坐标。

通过使用mapFromItem函数，您可以方便地在不同图形项之间转换坐标，从而实现复杂的图形布局和交互操作。

mapFromParent函数

mapFromParent是QGraphicsItem类中用于将父级图形项的坐标映射到当前图形项坐标系中的函数。通过mapFromParent函数，您可以方便地将父级图形项中的坐标转换为当前图形项的坐标系中，这在处理图形项的相对位置和布局时非常有用。

mapFromParent函数的语法

QPointF QGraphicsItem::mapFromParent(const QPointF &point) const;
QPolygonF QGraphicsItem::mapFromParent(const QRectF &rect) const;
QPointF QGraphicsItem::mapFromParent(const QPointF &point)
QPolygonF QGraphicsItem::mapFromParent(const QRectF &rect)
QPolygonF QGraphicsItem::mapFromParent(const QPolygonF &polygon)
QPainterPath QGraphicsItem::mapFromParent(const QPainterPath &path)
QPointF QGraphicsItem::mapFromParent(qreal x, qreal y)
QPolygonF QGraphicsItem::mapFromItem(qreal x, qreal y, qreal w, qreal h)
1
2
3
4
5
6
7
8

• mapFromParent函数接受一个参数：要映射的图行或点
• mapFromParent函数返回父级图形项中给定点或矩形在当前图形项坐标系中的坐标。

示例用法

QGraphicsItem *parentItem = ...; // 父级图形项
QGraphicsItem *childItem = ...; // 当前图形项

QPointF parentPoint(20, 20);
QPointF mappedPoint = childItem->mapFromParent(parentPoint);
1
2
3
4
5

在上面的示例中，mappedPoint将包含parentItem中parentPoint在childItem坐标系中的坐标。

通过使用mapFromParent函数，您可以轻松地在父级图形项和当前图形项之间进行坐标转换，从而实现复杂的图形布局和交互操作。

mapFromScene 函数

mapFromScene 是 QGraphicsItem 类中用于将场景坐标映射到当前图形项坐标系中的函数。通过 mapFromScene 函数，您可以方便地将场景中的坐标转换为当前图形项的坐标系中，这在处理图形项的相对位置和布局时非常有用。

mapFromScene 函数的语法

QPointF QGraphicsItem::mapFromScene(const QPointF &point) const;
QPolygonF QGraphicsItem::mapFromScene(const QRectF &rect) const;
QPolygonF QGraphicsItem::mapFromScene(const QPolygonF &polygon);
QPainterPath QGraphicsItem::mapFromScene(const QPainterPath &path)
QPointF QGraphicsItem::mapFromScene(qreal x, qreal y)
QPolygonF QGraphicsItem::mapFromScene(qreal x, qreal y, qreal w, qreal h)
1
2
3
4
5
6

• mapFromScene 函数接受一个参数：point 或 rect 是要映射的点或矩形。
• mapFromScene 函数返回场景中给定点或矩形在当前图形项坐标系中的坐标。

示例用法

QGraphicsItem *item = ...; // 当前图形项

QPointF scenePoint(100, 100);
QPointF mappedPoint = item->mapFromScene(scenePoint);
1
2
3
4

在上面的示例中，mappedPoint 将包含场景中 scenePoint 在 item 坐标系中的坐标。

通过使用 mapFromScene 函数，您可以轻松地在场景坐标和当前图形项坐标之间进行转换，从而实现复杂的图形布局和交互操作。

mapRectFromItem 函数

mapRectFromItem 是 QGraphicsItem 类中用于将另一个图形项的矩形区域映射到当前图形项坐标系中的函数。通过 mapRectFromItem 函数，您可以方便地将另一个图形项的矩形区域转换为当前图形项的坐标系中，这在处理图形项的相对位置和布局时非常有用。

mapRectFromItem 函数的语法

QRectF QGraphicsItem::mapRectFromItem(const QGraphicsItem *item, const QRectF &rect) const;
1

• mapRectFromItem 函数接受两个参数：item 是要映射的另一个图形项，rect 是该图形项中的矩形区域。
• mapRectFromItem 函数返回另一个图形项中给定矩形区域在当前图形项坐标系中的矩形区域。

示例用法

QGraphicsItem *item1 = ...; // 当前图形项
QGraphicsItem *item2 = ...; // 另一个图形项

QRectF item2Rect(50, 50, 100, 100);
QRectF mappedRect = item1->mapRectFromItem(item2, item2Rect);
1
2
3
4
5

在上面的示例中，mappedRect 将包含 item2 中 item2Rect 在 item1 坐标系中的矩形区域。
通过使用 mapRectFromItem 函数，您可以轻松地在另一个图形项的坐标系和当前图形项的坐标系之间进行矩形区域的转换，从而实现复杂的图形布局和交互操作。
在 Qt 中，mapRectFromParent 函数用于将父级图形项的矩形区域映射到当前图形项的坐标系中。这个函数可以帮助您在处理图形项的相对位置和布局时进行坐标转换。

mapRectFromParent 函数的语法

QRectF QGraphicsItem::mapRectFromParent(const QRectF &rect) const;
QRectF QGraphicsItem::mapRectFromParent(qreal x, qreal y, qreal w, qreal h);
1
2

• mapRectFromParent 函数接受一个参数：rect 是父级图形项中的矩形区域。
• mapRectFromParent 函数返回父级图形项中给定矩形区域在当前图形项坐标系中的矩形区域。

示例用法

QGraphicsItem *parentItem = ...; // 父级图形项
QGraphicsItem *childItem = ...; // 当前图形项

QRectF parentRect(50, 50, 100, 100);
QRectF mappedRect = childItem->mapRectFromParent(parentRect);
1
2
3
4
5

在上面的示例中，mappedRect 将包含父级图形项中 parentRect 在当前图形项坐标系中的矩形区域。

mapRectFromScene 函数

通过使用 mapRectFromParent 函数，您可以方便地在父级图形项的坐标系和当前图形项的坐标系之间进行矩形区域的转换，从而实现复杂的图形布局和交互操作。
在 Qt 中，mapRectFromScene 函数用于将场景中的矩形区域映射到当前图形项的坐标系中。这个函数可以帮助您在处理图形项的相对位置和布局时进行坐标转换。

mapRectFromScene 函数的语法

QRectF QGraphicsItem::mapRectFromScene(const QRectF &rect);
QRectF QGraphicsItem::mapRectFromScene(qreal x, qreal y, qreal w, qreal h);
1
2

• mapRectFromScene 函数接受一个参数：rect 是场景中的矩形区域。
• mapRectFromScene 函数返回场景中给定矩形区域在当前图形项坐标系中的矩形区域。

示例用法

QGraphicsItem *item = ...; // 当前图形项
QGraphicsScene *scene = item->scene(); // 获取当前图形项所在的场景

QRectF sceneRect(50, 50, 100, 100);
QRectF mappedRect = item->mapRectFromScene(sceneRect);
1
2
3
4
5

在上面的示例中，mappedRect 将包含场景中 sceneRect 在当前图形项坐标系中的矩形区域。

mapRectToItem 函数

通过使用 mapRectFromScene 函数，您可以方便地在场景坐标系和当前图形项的坐标系之间进行矩形区域的转换，从而实现复杂的图形布局和交互操作。
在 Qt 中，mapRectToItem 函数用于将当前图形项的矩形区域映射到另一个图形项的坐标系中。这个函数可以帮助您在处理图形项的相对位置和布局时进行坐标转换。

mapRectToItem 函数的语法

QRectF QGraphicsItem::mapRectToItem(const QGraphicsItem *item, const QRectF &rect);
QRectF QGraphicsItem::mapRectToItem(const QGraphicsItem *item, qreal x, qreal y, qreal w, qreal h)
1
2

• mapRectToItem 函数接受两个参数：item 是目标图形项，rect 是当前图形项中的矩形区域。
• mapRectToItem 函数返回当前图形项中给定矩形区域在目标图形项坐标系中的矩形区域。

示例用法

QGraphicsItem *sourceItem = ...; // 当前图形项
QGraphicsItem *targetItem = ...; // 目标图形项

QRectF sourceRect(50, 50, 100, 100);
QRectF mappedRect = sourceItem->mapRectToItem(targetItem, sourceRect);
1
2
3
4
5

在上面的示例中，mappedRect 将包含当前图形项中 sourceRect 在目标图形项坐标系中的矩形区域。

mapRectToParent 函数

通过使用 mapRectToItem 函数，您可以方便地在当前图形项的坐标系和另一个图形项的坐标系之间进行矩形区域的转换，从而实现复杂的图形布局和交互操作。
在 Qt 中，mapRectToParent 函数用于将当前图形项的矩形区域映射到其父级图形项的坐标系中。这个函数可以帮助您在处理图形项的相对位置和布局时进行坐标转换。

mapRectToParent 函数的语法

QRectF QGraphicsItem::mapRectToParent(const QRectF &rect);
QRectF QGraphicsItem::mapRectToParent(qreal x, qreal y, qreal w, qreal h) 
1
2

• mapRectToParent 函数接受一个参数：rect 是当前图形项中的矩形区域。
• mapRectToParent 函数返回当前图形项中给定矩形区域在其父级图形项坐标系中的矩形区域。

示例用法

QGraphicsItem *item = ...; // 当前图形项
QGraphicsItem *parentItem = item->parentItem(); // 获取当前图形项的父级图形项

QRectF itemRect(50, 50, 100, 100);
QRectF mappedRect = item->mapRectToParent(itemRect);
1
2
3
4
5

在上面的示例中，mappedRect 将包含当前图形项中 itemRect 在其父级图形项坐标系中的矩形区域。

mapRectToScene 函数

通过使用 mapRectToParent 函数，您可以方便地在当前图形项的坐标系和其父级图形项的坐标系之间进行矩形区域的转换，从而实现复杂的图形布局和交互操作。
在 Qt 中，mapRectToScene 函数用于将当前图形项的矩形区域映射到场景的坐标系中。这个函数可以帮助您在处理图形项的相对位置和布局时进行坐标转换。

mapRectToScene 函数的语法

QRectF QGraphicsItem::mapRectToScene(const QRectF &rect);
QRectF QGraphicsItem::mapRectToScene(qreal x, qreal y, qreal w, qreal h);
1
2

• mapRectToScene 函数接受一个参数：rect 是当前图形项中的矩形区域。
• mapRectToScene 函数返回当前图形项中给定矩形区域在场景坐标系中的矩形区域。

示例用法

QGraphicsItem *item = ...; // 当前图形项
QRectF itemRect(50, 50, 100, 100);
QRectF mappedRect = item->mapRectToScene(itemRect);
1
2
3

在上面的示例中，mappedRect 将包含当前图形项中 itemRect 在场景坐标系中的矩形区域。

mapToItem 函数

通过使用 mapRectToScene 函数，您可以方便地在当前图形项的坐标系和场景坐标系之间进行矩形区域的转换，从而实现复杂的图形布局和交互操作。
mapToItem 是一个用于在 Qt 中进行坐标转换的函数，它允许将一个点从一个图形项的坐标系映射到另一个图形项的坐标系。这对于处理图形项之间的交互和布局非常有用。

mapToItem 函数的语法

QPointF QGraphicsItem::mapToItem(const QGraphicsItem *item, const QPointF &point);
QPolygonF QGraphicsItem::mapToItem(const QGraphicsItem *item, const QRectF &rect)
QPolygonF QGraphicsItem::mapToItem(const QGraphicsItem *item, const QPolygonF &polygon)
QPainterPath QGraphicsItem::mapToItem(const QGraphicsItem *item, const QPainterPath &path)
QPointF QGraphicsItem::mapToItem(const QGraphicsItem *item, qreal x, qreal y)
QPolygonF QGraphicsItem::mapToItem(const QGraphicsItem *item, qreal x, qreal y, qreal w, qreal h)
1
2
3
4
5
6

• mapToItem 函数接受两个参数：item 是目标图形项，point 是当前图形项中的点。
• mapToItem 函数返回当前图形项中给定点在目标图形项坐标系中的对应点。

示例用法

QGraphicsItem *item1 = ...; // 当前图形项
QGraphicsItem *item2 = ...; // 目标图形项
QPointF item1Point(50, 50);
QPointF mappedPoint = item1->mapToItem(item2, item1Point);
1
2
3
4

在上面的示例中，mappedPoint 将是当前图形项 item1 中 item1Point 在目标图形项 item2 坐标系中的对应点。

mapToParent 函数

通过使用 mapToItem 函数，您可以方便地在不同图形项之间进行坐标转换，从而实现复杂的图形布局和交互操作。
mapToParent 是在 Qt 中用于进行坐标转换的函数，它允许将一个点从当前图形项的坐标系映射到其父图形项的坐标系。

mapToParent 函数的语法

QPointF QGraphicsItem::mapToParent(const QPointF &point) const;
QPolygonF QGraphicsItem::mapToParent(const QPolygonF &polygon)
QPainterPath QGraphicsItem::mapToParent(const QPainterPath &path)
QPointF QGraphicsItem::mapToParent(qreal x, qreal y)
QPolygonF QGraphicsItem::mapToParent(qreal x, qreal y, qreal w, qreal h)
1
2
3
4
5

• mapToParent 函数接受一个参数：point 是当前图形项中的点。
• mapToParent 函数返回当前图形项中给定点在父图形项坐标系中的对应点。

示例用法

QGraphicsItem *item = ...; // 当前图形项
QPointF itemPoint(50, 50);
QPointF mappedPoint = item->mapToParent(itemPoint);
1
2
3

在上面的示例中，mappedPoint 将是当前图形项 item 中 itemPoint 在父图形项坐标系中的对应点。

mapToScene 函数

通过使用 mapToParent 函数，您可以方便地在当前图形项和其父图形项之间进行坐标转换，从而实现更复杂的图形布局和交互操作。
mapToScene 是在 Qt 中用于进行坐标转换的函数，它允许将一个点从当前图形项的坐标系映射到场景的全局坐标系。

mapToScene 函数的语法

QPointF QGraphicsItem::mapToScene(const QPointF &point) const;
QPolygonF QGraphicsItem::mapToScene(const QRectF &rect)
QPolygonF QGraphicsItem::mapToScene(const QPolygonF &polygon)
QPainterPath QGraphicsItem::mapToScene(const QPainterPath &path)
QPointF QGraphicsItem::mapToScene(qreal x, qreal y)
QPolygonF QGraphicsItem::mapToScene(qreal x, qreal y, qreal w, qreal h)
1
2
3
4
5
6

• mapToScene 函数接受一个参数：point 是当前图形项中的点。
• mapToScene 函数返回当前图形项中给定点在场景坐标系中的对应点。

示例用法

QGraphicsItem *item = ...; // 当前图形项
QPointF itemPoint(50, 50);
QPointF mappedPoint = item->mapToScene(itemPoint);
1
2
3

在上面的示例中，mappedPoint 将是当前图形项 item 中 itemPoint 在场景坐标系中的对应点。

moveBy 移动函数

moveBy 是在 Qt 中用于移动图形项位置的函数，它允许您通过指定偏移量来移动图形项的位置。

moveBy 函数的语法

void QGraphicsItem::moveBy(qreal dx, qreal dy);
1

• moveBy 函数接受两个参数：dx 是沿 x 轴的偏移量，dy 是沿 y 轴的偏移量。
• 调用 moveBy 函数会将当前图形项沿指定偏移量移动。

示例用法

QGraphicsItem *item = ...; // 当前图形项
item->moveBy(10, 10); // 将图形项沿 x 轴移动 10 个单位，沿 y 轴移动 10 个单位
1
2

在上面的示例中，调用 moveBy(10, 10) 将使当前图形项向右下方移动 10 个单位。

opacity() 不透明函数

在 Qt 中，您可以使用 opacity() 函数来获取图形项的当前不透明度（opacity）级别。这个函数可以让您查询图形项当前的透明度值，以便在需要时进行进一步处理。

opacity() 函数的语法

qreal QGraphicsItem::opacity() const;
1

• opacity() 函数是一个常量成员函数，不会修改图形项的状态，只是返回当前图形项的不透明度级别。
• 返回值类型为 qreal，即浮点数，表示图形项的不透明度级别。取值范围为 0.0（完全透明）到 1.0（完全不透明）之间。

示例用法

QGraphicsItem *item = ...; // 当前图形项
qreal currentOpacity = item->opacity(); // 获取当前图形项的不透明度
1
2

在上面的示例中，currentOpacity 变量将保存当前图形项的不透明度级别，您可以根据这个值来进行后续的处理或判断。

通过使用 opacity() 函数，您可以方便地查询图形项当前的不透明度值，从而实现更灵活的图形项透明度控制和交互。

opaqueArea 不透明区域

在 Qt 中，opaqueArea 是 QGraphicsItem 类的一个函数，用于指定图形项的不透明区域。这个函数可以帮助提高绘图性能，因为它告诉场景框架哪些区域是不透明的，从而避免对这些区域进行不必要的绘制。

opaqueArea 函数的作用

opaqueArea 函数用于指定图形项的不透明区域，告诉场景框架哪些区域是不透明的。这样，当场景需要进行绘制时，就可以跳过这些不透明区域，提高绘图性能。

示例用法

QRectF QGraphicsItem::opaqueArea() const;
1

• opaqueArea() 函数返回一个 QRectF 对象，表示图形项的不透明区域的矩形范围。
• 您可以重写 opaqueArea() 函数来指定图形项的不透明区域。如果不重写该函数，默认情况下，整个图形项被视为不透明。

示例

class CustomItem : public QGraphicsItem
{
public:
    QRectF opaqueArea() const override
    {
        return boundingRect(); // 指定不透明区域为整个图形项的边界矩形
    }
};
1
2
3
4
5
6
7
8

在上面的示例中，CustomItem 类重写了 opaqueArea() 函数，将不透明区域指定为整个图形项的边界矩形。这样，当场景框架需要进行绘制时，就会跳过这个不透明区域，提高绘图性能。

通过合理地使用 opaqueArea 函数，您可以优化图形项的绘制性能，特别是对于复杂的图形项或需要频繁重绘的场景。

paint() 函数

在 Qt 中，绘制（painting）是一个重要的概念，用于在图形项（QGraphicsItem）上绘制内容。绘制通常涉及重写 QGraphicsItem 类的 paint() 函数来定义绘制行为。通过重写 paint() 函数，您可以自定义图形项的外观和绘制逻辑。

重写 paint() 函数

void QGraphicsItem::paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr);
1

• paint() 函数是 QGraphicsItem 类的虚函数，用于绘制图形项的内容。
• painter 参数是一个 QPainter 对象，用于执行绘制操作。
• option 参数提供了有关绘制选项的信息，例如绘制的状态和样式。
• widget 参数是可选的，通常用于提供与图形项相关的小部件。

示例用法

以下是一个简单的示例，展示了如何重写 paint() 函数来绘制一个简单的矩形：

class CustomItem : public QGraphicsItem
{
public:
    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override
    {
        Q_UNUSED(widget); // 避免未使用的警告

        // 设置绘制样式
        painter->setBrush(Qt::red);
        painter->setPen(Qt::black);

        // 绘制矩形
        painter->drawRect(boundingRect());
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在上面的示例中，CustomItem 类重写了 paint() 函数，设置了绘制样式（红色填充，黑色边框）并绘制了一个矩形。您可以根据需要自定义绘制逻辑，绘制任何您想要的内容。

调用 update() 函数

在修改了图形项的内容后，通常需要调用 update() 函数来触发重绘操作，以便更新图形项的外观。这会导致 paint() 函数被调用，从而实现内容的绘制更新。

// 在需要更新绘制内容时调用update()
item->update();
1
2

通过合理地使用 paint() 函数，您可以实现自定义的图形项绘制逻辑，从而创建各种视觉效果和图形展示。

panelModality 函数

panelModality() 是 Qt 中 QGraphicsItem 类的一个成员函数，用于获取图形项的面板模态性。面板模态性指的是图形项在场景中的模态性质，用于指示图形项是否会捕获鼠标事件。

该函数返回一个 Qt::PanelModality 枚举类型的值，表示图形项的面板模态性。Qt::PanelModality 枚举类型定义了以下几个值：

• NonModal: 表示图形项是非模态的，不会捕获鼠标事件。
• PanelModal: 表示图形项是面板模态的，会捕获鼠标事件。

您可以使用 panelModality() 函数来查询特定图形项的面板模态性。

parentItem函数

在 Qt 的图形项框架中，parentItem() 是 QGraphicsItem 类的一个成员函数，用于获取当前图形项的父图形项。每个 QGraphicsItem 都可以有一个父图形项，这种父子关系可以用来构建图形项的层次结构。

如果一个图形项是另一个图形项的子图形项，那么它将相对于父图形项进行定位。通过调用 parentItem() 函数，您可以获取当前图形项的父图形项。如果图形项没有父图形项（即它是场景的根项），则 parentItem() 将返回 nullptr。

这种父子关系可以用于实现复杂的图形场景，并管理图形项之间的层次关系和交互。

pos()位置函数

pos() 是 QGraphicsItem 类中的一个重要函数，用于获取图形项在其父项坐标系中的位置。该函数返回一个 QPointF 对象，表示图形项的位置。

在 Qt 中，图形项可以存在于场景中，也可以作为另一个图形项的子项存在。当一个图形项是另一个图形项的子项时，它的位置通常是相对于父项的坐标系的。pos() 函数返回的是图形项相对于其父项坐标系的位置。

如果一个图形项没有父项，那么它的位置是相对于场景的坐标系的。在这种情况下，pos() 函数返回的是图形项在场景坐标系中的位置。

当您调用 pos() 函数时，它返回一个 QPointF 对象，该对象包含了图形项在其父项坐标系中的位置。QPointF 类是 Qt 中用于表示二维坐标点的类，包含 x() 和 y() 方法用于获取 x 和 y 坐标值。

在 Qt 的图形框架中，每个图形项都可以有一个父项，形成一个树状结构。这种父子关系可以用来构建复杂的图形场景，并管理图形项之间的位置关系。当一个图形项是另一个图形项的子项时，它的位置通常是相对于父项的坐标系的。

通过调用 pos() 函数，您可以获得图形项相对于其父项坐标系的具体位置。这个位置信息可以用于很多方面，比如：

1. 布局管理：根据图形项的位置信息，您可以实现自定义的布局管理，确保图形项按照您的需求正确排列和定位。

2. 碰撞检测：在进行碰撞检测时，位置信息是至关重要的。通过获取图形项的位置信息，您可以判断两个图形项是否发生碰撞。

3. 动画效果：在实现动画效果时，您可能需要根据图形项的位置信息来计算动画的路径或目标位置。

4. 交互操作：根据图形项的位置信息，您可以实现鼠标交互操作，比如拖动图形项改变位置。

总之，pos() 函数提供了一种方便的方式来获取图形项的位置信息，帮助您在图形场景中管理和操作图形项。

removeSceneEventFilter 函数

removeSceneEventFilter 是一个函数，用于从场景中移除之前添加的事件过滤器。在 Qt 中，事件过滤器是一种机制，允许您在事件到达对象之前截获和处理这些事件。通过使用事件过滤器，您可以对特定对象的事件进行拦截和处理，而无需对这些对象进行子类化。

当您想要移除之前添加的事件过滤器时，可以使用 removeSceneEventFilter 函数。这个函数通常用于 QGraphicsScene 类，用于在场景级别管理事件过滤器。

下面是一个简单的示例，演示如何使用 removeSceneEventFilter 函数：

// 在 QGraphicsScene 中添加事件过滤器
MyEventFilter* eventFilter = new MyEventFilter();
scene->installEventFilter(eventFilter);

// 在某个时刻移除事件过滤器
scene->removeEventFilter(eventFilter);
1
2
3
4
5
6

在这个示例中，MyEventFilter 是一个自定义的事件过滤器类。首先，我们通过 installEventFilter 函数将事件过滤器添加到场景中。然后，当需要移除事件过滤器时，可以使用 removeEventFilter 函数来实现。

请注意，removeSceneEventFilter 的具体实现可能会根据您的代码结构和需求有所不同，但基本原理是相似的：通过调用相应的函数来移除之前添加的事件过滤器。

resetTransform 重置函数

resetTransform 是一个函数，用于将图形项的变换重置为默认值。在 Qt 中，图形项可以通过变换来实现旋转、缩放、平移等效果。resetTransform 函数可以将这些变换效果还原为默认状态。

当您调用 resetTransform 函数时，图形项的变换将被重置为默认值，即不进行任何旋转、缩放或平移。这可以很有用，特别是当您需要在某个时刻将图形项的变换还原到初始状态时。

下面是一个简单的示例，演示如何使用 resetTransform 函数：

// 创建一个 QGraphicsItem
QGraphicsRectItem* rectItem = new QGraphicsRectItem(0, 0, 100, 100);

// 对图形项进行一些变换，比如旋转和缩放
rectItem->setRotation(45);
rectItem->setScale(2);

// 在某个时刻将变换重置为默认状态
rectItem->resetTransform();
1
2
3
4
5
6
7
8
9

在这个示例中，我们首先创建一个 QGraphicsRectItem 对象 rectItem，然后对其进行旋转和缩放操作。最后，通过调用 resetTransform 函数，我们将图形项的变换效果重置为默认状态，即不再旋转或缩放。

通过使用 resetTransform 函数，您可以方便地将图形项的变换效果还原为初始状态，从而实现更灵活的图形操作和动画效果。
rotation 是一个用于设置或获取图形项旋转角度的属性。在 Qt 中，许多图形项类（如 QGraphicsItem 的子类）都具有 rotation 属性，用于控制图形项的旋转效果。

rotation() 获取旋转角度函数

QGraphicsItem::rotation() 是一个用于获取图形项旋转角度的函数。在 Qt 中，QGraphicsItem 类及其子类提供了这个函数，用于返回图形项当前的旋转角度。

以下是一个简单的示例，展示如何使用 QGraphicsItem::rotation() 函数来获取图形项的旋转角度：

// 假设有一个 QGraphicsRectItem 对象 rectItem
QGraphicsRectItem* rectItem = new QGraphicsRectItem(0, 0, 100, 100);

// 设置图形项的旋转角度为45度
rectItem->setRotation(45);

// 获取图形项的旋转角度
qreal rotationAngle = rectItem->rotation();
1
2
3
4
5
6
7
8

在这个示例中，我们首先创建了一个 QGraphicsRectItem 对象 rectItem，然后通过调用 setRotation 函数将其旋转角度设置为45度。接着，我们使用 rotation() 函数获取了图形项当前的旋转角度，并将其存储在 rotationAngle 变量中。

通过调用 QGraphicsItem::rotation() 函数，您可以方便地获取图形项的当前旋转角度，从而在需要时进行进一步处理或应用。

scale 缩放函数

scale 是一个用于设置或获取图形项缩放比例的函数。在 Qt 中，许多图形项类（如 QGraphicsItem 的子类）都具有 scale 函数，用于控制图形项的缩放效果。

通过调用 scale 函数，您可以在水平和垂直方向上分别设置图形项的缩放比例。缩放比例为1表示原始大小，小于1表示缩小，大于1表示放大。

下面是一个简单的示例，演示如何使用 scale 函数来缩放图形项：

// 创建一个 QGraphicsRectItem
QGraphicsRectItem* rectItem = new QGraphicsRectItem(0, 0, 100, 100);

// 设置图形项在水平和垂直方向上的缩放比例分别为2和0.5
rectItem->scale(2, 0.5);
1
2
3
4
5

在这个示例中，我们创建了一个 QGraphicsRectItem 对象 rectItem，然后通过调用 scale 函数将其在水平方向上放大为原来的2倍，在垂直方向上缩小为原来的一半。

通过控制 scale 函数，您可以实现图形项的缩放效果，从而创建各种动画效果、交互操作或视觉效果。

QGraphicsItem::scene() 获取场景函数

QGraphicsItem::scene() 是一个用于获取包含当前图形项的场景指针的函数。在 Qt 中，QGraphicsItem 类及其子类提供了这个函数，用于返回指向包含当前图形项的场景的指针。

当一个图形项被添加到一个场景中时，可以使用 scene() 函数来获取指向该场景的指针。这样可以方便地在图形项中访问场景的属性和方法，或者与其他图形项进行交互。

以下是一个简单的示例，展示如何使用 QGraphicsItem::scene() 函数来获取包含当前图形项的场景指针：

// 假设有一个 QGraphicsRectItem 对象 rectItem 已经被添加到场景中
QGraphicsRectItem* rectItem = new QGraphicsRectItem(0, 0, 100, 100);
scene->addItem(rectItem);

// 获取包含 rectItem 的场景指针
QGraphicsScene* itemScene = rectItem->scene();

if (itemScene) {
    // 对场景进行操作
    // 例如，获取场景的宽度和高度
    int sceneWidth = itemScene->width();
    int sceneHeight = itemScene->height();
}
1
2
3
4
5
6
7
8
9
10
11
12
13

在这个示例中，我们假设已经将一个 QGraphicsRectItem 对象 rectItem 添加到了一个场景中。通过调用 scene() 函数，我们获取了指向包含 rectItem 的场景的指针，并将其存储在 itemScene 变量中。然后，我们可以使用这个指针来访问场景的属性和方法，比如获取场景的宽度和高度。

通过使用 QGraphicsItem::scene() 函数，您可以方便地获取图形项所在的场景指针，从而实现与场景的交互和操作。

sceneBoundingRect() 获取场景坐标系中边界矩形

sceneBoundingRect() 是一个用于获取图形项在场景坐标系中边界矩形的函数。在 Qt 中，QGraphicsItem 类及其子类提供了这个函数，用于返回一个 QRectF 对象，表示图形项在场景坐标系中的边界矩形。

边界矩形是一个包围图形项的最小矩形，通常用于确定图形项在场景中的位置和大小。sceneBoundingRect() 函数返回的矩形考虑了图形项的变换效果，即如果图形项被旋转、缩放或移动，返回的边界矩形将相应地调整。

以下是一个简单的示例，展示如何使用 sceneBoundingRect() 函数来获取图形项在场景坐标系中的边界矩形：

// 假设有一个 QGraphicsRectItem 对象 rectItem 已经被添加到场景中
QGraphicsRectItem* rectItem = new QGraphicsRectItem(0, 0, 100, 100);
scene->addItem(rectItem);

// 获取图形项在场景坐标系中的边界矩形
QRectF boundingRect = rectItem->sceneBoundingRect();

// 输出边界矩形的位置和大小
qDebug() << "Bounding Rect: Top Left: " << boundingRect.topLeft() << ", Bottom Right: " << boundingRect.bottomRight();
qDebug() << "Bounding Rect Width: " << boundingRect.width() << ", Height: " << boundingRect.height();
1
2
3
4
5
6
7
8
9
10

在这个示例中，我们假设已经将一个 QGraphicsRectItem 对象 rectItem 添加到了一个场景中。通过调用 sceneBoundingRect() 函数，我们获取了图形项在场景坐标系中的边界矩形，并将其存储在 boundingRect 变量中。然后，我们可以使用这个矩形对象来获取边界矩形的位置、大小等信息。

通过使用 sceneBoundingRect() 函数，您可以方便地获取图形项在场景坐标系中的边界矩形，从而进行位置计算、布局调整等操作。

scenePos() 获取场景坐标

scenePos() 是一个用于获取图形项在场景坐标系中位置的函数。在 Qt 中，QGraphicsItem 类及其子类提供了这个函数，用于返回一个 QPointF 对象，表示图形项在场景坐标系中的位置。

场景坐标系是指整个场景的坐标系，与图形项自身的局部坐标系不同。scenePos() 函数返回的位置是相对于场景原点的坐标，考虑了图形项的变换效果，例如平移、旋转和缩放。

以下是一个简单的示例，展示如何使用 scenePos() 函数来获取图形项在场景坐标系中的位置：

// 假设有一个 QGraphicsRectItem 对象 rectItem 已经被添加到场景中
QGraphicsRectItem* rectItem = new QGraphicsRectItem(0, 0, 100, 100);
scene->addItem(rectItem);

// 获取图形项在场景坐标系中的位置
QPointF scenePosition = rectItem->scenePos();

// 输出图形项在场景中的位置
qDebug() << "Scene Position: " << scenePosition;
1
2
3
4
5
6
7
8
9

在这个示例中，我们假设已经将一个 QGraphicsRectItem 对象 rectItem 添加到了一个场景中。通过调用 scenePos() 函数，我们获取了图形项在场景坐标系中的位置，并将其存储在 scenePosition 变量中。然后，我们可以使用这个位置信息来进行进一步的操作，比如布局调整、碰撞检测等。

通过使用 scenePos() 函数，您可以方便地获取图形项在场景坐标系中的位置，从而进行与场景坐标系相关的计算和操作。

sceneTransform() 获取场景矩阵

sceneTransform() 是一个用于获取图形项在场景坐标系中的变换矩阵的函数。在 Qt 中，QGraphicsItem 类及其子类提供了这个函数，用于返回一个 QTransform 对象，表示图形项在场景坐标系中的变换矩阵。

变换矩阵包含了图形项的平移、旋转和缩放等变换信息，通过应用这个变换矩阵，可以将图形项的局部坐标系转换为场景坐标系。这对于在绘制、布局和交互中处理图形项的位置和变换非常有用。

以下是一个简单的示例，展示如何使用 sceneTransform() 函数来获取图形项在场景坐标系中的变换矩阵：

// 假设有一个 QGraphicsRectItem 对象 rectItem 已经被添加到场景中
QGraphicsRectItem* rectItem = new QGraphicsRectItem(0, 0, 100, 100);
scene->addItem(rectItem);

// 获取图形项在场景坐标系中的变换矩阵
QTransform sceneTransform = rectItem->sceneTransform();

// 输出图形项在场景中的变换矩阵
qDebug() << "Scene Transform Matrix: " << sceneTransform;
1
2
3
4
5
6
7
8
9

在这个示例中，我们假设已经将一个 QGraphicsRectItem 对象 rectItem 添加到了一个场景中。通过调用 sceneTransform() 函数，我们获取了图形项在场景坐标系中的变换矩阵，并将其存储在 sceneTransform 变量中。然后，我们可以使用这个变换矩阵来进行坐标变换、绘制操作等。

通过使用 sceneTransform() 函数，您可以方便地获取图形项在场景坐标系中的变换矩阵，从而进行与变换相关的操作，比如将局部坐标转换为场景坐标、获取旋转角度等。

scroll() 滚动函数

在 Qt 中，QGraphicsItem::scroll() 函数是用于在 QGraphicsItem 中滚动内容的函数。这个函数允许您在图形项内部滚动其内容，而不是在视图中滚动整个视图。

以下是 QGraphicsItem::scroll() 函数的一般语法：

void QGraphicsItem::scroll(qreal dx, qreal dy, const QRectF & rect = QRectF());
1

• dx：表示在水平方向上要滚动的距离，正值向右滚动，负值向左滚动。
• dy：表示在垂直方向上要滚动的距离，正值向下滚动，负值向上滚动。
• rect：可选参数，指定要滚动的矩形区域。如果未提供，则默认为图形项的边界矩形。

通过调用 QGraphicsItem::scroll() 函数，您可以实现在图形项内部滚动内容的效果。这在处理图形项中的大量内容或需要动态展示内容时非常有用。

以下是一个简单示例，展示如何在 QGraphicsItem 中使用 scroll() 函数向右和向下滚动内容：

// 假设有一个自定义的 QGraphicsItem 类 MyGraphicsItem，已经被添加到场景中
MyGraphicsItem* item = new MyGraphicsItem;
scene->addItem(item);

// 向右滚动 10 个像素，向下滚动 20 个像素
item->scroll(10, 20);
1
2
3
4
5
6

在这个示例中，我们假设已经创建了一个自定义的 QGraphicsItem 类 MyGraphicsItem 的实例，并将其添加到了一个场景中。通过调用 scroll() 函数，我们让图形项内部的内容向右滚动了 10 个像素，向下滚动了 20 个像素。

通过使用 QGraphicsItem::scroll() 函数，您可以实现在图形项内部滚动内容的效果，从而控制和展示图形项中的内容。

shape() 函数

在 Qt 中，shape() 函数是 QGraphicsItem 类中的一个虚拟函数，用于返回图形项的形状，即图形项的轮廓形状。这个函数通常被重写以定义图形项的实际形状，以便在场景中进行碰撞检测、绘制等操作时使用。

以下是 shape() 函数的一般语法：

QPainterPath QGraphicsItem::shape() const
1

• QPainterPath：是 Qt 中用于描述路径的类，可以表示复杂的图形形状。

通过重写 shape() 函数，您可以定义自定义的图形项形状，而不仅仅是默认的矩形形状。这对于实现更复杂的图形项、碰撞检测和绘制效果非常有用。

以下是一个简单的示例，展示如何在自定义的 QGraphicsItem 类中重写 shape() 函数来定义一个圆形的图形项：

class CircleItem : public QGraphicsItem {
public:
    QRectF boundingRect() const override {
        return QRectF(-50, -50, 100, 100); // 定义外接矩形
    }

    QPainterPath shape() const override {
        QPainterPath path;
        path.addEllipse(-50, -50, 100, 100); // 定义圆形形状
        return path;
    }

    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override {
        painter->drawEllipse(-50, -50, 100, 100); // 绘制圆形
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在这个示例中，我们创建了一个自定义的 CircleItem 类，继承自 QGraphicsItem，并重写了 boundingRect()、shape() 和 paint() 函数。在 shape() 函数中，我们使用 QPainterPath 来定义一个圆形形状，以便在场景中使用。在 paint() 函数中，我们将这个圆形绘制出来。

通过重写 shape() 函数，您可以定义自定义的图形项形状，从而实现更灵活和精确的图形项处理。

show() 显示项函数

显示项(默认情况下项是可见的)。
调用此函数相当于调用setVisible(true)。

stackBefore 调整图层的顺序

在 Qt 中，stackBefore 是一个函数，用于在 QGraphicsItem 的 Z 堆栈中调整项的顺序。Z 堆栈用于确定哪个项位于另一个项的前面。stackBefore 函数允许您将一个项放置在另一个项的前面。

以下是 stackBefore 函数的简要说明：

bool QGraphicsItem::stackBefore(const QGraphicsItem *sibling)
1

• 参数：sibling 是一个指向另一个 QGraphicsItem 对象的指针，表示要将当前项放置在其前面的兄弟项。
• 返回值：如果成功将当前项放置在指定兄弟项的前面，则返回 true；否则返回 false。

以下是一个简单的示例，演示如何使用 stackBefore 函数在 QGraphicsScene 中调整图形项的顺序：

#include <QApplication>
#include <QGraphicsScene>
#include <QGraphicsView>
#include <QGraphicsRectItem>

int main(int argc, char *argv[]) {
    QApplication app(argc, argv);

    QGraphicsScene scene;
    QGraphicsView view(&scene);

    QGraphicsRectItem *item1 = scene.addRect(10, 10, 100, 100, QPen(Qt::black), QBrush(Qt::red));
    QGraphicsRectItem *item2 = scene.addRect(50, 50, 100, 100, QPen(Qt::black), QBrush(Qt::blue));
	scene.addItem(item1);
	scene.addItem(item2);
    // 将item2放置在item1的前面
    item2->stackBefore(item1);

    view.show();

    return app.exec();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在这个示例中，我们创建了两个矩形图形项 item1 和 item2，然后使用 stackBefore 函数将 item2 放置在 item1 的前面。最后，我们显示了包含这些图形项的场景。这样，item2 将显示在 item1 的前面。

toGraphicsObject 转换为Object类

在 Qt 中，toGraphicsObject 是一个函数，用于将 QGraphicsItem 转换为 QGraphicsObject。QGraphicsObject 是 QGraphicsItem 的子类，提供了一些额外的功能，比如信号和槽机制。

以下是 toGraphicsObject 函数的简要说明：

QGraphicsObject* QGraphicsItem::toGraphicsObject()
1

• 返回值：返回一个指向 QGraphicsObject 对象的指针，该对象是从调用 toGraphicsObject 函数的 QGraphicsItem 对象转换而来的。

通常情况下，您可以使用 toGraphicsObject 函数来将 QGraphicsItem 对象转换为 QGraphicsObject 对象，以便利用 QGraphicsObject 提供的额外功能。

以下是一个简单的示例，演示如何使用 toGraphicsObject 函数将 QGraphicsItem 转换为 QGraphicsObject：

#include <QGraphicsItem>
#include <QGraphicsObject>

int main() {
    QGraphicsItem *item = new QGraphicsItem();
    
    QGraphicsObject *obj = item->toGraphicsObject();
    
    if (obj) {
        // 可以在这里使用QGraphicsObject的功能
    } else {
        // 转换失败
    }
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在这个示例中，我们创建了一个 QGraphicsItem 对象 item，然后使用 toGraphicsObject 函数将其转换为 QGraphicsObject 对象 obj。如果转换成功，我们可以利用 QGraphicsObject 提供的功能。如果转换失败，toGraphicsObject 函数将返回一个空指针。

toolTip() 获取 工具提示文本

在 Qt 中，QGraphicsItem::toolTip() 是一个函数，用于获取与 QGraphicsItem 相关联的工具提示文本。这个函数返回一个 QString 对象，其中包含了设置给该图形项的工具提示文本。

以下是 QGraphicsItem::toolTip() 函数的简要说明：

QString QGraphicsItem::toolTip() const
1

• 返回值：返回一个 QString 对象，其中包含与该 QGraphicsItem 相关联的工具提示文本。

您可以使用 QGraphicsItem::toolTip() 函数来获取图形项的工具提示文本，并根据需要进行处理或显示。

简单的示例

下面是一个简单的示例，演示如何使用 QGraphicsItem::toolTip() 函数获取图形项的工具提示文本：

#include <QGraphicsItem>
#include <QDebug>

int main() {
    QGraphicsItem *item = new QGraphicsItem();
    item->setToolTip("This is a custom tooltip");

    QString tooltip = item->toolTip();
    qDebug() << "Tooltip for the QGraphicsItem: " << tooltip;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12

在这个示例中，我们创建了一个 QGraphicsItem 对象 item，并使用 setToolTip() 函数设置了一个自定义的工具提示文本。然后，我们使用 QGraphicsItem::toolTip() 函数获取这个图形项的工具提示文本，并将其打印出来。

通过使用 QGraphicsItem::toolTip() 函数，您可以方便地获取图形项的工具提示文本，并在您的应用程序中进行进一步处理或显示。

topLevelItem() 获取在场景中的顶层图形项

在 Qt 中，QGraphicsItem::topLevelItem() 是一个函数，用于获取与给定 QGraphicsItem 相关联的顶层图形项（Top-level item）。顶层图形项是指在场景中没有父项的图形项，即直接添加到场景中而不是作为其他图形项的子项的图形项。

以下是 QGraphicsItem::topLevelItem() 函数的简要说明：

QGraphicsItem* QGraphicsItem::topLevelItem() const
1

• 返回值：返回与给定 QGraphicsItem 相关联的顶层图形项，如果该图形项本身就是顶层图形项，则返回自身。

通过调用 QGraphicsItem::topLevelItem() 函数，您可以获取在场景中的顶层图形项，这在处理图形项层次结构时可能非常有用。

下面是一个简单的示例，演示如何使用 QGraphicsItem::topLevelItem() 函数获取与给定图形项相关联的顶层图形项：

#include <QGraphicsItem>
#include <QDebug>

int main() {
    QGraphicsItem *parentItem = new QGraphicsItem();
    QGraphicsItem *childItem = new QGraphicsItem(parentItem);

    QGraphicsItem *topLevelItem = childItem->topLevelItem();

    if (topLevelItem == childItem) {
        qDebug() << "The item is a top-level item.";
    } else {
        qDebug() << "The top-level item is: " << topLevelItem;
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

在这个示例中，我们创建了一个父图形项 parentItem 和一个子图形项 childItem，将子图形项添加为父图形项的子项。然后，我们调用 childItem->topLevelItem() 函数来获取与子图形项相关联的顶层图形项。如果子图形项本身就是顶层图形项，则返回自身；否则返回子图形项所属的顶层图形项。

通过使用 QGraphicsItem::topLevelItem() 函数，您可以方便地获取与给定图形项相关联的顶层图形项，从而更好地管理和操作图形项在场景中的位置关系。

transform() 获取相关联的转换矩阵

QGraphicsItem::transform() 是一个函数，用于获取与 QGraphicsItem 相关联的转换矩阵。转换矩阵描述了如何对图形项进行平移、旋转和缩放等变换操作。

以下是 QGraphicsItem::transform() 函数的简要说明：

QTransform QGraphicsItem::transform() const
1

• 返回值：返回与 QGraphicsItem 相关联的转换矩阵 QTransform。

通过调用 QGraphicsItem::transform() 函数，您可以获取图形项的当前转换矩阵，从而了解该图形项的位置、旋转和缩放状态。

下面是一个简单的示例，演示如何使用 QGraphicsItem::transform() 函数获取与给定图形项相关联的转换矩阵：

#include <QGraphicsItem>
#include <QTransform>
#include <QDebug>

int main() {
    QGraphicsItem *item = new QGraphicsItem();
    
    // 设置图形项的变换矩阵
    QTransform transform;
    transform.translate(100, 100);
    transform.rotate(45);
    item->setTransform(transform);

    // 获取图形项的变换矩阵
    QTransform itemTransform = item->transform();

    qDebug() << "Item's transformation matrix:";
    qDebug() << itemTransform;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

在这个示例中，我们创建了一个图形项 item，并通过 setTransform() 函数设置了一个包含平移和旋转操作的转换矩阵。然后，我们调用 item->transform() 函数来获取与图形项相关联的转换矩阵，并将其打印输出。

通过使用 QGraphicsItem::transform() 函数，您可以方便地获取图形项的当前转换矩阵，从而对图形项的位置和变换状态进行操作和管理。

transform() 获取坐标转换的原点

QPointF QGraphicsItem::transformOriginPoint() const
1

返回项目坐标转换的原点。
默认原点为0,0
在 Qt 中，QGraphicsItem 类提供了 transformations() 函数，用于获取与图形项相关联的所有变换操作的列表。这个函数返回一个 QList<QGraphicsTransform *> 类型的列表，其中包含了应用于该图形项的所有变换操作。

以下是 QGraphicsItem::transformations() 函数的简要说明：

QList<QGraphicsTransform *> QGraphicsItem::transformations() const
1

• 返回值：返回一个 QList<QGraphicsTransform *> 类型的列表，包含与图形项相关联的所有变换操作。

transformations() 获取图形项应用的所有变换操作

通过调用 QGraphicsItem::transformations() 函数，您可以获取图形项应用的所有变换操作，这些变换操作可以包括平移、旋转、缩放等。

下面是一个简单的示例，演示如何使用 QGraphicsItem::transformations() 函数获取与给定图形项相关联的所有变换操作：

#include <QGraphicsItem>
#include <QGraphicsTransform>
#include <QDebug>

int main() {
    QGraphicsItem *item = new QGraphicsItem();

    // 添加一些变换操作到图形项
    QGraphicsScale *scale = new QGraphicsScale();
    scale->setXScale(2.0);
    scale->setYScale(2.0);
    item->setTransformations({scale});

    // 获取图形项的所有变换操作
    QList<QGraphicsTransform *> transformations = item->transformations();

    qDebug() << "Item's transformations:";
    for (QGraphicsTransform *transform : transformations) {
        qDebug() << transform;
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

在这个示例中，我们创建了一个图形项 item，并向其添加了一个缩放操作。然后，我们调用 item->transformations() 函数来获取与图形项相关联的所有变换操作，并将它们打印输出。

通过使用 QGraphicsItem::transformations() 函数，您可以方便地获取图形项应用的所有变换操作，从而更好地了解和管理图形项的变换状态。
在 Qt 中，QGraphicsItem::type() 函数用于返回图形项的类型。每个继承自 QGraphicsItem 的子类都可以重写这个函数，以便在需要时识别特定类型的图形项。

以下是 QGraphicsItem::type() 函数的简要说明：

int QGraphicsItem::type() const
1

• 返回值：返回一个整数值，代表图形项的类型。

type() 返回图形项类型

默认情况下，QGraphicsItem::type() 函数返回 QGraphicsItem::Type，这是一个枚举值，表示通用的图形项类型。如果您创建了自定义的 QGraphicsItem 子类，并希望能够识别该子类的类型，可以在子类中重写 type() 函数，并返回一个自定义的整数值。

以下是一个简单的示例，演示如何创建一个自定义的 QGraphicsItem 子类，并重写 type() 函数以返回自定义类型：

#include <QGraphicsItem>

class CustomGraphicsItem : public QGraphicsItem {
public:
    enum { Type = UserType + 1 };

    int type() const override {
        // 返回自定义的类型值
        return Type;
    }

    // 其他成员函数和数据成员
};

int main() {
    CustomGraphicsItem customItem;

    // 获取自定义图形项的类型
    int itemType = customItem.type();
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在这个示例中，我们创建了一个名为 CustomGraphicsItem 的自定义 QGraphicsItem 子类，并在其中定义了一个自定义的类型值。通过重写 type() 函数并返回这个自定义的类型值，我们可以在需要时识别和区分这个特定类型的图形项。

通过使用 QGraphicsItem::type() 函数，您可以方便地确定图形项的类型，从而在处理图形项时能够根据需要执行特定的操作。

ungrabKeyboard() 释放键盘抓取

void QGraphicsItem::ungrabKeyboard()
1

ungrabKeyboard() 释放鼠标抓取

void QGraphicsItem::ungrabMouse()
1

unsetCursor() 释放鼠标抓取

void QGraphicsItem::unsetCursor()
1

update() 刷新函数

在 Qt 中，QGraphicsItem::update() 是一个函数，用于请求重新绘制（刷新）QGraphicsItem。当调用 update() 函数时，Qt 会触发相应 QGraphicsItem 的重新绘制，以便更新其外观。

以下是 QGraphicsItem::update() 函数的简要说明：

void QGraphicsItem::update(const QRectF &rect = QRectF())
void QGraphicsItem::update(qreal x, qreal y, qreal width, qreal height)
1
2

• 功能：请求重新绘制 QGraphicsItem，以便更新其外观。
• 参数：可选参数 rect 指定需要更新的区域。如果不提供 rect 参数，则整个 QGraphicsItem 将被重新绘制。

在使用 QGraphicsItem::update() 函数时，您可以选择指定要更新的特定区域，以提高性能并减少不必要的重绘。如果不提供区域参数，整个 QGraphicsItem 将被重新绘制。

以下是一个简单的示例，演示如何在自定义的 QGraphicsItem 子类中使用 update() 函数来请求重新绘制：

#include <QGraphicsItem>
#include <QPainter>

class CustomGraphicsItem : public QGraphicsItem {
public:
    QRectF boundingRect() const override {
        return QRectF(0, 0, 100, 100);
    }

    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget) override {
        // 绘制图形项的外观
        painter->drawRect(boundingRect());
    }

    void updateItem() {
        update(); // 请求重新绘制整个图形项
    }
};

int main() {
    CustomGraphicsItem customItem;

    // 在某些操作后需要更新图形项的外观
    customItem.updateItem(); // 请求重新绘制

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

在这个示例中，我们创建了一个名为 CustomGraphicsItem 的自定义 QGraphicsItem 子类。在 updateItem() 函数中，我们调用 update() 函数来请求重新绘制整个图形项。这将触发 paint() 函数重新绘制图形项的外观。

通过使用 QGraphicsItem::update() 函数，您可以在需要时请求 QGraphicsItem 重新绘制，以更新其外观或响应特定事件。

事件函数

focusInEvent获得焦点触发事件

用于处理当一个窗口部件或一个图形项获得焦点时触发的事件。这个函数通常被重写以实现在获得焦点时执行特定的操作。

• 功能：处理窗口部件或图形项获得焦点时触发的事件。
• 参数：QFocusEvent *event，表示与获得焦点事件相关的事件对象。
• 返回值：无。

使用示例：

下面是一个简单的示例，演示了如何在一个自定义的QWidget子类中重写focusInEvent函数以处理获得焦点事件：

#include <QWidget>
#include <QFocusEvent>

class CustomWidget : public QWidget
{
protected:
    void focusInEvent(QFocusEvent *event) override
    {
        // 执行获得焦点时的操作
        qDebug() << "Widget has gained focus";
        
        // 调用基类的事件处理函数，确保事件被正确处理
        QWidget::focusInEvent(event);
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在这个示例中，CustomWidget是一个自定义的QWidget子类，重写了focusInEvent函数。当这个自定义窗口部件获得焦点时，会输出一条消息，并且调用基类的事件处理函数以确保事件被正确处理。

您可以根据需要重写focusInEvent函数来实现在窗口部件或图形项获得焦点时执行特定的操作。

focusOutEvent失去焦点触发事件

focusOutEvent是一个事件处理函数，用于处理当一个窗口部件或一个图形项失去焦点时触发的事件。这个函数通常被重写以实现在失去焦点时执行特定的操作。

• 功能：处理窗口部件或图形项失去焦点时触发的事件。
• 参数：QFocusEvent *event，表示与失去焦点事件相关的事件对象。
• 返回值：无。

使用示例：

下面是一个简单的示例，演示了如何在一个自定义的QWidget子类中重写focusOutEvent函数以处理失去焦点事件：

#include <QWidget>
#include <QFocusEvent>

class CustomWidget : public QWidget
{
protected:
    void focusOutEvent(QFocusEvent *event) override
    {
        // 执行失去焦点时的操作
        qDebug() << "Widget has lost focus";
        
        // 调用基类的事件处理函数，确保事件被正确处理
        QWidget::focusOutEvent(event);
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

在这个示例中，CustomWidget是一个自定义的QWidget子类，重写了focusOutEvent函数。当这个自定义窗口部件失去焦点时，会输出一条消息，并且调用基类的事件处理函数以确保事件被正确处理。

您可以根据需要重写focusOutEvent函数来实现在窗口部件或图形项失去焦点时执行特定的操作。

contextMenuEvent 上下文菜单事件

在 Qt 中，QGraphicsItem::contextMenuEvent 是用于处理图形项上下文菜单事件的虚拟函数。当用户在 QGraphicsItem 上右键单击时，会触发上下文菜单事件，可以通过重写 contextMenuEvent 函数来自定义处理这一事件。

下面是关于 QGraphicsItem::contextMenuEvent 函数的简要说明：

void QGraphicsItem::contextMenuEvent(QGraphicsSceneContextMenuEvent *event)
1

• 功能：处理图形项的上下文菜单事件。
• 参数：QGraphicsSceneContextMenuEvent *event 包含了有关上下文菜单事件的信息，如鼠标位置等。

通过重写 QGraphicsItem::contextMenuEvent 函数，您可以实现自定义的上下文菜单行为，例如显示特定的菜单项、执行特定的操作等。以下是一个简单的示例，展示了如何在自定义的 QGraphicsItem 子类中重写 contextMenuEvent 函数：

void CustomGraphicsItem::contextMenuEvent(QGraphicsSceneContextMenuEvent *event) {
    QMenu menu;
    menu.addAction("Action 1");
    menu.addAction("Action 2");
    menu.addAction("Action 3");

    QAction *selectedAction = menu.exec(event->screenPos());

    if (selectedAction == menu.actions().at(0)) {
        // 执行操作1
    } else if (selectedAction == menu.actions().at(1)) {
        // 执行操作2
    } else if (selectedAction == menu.actions().at(2)) {
        // 执行操作3
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在这个示例中，当用户在 CustomGraphicsItem 上右键单击时，会显示一个包含三个操作的上下文菜单。根据用户选择的操作，您可以执行相应的操作。

通过重写 QGraphicsItem::contextMenuEvent 函数，您可以为图形项添加上下文菜单功能，以提供更丰富的用户交互体验。

dragEnterEvent 拖动操作进入图形项的事件

在 Qt 中，QGraphicsItem::dragEnterEvent 是一个虚拟函数，用于处理拖放操作中拖动进入图形项的事件。当拖动一个外部对象（如文件、文本等）进入 QGraphicsItem 时，会触发 dragEnterEvent 事件，您可以重写这个函数来处理相应的操作。

下面是关于 QGraphicsItem::dragEnterEvent 函数的简要说明：

void QGraphicsItem::dragEnterEvent(QGraphicsSceneDragDropEvent *event)
1

• 功能：处理拖动操作进入图形项的事件。
• 参数：QGraphicsSceneDragDropEvent *event 包含了关于拖放事件的信息，如拖放的数据、鼠标位置等。

通过重写 QGraphicsItem::dragEnterEvent 函数，您可以在拖动对象进入图形项时执行特定的操作，比如判断拖放的数据类型、更改图形项的外观等。以下是一个简单的示例，展示了如何在自定义的 QGraphicsItem 子类中重写 dragEnterEvent 函数：

void CustomGraphicsItem::dragEnterEvent(QGraphicsSceneDragDropEvent *event) {
    if (event->mimeData()->hasFormat("text/plain")) {
        // 如果拖放的数据是文本类型
        event->acceptProposedAction(); // 接受拖放操作
    } else {
        // 其他类型的处理
        event->ignore(); // 忽略拖放操作
    }
}
1
2
3
4
5
6
7
8
9

在这个示例中，当拖动一个文本对象进入 CustomGraphicsItem 时，会检查拖放的数据类型，如果是纯文本，则接受拖放操作；否则将忽略该操作。

通过重写 QGraphicsItem::dragEnterEvent 函数，您可以根据需要实现自定义的拖放进入图形项时的行为，以支持更多交互功能。

dragLeaveEvent 拖动操作离开图形项的事件

在 Qt 中，QGraphicsItem::dragLeaveEvent 是一个虚拟函数，用于处理拖放操作中拖动离开图形项的事件。当拖动的外部对象（如文件、文本等）离开 QGraphicsItem 区域时，会触发 dragLeaveEvent 事件，您可以重写这个函数来执行相应的操作。

下面是关于 QGraphicsItem::dragLeaveEvent 函数的简要说明：

void QGraphicsItem::dragLeaveEvent(QGraphicsSceneDragDropEvent *event)
1

• 功能：处理拖动操作离开图形项的事件。
• 参数：QGraphicsSceneDragDropEvent *event 包含了关于拖放事件的信息，如拖放的数据、鼠标位置等。

通过重写 QGraphicsItem::dragLeaveEvent 函数，您可以在拖动对象离开图形项时执行特定的操作，例如清除临时状态、恢复图形项的外观等。以下是一个简单的示例，展示了如何在自定义的 QGraphicsItem 子类中重写 dragLeaveEvent 函数：

void CustomGraphicsItem::dragLeaveEvent(QGraphicsSceneDragDropEvent *event) {
    // 在拖动离开图形项时执行一些清理操作
    // 例如恢复图形项的初始状态或清除临时数据
}
1
2
3
4

在这个示例中，当拖动的对象离开 CustomGraphicsItem 区域时，可以在 dragLeaveEvent 中执行一些清理操作，以确保图形项的状态得到正确处理。

通过重写 QGraphicsItem::dragLeaveEvent 函数，您可以根据需要实现自定义的拖放离开图形项时的行为，以支持更多交互功能。

dragMoveEvent 拖动操作在图形项上移动的事件

在 Qt 中，QGraphicsItem::dragMoveEvent 是一个虚拟函数，用于处理拖放操作中拖动在图形项上移动的事件。当拖动的外部对象（如文件、文本等）在 QGraphicsItem 区域内移动时，会触发 dragMoveEvent 事件，您可以重写这个函数来执行相应的操作。

下面是关于 QGraphicsItem::dragMoveEvent 函数的简要说明：

void QGraphicsItem::dragMoveEvent(QGraphicsSceneDragDropEvent *event)
1

• 功能：处理拖动操作在图形项上移动的事件。
• 参数：QGraphicsSceneDragDropEvent *event 包含了关于拖放事件的信息，如拖放的数据、鼠标位置等。

通过重写 QGraphicsItem::dragMoveEvent 函数，您可以在拖动对象在图形项上移动时执行特定的操作，例如根据鼠标位置更新图形项的位置或外观。以下是一个简单的示例，展示了如何在自定义的 QGraphicsItem 子类中重写 dragMoveEvent 函数：

void CustomGraphicsItem::dragMoveEvent(QGraphicsSceneDragDropEvent *event) {
    // 根据鼠标位置更新图形项的位置或外观
    QPointF newPos = mapToScene(event->pos());
    setPos(newPos);
}
1
2
3
4
5

在这个示例中，当拖动的对象在 CustomGraphicsItem 区域内移动时，会根据鼠标位置更新图形项的位置。您可以根据需要在 dragMoveEvent 中执行任何与拖动移动相关的操作。

通过重写 QGraphicsItem::dragMoveEvent 函数，您可以根据需要实现自定义的拖动移动图形项时的行为，以支持更多交互功能。

dropEvent 拖动操作放置对象的事件

在 Qt 中，QGraphicsItem::dropEvent 是一个虚拟函数，用于处理拖放操作中放置对象的事件。当拖动的外部对象（如文件、文本等）在 QGraphicsItem 区域内放置时，会触发 dropEvent 事件，您可以重写这个函数来执行相应的操作。

下面是关于 QGraphicsItem::dropEvent 函数的简要说明：

void QGraphicsItem::dropEvent(QGraphicsSceneDragDropEvent *event)
1

• 功能：处理拖动操作放置对象的事件。
• 参数：QGraphicsSceneDragDropEvent *event 包含了关于拖放事件的信息，如拖放的数据、鼠标位置等。

通过重写 QGraphicsItem::dropEvent 函数，您可以在放置对象到图形项上时执行特定的操作，例如接受拖放的数据并进行相应的处理。以下是一个简单的示例，展示了如何在自定义的 QGraphicsItem 子类中重写 dropEvent 函数：

void CustomGraphicsItem::dropEvent(QGraphicsSceneDragDropEvent *event) {
    // 接受拖放的数据并进行处理
    if (event->mimeData()->hasText()) {
        QString text = event->mimeData()->text();
        // 进行文本数据的处理
    }
}
1
2
3
4
5
6
7

在这个示例中，当放置对象到 CustomGraphicsItem 区域内时，会检查拖放的数据是否包含文本，并进行相应的处理。您可以根据需要在 dropEvent 中执行任何与放置对象相关的操作。

通过重写 QGraphicsItem::dropEvent 函数，您可以根据需要实现自定义的放置对象到图形项上时的行为，以支持更多交互功能。

hoverEnterEvent 鼠标悬停在图形项上的进入事件

在 Qt 中，QGraphicsItem::hoverEnterEvent 是一个虚拟函数，用于处理鼠标悬停在图形项上的进入事件。当鼠标光标进入 QGraphicsItem 区域时，会触发 hoverEnterEvent 事件，您可以重写这个函数来执行特定的操作。

下面是关于 QGraphicsItem::hoverEnterEvent 函数的简要说明：

void QGraphicsItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event)
1

• 功能：处理鼠标悬停在图形项上的进入事件。
• 参数：QGraphicsSceneHoverEvent *event 包含了关于鼠标悬停事件的信息，如鼠标位置等。

通过重写 QGraphicsItem::hoverEnterEvent 函数，您可以在鼠标光标进入图形项时执行特定的操作，例如显示工具提示、改变图形项外观等。以下是一个简单的示例，展示了如何在自定义的 QGraphicsItem 子类中重写 hoverEnterEvent 函数：

void CustomGraphicsItem::hoverEnterEvent(QGraphicsSceneHoverEvent *event) {
    // 鼠标进入时显示工具提示
    setToolTip("This is a custom graphics item.");
}
1
2
3
4

在这个示例中，当鼠标光标进入 CustomGraphicsItem 区域时，会显示一个工具提示。您可以根据需要在 hoverEnterEvent 中执行任何与鼠标悬停进入相关的操作。

通过重写 QGraphicsItem::hoverEnterEvent 函数，您可以根据需要实现自定义的鼠标悬停进入图形项时的行为，以支持更多交互功能。

hoverLeaveEvent 鼠标离开图形项的事件

在 Qt 中，QGraphicsItem::hoverLeaveEvent 是一个虚拟函数，用于处理鼠标离开图形项的事件。当鼠标光标离开 QGraphicsItem 区域时，会触发 hoverLeaveEvent 事件，您可以重写这个函数来执行特定的操作。

下面是关于 QGraphicsItem::hoverLeaveEvent 函数的简要说明：

void QGraphicsItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event)
1

• 功能：处理鼠标离开图形项的事件。
• 参数：QGraphicsSceneHoverEvent *event 包含了关于鼠标离开事件的信息，如鼠标位置等。

通过重写 QGraphicsItem::hoverLeaveEvent 函数，您可以在鼠标光标离开图形项时执行特定的操作，例如隐藏工具提示、恢复图形项外观等。以下是一个简单的示例，展示了如何在自定义的 QGraphicsItem 子类中重写 hoverLeaveEvent 函数：

void CustomGraphicsItem::hoverLeaveEvent(QGraphicsSceneHoverEvent *event) {
    // 鼠标离开时隐藏工具提示
    setToolTip("");
}
1
2
3
4

在这个示例中，当鼠标光标离开 CustomGraphicsItem 区域时，会隐藏工具提示。您可以根据需要在 hoverLeaveEvent 中执行任何与鼠标离开相关的操作。

通过重写 QGraphicsItem::hoverLeaveEvent 函数，您可以根据需要实现自定义的鼠标离开图形项时的行为，以支持更多交互功能。

hoverMoveEvent 鼠标在图形项上移动的事件

在 Qt 中，QGraphicsItem::hoverMoveEvent 是一个虚拟函数，用于处理鼠标在图形项上移动的事件。当鼠标光标在 QGraphicsItem 区域内移动时，会触发 hoverMoveEvent 事件，您可以重写这个函数来执行特定的操作。

以下是关于 QGraphicsItem::hoverMoveEvent 函数的简要说明：

void QGraphicsItem::hoverMoveEvent(QGraphicsSceneHoverEvent *event)
1

• 功能：处理鼠标在图形项上移动的事件。
• 参数：QGraphicsSceneHoverEvent *event 包含了关于鼠标移动事件的信息，如鼠标位置等。

通过重写 QGraphicsItem::hoverMoveEvent 函数，您可以在鼠标光标在图形项上移动时执行特定的操作，例如更新工具提示内容、根据鼠标位置调整图形项外观等。以下是一个简单的示例，展示了如何在自定义的 QGraphicsItem 子类中重写 hoverMoveEvent 函数：

void CustomGraphicsItem::hoverMoveEvent(QGraphicsSceneHoverEvent *event) {
    // 更新工具提示内容为鼠标位置信息
    setToolTip(QString("Mouse position: (%1, %2)").arg(event->scenePos().x()).arg(event->scenePos().y()));
}
1
2
3
4

在这个示例中，当鼠标光标在 CustomGraphicsItem 区域内移动时，工具提示内容会显示当前鼠标的场景位置信息。您可以根据需要在 hoverMoveEvent 中执行任何与鼠标移动相关的操作。

通过重写 QGraphicsItem::hoverMoveEvent 函数，您可以根据需要实现自定义的鼠标在图形项上移动时的行为，以支持更多交互功能。

inputMethodEvent 输入法事件

在 Qt 中，QGraphicsItem::inputMethodEvent 是一个虚拟函数，用于处理输入法事件。输入法事件通常与输入中文或其他复杂字符时的文本输入有关。当用户在 QGraphicsItem 区域内使用输入法时，会触发 inputMethodEvent 事件，您可以重写这个函数来处理输入法相关的操作。

以下是关于 QGraphicsItem::inputMethodEvent 函数的简要说明：

void QGraphicsItem::inputMethodEvent(QInputMethodEvent *event)
1

• 功能：处理输入法事件，如输入中文或其他复杂字符时的文本输入。
• 参数：QInputMethodEvent *event 包含了关于输入法事件的信息，如输入的文本内容等。

通过重写 QGraphicsItem::inputMethodEvent 函数，您可以在输入法事件发生时执行特定的操作，例如处理输入的文本内容、更新图形项的显示等。以下是一个简单的示例，展示了如何在自定义的 QGraphicsItem 子类中重写 inputMethodEvent 函数：

void CustomGraphicsItem::inputMethodEvent(QInputMethodEvent *event) {
    // 处理输入的文本内容
    QString inputText = event->commitString();
    
    // 执行相应的操作，例如更新图形项的显示
    updateItemWithInputText(inputText);
}
1
2
3
4
5
6
7

在这个示例中，当用户在 CustomGraphicsItem 区域内输入文本时，会处理输入的文本内容并根据需要更新图形项的显示。您可以根据需要在 inputMethodEvent 中执行任何与输入法事件相关的操作。

通过重写 QGraphicsItem::inputMethodEvent 函数，您可以实现输入法事件处理的自定义逻辑，以支持更多交互功能。

inputMethodQuery 输入法查询的请求

在 Qt 中，QGraphicsItem::inputMethodQuery 是一个虚拟函数，用于处理有关输入法查询的请求。通过重写这个函数，您可以实现对输入法查询请求的自定义处理逻辑。

以下是关于 QGraphicsItem::inputMethodQuery 函数的简要说明：

QVariant QGraphicsItem::inputMethodQuery(Qt::InputMethodQuery query) const
1

• 功能：处理有关输入法查询的请求。
• 参数：Qt::InputMethodQuery query 是一个枚举值，表示输入法查询的类型。
• 返回值：QVariant 类型，包含了输入法查询的结果。

Qt::InputMethodQuery 枚举类型定义了一些用于输入法查询的类型，例如：

• Qt::ImEnabled：查询输入法是否启用。
• Qt::ImHints：查询输入法提示信息。
• Qt::ImCursorPosition：查询输入法的光标位置。
• 其他类型用于查询不同的输入法相关信息。

通过重写 QGraphicsItem::inputMethodQuery 函数，您可以根据输入法查询的类型返回相应的信息。以下是一个简单的示例，展示了如何在自定义的 QGraphicsItem 子类中重写 inputMethodQuery 函数：

QVariant CustomGraphicsItem::inputMethodQuery(Qt::InputMethodQuery query) const {
    if (query == Qt::ImEnabled) {
        return true; // 假设输入法启用
    } else if (query == Qt::ImCursorPosition) {
        return 5; // 假设光标位置在第5个字符处
    } else {
        return QGraphicsItem::inputMethodQuery(query);
    }
}
1
2
3
4
5
6
7
8
9

在这个示例中，根据输入法查询的类型返回相应的信息。如果查询是关于输入法是否启用或光标位置的，就返回相应的值；否则，调用基类的 inputMethodQuery 函数以处理其他类型的查询。

通过重写 QGraphicsItem::inputMethodQuery 函数，您可以实现对输入法查询请求的自定义处理，以支持更多定制化的输入法交互功能。

itemChange 图形项属性更改的通知

在 Qt 中，QGraphicsItem::itemChange 是一个虚拟函数，用于处理关于图形项属性更改的通知。通过重写这个函数，您可以捕获和响应图形项的属性变化，例如位置、旋转、缩放等的变化。

以下是关于 QGraphicsItem::itemChange 函数的简要说明：

QVariant QGraphicsItem::itemChange(GraphicsItemChange change, const QVariant &value)
1

• 功能：处理关于图形项属性更改的通知。
• 参数：
  • GraphicsItemChange change：表示图形项属性的更改类型。
  • const QVariant &value：包含有关属性更改的信息。
• 返回值：QVariant 类型，包含了属性更改的结果。

GraphicsItemChange 是一个枚举类型，定义了不同类型的图形项属性更改，例如：

• ItemPositionChange：位置更改。
• ItemRotationChange：旋转更改。
• ItemScaleChange：缩放更改。
• 其他类型用于表示不同的属性更改。

通过重写 QGraphicsItem::itemChange 函数，您可以根据属性更改的类型和值来执行相应的操作。以下是一个简单的示例，展示了如何在自定义的 QGraphicsItem 子类中重写 itemChange 函数：

QVariant CustomGraphicsItem::itemChange(GraphicsItemChange change, const QVariant &value) {
    if (change == ItemPositionChange && scene()) {
        QPointF newPos = value.toPointF();
        // 执行位置更改后的操作，例如更新其他相关属性
        emit positionChanged(newPos);
    }
    
    return QGraphicsItem::itemChange(change, value);
}
1
2
3
4
5
6
7
8
9

在这个示例中，当图形项的位置发生变化时，会发出一个自定义的信号 positionChanged，并在此函数中执行相应的操作。您可以根据需要处理不同类型的属性更改，并在函数中实现相应的逻辑。

通过重写 QGraphicsItem::itemChange 函数，您可以捕获和响应图形项的属性变化，实现更多定制化的交互行为和逻辑。

keyPressEvent 键盘按下事件

，可以重新实现此事件处理程序以接收此项目的按键事件。默认实现忽略该事件。如果重新实现此处理程序，则默认情况下将接受该事件。
注意，只有设置了ItemIsFocusable标志并具有键盘输入焦点的项目才会接收到键事件。

以下是一个简单的示例，展示了如何在自定义的 QGraphicsItem 子类中处理键盘事件，并根据按键执行相应的操作：

void QGraphicsItem::keyPressEvent(QKeyEvent *event) {
    if (event->key() == Qt::Key_Left) {
        // 处理按下左键的操作
    } else if (event->key() == Qt::Key_Right) {
        // 处理按下右键的操作
    } else {
        // 其他按键的处理
        QGraphicsItem::keyPressEvent(event); // 调用基类的处理函数
    }
}
1
2
3
4
5
6
7
8
9
10

在这个示例中，当键盘事件发生时，会检查按下的键是否是左键或右键，然后执行相应的操作。对于其他按键，会调用基类的 keyPressEvent 函数进行处理。

keyReleaseEvent 键盘释放事件

可以重新实现此事件处理程序以接收此项目的键释放事件。默认实现忽略该事件。如果重新实现此处理程序，则默认情况下将接受该事件。
注意，只有设置了ItemIsFocusable标志并具有键盘输入焦点的项目才会接收到键事件。

以下是一个简单的示例，展示了如何在自定义的 QGraphicsItem 子类中处理键盘释放事件，并根据释放的按键执行相应的操作：

void QGraphicsItem::keyReleaseEvent(QKeyEvent *event) {
    if (event->key() == Qt::Key_Left) {
        // 处理释放左键的操作
    } else if (event->key() == Qt::Key_Right) {
        // 处理释放右键的操作
    } else {
        // 其他按键的处理
        QGraphicsItem::keyReleaseEvent(event); // 调用基类的处理函数
    }
}
1
2
3
4
5
6
7
8
9
10

mouseDoubleClickEvent 鼠标双击事件

在 Qt 中，QGraphicsItem 类提供了 mouseDoubleClickEvent 函数，用于处理鼠标双击事件。当用户双击一个 QGraphicsItem 时，mouseDoubleClickEvent 函数会被调用，您可以重写这个函数来实现自定义的双击事件处理逻辑。

以下是一个简单的示例，展示了如何在自定义的 QGraphicsItem 子类中重写 mouseDoubleClickEvent 函数，并实现对鼠标双击事件的处理：

class CustomGraphicsItem : public QGraphicsItem {
public:
    CustomGraphicsItem() {}

protected:
    void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) override {
        if (event->button() == Qt::LeftButton) {
            // 处理左键双击事件的操作
        } else if (event->button() == Qt::RightButton) {
            // 处理右键双击事件的操作
        }

        // 调用基类的事件处理函数
        QGraphicsItem::mouseDoubleClickEvent(event);
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在这个示例中，当用户双击该自定义的 QGraphicsItem 对象时，会根据鼠标按键的类型执行相应的操作。您可以根据需要在 mouseDoubleClickEvent 函数中添加适当的逻辑来处理双击事件。

请注意，mouseDoubleClickEvent 函数中的参数是 QGraphicsSceneMouseEvent 类型的指针，它提供了关于鼠标双击事件的详细信息，如鼠标按键、位置等。

通过重写 mouseDoubleClickEvent 函数，您可以实现对鼠标双击事件的自定义处理，以满足您的应用程序需求。

mouseDoubleClickEvent 鼠标双击事件

在 Qt 中，QGraphicsItem 类提供了 mouseDoubleClickEvent 函数，用于处理鼠标双击事件。当用户双击一个 QGraphicsItem 时，mouseDoubleClickEvent 函数会被调用，您可以重写这个函数来实现自定义的双击事件处理逻辑。

以下是一个简单的示例，展示了如何在自定义的 QGraphicsItem 子类中重写 mouseDoubleClickEvent 函数，并实现对鼠标双击事件的处理：

class CustomGraphicsItem : public QGraphicsItem {
public:
    CustomGraphicsItem() {}

protected:
    void mouseDoubleClickEvent(QGraphicsSceneMouseEvent *event) override {
        if (event->button() == Qt::LeftButton) {
            // 处理左键双击事件的操作
        } else if (event->button() == Qt::RightButton) {
            // 处理右键双击事件的操作
        }

        // 调用基类的事件处理函数
        QGraphicsItem::mouseDoubleClickEvent(event);
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在这个示例中，当用户双击该自定义的 QGraphicsItem 对象时，会根据鼠标按键的类型执行相应的操作。您可以根据需要在 mouseDoubleClickEvent 函数中添加适当的逻辑来处理双击事件。

请注意，mouseDoubleClickEvent 函数中的参数是 QGraphicsSceneMouseEvent 类型的指针，它提供了关于鼠标双击事件的详细信息，如鼠标按键、位置等。

通过重写 mouseDoubleClickEvent 函数，您可以实现对鼠标双击事件的自定义处理，以满足您的应用程序需求。

在Qt中，QGraphicsItem类提供了mouseMoveEvent函数，用于处理鼠标移动事件。当鼠标指针在QGraphicsItem上移动时，mouseMoveEvent函数会被调用。您可以重写这个函数来实现自定义的鼠标移动事件处理逻辑。

以下是一个简单的示例，展示了如何在自定义的QGraphicsItem子类中重写mouseMoveEvent函数，并实现对鼠标移动事件的处理：

class CustomGraphicsItem : public QGraphicsItem {
public:
    CustomGraphicsItem() {}

protected:
    void mouseMoveEvent(QGraphicsSceneMouseEvent *event) override {
        // 获取鼠标移动的位置
        QPointF newPos = event->scenePos();

        // 执行一些与鼠标移动相关的操作，例如更新图形项的位置等
        setPos(newPos);

        // 调用基类的事件处理函数
        QGraphicsItem::mouseMoveEvent(event);
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在这个示例中，当鼠标在自定义的QGraphicsItem对象上移动时，会获取鼠标的新位置，并根据需要执行相关操作，例如更新图形项的位置。您可以根据应用程序的需求在mouseMoveEvent函数中添加适当的逻辑。

请注意，mouseMoveEvent函数中的参数是QGraphicsSceneMouseEvent类型的指针，它提供了关于鼠标移动事件的详细信息，如鼠标位置、按键状态等。

通过重写mouseMoveEvent函数，您可以实现对鼠标移动事件的自定义处理，以实现各种交互效果或行为。

mouseMoveEvent 鼠标移动事件

在Qt中，QGraphicsItem类提供了mouseMoveEvent函数，用于处理鼠标移动事件。当鼠标指针在QGraphicsItem上移动时，mouseMoveEvent函数会被调用。您可以重写这个函数来实现自定义的鼠标移动事件处理逻辑。

以下是一个简单的示例，展示了如何在自定义的QGraphicsItem子类中重写mouseMoveEvent函数，并实现对鼠标移动事件的处理：

class CustomGraphicsItem : public QGraphicsItem {
public:
    CustomGraphicsItem() {}

protected:
    void mouseMoveEvent(QGraphicsSceneMouseEvent *event) override {
        // 获取鼠标移动的位置
        QPointF newPos = event->scenePos();

        // 执行一些与鼠标移动相关的操作，例如更新图形项的位置等
        setPos(newPos);

        // 调用基类的事件处理函数
        QGraphicsItem::mouseMoveEvent(event);
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在这个示例中，当鼠标在自定义的QGraphicsItem对象上移动时，会获取鼠标的新位置，并根据需要执行相关操作，例如更新图形项的位置。您可以根据应用程序的需求在mouseMoveEvent函数中添加适当的逻辑。

请注意，mouseMoveEvent函数中的参数是QGraphicsSceneMouseEvent类型的指针，它提供了关于鼠标移动事件的详细信息，如鼠标位置、按键状态等。

通过重写mouseMoveEvent函数，您可以实现对鼠标移动事件的自定义处理，以实现各种交互效果或行为。

mousePressEvent 鼠标按下事件

在 Qt 中，QGraphicsItem 类提供了 mousePressEvent 函数，用于处理鼠标按下事件。当鼠标按下在 QGraphicsItem 上时，mousePressEvent 函数会被调用。您可以重写这个函数来实现自定义的鼠标按下事件处理逻辑。

以下是一个简单的示例，展示了如何在自定义的 QGraphicsItem 子类中重写 mousePressEvent 函数，并实现对鼠标按下事件的处理：

class CustomGraphicsItem : public QGraphicsItem {
public:
    CustomGraphicsItem() {}

protected:
    void mousePressEvent(QGraphicsSceneMouseEvent *event) override {
        if (event->button() == Qt::LeftButton) {
            // 处理左键按下事件的操作
        } else if (event->button() == Qt::RightButton) {
            // 处理右键按下事件的操作
        }

        // 调用基类的事件处理函数
        QGraphicsItem::mousePressEvent(event);
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在这个示例中，当用户在自定义的 QGraphicsItem 对象上按下鼠标时，会根据鼠标按键的类型执行相应的操作。您可以根据需要在 mousePressEvent 函数中添加适当的逻辑来处理鼠标按下事件。

请注意，mousePressEvent 函数中的参数是 QGraphicsSceneMouseEvent 类型的指针，它提供了关于鼠标按下事件的详细信息，如鼠标按键、位置等。

通过重写 mousePressEvent 函数，您可以实现对鼠标按下事件的自定义处理，以满足您的应用程序需求。

mouseReleaseEvent 处理鼠标释放事件

在 Qt 中，QGraphicsItem 类提供了 mouseReleaseEvent 函数，用于处理鼠标释放事件。当鼠标释放在 QGraphicsItem 上时，mouseReleaseEvent 函数会被调用。您可以重写这个函数来实现自定义的鼠标释放事件处理逻辑。

以下是一个简单的示例，展示了如何在自定义的 QGraphicsItem 子类中重写 mouseReleaseEvent 函数，并实现对鼠标释放事件的处理：

class CustomGraphicsItem : public QGraphicsItem {
public:
    CustomGraphicsItem() {}

protected:
    void mouseReleaseEvent(QGraphicsSceneMouseEvent *event) override {
        if (event->button() == Qt::LeftButton) {
            // 处理左键释放事件的操作
        } else if (event->button() == Qt::RightButton) {
            // 处理右键释放事件的操作
        }

        // 调用基类的事件处理函数
        QGraphicsItem::mouseReleaseEvent(event);
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在这个示例中，当用户释放鼠标按钮时，会根据鼠标按键的类型执行相应的操作。您可以根据需要在 mouseReleaseEvent 函数中添加适当的逻辑来处理鼠标释放事件。

请注意，mouseReleaseEvent 函数中的参数是 QGraphicsSceneMouseEvent 类型的指针，它提供了关于鼠标释放事件的详细信息，如鼠标按键、位置等。

通过重写 mouseReleaseEvent 函数，您可以实现对鼠标释放事件的自定义处理，以满足您的应用程序需求。

prepareGeometryChange 几何结构更改前之前发出信号

在 Qt 中，prepareGeometryChange 是一个重要的函数，用于在更改 QGraphicsItem 的几何结构（geometry）之前发出信号，以便允许相应的布局管理器（layout manager）或场景（scene）做出相应的调整。

当您需要更改 QGraphicsItem 的大小或形状时，通常会在更改之前调用 prepareGeometryChange 函数。这样做的目的是让相关的布局管理器或场景有机会在几何结构发生变化之前做出必要的调整，以确保布局的正确性。

以下是一个示例，展示了如何在自定义的 QGraphicsItem 子类中使用 prepareGeometryChange 函数：

class CustomGraphicsItem : public QGraphicsItem {
public:
    CustomGraphicsItem() {}

    QRectF boundingRect() const override {
        return m_rect;
    }

    void setRect(const QRectF &rect) {
        prepareGeometryChange(); // 在更改几何结构之前调用 prepareGeometryChange

        m_rect = rect;
        update(); // 通知 Qt 进行重绘
    }

protected:
    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr) override {
        // 绘制自定义图形
    }

private:
    QRectF m_rect;
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

在这个示例中，setRect 函数用于设置 CustomGraphicsItem 的矩形区域。在设置矩形区域之前，我们先调用 prepareGeometryChange 函数，以便在更改几何结构之前发出信号。然后更新矩形区域并调用 update 函数通知 Qt 进行重绘。

通过使用 prepareGeometryChange 函数，您可以确保在更改 QGraphicsItem 的几何结构时，相关的布局管理器或场景能够及时做出必要的调整，以保持正确的布局和显示。

sceneEvent 处理来自场景的各种事件

在 Qt 中，QGraphicsItem::sceneEvent 函数是一个重要的函数，用于处理来自场景的各种事件。当 QGraphicsItem 在场景中时，场景会将各种事件（如鼠标事件、键盘事件、焦点事件等）发送给 QGraphicsItem，sceneEvent 函数可以被重写来处理这些事件。

以下是一个简单的示例，展示了如何在自定义的 QGraphicsItem 子类中重写 sceneEvent 函数来处理事件：

class CustomGraphicsItem : public QGraphicsItem {
public:
    CustomGraphicsItem() {}

protected:
    bool sceneEvent(QEvent *event) override {
        if (event->type() == QEvent::GraphicsSceneMousePress) {
            // 处理鼠标按下事件
            QGraphicsSceneMouseEvent *mouseEvent = static_cast<QGraphicsSceneMouseEvent*>(event);
            // 处理鼠标按下事件的逻辑
            return true; // 表示事件已经被处理
        } else if (event->type() == QEvent::GraphicsSceneMouseRelease) {
            // 处理鼠标释放事件
            QGraphicsSceneMouseEvent *mouseEvent = static_cast<QGraphicsSceneMouseEvent*>(event);
            // 处理鼠标释放事件的逻辑
            return true; // 表示事件已经被处理
        }

        return QGraphicsItem::sceneEvent(event); // 其他事件交给基类处理
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

在这个示例中，我们重写了 sceneEvent 函数来处理鼠标按下和释放事件。在函数中，我们检查事件的类型，并根据需要处理特定类型的事件。如果事件被处理了，我们返回 true，表示事件已经被处理；如果事件未被处理，我们调用基类的 sceneEvent 函数将事件交给基类处理。

通过重写 sceneEvent 函数，您可以实现对来自场景的各种事件的自定义处理逻辑，以满足您的应用程序需求。请注意，在处理事件时，需要根据事件的类型进行适当的类型转换，以获取事件的详细信息并执行相应的操作。

sceneEventFilter 安装事件过滤器

在 Qt 中，QGraphicsItem::sceneEventFilter 是一个函数，用于在 QGraphicsItem 对象上安装事件过滤器，以便拦截和处理从场景发送给该项的事件。通过实现 sceneEventFilter 函数，您可以对特定类型的事件进行拦截和处理，而不必在每个 QGraphicsItem 子类中重复相同的事件处理逻辑。

以下是一个示例，展示了如何在自定义的 QGraphicsItem 子类中使用 sceneEventFilter 函数来拦截和处理事件：

class CustomGraphicsItem : public QGraphicsItem {
public:
    CustomGraphicsItem() {
        // 在构造函数中安装事件过滤器
        setFlag(QGraphicsItem::ItemIsFocusable);
        installSceneEventFilter(this);
    }

protected:
    bool sceneEventFilter(QGraphicsItem *watched, QEvent *event) override {
        if (watched == this) {
            if (event->type() == QEvent::GraphicsSceneMousePress) {
                // 处理鼠标按下事件
                QGraphicsSceneMouseEvent *mouseEvent = static_cast<QGraphicsSceneMouseEvent*>(event);
                // 处理鼠标按下事件的逻辑
                return true; // 表示事件已经被处理
            } else if (event->type() == QEvent::GraphicsSceneMouseRelease) {
                // 处理鼠标释放事件
                QGraphicsSceneMouseEvent *mouseEvent = static_cast<QGraphicsSceneMouseEvent*>(event);
                // 处理鼠标释放事件的逻辑
                return true; // 表示事件已经被处理
            }
        }

        return false; // 返回 false 表示事件未被处理
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

在这个示例中，我们在 CustomGraphicsItem 的构造函数中安装了事件过滤器，并在 sceneEventFilter 函数中实现了对鼠标按下和释放事件的处理逻辑。在 sceneEventFilter 函数中，我们首先检查事件的类型，然后根据需要处理特定类型的事件。如果事件被处理了，我们返回 true，表示事件已经被处理；如果事件未被处理，我们返回 false，表示事件未被处理。

通过使用 sceneEventFilter 函数，您可以方便地在 QGraphicsItem 对象上安装事件过滤器，并实现对特定类型事件的自定义处理逻辑，以满足您的应用程序需求。

updateMicroFocus()更新图形项的微焦点

在Qt中，QGraphicsItem::updateMicroFocus()函数用于更新图形项的微焦点。微焦点是指当前具有键盘焦点的图形项，通常用于处理键盘事件。当图形项的微焦点状态发生变化时，可以调用updateMicroFocus()函数来通知Qt框架更新微焦点的状态。

以下是QGraphicsItem::updateMicroFocus()函数的简要说明：

void QGraphicsItem::updateMicroFocus()
1

• 功能：更新图形项的微焦点状态，通知Qt框架微焦点发生了变化。
• 注意：通常情况下，不需要直接调用此函数。Qt框架会自动处理微焦点的变化，但在某些特定情况下可能需要手动调用此函数。

在一般情况下，Qt框架会自动处理图形项微焦点的变化，因此通常不需要手动调用updateMicroFocus()函数。然而，在某些特定情况下，如果您需要手动通知Qt框架微焦点状态发生了变化，可以调用这个函数。

请注意，微焦点是指当前具有键盘焦点的图形项，用于处理键盘事件。通过更新微焦点状态，Qt框架可以正确地由键盘事件并确保正确的图形项接收键盘输入。

wheelEvent 鼠标滚轮事件

在Qt中，QGraphicsItem::wheelEvent函数用于处理鼠标滚轮事件。当鼠标滚轮滚动时，会触发这个事件，您可以在QGraphicsItem的子类中重写这个函数来实现对鼠标滚轮事件的自定义处理逻辑。

以下是一个简单的示例，展示了如何在自定义的QGraphicsItem子类中重写wheelEvent函数来处理鼠标滚轮事件：

class CustomGraphicsItem : public QGraphicsItem {
public:
    CustomGraphicsItem() {}

    void wheelEvent(QGraphicsSceneWheelEvent *event) override {
        // 获取滚轮滚动的角度和方向
        int delta = event->delta();

        // 根据滚轮滚动的方向进行相应操作
        if (delta > 0) {
            // 向上滚动
            // 执行放大操作或其他操作
        } else {
            // 向下滚动
            // 执行缩小操作或其他操作
        }

        // 标记场景需要更新
        scene()->update();
    }

    QRectF boundingRect() const override {
        return QRectF(0, 0, 100, 100); // 设置图形项的边界矩形
    }

    void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = nullptr) override {
        // 绘制图形项的外观
        painter->drawRect(boundingRect());
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

在这个示例中，我们创建了一个自定义的CustomGraphicsItem类，并重写了wheelEvent函数来处理鼠标滚轮事件。在wheelEvent函数中，我们首先获取滚轮滚动的角度和方向，然后根据滚轮滚动的方向执行相应的操作，比如放大或缩小图形项。最后，我们通过调用scene()->update()来标记场景需要更新，以便刷新图形项的显示。

通过重写wheelEvent函数，您可以实现对鼠标滚轮事件的自定义处理逻辑，从而为用户提供更加灵活和交互性强的界面操作体验。