QT 笔记 QGraphicsScene介绍

QT QGraphicsScene类介绍

分别介绍了以下内容：

1. 类说明
2. 公共属性
3. 公共函数
4. 设置相关的函数
5. 槽函数
6. 信号量
7. Event事件

1.类说明

QGraphicsScene是Qt中用于管理2D图形项（QGraphicsItem）的场景类。它充当了图形项的容器，负责管理图形项的布局、渲染、事件处理等。QGraphicsScene可以看作是一个虚拟的画布，上面可以放置多个图形项，并且可以对这些图形项进行管理和操作。

以下是QGraphicsScene的一些主要特点和功能：

1. 图形项管理 ：QGraphicsScene可以管理多个QGraphicsItem对象，您可以在场景中添加、移除和操作这些图形项。

2. 坐标系统 ：QGraphicsScene使用自己的坐标系统，与窗口或视图的坐标系统分开。这使得在场景中放置和移动图形项更加灵活。

3. 事件处理 ：QGraphicsScene能够处理鼠标事件、键盘事件等，可以捕获这些事件并将它们传递给相应的图形项进行处理。

4. 渲染 ：QGraphicsScene负责管理图形项的绘制，可以将图形项渲染到相关的视图（QGraphicsView）上。

5. 选择和焦点 ：QGraphicsScene支持图形项的选择和焦点管理，可以通过选择和操作图形项来实现交互功能。

6. 交互 ：QGraphicsScene可以处理图形项之间的交互，例如碰撞检测、拖放等。

7. 优化 ：QGraphicsScene实现了一些优化机制，可以提高绘制性能，特别是在处理大量图形项时。

通过使用QGraphicsScene，您可以方便地创建复杂的2D图形界面，实现各种交互效果和动画。它为Qt的图形框架提供了一个强大的基础，使得开发者可以更轻松地构建具有丰富视觉效果的用户界面。

2.公共属性

backgroundBrush() 属性 获取背景画刷

backgroundBrush 是 QGraphicsScene 类中用于设置场景背景画刷（brush）的属性。背景画刷定义了场景的背景样式，可以是颜色、渐变、纹理等。

bspTreeDepth() 属性 获取树深度

bspTreeDepth 是 QGraphicsScene 类中用于设置二叉空间分区树（Binary Space Partitioning Tree）深度的属性。二叉空间分区树是一种用于优化场景中图形项渲染的数据结构，可以提高图形项的渲染效率。

原型

void QGraphicsScene::setBspTreeDepth(int depth)
int QGraphicsScene::bspTreeDepth() const

函数参数含义

• depth：要设置的二叉空间分区树的深度。深度值越大，分区越精细，但也会增加计算开销。

说明

二叉空间分区树是一种将场景划分为不重叠的区域，以便更有效地管理和渲染图形项的数据结构。通过调整二叉空间分区树的深度，可以在渲染图形项时平衡性能和精度之间的需求。

举例

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

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

    // 创建场景和视图
    QGraphicsScene scene;
    QGraphicsView view(&scene);

    // 设置二叉空间分区树的深度为3
    scene.setBspTreeDepth(3);

    // 添加一些图形项到场景中（这里省略）

    // 设置视图大小并显示
    view.setScene(&scene);
    view.show();

    return app.exec();
}

在这个示例中，我们创建了一个 QGraphicsScene 对象 scene 和一个 QGraphicsView 对象 view，然后使用 setBspTreeDepth() 函数将二叉空间分区树的深度设置为3。通过调整深度，可以根据需要平衡渲染性能和精度。

focusOnTouch() 属性 是否获得触摸焦点

此属性用于保存项目在接收触摸开始事件时是否获得焦点。

通常的行为是仅在单击项时转移焦点。触摸板上的点击通常被操作系统解释为等同于鼠标点击，从而生成一个合成的点击事件作为响应。但是，至少在macOS上可以配置此行为。

默认情况下，QGraphicsScene也会在触摸触控板或类似设备时转移焦点。如果操作系统被配置为在点击触控板时不生成合成的鼠标点击，这就令人惊讶了。如果操作系统确实在点击触控板时生成合成的鼠标点击，那么启动触摸手势的焦点转移就没有必要了。

关闭focusOnTouch后，QGraphicsScene的行为与macOS上的预期一致。

QFont font () 属性 场景的字体

此属性保存场景的默认字体

此属性提供场景的字体。场景字体默认为QApplication::font，并从QApplication::font解析其所有条目。

如果场景的字体发生变化，无论是直接通过setFont()还是当应用程序字体发生变化时间接发生变化，QGraphicsScene首先向自己发送一个FontChange事件，然后将FontChange事件发送给场景中的所有顶级小部件项。这些项通过将它们自己的字体解析到场景来响应，然后通知它们的子节点，这些子节点再通知它们的子节点，以此类推，直到所有小部件项都更新了它们的字体。

改变场景字体，(直接或间接地通过QApplication::setFont()，)自动调度重新绘制整个场景。

QBrush

QBrush foregroundBrush() 属性 前景的笔刷

这个属性保存场景的前景笔刷。

更改此属性以将场景的前景设置为不同的颜色，渐变或纹理。

前景画在项目之后(在上面)。默认的前景刷是Qt::NoBrush(即前景不绘制)。

bool hasFocus() 属性 是否有焦点

如果场景有焦点则返回true;否则返回false。如果场景有焦点，它将把关键事件从QKeyEvent转发到任何有焦点的项目。

qreal height() 属性 场景的高

这个方便的函数相当于调用scenRect().height()。

isActive() 属性 活动状态

说明：
QGraphicsScene::isActive() 函数用于检查场景是否处于活动状态。

QGraphicsScene::itemAt

bool QGraphicsScene::isActive() const

函数参数含义：

该函数没有参数。

示例：

// 检查场景是否处于活动状态
if(scene->isActive()) {
    qDebug() << "Scene is active.";
} else {
    qDebug() << "Scene is not active.";
}

在这个示例中，我们使用 isActive() 函数来检查场景是否处于活动状态。如果场景处于活动状态，将输出 "Scene is active."，否则输出 "Scene is not active."。

qreal minimumRenderSize() 属性 最小视图转换尺寸

此属性保存绘制项必须具有的最小视图转换大小

当渲染场景时，任何被转换为目标视图的宽度或高度小于minimumRenderSize()的项目都不会被渲染。如果一个项目没有被渲染，并且它剪辑了它的子项目，它们也不会被渲染。设置此值可以加快在缩小视图上渲染许多对象的场景的渲染速度。

缺省值为0。如果不设置，或者设置为0或负值，则始终呈现所有项。

例如，如果一个场景由多个视图渲染，其中一个视图充当总览，总是显示所有项目，设置此属性可能特别有用。在具有许多项目的场景中，这样的视图将使用高缩放因子，以便可以显示所有项目。由于缩放，较小的物品只会对最终渲染的场景做出微不足道的贡献。为了避免绘制这些项目并减少渲染场景所需的时间，您可以使用非负值调用setMinimumRenderSize()。

注意:由于太小而没有绘制的项仍然由Items()和itemAt()等方法返回，并参与碰撞检测和交互。建议您将minimumRenderSize()设置为小于或等于1的值，以避免交互式的大型未渲染项。

QRectF sceneRect() 属性 调色板

这个属性保存了场景矩形;场景的边界矩形

场景矩形定义了场景的范围。它主要由QGraphicsView用于确定视图的默认可滚动区域，并由QGraphicsScene用于管理项目索引。

如果未设置，或者设置为空QRectF, scenRect()将返回自场景创建以来场景中所有项目的最大边界矩形(即，当项目添加到场景中或在场景中移动时，矩形会增长，但不会缩小)。

style() 属性 场景的样式

QStyle *QGraphicsScene::style() const

返回场景的样式，如果场景没有被显式地分配样式，则与QApplication::style()相同。

width() 属性 场景的宽度

qreal QGraphicsScene::width() const

返回创景的宽度，相当于调用sceneRect().width()

3.公共函数

QGraphicsScene 构造函数

QGraphicsScene::QGraphicsScene是QGraphicsScene类的构造函数，用于创建一个新的QGraphicsScene对象。这个构造函数有几种不同的重载形式，可以接受不同的参数来初始化场景。

以下是QGraphicsScene::QGraphicsScene构造函数的一种常见形式：

QGraphicsScene::QGraphicsScene(const QRectF &sceneRect, QObject *parent = nullptr)
QGraphicsScene::QGraphicsScene(qreal x, qreal y, qreal width, qreal height, QObject *parent = nullptr)
QGraphicsScene::QGraphicsScene(QObject *parent = nullptr)

在这个构造函数中，sceneRect参数指定了场景的矩形范围，即场景的可视区域。parent参数用于指定场景的父对象，如果不需要指定父对象，则可以将其设置为nullptr。

除了上述形式，QGraphicsScene::QGraphicsScene构造函数还有其他重载形式，可以根据不同的需求来初始化场景。例如，还有一些构造函数可以接受不同类型的参数，如坐标值、大小等，以便更灵活地创建场景。

在使用QGraphicsScene时，通常会在构造函数中指定场景的大小和父对象（如果需要），然后可以通过调用其他成员函数来添加图形项、处理事件等。QGraphicsScene提供了丰富的功能，可以帮助您管理和操作2D图形项，实现各种交互和动画效果。

~QGraphicsScene 析构函数

[virtual] QGraphicsScene::~QGraphicsScene()

QGraphicsScene::~QGraphicsScene是QGraphicsScene类的析构函数，用于释放QGraphicsScene对象所占用的资源。析构函数在对象被销毁时自动调用，用于执行清理操作，例如释放内存、关闭文件等。

在Qt中，QGraphicsScene的析构函数通常会在对象不再需要时被调用，以确保资源得到正确释放，避免内存泄漏和其他问题。当删除QGraphicsScene对象时，其析构函数会被自动调用。

在析构函数中，通常会执行一些清理工作，例如删除场景中的所有图形项、断开与其他对象的连接等。如果QGraphicsScene对象包含了其他动态分配的资源，析构函数也应该负责释放这些资源，以避免资源泄漏。

如果您需要在QGraphicsScene对象被销毁时执行特定的清理操作，可以在析构函数中添加相应的代码。Qt会确保在对象销毁时自动调用析构函数，因此您无需手动调用它。

总之，QGraphicsScene::~QGraphicsScene是QGraphicsScene类的析构函数，用于在对象销毁时执行清理操作，确保资源的正确释放。

activePanel 活动面板

返回当前活动面板，如果当前没有活动面板，则返回nullptr。

activeWindow() 活动窗口

返回当前活动窗口，如果当前没有活动窗口，则返回nullptr。

addEllipse() 椭圆形状的图形项

说明：
QGraphicsScene::addEllipse() 是 QGraphicsScene 类中的一个函数，用于在场景中添加椭圆图形项。

原型：

QGraphicsEllipseItem * QGraphicsScene::addEllipse(const QRectF & rect, const QPen & pen = QPen(), const QBrush & brush = QBrush())
QGraphicsEllipseItem *QGraphicsScene::addEllipse(qreal x, qreal y, qreal w, qreal h, const QPen &pen = QPen(), const QBrush &brush = QBrush())

函数参数含义：

• rect：椭圆的边界矩形，指定椭圆的位置和大小。
• pen：椭圆的边框画笔，用于指定边框的样式、颜色和宽度。默认为 QPen()，即无边框。
• brush：椭圆的填充刷子，用于指定填充的样式和颜色。默认为 QBrush()，即无填充。

示例：

下面是一个示例，演示如何使用 QGraphicsScene::addEllipse() 函数向场景中添加一个椭圆图形项：

#include <QGraphicsScene>
#include <QGraphicsView>
#include <QGraphicsEllipseItem>
#include <QApplication>

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

    // 创建场景和视图
    QGraphicsScene scene;
    QGraphicsView view(&scene);

    // 创建一个椭圆图形项
    QRectF rect(0, 0, 100, 50); // 椭圆的边界矩形
    QPen pen(Qt::black); // 边框画笔
    QBrush brush(Qt::red); // 填充刷子

    QGraphicsEllipseItem *ellipseItem = scene.addEllipse(rect, pen, brush);

    // 设置视图大小并显示
    view.setScene(&scene);
    view.show();

    return app.exec();
}

在这个示例中，我们首先创建了一个 QGraphicsScene 对象 scene 和一个 QGraphicsView 对象 view。然后，我们定义了椭圆的边界矩形 rect、边框画笔 pen 和填充刷子 brush，并通过调用 scene.addEllipse(rect, pen, brush) 向场景中添加了一个椭圆图形项。最后，将场景设置给视图并显示出来。

通过这种方式，您可以使用 QGraphicsScene::addEllipse() 函数在场景中动态添加椭圆图形项，并根据需要设置其边框、填充等属性。

addItem() 添加图形项

说明：
QGraphicsScene::addItem() 是 QGraphicsScene 类中的一个函数，用于向场景中添加图形项。

原型：

QGraphicsItem * QGraphicsScene::addItem(QGraphicsItem * item)

函数参数含义：

• item：要添加到场景中的图形项对象。

示例：

下面是一个示例，演示如何使用 QGraphicsScene::addItem() 函数向场景中添加一个自定义图形项：

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

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

    // 创建场景和视图
    QGraphicsScene scene;
    QGraphicsView view(&scene);

    // 创建一个矩形图形项
    QGraphicsRectItem *rectItem = new QGraphicsRectItem(0, 0, 100, 50);
    rectItem->setBrush(Qt::blue); // 设置矩形填充颜色

    // 将矩形图形项添加到场景中
    scene.addItem(rectItem);

    // 设置视图大小并显示
    view.setScene(&scene);
    view.show();

    return app.exec();
}

在这个示例中，我们首先创建了一个 QGraphicsScene 对象 scene 和一个 QGraphicsView 对象 view。然后，我们创建了一个矩形图形项 rectItem，设置了矩形的位置、宽度和高度，以及填充颜色。最后，通过调用 scene.addItem(rectItem) 将矩形图形项添加到场景中，并将场景设置给视图，最终显示出来。

通过类似的方法，您可以使用 QGraphicsScene::addItem() 函数向场景中添加各种类型的图形项，包括矩形、椭圆、文本等，以实现丰富多彩的图形场景。

QGraphicsScene::addLine() 是 QGraphicsScene 类中的一个函数，用于在场景中添加直线图形项。

addLine() 添加直线图形项

说明：
QGraphicsScene::addLine() 函数用于在场景中添加直线图形项。

原型：

QGraphicsLineItem *QGraphicsScene::addLine(const QLineF &line, const QPen &pen = QPen())
QGraphicsLineItem * QGraphicsScene::addLine(qreal x1, qreal y1, qreal x2, qreal y2, const QPen & pen = QPen())

函数参数含义：

• x1、y1：直线的起点坐标。
• x2、y2：直线的终点坐标。
• pen：直线的画笔，用于指定直线的样式、颜色和宽度。默认为 QPen()，即无边框。

示例：

下面是一个示例，演示如何使用 QGraphicsScene::addLine() 函数向场景中添加一条直线图形项：

#include <QGraphicsScene>
#include <QGraphicsView>
#include <QGraphicsLineItem>
#include <QApplication>

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

    // 创建场景和视图
    QGraphicsScene scene;
    QGraphicsView view(&scene);

    // 添加一条直线图形项
    QGraphicsLineItem *lineItem = scene.addLine(0, 0, 100, 100, QPen(Qt::black));

    // 设置视图大小并显示
    view.setScene(&scene);
    view.show();

    return app.exec();
}

在这个示例中，我们首先创建了一个 QGraphicsScene 对象 scene 和一个 QGraphicsView 对象 view。然后，通过调用 scene.addLine(0, 0, 100, 100, QPen(Qt::black)) 向场景中添加了一条直线图形项，起点坐标为 (0, 0)，终点坐标为 (100, 100)，并设置了黑色的边框。最后，将场景设置给视图并显示出来。

通过类似的方法，您可以使用 QGraphicsScene::addLine() 函数向场景中添加直线图形项，实现绘制直线的效果。

QGraphicsScene::addPath() 是 QGraphicsScene 类中的一个函数，用于在场景中添加路径图形项。

addPath() 添加路径图形项

说明：
QGraphicsScene::addPath() 函数用于在场景中添加路径图形项。

原型：

QGraphicsPathItem * QGraphicsScene::addPath(const QPainterPath & path, const QPen & pen = QPen(), const QBrush & brush = QBrush())

函数参数含义：

• path：要绘制的路径。
• pen：路径的画笔，用于指定路径的边框样式、颜色和宽度。默认为 QPen()，即无边框。
• brush：路径的填充刷子，用于指定路径的填充样式和颜色。默认为 QBrush()，即无填充。

示例：

下面是一个示例，演示如何使用 QGraphicsScene::addPath() 函数向场景中添加一个自定义路径图形项：

#include <QGraphicsScene>
#include <QGraphicsView>
#include <QGraphicsPathItem>
#include <QPainterPath>
#include <QApplication>

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

    // 创建场景和视图
    QGraphicsScene scene;
    QGraphicsView view(&scene);

    // 创建一个路径
    QPainterPath path;
    path.moveTo(0, 0);
    path.lineTo(50, 0);
    path.lineTo(50, 50);
    path.lineTo(0, 50);
    path.closeSubpath();

    // 添加路径图形项到场景中
    QGraphicsPathItem *pathItem = scene.addPath(path, QPen(Qt::blue), QBrush(Qt::yellow));

    // 设置视图大小并显示
    view.setScene(&scene);
    view.show();

    return app.exec();
}

在这个示例中，我们首先创建了一个 QGraphicsScene 对象 scene 和一个 QGraphicsView 对象 view。然后，我们创建了一个自定义路径 path，通过一系列的 moveTo 和 lineTo 操作来定义路径的形状，最后通过 closeSubpath 封闭路径。接着，我们通过调用 scene.addPath(path, QPen(Qt::blue), QBrush(Qt::yellow)) 将路径图形项添加到场景中，并设置了蓝色的边框和黄色的填充。最后，将场景设置给视图并显示出来。

通过类似的方法，您可以使用 QGraphicsScene::addPath() 函数向场景中添加自定义路径图形项，实现绘制各种复杂形状的效果。

addPixmap() 添加像素图形项

说明：
QGraphicsScene::addPixmap() 函数用于在场景中添加像素图形项。

原型：

QGraphicsPixmapItem * QGraphicsScene::addPixmap(const QPixmap & pixmap)

函数参数含义：

• pixmap：要添加的像素图。

示例：

下面是一个示例，演示如何使用 QGraphicsScene::addPixmap() 函数向场景中添加一个像素图形项：

#include <QGraphicsScene>
#include <QGraphicsView>
#include <QGraphicsPixmapItem>
#include <QPixmap>
#include <QApplication>

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

    // 创建场景和视图
    QGraphicsScene scene;
    QGraphicsView view(&scene);

    // 加载图片
    QPixmap pixmap("image.jpg");

    // 添加像素图形项到场景中
    QGraphicsPixmapItem *pixmapItem = scene.addPixmap(pixmap);

    // 设置视图大小并显示
    view.setScene(&scene);
    view.show();

    return app.exec();
}

在这个示例中，我们首先创建了一个 QGraphicsScene 对象 scene 和一个 QGraphicsView 对象 view。然后，我们加载了一个图片文件 image.jpg，并将其作为 QPixmap 对象 pixmap。接着，通过调用 scene.addPixmap(pixmap) 将像素图形项添加到场景中。最后，将场景设置给视图并显示出来。

addRect() 添加矩形图形项

说明：
QGraphicsScene::addRect() 函数用于在场景中添加矩形图形项。

原型：

QGraphicsRectItem * QGraphicsScene::addRect(const QRectF & rect, const QPen & pen = QPen(), const QBrush & brush = QBrush())
QGraphicsRectItem *QGraphicsScene::addRect(qreal x, qreal y, qreal w, qreal h, const QPen &pen = QPen(), const QBrush &brush = QBrush())

函数参数含义：

• rect：要绘制的矩形区域，使用 QRectF 类型表示。
• pen：矩形的画笔，用于指定矩形的边框样式、颜色和宽度。默认为 QPen()，即无边框。
• brush：矩形的填充刷子，用于指定矩形的填充样式和颜色。默认为 QBrush()，即无填充。

示例：

下面是一个示例，演示如何使用 QGraphicsScene::addRect() 函数向场景中添加一个矩形图形项：

#include <QGraphicsScene>
#include <QGraphicsView>
#include <QGraphicsRectItem>
#include <QRectF>
#include <QPen>
#include <QBrush>
#include <QApplication>

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

    // 创建场景和视图
    QGraphicsScene scene;
    QGraphicsView view(&scene);

    // 创建一个矩形
    QRectF rect(0, 0, 100, 50);

    // 添加矩形图形项到场景中
    QGraphicsRectItem *rectItem = scene.addRect(rect, QPen(Qt::red), QBrush(Qt::green));

    // 设置视图大小并显示
    view.setScene(&scene);
    view.show();

    return app.exec();
}

在这个示例中，我们首先创建了一个 QGraphicsScene 对象 scene 和一个 QGraphicsView 对象 view。然后，我们创建了一个矩形 rect，通过指定矩形的左上角坐标、宽度和高度来定义矩形的大小和位置。接着，通过调用 scene.addRect(rect, QPen(Qt::red), QBrush(Qt::green)) 将矩形图形项添加到场景中，并设置了红色的边框和绿色的填充。最后，将场景设置给视图并显示出来。

addSimpleText() 添加简单的文本项

说明：
QGraphicsScene::addSimpleText() 函数用于在场景中添加简单的文本项。

原型：

QGraphicsSimpleTextItem * QGraphicsScene::addSimpleText(const QString & text, const QFont & font = QFont())

函数参数含义：

• text：要显示的文本内容。
• font：文本的字体设置，包括字体、大小、粗细等。默认为 QFont()，即使用默认字体设置。

示例：

下面是一个示例，演示如何使用 QGraphicsScene::addSimpleText() 函数向场景中添加一个简单的文本项：

#include <QGraphicsScene>
#include <QGraphicsView>
#include <QGraphicsSimpleTextItem>
#include <QFont>
#include <QApplication>

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

    // 创建场景和视图
    QGraphicsScene scene;
    QGraphicsView view(&scene);

    // 添加简单的文本项到场景中
    QGraphicsSimpleTextItem *textItem = scene.addSimpleText("Hello, QGraphicsScene!");
    textItem->setFont(QFont("Arial", 16)); // 设置文本的字体和大小

    // 设置文本项的位置
    textItem->setPos(100, 100);

    // 设置视图大小并显示
    view.setScene(&scene);
    view.show();

    return app.exec();
}

在这个示例中，我们首先创建了一个 QGraphicsScene 对象 scene 和一个 QGraphicsView 对象 view。然后，通过调用 scene.addSimpleText("Hello, QGraphicsScene!") 添加了一个显示文本 "Hello, QGraphicsScene!" 的简单文本项到场景中。接着，我们使用 textItem->setFont(QFont("Arial", 16)) 设置了文本的字体为 Arial，大小为 16。最后，通过 textItem->setPos(100, 100) 设置了文本项的位置为 (100, 100)。将场景设置给视图并显示出来。

addText() 添加文本项

说明：
QGraphicsScene::addText() 函数用于在场景中添加文本项。

原型：

QGraphicsTextItem *QGraphicsScene::addText(const QString &text, const QFont &font = QFont())

函数参数含义：

• text：要显示的文本内容。
• font：文本的字体设置，包括字体、大小、粗细等。默认为 QFont()，即使用默认字体设置。

示例：

下面是一个示例，演示如何使用 QGraphicsScene::addText() 函数向场景中添加一个简单的文本项：

#include <QGraphicsScene>
#include <QGraphicsView>
#include <QGraphicsTextItem>
#include <QFont>
#include <QApplication>

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

    // 创建场景和视图
    QGraphicsScene scene;
    QGraphicsView view(&scene);

    // 创建自定义文本项
    // 创建并添加简单的文本项到场景中
    QGraphicsTextItem  *textItem = scene.addText("Hello, QGraphicsScene!",QFont("Arial", 16));
    
    // 设置文本项的位置
    textItem->setPos(100, 100);

    view.show();

    return app.exec();
}

在这个示例中，我们创建了一个自定义的 QGraphicsTextItem 对象 textItem，设置了文本内容为 "Hello, QGraphicsScene!"，并设置了字体为 Arial，大小为 16。然后，通过 setPos 方法设置了文本项的位置为 (100, 100)，最后使用 scene.addItem(textItem) 将文本项添加到场景中。

addWidget() 添加代理部件

说明：
QGraphicsScene::addWidget() 函数用于在场景中添加代理部件。

原型：

QGraphicsProxyWidget *QGraphicsScene::addWidget(QWidget *widget, Qt::WindowFlags wFlags = Qt::WindowFlags())

函数参数含义：

• widget：要显示的widget。
• font：设置嵌入代理小部件，默认窗口标志。

示例：

下面是一个示例，演示如何使用 QGraphicsScene::addWidget() 函数向场景中添加添加代理部件：

#include <QGraphicsScene>
#include <QGraphicsView>
#include <QGraphicsProxyWidget>
#include <QLabel>
#include <QApplication>

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

    // 创建场景和视图
    QGraphicsScene scene;
    QGraphicsView view(&scene);

    // 创建一个 QWidget（这里使用 QLabel 作为示例）
    QLabel *label = new QLabel("Hello, QGraphicsScene!");

    // 创建一个 QGraphicsProxyWidget，并将 QLabel 添加到场景中
    QGraphicsProxyWidget *proxyWidget = scene.addWidget(label);
    proxyWidget->setPos(100, 100); // 设置 Widget 在场景中的位置

    view.show();

    return app.exec();
}

在这个示例中，我们首先创建了一个 QLabel 对象 label，并设置了其文本内容为 "Hello, QGraphicsScene!"。然后，我们创建了一个 QGraphicsProxyWidget 对象 proxyWidget，并通过 scene.addWidget(label) 将 QLabel 添加到 QGraphicsScene 中。最后，我们使用 proxyWidget->setPos(100, 100) 设置了 Widget 在场景中的位置为 (100, 100)。

clearFocus 清除控件焦点

clearFocus 是 QWidget 类中的一个函数，用于清除控件（widget）的焦点。在用户界面中，焦点指示用户当前可以接收键盘输入的控件。通过调用 clearFocus 函数，您可以将焦点从当前控件中移除，使其不再接收键盘输入。

原型

void QWidget::clearFocus()

函数参数含义

该函数没有参数。

说明

在用户界面中，焦点通常用于指示用户当前正在与之交互的控件。通过清除控件的焦点，可以在需要时将焦点从一个控件转移到另一个控件，或者在不需要任何控件接收键盘输入时清除焦点。

举例

#include <QApplication>
#include <QWidget>
#include <QPushButton>

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

    // 创建一个父窗口
    QWidget parentWidget;
    parentWidget.setWindowTitle("Parent Widget");

    // 创建一个按钮并将其添加到父窗口中
    QPushButton button("Click Me", &parentWidget);
    button.setGeometry(100, 100, 100, 30);

    // 显示父窗口和按钮
    parentWidget.show();

    // 当按钮被点击时，清除按钮的焦点
    QObject::connect(&button, &QPushButton::clicked, [&button](){
        button.clearFocus();
    });

    return app.exec();
}

在这个示例中，我们创建了一个父窗口 parentWidget 和一个按钮 button，将按钮添加到父窗口中。当按钮被点击时，我们通过连接按钮的 clicked 信号来调用 clearFocus 函数，从而清除按钮的焦点。

collidingItems() 获取碰撞项

collidingItems 是 QGraphicsScene 类中的一个函数，用于获取场景与图形项发生碰撞的其他图形项。在 Qt 中，碰撞检测是一种常见的操作，用于检查图形项之间是否存在重叠或碰撞。

原型

QList<QGraphicsItem *> QGraphicsScene::collidingItems(const QGraphicsItem *item, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const

函数参数含义

• item：图像项
• mode：指定碰撞检测的模式，默认为 Qt::IntersectsItemShape，表示检测图形项的形状是否相交。

返回值

函数返回一个 QList<QGraphicsItem *> 类型的列表，包含与图形项发生碰撞的其他图形项。

说明
collidingItems 函数用于检测场景当前图形项与其他图形项之间的碰撞关系。您可以使用这个函数来获取与图形项发生碰撞的其他图形项，并进一步处理这些碰撞情况，比如进行碰撞响应、碰撞检测等操作。

举例

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

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

    // 创建场景和视图
    QGraphicsScene scene;
    QGraphicsView view(&scene);

    // 添加三个矩形图形项到场景中
        QGraphicsRectItem *rect1 = scene.addRect(0, 0, 100, 100);
        QGraphicsRectItem *rect2 = scene.addRect(50, 50, 100, 100);
        QGraphicsRectItem *rect3 = scene.addRect(50, 70, 90, 100);
        // 获取与 rect3 发生碰撞的图形项，有rect1和rect2
           QList<QGraphicsItem *> collidingItems = scene.collidingItems(rect3);
        // 输出碰撞项的数量
            qDebug() << "Number of colliding items with rect1: " << collidingItems.size();

    // 设置视图大小并显示
    view.setScene(&scene);
    view.show();

    return app.exec();
}

在这个示例中，我们创建了一个场景并添加了两个矩形图形项 rect1 、rect2 和rect3到场景中。然后，我们使用 collidingItems 函数来获取与 rect1 发生碰撞的其他图形项，并输出碰撞项的数量。

createItemGroup 创建分组

createItemGroup 是 QGraphicsScene 类中的一个函数，用于将一组图形项（QGraphicsItem）创建为一个组合项（QGraphicsItemGroup）。组合项是一种特殊的图形项，可以将多个图形项组合在一起，以便作为一个整体进行处理。

原型

QGraphicsItemGroup *QGraphicsScene::createItemGroup(const QList<QGraphicsItem *> &items)

函数参数含义

• items：一个包含要组合的图形项的列表。

返回值

函数返回一个 QGraphicsItemGroup 类型的指针，表示创建的组合项。

说明
createItemGroup 函数用于将一组图形项组合为一个组合项，这样可以方便地对这些图形项进行统一管理和操作。组合项可以被移动、旋转、缩放等，同时也可以对组合项中的各个子项进行单独的操作。

举例

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

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

    // 创建场景和视图
    QGraphicsScene scene;
    QGraphicsView view(&scene);

    // 创建几个矩形图形项
    QGraphicsRectItem *rect1 = scene.addRect(0, 0, 100, 100);
    QGraphicsRectItem *rect2 = scene.addRect(50, 50, 100, 100);

    // 将这两个矩形图形项创建为一个组合项
    QList<QGraphicsItem *> itemsToGroup;
    itemsToGroup << rect1 << rect2;
    QGraphicsItemGroup *group = scene.createItemGroup(itemsToGroup);

    // 设置组合项的位置
    group->setPos(200, 200);

    // 设置视图大小并显示
    view.setScene(&scene);
    view.show();

    return app.exec();
}

在这个示例中，我们创建了两个矩形图形项 rect1 和 rect2，然后使用 createItemGroup 函数将它们创建为一个组合项 group。最后，我们设置了组合项的位置并将场景显示在视图中。

destroyItemGroup 销毁分组

原型

void QGraphicsScene::destroyItemGroup(QGraphicsItemGroup *group)

函数参数含义

• group：一个包含要销毁的图形项的分组。

返回值

空。

说明
destroyItemGroup 是 QGraphicsScene 类中的一个函数，将group中的所有项重置为group的父项，然后从场景中删除group，最后删除它。项的位置和转换从组映射到组的父组。

举例

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

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

    // 创建场景和视图
    QGraphicsScene scene;
    QGraphicsView view(&scene);

    // 创建几个矩形图形项
    QGraphicsRectItem *rect1 = scene.addRect(0, 0, 100, 100);
    QGraphicsRectItem *rect2 = scene.addRect(50, 50, 100, 100);

    // 将这两个矩形图形项创建为一个组合项
    QList<QGraphicsItem *> itemsToGroup;
    itemsToGroup << rect1 << rect2;
    QGraphicsItemGroup *group = scene.createItemGroup(itemsToGroup);

    // 设置组合项的位置
    group->setPos(200, 200);
    
	//销毁分组
	scene.destroyItemGroup(group);
	
    // 设置视图大小并显示
    view.setScene(&scene);
    view.show();

    return app.exec();
}

在这个示例中，我们创建了两个矩形图形项 rect1 和 rect2，然后使用 createItemGroup 函数将它们创建为一个组合项 group，然后通过destroyItemGroup 函将分组group销毁。

drawBackground 绘制场景背景

QGraphicsScene::drawBackground 是一个用于绘制场景背景的虚拟函数。在自定义的 QGraphicsScene 类中重写这个函数可以实现自定义的背景绘制效果。

函数原型：

virtual void QGraphicsScene::drawBackground(QPainter *painter, const QRectF &rect);

参数说明：

• painter：用于绘制的 QPainter 对象。
• rect：指定需要绘制的区域的矩形。

示例说明：

下面是一个简单的示例，演示了如何在自定义的 QGraphicsScene 类中重写 drawBackground 函数，以实现自定义背景绘制效果：

#include <QGraphicsScene>
#include <QPainter>
#include <QDebug>

class CustomGraphicsScene : public QGraphicsScene
{
protected:
    void drawBackground(QPainter *painter, const QRectF &rect) override
    {
        QBrush brush(Qt::lightGray);
        painter->fillRect(rect, brush);
        qDebug() << "Custom background drawn";
    }
};

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

    CustomGraphicsScene scene;
    QGraphicsView view(&scene);
    view.show();

    return app.exec();
}

在这个示例中，我们创建了一个自定义的 CustomGraphicsScene 类，重写了 drawBackground 函数来绘制自定义的灰色背景。在这个函数中，我们使用 QPainter 对象绘制了一个灰色矩形作为背景，并输出一条消息表示自定义背景已绘制。

drawForeground 绘制场景前景

QGraphicsScene::drawForeground 是一个虚拟函数，用于在场景的前景中绘制内容。通过重写这个函数，你可以实现自定义的前景绘制效果。

函数原型：

virtual void QGraphicsScene::drawForeground(QPainter *painter, const QRectF &rect);

参数说明：

• painter：用于绘制的 QPainter 对象。
• rect：指定需要绘制的区域的矩形。

示例说明：

下面是一个简单的示例，演示了如何在自定义的 QGraphicsScene 类中重写 drawForeground 函数，以实现自定义的前景绘制效果：

#include <QGraphicsScene>
#include <QPainter>
#include <QDebug>

class CustomGraphicsScene : public QGraphicsScene
{
protected:
    void drawForeground(QPainter *painter, const QRectF &rect) override
    {
        QPen pen(Qt::red);
        painter->setPen(pen);
        painter->drawText(rect, Qt::AlignCenter, "Custom foreground");
        qDebug() << "Custom foreground drawn";
    }
};

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

    CustomGraphicsScene scene;
    QGraphicsView view(&scene);
    view.show();

    return app.exec();
}

在这个示例中，我们创建了一个自定义的 CustomGraphicsScene 类，重写了 drawForeground 函数来绘制自定义的红色文本作为前景。在这个函数中，我们使用 QPainter 对象设置了红色画笔，并在指定的矩形区域中居中绘制了文本，并输出一条消息表示自定义前景已绘制。

focusItem() 获取当前拥有焦点的图形项

函数说明：
QGraphicsScene::focusItem() 用于获取当前拥有焦点的图形项。

原型：

QGraphicsItem *QGraphicsScene::focusItem() const

函数参数含义：

• 无参数。
• 返回类型为 QGraphicsItem *，表示当前拥有焦点的图形项。如果没有图形项拥有焦点，则返回 nullptr。

示例：

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

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

    // 创建场景和视图
    QGraphicsScene scene;
    QGraphicsView view(&scene);

    // 创建几个矩形图形项
    QGraphicsRectItem *rect1 = scene.addRect(0, 0, 100, 100);
    QGraphicsRectItem *rect2 = scene.addRect(50, 50, 100, 100);

    // 设置第一个矩形图形项为焦点项
    rect1->setFlag(QGraphicsItem::ItemIsFocusable);
    rect1->setFocus();

    // 获取当前拥有焦点的图形项
    QGraphicsItem *focusedItem = scene.focusItem();

    // 输出当前拥有焦点的图形项的类型
    if (focusedItem) {
        qDebug() << "Focused item type:" << focusedItem->type();
    } else {
        qDebug() << "No item has focus.";
    }

    // 设置视图大小并显示
    view.setScene(&scene);
    view.show();

    return app.exec();
}

示例说明：

1. 在这个示例中，我们创建了一个场景并向其中添加了两个矩形图形项 rect1 和 rect2。
2. 我们将 rect1 设置为可获得焦点，并将其设置为当前拥有焦点的图形项。
3. 使用 QGraphicsScene::focusItem() 函数获取当前拥有焦点的图形项，并将其存储在 focusedItem 中。
4. 最后，我们输出当前拥有焦点的图形项的类型，如果没有图形项拥有焦点，则输出 "No item has focus."。
5. 最后，我们将场景设置到视图中并显示出来。

inputMethodQuery() 查询输入法的状态和信息

函数说明：
QGraphicsScene::inputMethodQuery() 查询输入法的状态和信息。

原型：

[virtual] QVariant QGraphicsScene::inputMethodQuery(Qt::InputMethodQuery query) const

函数参数含义：

• query：指定查询哪个属性。
• 返回类型为 QVariant *，输入法的属性。

invalidate() 标记场景中的特定区域为无效

说明：
QGraphicsScene::invalidate() 函数用于标记场景中的特定区域为无效，以便在下一次重绘时更新该区域。

原型：

void QGraphicsScene::invalidate(const QRectF &rect, SceneLayers layers = AllLayers)

函数参数含义：

• rect：指定需要标记为无效的矩形区域。
• layers：指定需要更新的图层，默认值为 AllLayers，表示更新所有图层。

举例：

// 创建一个矩形区域
QRectF invalidRect(10, 10, 100, 100);

// 标记矩形区域为无效，以便进行更新
scene->invalidate(invalidRect);

在这个例子中，我们创建了一个矩形区域 invalidRect，然后使用 invalidate() 函数将该矩形区域标记为无效，以便在下一次重绘时更新这个区域。

itemAt() 指定点位置的图形项

说明：
QGraphicsScene::itemAt() 函数用于返回场景中指定点位置的图形项。

原型：

QGraphicsItem *QGraphicsScene::itemAt(const QPointF &position, const QTransform &deviceTransform) const
QGraphicsItem *QGraphicsScene::itemAt(qreal x, qreal y, const QTransform &deviceTransform) const

函数参数含义：

• position：指定的点位置，即要查找图形项的坐标位置。
• deviceTransform：设备变换，用于将场景坐标转换为设备坐标。

示例：

// 获取鼠标点击位置
QPointF mousePos = mapToScene(event->pos());

// 查找该位置处的图形项
QGraphicsItem *item = scene->itemAt(mousePos);
if (item) {
    qDebug() << "Found item at position: " << mousePos;
} else {
    qDebug() << "No item found at position: " << mousePos;
}

在这个示例中，我们首先获取鼠标点击位置 mousePos，然后使用 itemAt() 函数查找该位置处的图形项。如果找到了图形项，将输出 "Found item at position: "，否则输出 "No item found at position: "。

QGraphicsScene::items() 函数用于返回场景中包含的所有图形项。下面是关于该函数的详细信息：
itemIndexMethod 是 QGraphicsScene 类中的一个函数，用于设置或获取场景中图形项的索引方法。下面是关于该函数的详细信息：

itemIndexMethod 图形项的索引方法

说明：
QGraphicsScene::itemIndexMethod 函数用于设置或获取场景中图形项的索引方法。

原型：

QGraphicsScene::ItemIndexMethod QGraphicsScene::itemIndexMethod() const
void QGraphicsScene::setItemIndexMethod(QGraphicsScene::ItemIndexMethod method)

函数参数含义：

• method：要设置的图形项索引方法，是 QGraphicsScene::ItemIndexMethod 枚举类型的值。

返回值：

• QGraphicsScene::ItemIndexMethod：当前图形项的索引方法。

示例：

// 获取当前图形项索引方法
QGraphicsScene::ItemIndexMethod currentIndexMethod = scene->itemIndexMethod();
qDebug() << "Current item index method: " << currentIndexMethod;

// 设置图形项索引方法为 BSPTreeIndex
scene->setItemIndexMethod(QGraphicsScene::BspTreeIndex);

在这个示例中，我们首先使用 itemIndexMethod() 函数获取当前的图形项索引方法，并输出它。然后，我们使用 setItemIndexMethod() 函数将图形项索引方法设置为 QGraphicsScene::BspTreeIndex。

items() 返回所有图形项

说明：
QGraphicsScene::items() 函数返回场景中包含的所有图形项。

原型：

QList<QGraphicsItem *> QGraphicsScene::items(Qt::SortOrder order = Qt::DescendingOrder) 
const
QList<QGraphicsItem *> QGraphicsScene::items(const QPointF &pos, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape, Qt::SortOrder order = Qt::DescendingOrder, const QTransform &deviceTransform = QTransform()) const
QList<QGraphicsItem *> QGraphicsScene::items(const QRectF &rect, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape, Qt::SortOrder order = Qt::DescendingOrder, const QTransform &deviceTransform = QTransform()) const
QList<QGraphicsItem *> QGraphicsScene::items(const QPolygonF &polygon, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape, Qt::SortOrder order = Qt::DescendingOrder, const QTransform &deviceTransform = QTransform()) const
QList<QGraphicsItem *> QGraphicsScene::items(const QPainterPath &path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape, Qt::SortOrder order = Qt::DescendingOrder, const QTransform &deviceTransform = QTransform()) const
QList<QGraphicsItem *> QGraphicsScene::items(qreal x, qreal y, qreal w, qreal h, Qt::ItemSelectionMode mode, Qt::SortOrder order, const QTransform &deviceTransform = QTransform()) const

函数参数含义：

• order：可选参数，用于指定返回图形项的顺序，可以是 Qt::AscendingOrder 或 Qt::DescendingOrder。

返回值：

函数返回一个 QList<QGraphicsItem *> 对象，其中包含场景中的所有图形项。

示例：

// 获取场景中的所有图形项
QList<QGraphicsItem *> allItems = scene->items();

// 遍历所有图形项并输出它们的类型
for (QGraphicsItem *item : allItems) {
    qDebug() << "Item type: " << item->type();
}

在这个示例中，我们使用 items() 函数获取场景中的所有图形项，并遍历这些图形项以输出它们的类型。

QGraphicsScene::itemsBoundingRect() 是 QGraphicsScene 类中的一个函数，用于返回包围场景中所有图形项的矩形。下面是关于该函数的详细信息：

itemsBoundingRect 返回一个矩形

说明：
QGraphicsScene::itemsBoundingRect() 函数返回一个矩形，该矩形是包围场景中所有图形项的最小矩形。
原型：

QRectF QGraphicsScene::itemsBoundingRect() const

返回值：

• QRectF：一个矩形，表示包围场景中所有图形项的最小矩形。

示例：

// 获取包围所有图形项的矩形
QRectF boundingRect = scene->itemsBoundingRect();
qDebug() << "Bounding rectangle: " << boundingRect;

在这个示例中，我们使用 itemsBoundingRect() 函数获取包围场景中所有图形项的矩形，并将其输出。

这个函数对于确定场景中所有图形项所占空间的边界非常有用。

mouseGrabberItem() 捕获鼠标事件的图形项

说明：
QGraphicsScene::mouseGrabberItem() 函数返回当前捕获鼠标事件的图形项。如果没有图形项捕获鼠标事件，则返回 nullptr。

原型：

QGraphicsItem *QGraphicsScene::mouseGrabberItem() const

返回值：

• QGraphicsItem *：当前捕获鼠标事件的图形项，如果没有则返回 nullptr。

示例：

// 获取当前捕获鼠标事件的图形项
QGraphicsItem *grabberItem = scene->mouseGrabberItem();
if (grabberItem) {
    qDebug() << "Mouse is grabbed by item: " << grabberItem;
} else {
    qDebug() << "No item is currently grabbing the mouse.";
}

在这个示例中，我们使用 mouseGrabberItem() 函数来获取当前捕获鼠标事件的图形项，并根据返回值输出相应信息。

这个函数在处理鼠标事件时非常有用，可以帮助您确定哪个图形项当前正在处理鼠标事件。

QPalette palette() 属性 调色板

这个属性保存场景的默认调色板

这个属性提供场景的调色板。场景调色板默认为QApplication::调色板，并从QApplication::调色板解析其所有条目。

如果场景的调色板发生变化，无论是直接通过setPalette()还是在应用程序调色板发生变化时间接发生变化，QGraphicsScene首先向自己发送一个PaletteChange事件，然后将PaletteChange事件发送给场景中的所有顶级小部件项。这些项通过将它们自己的调色板解析到场景来响应，然后通知它们的子节点，子节点再通知它们的子节点，以此类推，直到所有小部件项都更新了它们的调色板。

改变场景调色板，(直接或间接地通过QApplication::setPalette()，)自动调度重新绘制整个场景。

removeItem 是 QGraphicsScene 类中的一个函数，用于从场景中移除特定的图形项。下面是关于 removeItem 函数的详细信息：

removeItem 移除图形项

说明：
removeItem 函数用于从 QGraphicsScene 中移除特定的图形项。

原型：

void QGraphicsScene::removeItem(QGraphicsItem *item)

参数：

• item：要从场景中移除的图形项。

示例：

// 创建一个图形项
QGraphicsRectItem *rectItem = new QGraphicsRectItem(0, 0, 100, 100);
scene->addItem(rectItem); // 将图形项添加到场景中

// 移除图形项
scene->removeItem(rectItem);
delete rectItem; // 在删除图形项之前，确保将其从场景中移除

在这个示例中，我们首先创建一个 QGraphicsRectItem 对象 rectItem，然后将其添加到场景中。接着使用 removeItem 函数从场景中移除该图形项，并在最后删除该图形项。

使用 removeItem 函数可以方便地管理场景中的图形项，确保在不需要某个图形项时将其从场景中移除，以避免内存泄漏或不必要的资源占用。
QGraphicsScene::render 是 Qt 中 QGraphicsScene 类的成员函数，用于在场景中绘制内容。这个函数可以将场景中的内容渲染到指定的绘图设备上。下面是关于 QGraphicsScene::render 函数的一些基本信息：

render 绘制内容

作用：
QGraphicsScene::render 函数用于在 QGraphicsScene 中绘制内容，并将其渲染到指定的绘图设备上。

原型：

void QGraphicsScene::render(QPainter *painter, const QRectF &target = QRectF(), const QRectF &source = QRectF(), Qt::AspectRatioMode aspectRatioMode = Qt::KeepAspectRatio)

参数：

• painter：用于绘制的 QPainter 对象。
• target：目标矩形，指定绘制的目标区域。
• source：源矩形，指定要绘制的源区域。
• aspectRatioMode：指定如何处理源区域和目标区域的纵横比。

示例：

// 创建一个绘图设备
QImage image(800, 600, QImage::Format_ARGB32);
QPainter painter(&image);

// 在场景中绘制内容并渲染到图像上
scene->render(&painter, QRectF(0, 0, 800, 600), QRectF(0, 0, 800, 600));

// 保存图像到文件
image.save("scene_image.png");

在这个示例中，我们创建了一个 QImage 对象作为绘图设备，并创建了一个 QPainter 对象来绘制内容。然后，我们使用 QGraphicsScene::render 函数将场景中的内容渲染到图像上，并最终将图像保存到文件中。

通过使用 QGraphicsScene::render 函数，您可以将 QGraphicsScene 中的内容绘制到指定的绘图设备上，实现自定义的绘图需求。

selectedItems() 被选中的图形项

在 Qt 的 QGraphicsScene 类中，selectedItems() 是一个函数，用于获取当前被选中的图形项（items）。这个函数返回一个 QList<QGraphicsItem *> 类型的列表，其中包含了当前被选中的所有图形项。下面是关于 selectedItems() 函数的一些基本信息：

作用：
selectedItems() 函数用于获取当前被选中的图形项。

返回类型：
QList<QGraphicsItem *>，包含了当前被选中的所有图形项。

示例用法：

QList<QGraphicsItem *> selectedItems = scene->selectedItems();
foreach(QGraphicsItem *item, selectedItems) {
    // 对选中的图形项执行操作
    item->setPos(item->pos() + QPointF(10, 10));
}

在这个示例中，我们调用 selectedItems() 函数来获取当前被选中的图形项，并将它们存储在 selectedItems 列表中。然后，我们使用 foreach 循环遍历选中的图形项，并对它们执行操作（在这里是移动它们的位置）。

通过使用 selectedItems() 函数，您可以轻松地访问当前被选中的图形项，并对它们进行操作，以实现交互性的功能，比如移动、删除或修改选中的图形项。

在Qt中，QGraphicsScene::selectionArea()是一个函数，用于获取当前选择的图形项形成的区域。这个函数返回一个QPainterPath对象，表示当前选择的图形项的组合区域。这在需要对选择的图形项进行自定义绘制或其他操作时非常有用。

selectionArea() 获取所选择的图形项形成的区域

作用：
QGraphicsScene::selectionArea()函数用于获取当前选择的图形项形成的区域。

返回类型：
QPainterPath，表示当前选择的图形项的组合区域。

示例用法：

QPainterPath selectionPath = scene->selectionArea();
// 使用selectionPath执行自定义绘制或其他操作

在这个示例中，我们调用selectionArea()函数来获取当前选择的图形项形成的区域，并将其存储在selectionPath中。然后，您可以使用selectionPath来执行自定义的绘制或其他操作，比如在该区域内绘制特定的图形或执行其他操作。

通过使用QGraphicsScene::selectionArea()函数，您可以获取当前选择的图形项的组合区域，为进一步的操作提供了更多的灵活性和控制。

对不起，我之前的回答有误。在Qt中确实存在QGraphicsScene::sendEvent()函数，它用于将事件发送到场景中的特定图形项。这个函数的作用是将事件直接发送给指定的图形项，而不是通过事件循环。

sendEvent()函数

语法：

bool QGraphicsScene::sendEvent(QGraphicsItem *item, QEvent *event)

参数：

• item：要接收事件的图形项。
• event：要发送的事件对象。

返回值：

• 如果事件成功发送并被接收处理，则返回true；否则返回false。

示例：

QGraphicsItem *item = scene->itemAt(pos);
if (item) {
    QMouseEvent mouseEvent(QEvent::MouseButtonPress, pos, pos, Qt::LeftButton, Qt::LeftButton, Qt::NoModifier);
    scene->sendEvent(item, &mouseEvent);
}

通过调用QGraphicsScene::sendEvent()函数，您可以直接将事件发送给指定的图形项。这样可以方便地模拟事件的传递过程。

update 更新场景

QGraphicsScene::update是Qt中QGraphicsScene类的一个函数，用于更新场景中的特定区域或整个场景的绘图。该函数会触发相应区域的重新绘制。

函数原型：

void QGraphicsScene::update(const QRectF &rect)
void QGraphicsScene::update(qreal x, qreal y, qreal w, qreal h)

参数含义：

• rect：一个QRectF对象，表示需要更新的区域的边界框。如果传递空的QRectF对象，则将更新整个场景。

** 示例用法：**

QRectF updateRect(0, 0, 100, 100); // 定义一个需要更新的区域
scene->update(updateRect); // 更新指定区域

在上面的示例中，我们定义了一个矩形区域updateRect，然后调用update函数来更新这个指定的区域。如果要更新整个场景，可以传递一个空的QRectF对象。

views() 关联的视图

QGraphicsScene::views() 是 Qt 中 QGraphicsScene 类的一个函数，用于返回与场景关联的视图（View）。视图是用来显示场景内容的窗口或部件，可以是 QGraphicsView 或其子类的实例。
函数原型：

QList<QGraphicsView *> QGraphicsScene::views() const

返回值：

• QList<QGraphicsView *>：一个包含与场景关联的所有视图的列表。

示例用法：

QGraphicsScene scene;
QGraphicsView view1(&scene);
QGraphicsView view2(&scene);

QList<QGraphicsView *> viewList = scene.views();
// viewList 现在包含了指向 view1 和 view2 的指针

在上面的示例中，我们创建了一个场景 scene，并将两个视图 view1 和 view2 与该场景关联。通过调用 scene.views()，我们获取了一个包含这两个视图指针的列表 viewList。

4.设置相关函数

setActivePanel() 激活图像项

	void QGraphicsScene::setActivePanel(QGraphicsItem *item)

激活图形项，该图形项必须是此场景中的图形项品。您还可以为item传递0，在这种情况下，QGraphicsScene将停用任何当前活动的面板。

如果场景当前处于非活动状态，则项目保持非活动状态，直到场景变为活动状态(或者，如果项目为nullptr，则没有项目将被激活)。

setActiveWindow() 激活小部件

	void QGraphicsScene::setActiveWindow(QGraphicsWidget *widget)

激活小部件，该小部件必须是此场景中的小部件。您还可以为widget传递0，在这种情况下，QGraphicsScene将停用任何当前活动的窗口。

setBackgroundBrush() 设置场景的背景

	void setBackgroundBrush(const QBrush &brush)

设置此属性将场景的背景更改为不同的颜色、渐变或纹理。默认的背景刷是Qt::NoBrush。背景画在项目的前面(后面)。

bspTreeDepth() 设置索引的深度

	void setBspTreeDepth(int depth)

这个属性保存QGraphicsScene的BSP索引树的深度

当使用NoIndex时，此属性不起作用。

这个值决定了QGraphicsScene的BSP树的深度。深度直接影响QGraphicsScene的性能和内存使用;后者随着树的深度呈指数增长。有了最佳的树深度，QGraphicsScene可以立即确定物品的位置，甚至对于具有数千或数百万物品的场景也是如此。这也大大提高了渲染性能。

默认情况下，该值为0，在这种情况下，Qt将根据场景中物品的大小、位置和数量猜测一个合理的默认深度。但是，如果这些参数频繁更改，那么QGraphicsScene在内部重新调整深度时可能会遇到减速。通过设置此属性固定树的深度，可以避免潜在的减速。

setFocus() 设置焦点

void QGraphicsScene::setFocus(Qt::FocusReason focusReason = Qt::OtherFocusReason)

通过向场景发送一个QFocusEvent，传递focusReason作为原因，在场景上设置焦点。如果场景在先前失去焦点后重新获得焦点，而一个项目有焦点，则最后一个焦点项目将以focusReason作为原因获得焦点。

如果场景已经有焦点，则此函数不执行任何操作。

setFocusItem() 设置焦点图形项

void QGraphicsScene::setFocusItem(QGraphicsItem *item, Qt::FocusReason focusReason = Qt::OtherFocusReason)

将场景的焦点项设置为item，并使用焦点原因focusReason，在从之前可能具有焦点的任何项中移除焦点后。

如果item为nullptr，或者它不接受焦点(即，它没有启用QGraphicsItem::ItemIsFocusable标志)，或者不可见或未启用，则此函数仅从任何先前的焦点项中移除焦点。

如果item不是nullptr，并且场景当前没有焦点(即hasFocus()返回false)，该函数将自动调用setFocus()。

setFocusOnTouch() 设置是否获得焦点

void setFocusOnTouch(bool enabled)

此属性用于保存项目在接收触摸开始事件时是否获得焦点。

通常的行为是仅在单击项时转移焦点。触摸板上的点击通常被操作系统解释为等同于鼠标点击，从而生成一个合成的点击事件作为响应。但是，至少在macOS上可以配置此行为。

setFont() 设置字体

void setFont(const QFont &font)

设置场景字体。场景字体默认为QApplication::font，并从QApplication::font解析其所有条目。

如果场景的字体发生变化，无论是直接通过setFont()还是当应用程序字体发生变化时间接发生变化，QGraphicsScene首先向自己发送一个FontChange事件，然后将FontChange事件发送给场景中的所有顶级小部件项。这些项通过将它们自己的字体解析到场景来响应，然后通知它们的子节点，这些子节点再通知它们的子节点，以此类推，直到所有小部件项都更新了它们的字体。

改变场景字体，(直接或间接地通过QApplication::setFont()，)自动调度重新绘制整个场景。

setForegroundBrush() 设置前景笔刷

void setForegroundBrush(const QBrush &brush)

设置Qt中的绘图项（例如QGraphicsItem）的前景笔刷（brush），用于定义绘图项的前景颜色或纹理。

setItemIndexMethod() 设置图形项索引方法。

void setItemIndexMethod(QGraphicsScene::ItemIndexMethod method)

QGraphicsScene对场景应用了一个索引算法，以加速items()和itemAt()等项目发现函数。索引对于静态场景是最有效的(即，项目不移动的地方)。对于动态场景，或具有许多动画项的场景，索引记账可以超过快速查找速度。

对于一般情况，默认索引方法BspTreeIndex工作得很好。如果你的场景使用了很多动画，并且速度很慢，你可以通过调用setItemIndexMethod(NoIndex)来禁用索引。

setItemIndexMethod() 设置最小视图转换大小

void setMinimumRenderSize(qreal minSize)

设置绘制项必须具有的最小视图转换大小

当渲染场景时，任何被转换为目标视图的宽度或高度小于minimumRenderSize()的项目都不会被渲染。如果一个项目没有被渲染，并且它剪辑了它的子项目，它们也不会被渲染。设置此值可以加快在缩小视图上渲染许多对象的场景的渲染速度。

缺省值为0。如果不设置，或者设置为0或负值，则始终呈现所有项。

例如，如果一个场景由多个视图渲染，其中一个视图充当总览，总是显示所有项目，设置此属性可能特别有用。在具有许多项目的场景中，这样的视图将使用高缩放因子，以便可以显示所有项目。由于缩放，较小的物品只会对最终渲染的场景做出微不足道的贡献。为了避免绘制这些项目并减少渲染场景所需的时间，您可以使用非负值调用setMinimumRenderSize()。

注意:由于太小而没有绘制的项仍然由Items()和itemAt()等方法返回，并参与碰撞检测和交互。建议您将minimumRenderSize()设置为小于或等于1的值，以避免交互式的大型未渲染项。

setItemIndexMethod() 设置认调色板

void setPalette(const QPalette &palette)

设置场景的默认调色板

这个属性提供场景的调色板。场景调色板默认为QApplication::调色板，并从QApplication::调色板解析其所有条目。

如果场景的调色板发生变化，无论是直接通过setPalette()还是在应用程序调色板发生变化时间接发生变化，QGraphicsScene首先向自己发送一个PaletteChange事件，然后将PaletteChange事件发送给场景中的所有顶级小部件项。这些项通过将它们自己的调色板解析到场景来响应，然后通知它们的子节点，子节点再通知它们的子节点，以此类推，直到所有小部件项都更新了它们的调色板。

setItemIndexMethod() 设置场景矩形

void setSceneRect(const QRectF &rect)
setSceneRect(qreal x, qreal y, qreal w, qreal h)

设置场景矩形;场景的边界矩形

场景矩形定义了场景的范围。它主要由QGraphicsView用于确定视图的默认可滚动区域，并由QGraphicsScene用于管理项目索引。

如果未设置，或者设置为空QRectF, scen直立()将返回自场景创建以来场景中所有项目的最大边界矩形(即，当项目添加到场景中或在场景中移动时，矩形会增长，但不会缩小)。

setSelectionArea() 设置选择区域

void QGraphicsScene::setSelectionArea(const QPainterPath &path, const QTransform &deviceTransform)
void QGraphicsScene::setSelectionArea(const QPainterPath &path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape, const QTransform &deviceTransform = QTransform())
void QGraphicsScene::setSelectionArea(const QPainterPath &path, Qt::ItemSelectionOperation selectionOperation, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape, const QTransform &deviceTransform = QTransform())

将选择区域设置为path。该区域内的所有项目将立即被选中，而该区域外的所有项目将被取消选中。您可以通过调用selectedItems()获得所有选中项目的列表。

deviceTransform是应用于视图的转换，如果场景包含忽略转换的项，则需要提供该转换。

对于要选择的项，必须将其标记为可选择的(QGraphicsItem::ItemIsSelectable)。

setStickyFocus() 设置点击焦点

void setStickyFocus(bool enabled)

设置点击场景背景是否会清除焦点

在一个带有stickkyfocus设置为true的QGraphicsScene中，当用户点击场景背景或不接受焦点的项目时，焦点将保持不变。否则，焦点将被清除。

默认情况下，此属性为false。

焦点会随着鼠标的按压而改变。您可以在QGraphicsScene的子类中重新实现mousePressEvent()，以根据用户单击的位置切换此属性。

setStyle() 设置场景的样式

void setStyle(QStyle *style)

设置或替换要样式的场景的样式，并将样式重新设置为此场景。任何先前分配的样式都会被删除。场景的样式默认为QApplication::style()，并作为场景中所有QGraphicsWidget项目的默认样式。

更改样式，无论是直接调用此函数，还是间接调用QApplication::setStyle()，都将自动更新场景中没有显式分配样式的所有小部件的样式。

如果style为nullptr, QGraphicsScene将恢复为QApplication::style()。

5. 槽函数

advance() 逐帧更新图像项的状态

说明：
QGraphicsScene::advance() 是 Qt 中 QGraphicsScene 类的一个槽函数（slot），用于推进场景中项的状态。通过调用这个槽函数，可以触发场景中每个图形项的 advance() 函数，从而实现定期更新图形项的状态。

函数原型：

[slot] void QGraphicsScene::advance();

参数说明：

该槽函数没有参数。

完整示例：

下面是一个完整示例，演示了如何在 Qt 中创建一个简单的图形场景，并使用 QGraphicsScene::advance() 槽函数推进场景中项的状态：

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

class CustomGraphicsScene : public QGraphicsScene
{
    Q_OBJECT

public:
    CustomGraphicsScene(QObject *parent = nullptr) : QGraphicsScene(parent) {}

public slots:
    void advance()
    {
        // 在这里更新场景中项的状态，例如移动图形项
        QGraphicsScene::advance();
    }
};

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

    // 创建自定义的场景
    CustomGraphicsScene scene;

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

    // 创建视图并关联场景
    QGraphicsView view(&scene);
    view.show();

    // 创建定时器，每隔一段时间推进场景中项的状态
    QTimer timer;
    QObject::connect(&timer, &QTimer::timeout, &scene, &CustomGraphicsScene::advance);
    timer.start(1000); // 每秒推进一次

    return app.exec();
}

#include "main.moc"

在这个示例中，我们创建了一个自定义的 CustomGraphicsScene 类，将 advance() 函数声明为一个槽函数，并在其中更新场景中项的状态。我们创建了一个蓝色矩形项，并将其添加到场景中。然后，我们创建了一个视图并将其关联到场景。通过定时器定期调用 scene.advance() 槽函数，我们可以推进场景中项的状态，实现动画效果。

clear() 清空场景中的所有项

说明：
QGraphicsScene::clear() 是 Qt 中 QGraphicsScene 类的一个槽函数（slot），用于清空场景中的所有项。调用这个槽函数会移除场景中的所有图形项，使场景变为空白。

函数原型：

[slot] void QGraphicsScene::clear();

参数说明：

该槽函数没有参数。

完整示例：

下面是一个完整示例，演示了如何在 Qt 中创建一个简单的图形场景，并使用 QGraphicsScene::clear() 槽函数清空场景中的所有项：

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

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

    // 创建场景
    QGraphicsScene scene;

    // 创建一个矩形项
    QGraphicsRectItem *rectItem = scene.addRect(0, 0, 100, 100);
    rectItem->setBrush(Qt::blue);

    // 创建视图并关联场景
    QGraphicsView view(&scene);
    view.show();

    // 创建清空按钮
    QPushButton clearButton("Clear Scene");
    QObject::connect(&clearButton, &QPushButton::clicked, &scene, &QGraphicsScene::clear);
    clearButton.show();

    return app.exec();
}

在这个示例中，我们创建了一个简单的图形场景，并向其中添加了一个蓝色矩形项。我们还创建了一个清空按钮，当点击按钮时，会调用 scene.clear() 槽函数来清空场景中的所有项。

clearSelection() 清除所有被选中的图形项

说明：
QGraphicsScene::clearSelection() 是 Qt 中 QGraphicsScene 类的一个槽函数（slot），用于清除场景中所有被选中的图形项。调用这个槽函数会取消选择场景中所有被选中的图形项，使它们变为未选中状态。

函数原型：

[slot] void QGraphicsScene::clearSelection();

参数说明：

该槽函数没有参数。

完整示例：

下面是一个简单示例，演示了如何在 Qt 中创建一个简单的图形场景，并使用 QGraphicsScene::clearSelection() 槽函数来清除场景中所有被选中的图形项：

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

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

    // 创建场景
    QGraphicsScene scene;

    // 创建两个矩形项并添加到场景中
    QGraphicsRectItem *rectItem1 = scene.addRect(0, 0, 100, 100);
    QGraphicsRectItem *rectItem2 = scene.addRect(150, 0, 100, 100);

    // 选中第一个矩形项
    rectItem1->setSelected(true);

    // 创建视图并关联场景
    QGraphicsView view(&scene);
    view.show();

    // 创建按钮来清除选中状态
    QPushButton clearSelectionButton("Clear Selection");
    QObject::connect(&clearSelectionButton, &QPushButton::clicked, &scene, &QGraphicsScene::clearSelection);
    clearSelectionButton.show();

    return app.exec();
}

在这个示例中，我们创建了一个图形场景，并向其中添加了两个矩形项。然后，我们手动选中第一个矩形项，并创建了一个按钮。当点击按钮时，会调用 scene.clearSelection() 槽函数来清除场景中所有被选中的图形项的选中状态。

invalidate 强制场景刷新

用于通知场景需要重新绘制一部分或全部内容。这个函数通常在需要强制场景刷新时调用。

函数原型：

[slot] void QGraphicsScene::invalidate(const QRectF &rect = QRectF(), QGraphicsScene::SceneLayers layers = AllLayers)

参数说明：

• rect：指定需要重新绘制的矩形区域。
• layers：指定需要重新绘制的图层，默认为 AllLayers，表示所有图层。

完整示例：

下面是一个简单示例，演示了如何在 Qt 中创建一个简单的图形场景，并使用 QGraphicsScene::invalidate 函数来通知场景重新绘制指定区域：

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

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

    // 创建场景
    QGraphicsScene scene;

    // 创建一个矩形项并添加到场景中
    QGraphicsRectItem *rectItem = scene.addRect(0, 0, 100, 100);
    rectItem->setBrush(Qt::blue);

    // 创建视图并关联场景
    QGraphicsView view(&scene);
    view.show();

    // 在一段时间后，通知场景重新绘制指定区域
    QTimer timer;
    timer.setSingleShot(true);
    QObject::connect(&timer, &QTimer::timeout, [&scene, rectItem]() {
        QRectF rect = rectItem->sceneBoundingRect();
        scene.invalidate(rect);
    });
    timer.start(2000); // 2秒后重新绘制矩形项的区域

    return app.exec();
}

在这个示例中，我们创建了一个图形场景，并向其中添加了一个蓝色矩形项。然后，我们使用 QTimer 在2秒后调用 scene.invalidate 函数，通知场景重新绘制矩形项的区域。

update 更新场景

用于强制更新场景中的一部分或全部内容。这个函数通常在需要立即更新场景而不等待事件循环时使用。

函数原型：

[slot] void QGraphicsScene::update(const QRectF &rect);

参数说明：

• rect：指定需要更新的矩形区域。

完整示例：

下面是一个简单示例，演示了如何在 Qt 中创建一个简单的图形场景，并使用 QGraphicsScene::update 槽函数来强制更新指定区域的内容：

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

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

    // 创建场景
    QGraphicsScene scene;

    // 创建一个矩形项并添加到场景中
    QGraphicsRectItem *rectItem = scene.addRect(0, 0, 100, 100);
    rectItem->setBrush(Qt::blue);

    // 创建视图并关联场景
    QGraphicsView view(&scene);
    view.show();

    // 创建按钮来强制更新矩形项的区域
    QPushButton updateButton("Update Rectangle");
    QObject::connect(&updateButton, &QPushButton::clicked, [&scene, rectItem]() {
        QRectF rect = rectItem->sceneBoundingRect();
        scene.update(rect);
    });
    updateButton.show();

    return app.exec();
}

在这个示例中，我们创建了一个图形场景，并向其中添加了一个蓝色矩形项。然后，我们创建了一个按钮，当点击按钮时，会调用 scene.update 槽函数，强制更新矩形项的区域。

6. 信号量

changed 场景的内容发生改变

QGraphicsScene::changed 是一个信号，表示场景的内容已经发生了变化。当场景中的图形项、属性或其他内容发生变化时，此信号会被发射。

信号原型：

[signal] void QGraphicsScene::changed(const QList<QRectF> &region);

参数说明：

• region：表示发生变化的区域列表。

示例说明：

以下是一个简单示例，演示了如何连接 QGraphicsScene::changed 信号，以便在场景内容发生变化时进行处理：

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

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

    // 创建场景
    QGraphicsScene scene;

    // 创建一个矩形项并添加到场景中
    QGraphicsRectItem *rectItem = scene.addRect(0, 0, 100, 100);
    rectItem->setBrush(Qt::blue);

    // 创建视图并关联场景
    QGraphicsView view(&scene);
    view.show();

    // 连接 changed 信号的槽函数
    QObject::connect(&scene, &QGraphicsScene::changed, [&scene](const QList<QRectF> &region) {
        qDebug() << "Scene content changed in the following regions:";
        for (const QRectF &rect : region) {
            qDebug() << rect;
        }
    });

    // 修改矩形项，触发 changed 信号
    rectItem->setRect(50, 50, 150, 150);

    return app.exec();
}

在这个示例中，我们创建了一个图形场景，并向其中添加了一个蓝色矩形项。然后，我们连接了 QGraphicsScene::changed 信号到一个槽函数，当场景内容发生变化时，会输出变化的区域。

focusItemChanged 场景中焦点图形项的改变

QGraphicsScene::focusItemChanged 是一个信号，表示场景中焦点图形项的改变。当焦点图形项在场景中发生变化时，此信号会被发射。

信号原型：

[signal] void QGraphicsScene::focusItemChanged(QGraphicsItem *newFocus, QGraphicsItem *oldFocus, Qt::FocusReason reason);

参数说明：

• newFocus：指向新的焦点图形项的指针。
• oldFocus：指向旧的焦点图形项的指针。
• reason：焦点改变的原因，是一个 Qt::FocusReason 枚举值，表示焦点改变的原因。

示例说明：

以下是一个简单示例，演示了如何连接 QGraphicsScene::focusItemChanged 信号，以便在焦点图形项改变时进行处理：

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

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

    // 创建场景
    QGraphicsScene scene;

    // 创建两个矩形项并添加到场景中
    QGraphicsRectItem *rectItem1 = scene.addRect(0, 0, 100, 100);
    QGraphicsRectItem *rectItem2 = scene.addRect(150, 0, 100, 100);
    rectItem1->setBrush(Qt::blue);
    rectItem2->setBrush(Qt::green);

    // 创建视图并关联场景
    QGraphicsView view(&scene);
    view.show();

    // 连接 focusItemChanged 信号的槽函数
    QObject::connect(&scene, &QGraphicsScene::focusItemChanged, [&scene](QGraphicsItem *newFocus, QGraphicsItem *oldFocus, Qt::FocusReason reason) {
        if (newFocus) {
            qDebug() << "New focus item: " << newFocus;
        }
        if (oldFocus) {
            qDebug() << "Old focus item: " << oldFocus;
        }
        qDebug() << "Focus change reason: " << reason;
    });

    // 设置第一个矩形项为焦点项，触发 focusItemChanged 信号
    scene.setFocusItem(rectItem1);

    return app.exec();
}

在这个示例中，我们创建了一个图形场景，并向其中添加了两个矩形项。然后，我们连接了 QGraphicsScene::focusItemChanged 信号到一个槽函数，当焦点图形项改变时，会输出新旧焦点图形项以及焦点改变的原因。

sceneRectChanged 场景的矩形范围发生变化

QGraphicsScene::sceneRectChanged 是一个信号，表示场景的矩形范围发生了变化。当场景的矩形范围发生变化时，此信号会被发射。

信号原型：

[signal] void QGraphicsScene::sceneRectChanged(const QRectF &rect);

参数说明：

• rect：表示新的场景矩形范围。

示例说明：

以下是一个简单示例，演示了如何连接 QGraphicsScene::sceneRectChanged 信号，以便在场景矩形范围发生变化时进行处理：

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

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

    // 创建场景
    QGraphicsScene scene;

    // 设置场景矩形范围
    scene.setSceneRect(0, 0, 400, 400);

    // 创建视图并关联场景
    QGraphicsView view(&scene);
    view.show();

    // 连接 sceneRectChanged 信号的槽函数
    QObject::connect(&scene, &QGraphicsScene::sceneRectChanged, [&scene](const QRectF &rect) {
        qDebug() << "Scene rect changed to: " << rect;
    });

    // 修改场景矩形范围，触发 sceneRectChanged 信号
    scene.setSceneRect(0, 0, 600, 600);

    return app.exec();
}

在这个示例中，我们创建了一个图形场景，并设置了初始的矩形范围。然后，我们连接了 QGraphicsScene::sceneRectChanged 信号到一个槽函数，当场景的矩形范围发生变化时，会输出新的矩形范围。

QGselectionChanged 选定项的改变

QGraphicsScene::selectionChanged 是一个信号，表示场景中选定项的改变。当场景中的选定项发生变化时，此信号会被发射。

信号原型：

[signal] void QGraphicsScene::selectionChanged();

参数说明：

这个信号没有参数。

示例说明：

以下是一个简单示例，演示了如何连接 QGraphicsScene::selectionChanged 信号，以便在场景中选定项发生变化时进行处理：

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

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

    // 创建场景
    QGraphicsScene scene;

    // 创建矩形项并添加到场景中
    QGraphicsRectItem *rectItem = scene.addRect(0, 0, 100, 100);
    rectItem->setFlag(QGraphicsItem::ItemIsSelectable);

    // 创建视图并关联场景
    QGraphicsView view(&scene);
    view.show();

    // 连接 selectionChanged 信号的槽函数
    QObject::connect(&scene, &QGraphicsScene::selectionChanged, [&scene]() {
        qDebug() << "Selection changed";
    });

    // 选定矩形项，触发 selectionChanged 信号
    rectItem->setSelected(true);

    return app.exec();
}

在这个示例中，我们创建了一个图形场景，并向其中添加了一个可选中的矩形项。然后，我们连接了 QGraphicsScene::selectionChanged 信号到一个槽函数，当选定项发生变化时，会输出 "Selection changed"。

7. Event事件

contextMenuEvent 处理上下文菜单事件的函数

contextMenuEvent 是用于处理上下文菜单事件的函数，通常在自定义的 QGraphicsScene 类中重写这个函数来处理场景中的上下文菜单事件。

函数原型：

virtual void QGraphicsScene::contextMenuEvent(QGraphicsSceneContextMenuEvent *event);

参数说明：

• event：表示上下文菜单事件的对象，包含了与事件相关的信息，如鼠标点击位置等。

示例说明：

以下是一个简单的示例，演示了如何在自定义的 QGraphicsScene 类中重写 contextMenuEvent 函数，以便处理场景中的上下文菜单事件：

#include <QGraphicsScene>
#include <QGraphicsSceneContextMenuEvent>
#include <QMenu>
#include <QDebug>

class CustomGraphicsScene : public QGraphicsScene
{
protected:
    void contextMenuEvent(QGraphicsSceneContextMenuEvent *event) override
    {
        QMenu menu;
        QAction *action1 = menu.addAction("Action 1");
        QAction *action2 = menu.addAction("Action 2");

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

        if (selectedAction == action1)
        {
            qDebug() << "Action 1 selected";
        }
        else if (selectedAction == action2)
        {
            qDebug() << "Action 2 selected";
        }
    }
};

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

    CustomGraphicsScene scene;
    QGraphicsView view(&scene);
    view.show();

    return app.exec();
}

在这个示例中，我们创建了一个自定义的 CustomGraphicsScene 类，重写了 contextMenuEvent 函数来处理上下文菜单事件。在这个函数中，我们创建了一个简单的菜单，并根据用户选择的动作输出相应的信息。

dragEnterEvent 拖放 拖入事件

用于处理拖放操作中的"进入"事件。在Qt中，当拖动物体进入场景时，会触发这个事件。你可以在自定义的 QGraphicsScene 类中重写这个函数，以处理拖放操作的进入事件。

函数原型：

virtual void QGraphicsScene::dragEnterEvent(QGraphicsSceneDragDropEvent *event);

参数说明：

• event：表示拖放事件的对象，包含有关拖放操作的信息，如拖放的数据、拖放的位置等。

示例说明：

下面是一个简单的示例，演示了如何在自定义的 QGraphicsScene 类中重写 dragEnterEvent 函数，以处理拖放操作的进入事件：

#include <QGraphicsScene>
#include <QGraphicsSceneDragDropEvent>
#include <QDebug>

class CustomGraphicsScene : public QGraphicsScene
{
protected:
    void dragEnterEvent(QGraphicsSceneDragDropEvent *event) override
    {
        if (event->mimeData()->hasFormat("text/plain"))
        {
            event->acceptProposedAction();
            qDebug() << "Drag entered with text data";
        }
        else
        {
            event->ignore();
        }
    }
};

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

    CustomGraphicsScene scene;
    QGraphicsView view(&scene);
    view.show();

    return app.exec();
}

在这个示例中，我们创建了一个自定义的 CustomGraphicsScene 类，重写了 dragEnterEvent 函数来处理拖放操作的进入事件。在这个函数中，我们检查拖放的数据是否为纯文本格式，如果是，则接受拖放操作；否则，忽略该事件。

dragLeaveEvent 拖放 拖离事件

QGraphicsScene::dragLeaveEvent 是一个事件处理函数，用于处理拖放操作中的"离开"事件。在Qt中，当拖动物体离开场景时，会触发这个事件。你可以在自定义的 QGraphicsScene 类中重写这个函数，以处理拖放操作的离开事件。

函数原型：

virtual void QGraphicsScene::dragLeaveEvent(QGraphicsSceneDragDropEvent *event);

参数说明：

• event：表示拖放事件的对象，包含有关拖放操作的信息，如拖放的数据、拖放的位置等。

示例说明：

下面是一个简单的示例，演示了如何在自定义的 QGraphicsScene 类中重写 dragLeaveEvent 函数，以处理拖放操作的离开事件：

#include <QGraphicsScene>
#include <QGraphicsSceneDragDropEvent>
#include <QDebug>

class CustomGraphicsScene : public QGraphicsScene
{
protected:
    void dragLeaveEvent(QGraphicsSceneDragDropEvent *event) override
    {
        qDebug() << "Drag left the scene";
    }
};

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

    CustomGraphicsScene scene;
    QGraphicsView view(&scene);
    view.show();

    return app.exec();
}

在这个示例中，我们创建了一个自定义的 CustomGraphicsScene 类，重写了 dragLeaveEvent 函数来处理拖放操作的离开事件。在这个函数中，我们简单地输出一条消息，表示拖放操作已离开场景。

dragMoveEvent 拖放 移动事件

QGraphicsScene::dragMoveEvent 是一个事件处理函数，用于处理拖放操作中的"移动"事件。在Qt中，当拖动物体在场景中移动时，会触发这个事件。你可以在自定义的 QGraphicsScene 类中重写这个函数，以处理拖放操作的移动事件。

函数原型：

virtual void QGraphicsScene::dragMoveEvent(QGraphicsSceneDragDropEvent *event);

参数说明：

• event：表示拖放事件的对象，包含有关拖放操作的信息，如拖放的数据、拖放的位置等。

示例说明：

下面是一个简单的示例，演示了如何在自定义的 QGraphicsScene 类中重写 dragMoveEvent 函数，以处理拖放操作的移动事件：

#include <QGraphicsScene>
#include <QGraphicsSceneDragDropEvent>
#include <QDebug>

class CustomGraphicsScene : public QGraphicsScene
{
protected:
    void dragMoveEvent(QGraphicsSceneDragDropEvent *event) override
    {
        qDebug() << "Drag moved in the scene";
    }
};

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

    CustomGraphicsScene scene;
    QGraphicsView view(&scene);
    view.show();

    return app.exec();
}

在这个示例中，我们创建了一个自定义的 CustomGraphicsScene 类，重写了 dragMoveEvent 函数来处理拖放操作的移动事件。在这个函数中，我们简单地输出一条消息，表示拖放操作正在场景中移动。

dropEvent 拖动 放下事件

dropEvent 是一个事件处理函数，用于处理拖放操作中的"放下"事件。在 Qt 中，当用户拖动一个控件或数据并释放鼠标时，会触发 dropEvent 事件，你可以在这个事件处理函数中实现相应的逻辑来处理放下操作。

函数原型：

void QGraphicsScene::dropEvent(QGraphicsSceneDragDropEvent *event);

参数说明：

• event：包含有关拖放操作的信息，如拖放的数据、放下位置等。

示例说明：

下面是一个简单的示例，演示了如何在自定义的 QGraphicsScene 类中重写 dropEvent 函数，以处理放下事件并输出相关信息：

#include <QGraphicsScene>
#include <QGraphicsSceneDragDropEvent>
#include <QDebug>

class CustomGraphicsScene : public QGraphicsScene
{
protected:
    void dropEvent(QGraphicsSceneDragDropEvent *event) override
    {
        if (event->mimeData()->hasText()) {
            QString text = event->mimeData()->text();
            QPointF position = event->scenePos();
            qDebug() << "Dropped text:" << text << "at position:" << position;
        } else {
            event->ignore();
        }
    }
};

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

    CustomGraphicsScene scene;
    QGraphicsView view(&scene);
    view.setAcceptDrops(true); // 允许视图接受拖放操作
    view.show();

    return app.exec();
}

在这个示例中，我们创建了一个自定义的 CustomGraphicsScene 类，重写了 dropEvent 函数来处理放下事件。在函数中，我们首先检查放下的数据是否为文本，如果是文本，则获取文本内容和放下位置，并输出相关信息；如果不是文本数据，则调用 event->ignore() 表示忽略该事件。

请注意，为了使视图能够接受拖放操作，我们调用了 view.setAcceptDrops(true) 来设置视图为接受拖放操作。

focusInEvent 场景获得焦点

focusInEvent 是一个事件处理函数，用于处理控件获得焦点时触发的事件。在 Qt 中，当一个控件获得焦点时（例如用户点击了该控件），会触发 focusInEvent 事件，你可以在这个事件处理函数中编写相应的逻辑来处理控件获得焦点的情况。

函数原型：

void QGraphicsScene::focusInEvent(QFocusEvent *event);

参数说明：

• event：包含有关焦点事件的信息，如焦点类型、焦点状态等。

示例说明：

下面是一个简单的示例，演示了如何在自定义的 QGraphicsScene 类中重写 focusInEvent 函数，以处理控件获得焦点事件并输出相关信息：

#include <QGraphicsItem>
#include <QGraphicsScene>
#include <QFocusEvent>
#include <QDebug>

class CustomGraphicsScene : public QGraphicsScene
{
protected:
    void focusInEvent(QFocusEvent *event) override
    {
        qDebug() << "scene has gained focus";
    }
};

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

    QGraphicsScene scene;
    CustomGraphicsItem item;
    scene.addItem(&item);

    QGraphicsView view(&scene);
    view.show();

    scene.setFocus(); // 让 scene 获得焦点

    return app.exec();
}

在这个示例中，我们创建了一个自定义的 CustomGraphicsScene 类，重写了 focusInEvent 函数来处理控件获得焦点事件。在函数中，我们简单地输出一条消息表示该项已获得焦点，并调用 QGraphicsScene::focusInEvent(event) 来处理焦点事件。

在 main 函数中，我们创建了一个场景和一个自定义项，并将该项添加到场景中。然后，我们创建了一个视图并显示出来，最后通过调用 scene.setFocus() 让该项获得焦点。

focusOutEvent 焦点离开事件

在 Qt 中，focusOutEvent 是一个用于处理焦点离开事件的函数，通常在继承自 QWidget 或其子类的自定义部件中使用

函数原型：

void QGraphicsScene::focusOutEvent(QFocusEvent *event);

参数说明：

• event：包含有关焦点事件的信息，如焦点类型、焦点状态等。

示例

下面是一个简单的示例，演示了如何在场景级别处理焦点离开事件：

#include <QGraphicsScene>
#include <QFocusEvent>
#include <QDebug>

class CustomGraphicsScene : public QGraphicsScene
{
protected:
    void focusOutEvent(QFocusEvent *event) override
    {
        qDebug() << "scene has lose focus";

    }
};

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    
    QGraphicsScene scene;
    CustomGraphicsItem item;
    scene.addItem(&item);

    QGraphicsView view(&scene);
    view.show();

    QGraphicsView view(&scene);
    view.show();

    view.setFocus(); // 让视图获得焦点,此时scene失去焦点

    return app.exec();
}

在这个示例中，我们创建了一个自定义的 CustomGraphicsScene 类，重写了 focusInEvent 函数来处理控件获得焦点事件。在函数中，我们简单地输出一条消息表示该项已获得焦点

在 main 函数中，我们创建了一个自定义场景和一个矩形项，并将矩形项添加到场景中。然后，我们安装了一个事件过滤器来捕获场景级别的焦点事件。最后，我们通过调用 view.setFocus() 让视图获得焦点，此时scene失去焦点。

focusOutEvent 场景的输入法事件

函数原型：

void QGraphicsScene::inputMethodEvent(QInputMethodEvent *event)

此事件处理程序(用于事件事件)可以在子类中重新实现，以接收场景的输入法事件。

默认实现将事件转发给focusItem()。如果当前没有焦点项或当前焦点项不接受输入法，则此函数不执行任何操作。

keyPressEvent 键盘按下事件

函数原型：

QGraphicsScene::keyPressEvent(QKeyEvent *keyEvent)

事件keyEvent的事件处理程序可以在子类中重新实现，以接收按键事件。默认实现将事件转发到当前焦点项。

keyReleaseEvent 键盘释放事件

函数原型：

void QGraphicsScene::keyReleaseEvent(QKeyEvent *keyEvent)

事件keyEvent的事件处理程序可以在子类中重新实现，以接收键释放事件。默认实现将事件转发到当前焦点项。

mouseDoubleClickEvent 鼠标双击事件

函数原型：

void QGraphicsScene::mouseDoubleClickEvent(QGraphicsSceneMouseEvent *mouseEvent)

mouseEvent的事件处理程序可以在子类中重新实现，以接收场景的鼠标双击事件。

如果有人在场景上双击，场景将首先接收鼠标按下事件，然后是释放事件(即单击)，然后是双击事件，最后是释放事件。如果双击事件传递给的项目与接收第一次新闻和发布的项目不同，则它将作为新闻事件传递。然而，在这种情况下，tripleclick事件不会作为双击事件传递。

默认实现类似于mousePressEvent()。

注意:请参阅items()获取哪些项被此函数视为可见的定义。

mouseMoveEvent 鼠标移动事件

函数原型：

void QGraphicsScene::mouseMoveEvent(QGraphicsSceneMouseEvent *mouseEvent)

事件mouseEvent的事件处理程序可以在子类中重新实现，以接收场景的鼠标移动事件。

默认实现取决于鼠标抓取器状态。如果存在鼠标抓取项，则将事件发送给鼠标抓取项。如果在当前位置有任何接受悬停事件的项目，则该事件被转换为悬停事件并接受;否则它将被忽略。

mousePressEvent 鼠标按下事件

函数原型：

void QGraphicsScene::mousePressEvent(QGraphicsSceneMouseEvent *mouseEvent)

事件mouseEvent的事件处理程序可以在子类中重新实现，以接收场景的鼠标按下事件。

默认实现取决于场景的状态。如果有鼠标抓取器项，则将事件发送给鼠标抓取器。否则，它将被转发到最上面的可见项，该项接受来自事件的场景位置的鼠标事件，并且该项立即成为鼠标抓取项。

如果在场景的给定位置上没有项目，则重置选择区域，任何焦点项目将失去其输入焦点，然后忽略事件。

注意:请参阅items()获取哪些项被此函数视为可见的定义。

mouseReleaseEvent 鼠标释放事件

函数原型：

void QGraphicsScene::mouseReleaseEvent(QGraphicsSceneMouseEvent *mouseEvent)

事件mouseEvent的事件处理程序可以在子类中重新实现，以接收场景的鼠标释放事件。

默认实现取决于鼠标抓取器状态。如果没有鼠标抓取器，则忽略该事件。否则，如果存在鼠标抓取项，则将事件发送给鼠标抓取项。如果此鼠标释放表示鼠标上最后按下的按钮，则鼠标抓取项将失去鼠标抓取。

mouseReleaseEvent 鼠标滚轮事件

函数原型：

void QGraphicsScene::wheelEvent(QGraphicsSceneWheelEvent *wheelEvent)

事件wheelEvent的事件处理程序可以在子类中重新实现，以接收场景的鼠标滚轮事件。

默认情况下，将事件传递给光标下最上面的可见项。如果被忽略，事件将传播到下面的项目，直到事件被接受或到达场景为止。如果没有项接受该事件，则忽略该事件。

注意:请参阅items()获取哪些项被此函数视为可见的定义。

event 事件处理事件

函数原型：

bool QGraphicsScene::event(QEvent *event)

处理事件事件，并将其分派给相应的事件处理程序。

除了调用便利事件处理程序之外，该函数还负责在没有鼠标抓取器项时将鼠标移动事件转换为悬停事件。悬停事件直接传递给项目;它们没有方便功能。

与QWidget不同，QGraphicsScene没有方便的函数enterEvent()和leaveEvent()。使用这个函数来获取这些事件。

如果事件已被识别并处理，则返回true;否则，返回false。

eventFilter 事件过滤器

函数原型：

bool QGraphicsScene::eventFilter(QObject *watched, QEvent *event)

重新实现:QObject::eventFilter(QObject *watched, QEvent *event)。

QGraphicsScene过滤QApplication的事件来检测调色板和字体的变化。