此篇文章来源于自己在完成一个图片编辑软件而遇到的三个类：QGraphicsScene、QGraphicsPixmapItem、QGraphicsView。此篇文章先介绍QGraphicsView，另外两个类在其他文章，大家可查看博主其他文章。本人能力有限，大家有任何问题可评论区评论，共同学习，共同进步。

一、QGraphicsView介绍

QGraphicsView 是 Qt GUI 库中的一个核心类，它是 Qt 图形视图框架的一部分，主要用于可视化地显示 QGraphicsScene 中的内容。QGraphicsView 提供了一个灵活且可定制的二维图形界面，支持丰富的交互功能，如平移、缩放、旋转，并能够管理和布局复杂的图形场景。

基本特性：

  1. 视图与场景分离：

    • QGraphicsView 类本身负责渲染和显示图形场景 (QGraphicsScene)，而场景则负责存储和管理所有的图形项 (QGraphicsItem)，这些图形项可以是文本、形状、图片等任何可视化元素。

  2. 视口与坐标系统：

    • QGraphicsView 内部有一个视口，视口映射的是场景的部分或全部内容。它可以有自己的坐标系统，并且可以通过调整视口边界或缩放级别来改变显示效果。
    • 视口坐标与场景坐标之间存在转换关系，QGraphicsView 提供了一系列方法来处理这种坐标变换。

  3. 交互功能：

    • 支持鼠标滚轮和键盘事件，用于缩放和平移场景内容。
    • 使用 scroll() 和 centerOn() 方法可以方便地移动视图焦点。
    • scale() 和 rotate() 方法可用于缩放和旋转视图中的场景内容。
    • 可以通过 dragMode 属性控制用户是否可以拖动场景或视图。

  4. 缓存机制：

    • QGraphicsView 支持多种缓存模式 (CacheModeFlag)，通过预渲染并缓存部分内容在 QPixmap 中，提高复杂场景的重绘效率。

  5. 适应场景大小：

    • fitInView() 函数可以自动调整视图大小以适应指定的场景区域，并可以选择保持纵横比或忽略它。

  6. 事件处理与信号槽：

    • QGraphicsView 处理各种图形视图相关的事件，包括但不限于鼠标点击、鼠标移动、鼠标滚轮事件等。
    • 它还发出一系列信号，以便与其他组件协同工作，比如当视图区域发生更改时，可以连接相应的槽函数进行响应。

  7. 可扩展性：

    • 用户可以通过继承 QGraphicsView 并重写其虚函数来自定义视图的行为，例如实现自定义的绘图、鼠标跟踪以及触摸屏交互等高级功能。

总结来说，QGraphicsView 是构建复杂图形用户界面的强大工具，尤其适用于那些需要动态更新、可交互的2D图形化应用程序，如图表绘制、流程图编辑器、游戏地图显示等等。通过结合使用 QGraphicsScene 和 QGraphicsItem，开发者可以创建出高度定制化、性能优良的图形用户界面组件。

下面是一个简单的 QGraphicsView 使用示例，展示如何创建一个包含一个矩形图形项的基本场景，并将其显示在一个 QGraphicsView 控件中：

#include <QtWidgets>

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

    // 创建一个图形场景
    QGraphicsScene* scene = new QGraphicsScene();

    // 在场景中添加一个矩形图形项
    QGraphicsRectItem* rectItem = scene->addRect(50, 50, 100, 100);
    rectItem->setBrush(Qt::blue); // 设置填充颜色
    rectItem->setPen(QPen(Qt::black)); // 设置边框颜色

    // 创建一个图形视图并设置场景
    QGraphicsView* view = new QGraphicsView();
    view->setScene(scene);

    // 设置视图的一些基本属性
    view->setRenderHint(QPainter::Antialiasing); // 启用抗锯齿
    view->setDragMode(QGraphicsView::ScrollHandDrag); // 允许拖拽视图进行平移

    // 显示视图到窗口
    QMainWindow window;
    window.setCentralWidget(view);
    window.show();

    return app.exec();
}
  • 首先，我们创建了一个 QGraphicsScene 对象，它是所有图形项的容器。
  • 然后，在场景中添加了一个 QGraphicsRectItem（矩形图形项），并设置了填充色和边框色。
  • 接着，我们创建了 QGraphicsView 对象，并将其关联到已创建的场景上，这样视图就能显示场景内的内容。
  • 设置视图的渲染提示和拖拽模式，增强了视觉效果并允许用户通过鼠标拖拽来平移视图内容。
  • 最后，我们将 QGraphicsView 设置为主窗口的中央部件并显示窗口。

运行这段代码，你会看到一个蓝色矩形出现在一个可滚动和平移的视图窗口中。这只是 QGraphicsView 功能的冰山一角，实际上还可以进一步添加更多图形项，实现动画、交互等功能。

二、成员函数

1、QGraphicsView::QGraphicsView(QGraphicsScene *scene, QWidget *parent = nullptr)

QGraphicsView::QGraphicsView(QGraphicsScene *scene, QWidget *parent = nullptr) 是 QGraphicsView 类的一个构造函数。在 Qt 框架中，QGraphicsView 是一个用于显示 QGraphicsScene 中图形内容的视图组件。这个构造函数的用途是初始化一个新的 QGraphicsView 实例，并且可以指定一个与之关联的 QGraphicsScene 和父级 QWidget。

参数说明：

  • QGraphicsScene *scene: 这是一个指向 QGraphicsScene 对象的指针。如果传入非空指针，则新创建的 QGraphicsView 将自动关联到该场景，用于显示场景中的图形元素。如果没有提供场景，或者传入 nullptr，则视图可以稍后通过调用 setScene() 方法来关联场景。
  • QWidget *parent: 这是指向父级 QWidget 对象的指针，默认为 nullptr。如果提供了父级窗口部件，那么新建的 QGraphicsView 将成为其子部件，并遵循父级的布局管理和生命周期管理规则。

例如，基于上面的构造函数，你可以这样创建一个关联了特定场景的 QGraphicsView：

// 创建一个图形场景
QGraphicsScene *myScene = new QGraphicsScene();

// 创建一个图形视图并将场景关联到视图上
QGraphicsView *myView = new QGraphicsView(myScene, this);

这里假设 this 是当前的 QWidget 或者 QObject 子类实例，即将 myView 添加为其子部件。

2、QGraphicsView::QGraphicsView(QWidget *parent = nullptr)

QGraphicsView::QGraphicsView(QWidget *parent = nullptr) 是 QGraphicsView 类的一个构造函数，它的主要作用是创建一个新的 QGraphicsView 对象实例。在这个版本的构造函数中，没有直接关联一个 QGraphicsScene 对象。

参数说明：

  • QWidget *parent: 这是一个指向父级 QWidget 对象的指针，默认值为 nullptr。如果提供了父级窗口部件（即传递非空指针），那么新创建的 QGraphicsView 将成为该父窗口部件的子部件，会受到父窗口部件的布局管理，并且会在父窗口部件销毁时自动被删除。如果没有提供父窗口部件，那么 QGraphicsView 将成为一个顶级窗口或者可以在之后通过调用 setParent() 方法来设置父窗口部件。

使用这个构造函数创建 QGraphicsView 的示例代码如下：

// 创建一个图形视图，暂时不关联任何图形场景
QGraphicsView *myView = new QGraphicsView(this);

// 创建一个图形场景
QGraphicsScene *myScene = new QGraphicsScene();

// 将创建的图形场景关联到视图上
myView->setScene(myScene);

在这个例子中，首先创建了一个没有关联场景的 QGraphicsView，然后创建了一个 QGraphicsScene，最后通过调用 setScene() 方法将场景设置给视图。这样，即使在创建视图时不直接关联场景，也能在后续操作中完成关联。

3、void QGraphicsView::invalidateScene(const QRectF &rect = QRectF(), QGraphicsScene::SceneLayers layers = QGraphicsScene::AllLayers)

QGraphicsView::invalidateScene(const QRectF &rect = QRectF(), QGraphicsScene::SceneLayers layers = QGraphicsScene::AllLayers) 是 QGraphicsView 类的一个成员函数，用于通知视图某个区域的场景内容已经改变，需要重新绘制。

参数说明：

  • const QRectF &rect: 表示需要无效化的场景区域，默认为空 QRectF，表示整个场景都需要无效化并重新绘制。如果你仅修改了场景中的某个特定区域，可以传递这个区域的矩形坐标，这样只会重新绘制这一部分区域，从而提升性能。
  • QGraphicsScene::SceneLayers layers: 表示需要无效化的场景层，默认为 QGraphicsScene::AllLayers，表示所有层都需要无效化。也可以指定只无效化某一层或多层，如背景层、前景层等。

当你调用此函数时，视图将会安排在下次事件循环迭代时更新指定区域的显示，确保视图所显示的内容与场景中的实际内容一致。这对于在程序中动态修改了场景内容，尤其是图形项的位置、大小、形状或外观等属性后，是非常有用的。

4、void QGraphicsView::rubberBandChanged(QRect rubberBandRect, QPointF fromScenePoint, QPointF toScenePoint)

void QGraphicsView::rubberBandChanged(QRect rubberBandRect, QPointF fromScenePoint, QPointF toScenePoint) 这个函数签名看起来并不是标准的 Qt QGraphicsView 类的成员函数。通常，在 QGraphicsView 中处理橡皮筋选择（rubber band selection）时，不会有直接名为 rubberBandChanged 的信号或槽函数，并且不接受这种特定形式的参数。

不过，基于函数名和参数，我们可以推测这可能是一个自定义实现或者派生类中的一个函数，用来响应橡皮筋选择框的变化。在这个假设下：

  • QRect rubberBandRect: 橡皮筋选择框当前的矩形区域，它代表用户通过鼠标拖拽在视图上画出的选择范围。
  • QPointF fromScenePoint: 橡皮筋选择开始时在场景坐标系下的点。
  • QPointF toScenePoint: 橡皮筋选择结束时（或者当前状态）在场景坐标系下的点。

当用户在 QGraphicsView 上拖动鼠标来创建一个选择区域时，这个函数可能是用来实时更新并显示橡皮筋效果，或者是用来记录选择过程中的相关数据。在标准Qt库中，要实现橡皮筋选择的效果，一般会通过重载鼠标事件处理函数并在其中创建一个临时的 QRubberBand 对象，并随着鼠标移动动态调整其位置和大小。

#include <QGraphicsView>
#include <QRubberBand>
#include <QMouseEvent>

class CustomGraphicsView : public QGraphicsView {
    Q_OBJECT
public:
    CustomGraphicsView(QWidget *parent = nullptr) : QGraphicsView(parent), rubberBand(new QRubberBand(QRubberBand::Rectangle, this)) {}

protected:
    void mousePressEvent(QMouseEvent *event) override {
        if (event->button() == Qt::LeftButton) {
            rubberBandOrigin = event->pos();
            rubberBand->setGeometry(QRect(rubberBandOrigin, QSize()));
            rubberBand->show();
        }
        QGraphicsView::mousePressEvent(event);
    }

    void mouseMoveEvent(QMouseEvent *event) override {
        if (rubberBand->isVisible()) {
            QRect rect = rubberBand->geometry();
            rect.setBottomRight(event->pos());
            rubberBand->setGeometry(rect);
            // 在这里可以模拟调用 rubberBandChanged 函数，传递当前的矩形区域
            rubberBandChanged(rect, rubberBandOrigin.toPoint(), event->pos().toPoint());
        }
        QGraphicsView::mouseMoveEvent(event);
    }

    void mouseReleaseEvent(QMouseEvent *event) override {
        if (rubberBand->isVisible()) {
            rubberBand->hide();
            // 处理选择完成逻辑...
        }
        QGraphicsView::mouseReleaseEvent(event);
    }

signals:
    // 假设我们添加了一个自定义信号用于通知橡皮筋框变化
    void rubberBandChanged(const QRect &rect, const QPointF &from, const QPointF &to);

private:
    QPoint rubberBandOrigin;
    QRubberBand *rubberBand;
};

// 主要程序中连接信号与槽
int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    CustomGraphicsView view;
    QObject::connect(&view, &CustomGraphicsView::rubberBandChanged,
                     [](const QRect &r, const QPointF &f, const QPointF &t) {
                         // 在这里处理橡胶带矩形变化的实际逻辑
                         qDebug() << "Rubber band changed:"
                                 << "Rect:" << r << ", From:" << f << ", To:" << t;
                     });
    // ...
    return app.exec();
}

请注意，在上述示例中，我假设了一个自定义信号 rubberBandChanged，并给出了一个简单的槽函数来处理这个信号。在实际应用中，你可以根据需求在mouseMoveEvent内部实现自己的 rubberBandChanged 函数逻辑。

5、void QGraphicsView::setupViewport(QWidget *widget)

void QGraphicsView::setupViewport(QWidget *widget) 是 QGraphicsView 类的一个保护成员函数，用于设置视口（viewport）。视口是 QGraphicsView 内部用于显示 QGraphicsScene 内容的区域，它是一个 QWidget。

当你调用这个函数并传入一个 QWidget 指针时，这个 QWidget 将作为 QGraphicsView 的视口，所有的绘画和事件处理都会在这个视口 widget 上进行。默认情况下，QGraphicsView 会自动创建并管理其视口，但如果你需要自定义视口的行为，例如使用自定义的 QWidget 子类，就可以通过覆盖 setupViewport() 函数来实现。

示例用法：

class MyCustomWidget : public QWidget {
    // 自定义视口类的实现...
};

MyCustomWidget customViewport;

void MyGraphicsView::setupViewport()
{
    QGraphicsView::setupViewport(&customViewport);
    // 可以在这里对 customViewport 进行额外的配置
}

MyGraphicsView::MyGraphicsView(QWidget *parent)
    : QGraphicsView(parent)
{
    setupViewport(); // 调用自定义的 setupViewport 函数
    // ...
}

在上面的例子中，MyGraphicsView 类覆盖了 setupViewport() 函数，将自定义的 MyCustomWidget 设置为了视口。这样，QGraphicsView 所有的渲染和事件处理都将发生在 MyCustomWidget 上。

6、void QGraphicsView::updateScene(const QList<QRectF> &rects)

void QGraphicsView::updateScene(const QList<QRectF> &rects) 是 QGraphicsView 类的一个成员函数，用于通知视图中指定的一组矩形区域需要更新场景内容。当场景中的某些图形元素发生变化时，调用此函数可以确保视图正确地重绘这些变化区域。

该函数接受一个 QList<QRectF> 类型的参数，其中包含了需要更新的矩形区域列表。每个 QRectF 都代表了场景坐标系下的一个区域。

通常情况下，在 QGraphicsScene 中修改或移动项目后，若只关心部分区域的变化，而不是整个场景，调用此方法比调用 QGraphicsView::update() 更高效，因为它允许更精确地控制重绘的范围。

示例用法：

// 假设我们有一些在sceneRect内的矩形区域发生了改变
QList<QRectF> updatedAreas;
updatedAreas << QRectF(0, 0, 100, 100) << QRectF(50, 50, 200, 200); // 这些是需要更新的矩形区域

// 获取视图对象引用
QGraphicsView* view = ...; // 假设已经初始化并连接到了对应的QGraphicsScene

// 更新视图中的指定场景区域
view->updateScene(updatedAreas);

上述代码将指示 QGraphicsView 重新绘制与 updatedAreas 列表中所给定的矩形区域相对应的视图部分。这样，视图只会刷新必要的部分，从而提高性能。

7、void QGraphicsView::updateSceneRect(const QRectF &rect)

void QGraphicsView::updateSceneRect(const QRectF &rect) 是 QGraphicsView 类中的另一个成员函数，不同于 updateScene(const QList<QRectF> &rects) 函数，它主要用于更新视图所显示的整个场景区域（即场景边界）而非仅仅更新特定的矩形区域。

这个函数接收一个 QRectF 类型的参数，该参数定义了一个新的场景矩形区域。当调用此函数时，它会更新视图内部对场景矩形边界的认知，并可能触发视图进行相应的调整和重绘，以适应新场景矩形的大小。

使用场景矩形的主要目的是为了设置视图可视范围的边界以及视图对场景内容的适应策略。例如，当你动态添加或删除场景中的项，或者场景本身的大小发生改变时，调用 updateSceneRect() 方法可以确保视图及时响应这些变化。

// 假设我们改变了场景的大小或位置
QRectF newSceneRect(0, 0, 800, 600); // 新的场景矩形区域

// 获取视图对象引用
QGraphicsView* view = ...; // 假设已经初始化并连接到了对应的QGraphicsScene

// 更新视图的场景矩形
view->setSceneRect(newSceneRect);
// 或者如果只是扩展/收缩而不改变原点，也可以选择：
view->updateSceneRect(view->sceneRect().united(newSceneRect));

// 视图会自动调整以适应新的场景矩形并可能重绘视图内容

请注意，虽然函数名中有“update”，但它并不一定直接导致视图立即重绘，而是更改视图中用来参考的场景区域。实际的重绘操作通常是间接的，由Qt的事件循环根据场景矩形和其他因素来决定何时及如何进行。

8、QGraphicsView::~QGraphicsView()

QGraphicsView::~QGraphicsView() 是C++中 QGraphicsView 类的一个析构函数。在面向对象编程中，析构函数是一种特殊的成员函数，它在对象生命周期结束时自动调用，用于释放对象占用的资源和执行必要的清理工作。

对于 QGraphicsView 类来说，其析构函数的作用主要包括但不限于：

  1. 删除关联的 QGraphicsScene 对象，如果视图拥有该场景的所有权（即通过 setScene(QGraphicsScene*) 设置了场景且采用的是父对象管理子对象的内存策略）。

  2. 清理与视图相关的任何事件处理器、定时器或者其他系统资源。

  3. 释放视图本身占用的内存空间。

在编写自定义的 QGraphicsView 子类时，通常不需要显式地覆盖析构函数，除非需要在销毁视图前进行额外的清理工作。在大多数情况下，Qt框架提供的默认析构函数就已经能够妥善地处理资源回收。

9、void QGraphicsView::centerOn(const QPointF &pos)

void QGraphicsView::centerOn(const QPointF &pos) 是 QGraphicsView 类的一个成员函数，它用于将视图中心定位到指定的场景坐标点 pos 上。这意味着当调用此函数后，视图的中心点将对准场景中的 pos 位置，使得该点位于视图的可见区域中央。

示例用法：

// 假设有以下变量：
QGraphicsView* view = ...; // 已经初始化的 QGraphicsView 对象
QGraphicsItem* item = ...; // 场景中的某个 QGraphicsItem 对象

// 获取item在场景坐标系下的中心点位置
QPointF pos = item->scenePos();

// 让视图中心对准item的中心位置
view->centerOn(pos);

在这段代码中，首先获取了场景中的某个图形项的场景坐标位置，然后调用 centerOn() 函数使视图的中心点与该图形项的中心点对齐。这样，无论图形项在场景中的具体位置如何，都能快速地让其居于视图的中央显示。

10、void QGraphicsView::centerOn(qreal x, qreal y)

void QGraphicsView::centerOn(qreal x, qreal y) 是 QGraphicsView 类的一个成员函数，它同样用于将视图的中心点定位到指定的场景坐标 (x, y) 上。这个函数提供了一种更为直接的方式来指定坐标，无需创建一个 QPointF 对象。

示例用法：

// 假设有以下变量：
QGraphicsView* view = ...; // 已经初始化的 QGraphicsView 对象

// 让视图中心对准场景坐标 (100, 200)
view->centerOn(100, 200);

在这个示例中，调用 centerOn(100, 200) 后，视图将滚动到适当的位置，使得场景坐标 (100, 200) 处于视图的中心位置。

11、void QGraphicsView::centerOn(const QGraphicsItem *item)

void QGraphicsView::centerOn(const QGraphicsItem *item)是QGraphicsView类的一个成员函数。该函数用于将视图中心对准指定的QGraphicsItem项目。

具体来说，当你调用这个函数并传入一个QGraphicsItem对象指针时，图形视图会自动滚动并调整其内容，使得该图形项位于视图的中心位置，便于用户查看或聚焦于该特定的图形项。

示例代码：

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

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

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

    // 在场景中添加一个矩形图形项
    QGraphicsRectItem* rect = new QGraphicsRectItem(0, 0, 100, 100);
    scene.addItem(rect);

    // 将视图中心对准刚添加的矩形图形项
    view.centerOn(rect);

    // 显示视图
    view.show();

    return app.exec();
}

在这个例子中，我们首先创建了一个QGraphicsScene（图形场景）和QGraphicsView（图形视图）。然后我们在场景中添加了一个QGraphicsRectItem（矩形图形项），最后调用view.centerOn(rect)将视图的中心点移动到这个矩形图形项的位置上，确保它在视图窗口中居中显示。

12、void QGraphicsView::contextMenuEvent(QContextMenuEvent *event)

void QGraphicsView::contextMenuEvent(QContextMenuEvent *event) 是Qt GUI框架中的一个成员函数，它属于QGraphicsView类。当用户在QGraphicsView组件上执行右键点击（或者在某些操作系统上的等效操作，触发上下文菜单事件）时，该函数会被调用。

当你重写此函数时，你可以自定义在该视图上右键点击时的行为，比如弹出自定义的上下文菜单（Context Menu）或其他相应操作。

例如：

void MyGraphicsView::contextMenuEvent(QContextMenuEvent *event)
{
    QMenu menu(this);
    QAction *actionZoomIn = menu.addAction(tr("Zoom In"));
    QAction *actionZoomOut = menu.addAction(tr("Zoom Out"));

    connect(actionZoomIn, &QAction::triggered, this, [=]{ zoomIn(); });
    connect(actionZoomOut, &QAction::triggered, this, [=]{ zoomOut(); });

    menu.exec(event->globalPos());
}

在这个例子中，当用户在MyGraphicsView上右键点击时，会弹出一个包含“放大”和“缩小”选项的上下文菜单。当用户选择这些动作时，对应的zoomIn()和zoomOut()函数会被调用以实现相应的功能。

13、void QGraphicsView::dragEnterEvent(QDragEnterEvent *event)

void QGraphicsView::dragEnterEvent(QDragEnterEvent *event) 是Qt GUI框架中 QGraphicsView 类的一个重载事件处理函数。当拖拽操作中的数据进入 QGraphicsView 视图的有效范围时，这个函数会被调用。

在自定义 dragEnterEvent 函数时，您可以决定是否接受这次拖拽操作，以及设定拖拽的数据格式和操作类型。例如：

void MyGraphicsView::dragEnterEvent(QDragEnterEvent *event)
{
    // 检查拖拽的数据是否有我们感兴趣的内容类型
    if (event->mimeData()->hasFormat("application/x-qgraphicsitem")) {
        // 设置拖拽动作的接受策略
        event->acceptProposedAction();
    } else {
        // 拒绝此次拖拽操作
        event->ignore();
    }
}

在这个例子中，我们检查了拖拽的数据是否携带 "application/x-qgraphicsitem" 类型，如果是，则接受拖拽操作，否则忽略。通过这种方式，您可以定制您的 QGraphicsView 对拖拽事件的响应行为。

14、void QGraphicsView::dragLeaveEvent(QDragLeaveEvent *event)

void QGraphicsView::dragLeaveEvent(QDragLeaveEvent *event) 是Qt框架中的一个事件处理函数，它是 QGraphicsView 类的一个重载方法。当拖拽的对象离开 QGraphicsView 视图的有效区域时，这个函数会被调用。

在自定义这个函数时，通常用来清理在 dragEnterEvent 或 dragMoveEvent 中设置的一些临时状态，例如恢复视图或场景的原始样式，或者取消任何正在等待的拖拽操作指示。

例如：

void MyGraphicsView::dragLeaveEvent(QDragLeaveEvent *event)
{
    // 清理操作，如隐藏拖拽过程中的临时指示器
    myDragIndicatorItem->setVisible(false);
    event->accept();
}

在上面的示例中，当拖拽事件离开视图时，隐藏了一个可能用于指示当前拖拽位置的临时图形项（myDragIndicatorItem）。调用 event->accept() 表示已处理此事件，不再需要进一步传递给其它事件处理器。

15、void QGraphicsView::dragMoveEvent(QDragMoveEvent *event)

void QGraphicsView::dragMoveEvent(QDragMoveEvent *event) 是Qt GUI框架中 QGraphicsView 类的一个重载事件处理函数。当拖拽操作中的数据在 QGraphicsView 视图内移动时，这个函数会被调用。

在自定义 dragMoveEvent 函数时，您可以实时追踪拖拽操作的位置，并据此做出反应，比如更新预览效果或更改拖拽反馈指示。例如：

void MyGraphicsView::dragMoveEvent(QDragMoveEvent *event)
{
    // 获取当前鼠标位置对应的场景坐标
    QPointF scenePos = this->mapToScene(event->pos());

    // 若拖拽的是图片文件
    if (event->mimeData()->hasUrls()) {
        foreach (const QUrl &url, event->mimeData()->urls()) {
            if (QFile::exists(url.toLocalFile())) {
                // 更新拖拽预览效果，这里假设有一个跟随鼠标移动的预览图
                myPreviewPixmapItem->setPos(scenePos);
                // 接受拖动事件，允许继续拖拽操作
                event->acceptProposedAction();
                break;
            }
        }
    } else {
        event->ignore(); // 如果拖拽的数据不符合要求，则忽略此事件
    }
}

在这个示例中，当拖拽的数据包含有效的图片文件URL时，我们将一个预览图元（myPreviewPixmapItem）跟随鼠标在场景中的位置进行移动，从而实现拖拽过程中图片预览的效果。如果拖拽的数据不满足要求，则忽略此次拖动事件。

16、void QGraphicsView::drawBackground(QPainter *painter, const QRectF &rect)

void QGraphicsView::drawBackground(QPainter *painter, const QRectF &rect) 是Qt GUI框架中 QGraphicsView 类的一个虚函数，用于自定义视图背景的绘制方式。每当视图区域需要重绘其背景时，这个函数会被调用。

在派生自 QGraphicsView 的类中重写此函数，可以让您自定义视图背景的样式和内容，如添加颜色填充、渐变、图案或者绘制自定义图形等。

下面是一个简单的例子：

class CustomGraphicsView : public QGraphicsView
{
protected:
    void drawBackground(QPainter *painter, const QRectF &rect) override
    {
        // 获取视图的背景色
        QColor backgroundColor = Qt::lightGray;

        // 设置画笔的颜色
        painter->setBrush(backgroundColor);

        // 填充背景矩形
        painter->drawRect(rect);

        // 或者绘制更复杂的背景，例如添加渐变背景
        QLinearGradient gradient(rect.topLeft(), rect.bottomRight());
        gradient.setColorAt(0.0, Qt::white);
        gradient.setColorAt(1.0, Qt::darkGray);
        painter->fillRect(rect, gradient);
    }
};

在这个例子中，我们首先设置了画笔的背景色并填充了给定的矩形区域作为背景。另外，还演示了如何使用线性渐变来填充背景，从左上角到右下角颜色逐渐变化。通过这样的方式，您可以根据需求自由地定制 QGraphicsView 的背景显示效果。

17、void QGraphicsView::drawForeground(QPainter *painter, const QRectF &rect)

void QGraphicsView::drawForeground(QPainter *painter, const QRectF &rect) 同样是Qt GUI框架中的 QGraphicsView 类的一个虚函数，它提供了自定义视图前景绘制的能力。当视图区域的内容需要更新（包括前景部分）时，该函数会被调用。

在自定义的 QGraphicsView 子类中重写此方法，可以实现一些特定的前景元素绘制，比如覆盖在所有场景项之上的标注、图标或其他固定装饰元素等。

以下是一个基本示例：

class CustomGraphicsView : public QGraphicsView
{
protected:
    void drawForeground(QPainter *painter, const QRectF &rect) override
    {
        // 继承默认行为的同时，在前景绘制一个十字线辅助线
        QGraphicsView::drawForeground(painter, rect);

        // 设置线条颜色为红色
        painter->setPen(QPen(Qt::red, 1, Qt::DashLine));

        // 在视图中心绘制垂直和水平的十字线
        QPointF center = mapToScene(rect.center());
        painter->drawLine(center.x(), 0, center.x(), height());
        painter->drawLine(0, center.y(), width(), center.y());
    }
};

在这个示例中，除了保留默认的前景绘制外，我们在视图的中心位置额外绘制了一条红色的十字线作为辅助线。这只是一个简单示例，实际应用中可以根据具体需求绘制任意的前景元素。

18、void QGraphicsView::dropEvent(QDropEvent *event)

void QGraphicsView::dropEvent(QDropEvent *event) 是Qt框架中的 QGraphicsView 类的一个重载事件处理函数，用于处理拖放操作中的“放置”阶段（drop）。当用户将数据从外部源（例如文件管理器或其他应用程序）拖放到 QGraphicsView 上，并释放鼠标按钮完成拖放动作时，这个函数会被调用。

在自定义的 QGraphicsView 类中，你可以通过重写 dropEvent 函数来处理拖放到视图上的数据，通常包括解析拖放的数据格式，然后根据这些数据在场景中添加或更新相应的图形项目。下面是一个简化的示例：

class CustomGraphicsView : public QGraphicsView
{
protected:
    void dropEvent(QDropEvent *event) override
    {
        if (event->mimeData()->hasFormat("text/uri-list")) { // 检查是否拖放的是文件路径
            event->acceptProposedAction();

            QStringList files = event->mimeData()->urls().map(
                [](const QUrl& url) { return url.toLocalFile(); });

            for (const QString &file : files) {
                // 假设我们加载图像文件并将其显示为场景中的QGraphicsPixmapItem
                QPixmap pixmap(file);
                if (!pixmap.isNull()) {
                    QGraphicsPixmapItem *item = new QGraphicsPixmapItem(pixmap);
                    scene()->addItem(item);
                    // 可能还需要设置初始位置或调整缩放等
                }
            }
        } else {
            event->ignore();
        }
    }
};

在这个示例中，如果拖放的数据包含文件路径，那么我们就获取这些路径并将它们转换为本地文件名。接着，尝试加载每个文件为 QPixmap，并创建一个新的 QGraphicsPixmapItem 显示所加载的图像，最后将这些图形项添加到与视图关联的 QGraphicsScene 中。当然，实际应用场景可能更为复杂，需要处理更多的数据类型和逻辑。

19、void QGraphicsView::ensureVisible(const QRectF &rect, int xmargin = 50, int ymargin = 50)

void QGraphicsView::ensureVisible(const QRectF &rect, int xmargin = 50, int ymargin = 50) 是Qt GUI框架中 QGraphicsView 类的一个成员函数，它的作用是确保指定的 QRectF 区域在视图中可见，并且在其周围留下一定的边距（默认为左右各50像素，上下各50像素）。

参数说明：

  • const QRectF &rect: 需要确保在视图中可见的矩形区域，该区域基于场景坐标系。
  • int xmargin: 水平方向上的额外边距（可选，默认为50像素），确保矩形区域两边都有至少这么多的空白空间。
  • int ymargin: 垂直方向上的额外边距（可选，默认为50像素），确保矩形区域上下都有至少这么多的空白空间。

通过调用这个函数，视图会自动滚动到合适的位置，使指定的矩形区域完全出现在视图中，并且留有一定的边距，提高用户的视觉体验和交互便利性。

20、void QGraphicsView::ensureVisible(qreal x, qreal y, qreal w, qreal h, int xmargin = 50, int ymargin = 50)

void QGraphicsView::ensureVisible(qreal x, qreal y, qreal w, qreal h, int xmargin = 50, int ymargin = 50) 是Qt GUI框架中 QGraphicsView 类的一个成员函数，它的作用是确保指定的矩形区域（由x、y、w、h四个参数确定）在视图中可见，并且在该矩形区域四周提供指定的边距（默认分别为左右各50像素，上下各50像素）。

参数说明：

  • qreal x: 矩形区域的左上角x坐标，基于场景坐标系。
  • qreal y: 矩形区域的左上角y坐标，基于场景坐标系。
  • qreal w: 矩形区域的宽度。
  • qreal h: 矩形区域的高度。
  • int xmargin: 水平方向上的额外边距（可选，默认为50像素），确保矩形区域两边都有至少这么多的空白空间。
  • int ymargin: 垂直方向上的额外边距（可选，默认为50像素），确保矩形区域上下都有至少这么多的空白空间。

调用此函数后，视图会自动滚动到适当的位置，确保指定大小和位置的矩形区域及其周围边距都在视图的可视范围内。这对于高亮显示某个特定区域或焦点跟踪非常有用。

21、void QGraphicsView::ensureVisible(const QGraphicsItem *item, int xmargin = 50, int ymargin = 50)

void QGraphicsView::ensureVisible(const QGraphicsItem *item, int xmargin = 50, int ymargin = 50) 是Qt GUI框架中 QGraphicsView 类的一个成员函数，它的作用是确保指定的 QGraphicsItem 在视图中可见，并且为其四周预留一定数量的空白边距（默认为左右各50像素，上下各50像素）。

参数说明：

  • const QGraphicsItem *item: 指向需要确保可见的 QGraphicsItem 指针。
  • int xmargin: 水平方向上的额外边距（可选，默认为50像素），确保图形项两边都有至少这么多的空白空间。
  • int ymargin: 垂直方向上的额外边距（可选，默认为50像素），确保图形项上下都有至少这么多的空白空间。

当调用此函数时，QGraphicsView 会自动滚动至适当的位置，确保指定的图形项及围绕它的指定边距完全显示在视图内，有助于用户更好地查看和操作指定的图形项。

22、bool QGraphicsView::event(QEvent *event)

bool QGraphicsView::event(QEvent *event) 是Qt GUI框架中 QGraphicsView 类的一个重载函数，它处理发送给视图的各种事件。该函数的主要目的是对传入的事件进行处理，并根据事件类型执行相应的操作。

在自定义的 QGraphicsView 类中，可以通过重写 event() 函数来处理特定类型的事件，或者修改事件的默认处理方式。当事件被分发给视图时，会先调用此函数，如果该函数返回 true，则表示事件已被处理，不会再传递给其他事件处理器；如果返回 false，则表明事件未被处理，将会继续传递给父类或者其他已安装的事件过滤器。

例如，你可以在 event() 函数中捕获并处理键盘、鼠标、窗口以及其他各种类型的事件，如下所示：

bool CustomGraphicsView::event(QEvent *event)
{
    switch (event->type()) {
    case QEvent::KeyPress:
        // 处理按键事件
        break;
    case QEvent::MouseButtonPress:
        // 处理鼠标按下事件
        break;
    default:
        // 对于其他事件，调用基类的处理方式
        return QGraphicsView::event(event);
    }

    // 如果在此处处理了事件，则返回true
    return true;
}

需要注意的是，对于大部分标准的GUI事件，Qt已经为 QGraphicsView 提供了专门的事件处理函数（如 keyPressEvent, mousePressEvent 等），在大多数情况下，优先使用这些专用函数而非直接在 event() 中处理事件。

23、void QGraphicsView::fitInView(const QRectF &rect, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio)

void QGraphicsView::fitInView(const QRectF &rect, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio) 是Qt GUI框架中 QGraphicsView 类的一个成员函数。该函数的作用是调整视图的缩放级别，使得指定的 QRectF 区域适应视图的大小，保持或忽略指定的宽高比。

参数说明：

  • const QRectF &rect：这是要在视图中适应的场景坐标的矩形区域。
  • Qt::AspectRatioMode aspectRatioMode：这是一个枚举值，决定了是否保持原矩形的宽高比。默认值为 Qt::IgnoreAspectRatio，意味着在适应视图时不考虑原矩形的宽高比。如果希望保持宽高比，可以选择 Qt::KeepAspectRatio 或 Qt::KeepAspectRatioByExpanding。

调用此函数后，视图会自动调整其缩放比例，使得整个指定的矩形区域能在视图中完整显示，同时根据 aspectRatioMode 参数选择是否保持原始矩形的比例关系。这对于确保用户可以看到全部内容，特别是在场景较大的时候很有用。

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

class MyGraphicsView : public QGraphicsView
{
public:
    MyGraphicsView(QWidget *parent = nullptr) : QGraphicsView(parent)
    {
        // 创建一个场景和一个矩形项
        QGraphicsScene *scene = new QGraphicsScene(this);
        QGraphicsRectItem *rectItem = scene->addRect(-100, -100, 200, 200, QPen(Qt::black), QBrush(Qt::blue));
        
        // 设置视图的场景
        setScene(scene);

        // 让视图自动适应矩形项的大小，保持宽高比
        fitInView(rectItem->boundingRect(), Qt::KeepAspectRatio);
    }
};

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

    // 创建并显示图形视图
    MyGraphicsView view;
    view.show();

    return app.exec();
}

在这个例子中，我们首先创建了一个 QGraphicsView 的子类 MyGraphicsView。在构造函数中，我们创建了一个 QGraphicsScene 场景并添加了一个 QGraphicsRectItem 矩形项。然后，我们调用 fitInView() 函数，传入矩形项的边界矩形（boundingRect() 方法获取），并指定要保持宽高比（Qt::KeepAspectRatio）。最后，我们创建并显示 MyGraphicsView 实例，此时视图将自动调整缩放比例，使得矩形项恰好适应视图的大小且保持原始的宽高比。

24、void QGraphicsView::fitInView(qreal x, qreal y, qreal w, qreal h, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio)

void QGraphicsView::fitInView(qreal x, qreal y, qreal w, qreal h, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio) 这个函数的作用是调整 QGraphicsView 的缩放级别，使其能够容纳指定坐标(x, y)处，宽度(w)和高度(h)的区域，并根据 aspectRatioMode 参数来决定是否保持纵横比。

参数说明：

  • qreal x: 要适应的区域左上角的x坐标（基于场景坐标系）。
  • qreal y: 要适应的区域左上角的y坐标（基于场景坐标系）。
  • qreal w: 要适应的区域的宽度。
  • qreal h: 要适应的区域的高度。
  • Qt::AspectRatioMode aspectRatioMode：一个枚举值，用于指定是否保持适应区域的纵横比。默认为 Qt::IgnoreAspectRatio，即不保持纵横比；如果设置为 Qt::KeepAspectRatio 或 Qt::KeepAspectRatioByExpanding，则视图在缩放时会尽量保持适应区域的纵横比。

实例：

QGraphicsView view;
view.setScene(new QGraphicsScene());

// 假设有某个矩形区域需要适应视图大小
qreal x = 50;
qreal y = 50;
qreal w = 200;
qreal h = 100;

// 调整视图以适应这个矩形区域，并保持纵横比
view.fitInView(x, y, w, h, Qt::KeepAspectRatio);

// 显示视图
view.show();

在这段代码中，视图会自动调整其缩放级别，使得坐标(50, 50)处，宽为200，高为100的区域能在视图中完全显示，同时保持原始的宽高比。

25、void QGraphicsView::fitInView(const QGraphicsItem *item, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio)

void QGraphicsView::fitInView(const QGraphicsItem *item, Qt::AspectRatioMode aspectRatioMode = Qt::IgnoreAspectRatio) 是Qt GUI库中 QGraphicsView 类的一个成员函数，用于调整视图的缩放级别，使得指定的 QGraphicsItem 完全显示在视图内，并根据 aspectRatioMode 参数来决定是否保持该图形项的纵横比。

参数说明：

  • const QGraphicsItem *item：指向需要适应视图的 QGraphicsItem 指针。
  • Qt::AspectRatioMode aspectRatioMode：一个枚举值，指定适应视图时是否保持图形项的纵横比。默认值为 Qt::IgnoreAspectRatio，这意味着在适应视图时不考虑图形项的原有比例；如果设置为 Qt::KeepAspectRatio 或 Qt::KeepAspectRatioByExpanding，则视图在缩放时会尽可能保持图形项的纵横比。

实例：

// 假设已经有一个 QGraphicsView 对象 view 和 QGraphicsItem 对象 myItem
// myItem 已经添加到了 view 关联的 QGraphicsScene 中

// 调整视图以适应 myItem 的大小，并保持纵横比
view.fitInView(myItem, Qt::KeepAspectRatio);

// 显示视图
view.show();

在这个示例中，QGraphicsView 对象 view 会自动调整其缩放级别，使得 myItem 完全显示在视图内，并且保持 myItem 的原始纵横比。如果视图原本的大小不足以完整显示 myItem，则视图会进行相应的缩放。

26、void QGraphicsView::focusInEvent(QFocusEvent *event)

void QGraphicsView::focusInEvent(QFocusEvent *event) 是Qt GUI框架中 QGraphicsView 类的一个重载事件处理函数。当 QGraphicsView 控件获得焦点时（例如用户通过键盘Tab键切换焦点或鼠标点击该控件），该函数会被调用。

通过重写这个函数，开发者可以自定义视图获取焦点时的行为，比如改变视图外观以显示当前具有焦点，或者启动某些与焦点有关的功能。

一个简单的重写示例：

void CustomGraphicsView::focusInEvent(QFocusEvent *event)
{
    // 调用父类的实现，以确保默认的焦点事件处理也能执行
    QGraphicsView::focusInEvent(event);

    // 自定义处理焦点进入事件的代码
    if (event->gotFocus())
    {
        // 当视图获取焦点时，改变其边框颜色
        setStyleSheet("border: 2px solid red;");

        // 或者执行其他与获取焦点相关的操作
        // ...
    }
}

在这个示例中，当 CustomGraphicsView 获得焦点时，视图的边框颜色会变为红色，以此来可视化地标识当前焦点所在。当然，你可以根据自己的需求编写不同的处理逻辑。

27、bool QGraphicsView::focusNextPrevChild(bool next)

bool QGraphicsView::focusNextPrevChild(bool next) 是Qt GUI框架中 QGraphicsView 类的一个成员函数。此函数用于在视图的子控件之间切换焦点，参数 next 决定了焦点是向前切换还是向后切换。

当 next 参数为 true 时，焦点会转移到下一个可以接收焦点的子控件；当 next 为 false 时，焦点会转移到前一个可以接收焦点的子控件。

该函数的返回值为布尔类型，如果成功转移焦点，则返回 true，否则返回 false，例如当没有更多可聚焦的子控件时。

在 QGraphicsView 中，此函数主要用于处理嵌套在视图内部的可聚焦控件，如文本编辑框或其他可聚焦的 QGraphicsItem。通常情况下，开发者并不需要直接调用此函数，而是依赖于键盘导航（如 Tab 键）或者通过其他方式间接触发焦点切换。不过在某些情况下，如果需要自定义焦点切换逻辑，可能需要重写或利用这个函数。

28、void QGraphicsView::focusOutEvent(QFocusEvent *event)

void QGraphicsView::focusOutEvent(QFocusEvent *event) 是Qt GUI框架中 QGraphicsView 类的一个重载事件处理函数。当 QGraphicsView 控件失去焦点时（例如用户通过键盘Tab键切换焦点至其他控件或鼠标点击了其他可聚焦的控件），该函数会被调用。

通过重写这个函数，开发者可以自定义视图失去焦点时的行为，例如改变视图的外观以显示当前不再具有焦点，或者停止某些与焦点有关的功能。

一个简单的重写示例：

void CustomGraphicsView::focusOutEvent(QFocusEvent *event)
{
    // 调用父类的实现，以确保默认的焦点事件处理也能执行
    QGraphicsView::focusOutEvent(event);

    // 自定义处理焦点离开事件的代码
    if (event->lostFocus())
    {
        // 当视图失去焦点时，恢复其边框颜色
        unsetStyleSheet();

        // 或者执行其他与失去焦点相关的操作
        // ...
    }
}

在这个示例中，当 CustomGraphicsView 失去焦点时，视图会恢复其原来的边框样式，以此来反映当前焦点已不在该视图上。你可以根据具体需求编写不同的处理逻辑。

29、void QGraphicsView::inputMethodEvent(QInputMethodEvent *event)

void QGraphicsView::inputMethodEvent(QInputMethodEvent *event) 是Qt GUI框架中 QGraphicsView 类的一个重载事件处理函数，它负责处理与输入法（IME）相关的事件。在多语言环境下，特别是东亚地区（如中国、日本、韩国等），输入法事件常用于处理文字输入，如汉字、假名、韩文等字符的输入。

当用户使用输入法进行文本输入时，操作系统会发送 QInputMethodEvent 到当前具有焦点的控件。重写 inputMethodEvent 函数可以使 QGraphicsView 或其子类支持通过输入法输入文本，并在图形场景中显示相应的文本内容。

然而，QGraphicsView 默认情况下可能并不直接支持这种事件，因为它的主要用途是对图形场景进行显示和交互。通常，如果您想在 QGraphicsView 中的某个 QGraphicsItem 中接收和处理输入法事件，您需要在相应的 QGraphicsItem 子类中重写 inputMethodEvent 函数。而对于 QGraphicsView 自身，可能需要处理输入法事件来更新视图状态或协助焦点管理等。

在Qt中，通常我们会为 QGraphicsTextItem 这样的文本项处理输入法事件，而不是直接在 QGraphicsView 上处理。这是因为 QGraphicsView 主要是用于显示和控制 QGraphicsScene 中的图形项，而输入法事件通常关联到文本输入。

以下是一个在 QGraphicsTextItem 子类中处理输入法事件的示例：

class CustomGraphicsTextItem : public QGraphicsTextItem
{
public:
    using QGraphicsTextItem::QGraphicsTextItem;

protected:
    void inputMethodEvent(QInputMethodEvent *event) override
    {
        // 删除现有预编辑文本（如果有）
        if (!preeditText().isEmpty()) {
            setText(preeditText().mid(preeditText().indexOf(QString("\uFFF9")) + 1,
                                     preeditText().length() - 2));
        }

        // 分配新的预编辑文本
        setText(event->preeditString());

        // 处理插入的文本
        for (auto it = event->attributes().constBegin(); it != event->attributes().constEnd(); ++it) {
            if (it.value().type() == QVariant::String && it.key() == QLatin1String("insert")) {
                setText(text() + it.value().toString());
            }
        }

        // 调用父类的实现以确保默认行为
        QGraphicsTextItem::inputMethodEvent(event);
    }
};

// 使用自定义的文本项
CustomGraphicsTextItem *textItem = new CustomGraphicsTextItem("Hello, World!", scene);

在上述代码中，我们创建了一个名为 CustomGraphicsTextItem 的 QGraphicsTextItem 子类，并重写了 inputMethodEvent 函数，以处理输入法事件并更新文本项的内容。

实际上，QGraphicsTextItem 已经内置了对输入法事件的支持，通常不需要额外重写 inputMethodEvent。但在某些特殊需求下，如自定义预编辑文本的显示方式或扩展输入法事件处理逻辑时，才需要这样做。在常规使用情境下，我们只需创建一个 QGraphicsTextItem，它就能自动处理输入法事件。

30、QVariant QGraphicsView::inputMethodQuery(Qt::InputMethodQuery query) const

QVariant QGraphicsView::inputMethodQuery(Qt::InputMethodQuery query) const 是Qt GUI框架中 QGraphicsView 类的一个成员函数，用于查询与输入法相关的信息。当输入法（IME）需要获取与视图相关的输入法属性时，会调用此函数。

参数 query 是一个枚举类型 Qt::InputMethodQuery，用于指定要查询的信息类型，例如：

  • Qt::ImCursorRectangle：查询光标所在的矩形区域。
  • Qt::ImFont：查询当前使用的字体。
  • Qt::ImHints：查询输入法提示信息。
  • Qt::ImMicroFocus：查询微焦点区域（输入法所需关注的文本区域）。

该函数返回一个 QVariant 对象，包含了对应查询请求的结果。

虽然 QGraphicsView 类可能不直接处理文本输入，但其子类（如 QGraphicsTextItem）可能需要支持输入法功能。在某些情况下，QGraphicsView 可能需要参与输入法查询以协助正确的焦点管理和文本布局。

一个典型的使用场景可能是在自定义的 QGraphicsItem 子类中，而不是直接在 QGraphicsView 中使用 inputMethodQuery 函数。例如：

QVariant MyGraphicsTextItem::inputMethodQuery(Qt::InputMethodQuery query) const
{
    if (query == Qt::ImCursorPosition) {
        QTextCursor cursor = textCursor();
        return QVariant(cursor.position());
    }

    return QGraphicsTextItem::inputMethodQuery(query);
}

31、bool QGraphicsView::isTransformed() const

bool QGraphicsView::isTransformed() const 是Qt GUI框架中 QGraphicsView 类的一个成员函数，用于检测视图是否应用了任何变换（如缩放、旋转、平移等）。如果视图应用了任何变换，该函数将返回 true，反之则返回 false。

这个函数可以帮助开发人员了解视图当前的状态，例如在需要保存视图状态或恢复之前的状态时，可以检查视图是否进行了变换操作。在实际应用中，结合 resetTransform() 等函数可以有效地管理视图的变换状态。

32、QGraphicsItem *QGraphicsView::itemAt(const QPoint &pos) const

QGraphicsItem *QGraphicsView::itemAt(const QPoint &pos) const 是Qt GUI框架中 QGraphicsView 类的一个成员函数，它用于查找在视图坐标系统中指定点（pos）下的 QGraphicsItem 对象。

函数参数：

  • const QPoint &pos：表示视图坐标系中的一个点。

返回值：

  • QGraphicsItem *：返回位于指定点下的顶层可见 QGraphicsItem 指针，如果没有找到任何项目，则返回 nullptr。

这个函数对于实现交互式图形界面非常有用，例如，当用户在视图上单击鼠标时，我们可以调用 itemAt() 来确定用户点击的具体图形项目，并根据该项目执行相应的操作。此外，该函数只会返回最上层的图形项目，如果有多个项目重叠在同一位置，只有最上层的项目会被返回。如果需要获取所有重叠的项目，可以使用 items() 函数。

33、QGraphicsItem *QGraphicsView::itemAt(int x, int y) const

QGraphicsItem *QGraphicsView::itemAt(int x, int y) const 是Qt GUI框架中 QGraphicsView 类的一个成员函数，其功能与 itemAt(const QPoint &pos) const 几乎相同，只是参数形式不同。这个函数同样用于查找在视图坐标系统中指定位置（x 和 y）下的顶层可见 QGraphicsItem 对象。

函数参数：

  • int x：表示视图坐标系中的x坐标值。
  • int y：表示视图坐标系中的y坐标值。

返回值：

  • QGraphicsItem *：返回位于指定位置下的顶层可见 QGraphicsItem 指针，如果没有找到任何项目，则返回 nullptr。

这个函数可以帮助开发人员快速定位到视图上特定坐标点的图形项目，进而实现诸如鼠标单击事件处理、交互式图形界面等功能。同理，如果需要获取所有位于同一位置的重叠项目，应使用 items() 函数配合相应参数。

34、QList<QGraphicsItem *> QGraphicsView::items() const

QList<QGraphicsItem *> QGraphicsView::items() const 是Qt GUI框架中 QGraphicsView 类的一个成员函数，它返回与视图关联的 QGraphicsScene 中的所有可见 QGraphicsItem 对象列表。

这个函数不接受任何参数，它遍历整个场景并收集所有可见的图形项。返回值是一个 QList<QGraphicsItem*> 类型的容器，包含了场景中所有可见的 QGraphicsItem 指针。

当你需要访问视图中所有的图形项，或者对所有图形项进行某种操作时，可以使用这个函数。例如，你可能想要遍历所有图形项以改变它们的颜色或处理碰撞检测等。

请注意，这个函数返回的是所有可见的图形项，如果某个图形项被其他图形项遮挡或其自身的可见性设置为隐藏，则不会被包含在这个列表中。如果你需要获取场景中所有的（无论是否可见）QGraphicsItem，应当调用 QGraphicsScene::items() 函数。

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

// 为了方便展示，我们定义一个简单的自定义图形项，带有名称
class NamedRectItem : public QGraphicsRectItem
{
public:
    NamedRectItem(const QString &name, QGraphicsItem *parent = nullptr)
        : QGraphicsRectItem(0, 0, 50, 50, parent), m_name(name)
    {}

    QString name() const { return m_name; }

private:
    QString m_name;
};

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

    // 创建一个QGraphicsView和QGraphicsScene
    QGraphicsView view;
    QGraphicsScene *scene = new QGraphicsScene(&view);

    // 添加几个自定义的NamedRectItem到场景中
    NamedRectItem item1("Item 1");
    NamedRectItem item2("Item 2");
    NamedRectItem item3("Item 3");

    scene->addItem(&item1);
    scene->addItem(&item2);
    scene->addItem(&item3);

    // 设置视图的场景并显示视图
    view.setScene(scene);
    view.show();

    // 获取并打印所有可见的QGraphicsItem的名称
    QList<QGraphicsItem *> visibleItems = view.items();
    for (QGraphicsItem *item : visibleItems) {
        NamedRectItem *namedItem = qgraphicsitem_cast<NamedRectItem *>(item);
        if (namedItem) {
            std::cout << "Visible Item Name: " << namedItem->name().toStdString() << std::endl;
        }
    }

    return app.exec();
}

在这个示例中，我们首先创建了一个自定义的 NamedRectItem 类，它继承自 QGraphicsRectItem 并带有一个名称属性。然后我们创建了三个这样的图形项并添加到场景中。接下来，我们通过调用 view.items() 获取所有可见的图形项，并将它们转换为 NamedRectItem 类型（如果可以的话），然后打印出它们的名称。

35、QList<QGraphicsItem *> QGraphicsView::items(const QPoint &pos) const

QList<QGraphicsItem *> QGraphicsView::items(const QPoint &pos) const 是Qt GUI框架中 QGraphicsView 类的一个成员函数，它返回与视图关联的 QGraphicsScene 中位于指定位置（相对于视图坐标系）的所有图形项的列表，包括那些被其他图形项遮挡但仍处于该位置的项。

函数参数：

  • const QPoint &pos：表示视图坐标系中的一个点。

返回值：

  • QList<QGraphicsItem *>：返回位于指定位置的所有图形项的指针列表，即使这些图形项互相重叠。

示例代码：

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

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

    QGraphicsView view;
    QGraphicsScene *scene = new QGraphicsScene(&view);

    // 添加几个重叠的矩形图形项
    QGraphicsRectItem *item1 = scene->addRect(50, 50, 100, 100, QPen(Qt::black), QBrush(Qt::blue));
    QGraphicsRectItem *item2 = scene->addRect(75, 75, 50, 50, QPen(Qt::black), QBrush(Qt::red));

    view.setScene(scene);
    view.show();

    // 获取并打印指定位置的所有图形项
    QPoint pos(100, 100); // 选择一个在两个矩形相交区域的位置
    QList<QGraphicsItem *> itemsAtPosition = view.items(pos);

    for (QGraphicsItem *item : itemsAtPosition) {
        qDebug() << "Item at position: " << item;
    }

    return app.exec();
}

在这个示例中，我们创建了两个重叠的矩形图形项，然后通过调用 view.items(pos) 获取指定位置（这里是矩形相交区域的一个点）的所有图形项，并打印出它们的地址。运行程序，你会看到输出了两个矩形的地址，尽管在视图上只看到红色矩形的一部分。

36、QList<QGraphicsItem *> QGraphicsView::items(int x, int y) const

QList<QGraphicsItem *> QGraphicsView::items(int x, int y) const 是Qt GUI框架中 QGraphicsView 类的一个成员函数，它返回与视图关联的 QGraphicsScene 中位于指定坐标（x, y，相对于视图坐标系）的所有图形项的列表，包括那些被其他图形项遮挡但仍处于该位置的项。

函数参数：

  • int x：表示视图坐标系中的x坐标值。
  • int y：表示视图坐标系中的y坐标值。

返回值：

  • QList<QGraphicsItem *>：返回位于指定坐标的所有图形项的指针列表，即使这些图形项互相重叠。

示例代码：

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

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

    QGraphicsView view;
    QGraphicsScene *scene = new QGraphicsScene(&view);

    // 添加几个重叠的矩形图形项
    QGraphicsRectItem *item1 = scene->addRect(50, 50, 100, 100, QPen(Qt::black), QBrush(Qt::blue));
    QGraphicsRectItem *item2 = scene->addRect(75, 75, 50, 50, QPen(Qt::black), QBrush(Qt::red));

    view.setScene(scene);
    view.show();

    // 获取并打印指定坐标的所有图形项
    int x = 100;
    int y = 100; // 选择一个在两个矩形相交区域的坐标
    QList<QGraphicsItem *> itemsAtPosition = view.items(x, y);

    for (QGraphicsItem *item : itemsAtPosition) {
        qDebug() << "Item at position (" << x << ", " << y << "): " << item;
    }

    return app.exec();
}

在这个示例中，我们创建了两个重叠的矩形图形项，然后通过调用 view.items(x, y) 获取指定坐标（这里是矩形相交区域的一个点）的所有图形项，并打印出它们的地址。运行程序，你会看到输出了两个矩形的地址，尽管在视图上只看到红色矩形的一部分。

37、QList<QGraphicsItem *> QGraphicsView::items(const QRect &rect, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const

QList<QGraphicsItem *> QGraphicsView::items(const QRect &rect, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const 是Qt GUI框架中 QGraphicsView 类的一个成员函数，它返回与视图关联的 QGraphicsScene 中与指定矩形区域相交的所有图形项的列表。函数接受两个参数：

  1. const QRect &rect：表示一个矩形区域，相对于视图坐标系。
  2. Qt::ItemSelectionMode mode：一个枚举值，用于指定选择模式，默认值为 Qt::IntersectsItemShape。此模式表示返回与矩形区域形状相交的所有图形项。还有其他选项，如 Qt::ContainsItemShape（返回完全包含在矩形内的图形项）、Qt::IntersectsItemBoundingRect（返回矩形与图形项边界矩形相交的图形项）等。

返回值：

  • QList<QGraphicsItem *>：返回与指定矩形区域相交的所有图形项的指针列表。

示例代码：

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

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

    QGraphicsView view;
    QGraphicsScene *scene = new QGraphicsScene(&view);

    // 添加几个图形项
    QGraphicsRectItem *item1 = scene->addRect(50, 50, 100, 100, QPen(Qt::black), QBrush(Qt::blue));
    QGraphicsRectItem *item2 = scene->addRect(150, 150, 50, 50, QPen(Qt::black), QBrush(Qt::red));
    QGraphicsRectItem *item3 = scene->addRect(100, 100, 50, 50, QPen(Qt::black), QBrush(Qt::green));

    view.setScene(scene);
    view.show();

    // 获取并打印与指定矩形区域相交的所有图形项
    QRect rect(75, 75, 150, 150); // 选择一个覆盖部分图形项的矩形区域
    Qt::ItemSelectionMode mode = Qt::IntersectsItemShape;
    QList<QGraphicsItem *> itemsInRect = view.items(rect, mode);

    for (QGraphicsItem *item : itemsInRect) {
        qDebug() << "Item in rectangle: " << item;
    }

    return app.exec();
}

在这个示例中，我们创建了三个矩形图形项，然后通过调用 view.items(rect, mode) 获取与指定矩形区域相交的所有图形项，并打印出它们的地址。运行程序，你会看到输出了与矩形区域相交的蓝色和绿色矩形的地址。

38、QList<QGraphicsItem *> QGraphicsView::items(int x, int y, int w, int h, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const

QList<QGraphicsItem *> QGraphicsView::items(int x, int y, int w, int h, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const 是Qt GUI框架中 QGraphicsView 类的一个成员函数，它返回与视图关联的 QGraphicsScene 中与指定矩形区域相交的所有图形项的列表。函数接受五个参数：

  1. int x：矩形左上角的x坐标，相对于视图坐标系。
  2. int y：矩形左上角的y坐标，相对于视图坐标系。
  3. int w：矩形的宽度。
  4. int h：矩形的高度。
  5. Qt::ItemSelectionMode mode：一个枚举值，用于指定选择模式，默认值为 Qt::IntersectsItemShape。此模式表示返回与矩形区域形状相交的所有图形项。还有其他选项，如 Qt::ContainsItemShape（返回完全包含在矩形内的图形项）、Qt::IntersectsItemBoundingRect（返回矩形与图形项边界矩形相交的图形项）等。

返回值：

  • QList<QGraphicsItem *>：返回与指定矩形区域相交的所有图形项的指针列表。

示例代码：

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

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

    QGraphicsView view;
    QGraphicsScene *scene = new QGraphicsScene(&view);

    // 添加几个图形项
    QGraphicsRectItem *item1 = scene->addRect(50, 50, 100, 100, QPen(Qt::black), QBrush(Qt::blue));
    QGraphicsRectItem *item2 = scene->addRect(150, 150, 50, 50, QPen(Qt::black), QBrush(Qt::red));
    QGraphicsRectItem *item3 = scene->addRect(100, 100, 50, 50, QPen(Qt::black), QBrush(Qt::green));

    view.setScene(scene);
    view.show();

    // 获取并打印与指定矩形区域相交的所有图形项
    int x = 75;
    int y = 75;
    int w = 150;
    int h = 150; // 选择一个覆盖部分图形项的矩形区域
    Qt::ItemSelectionMode mode = Qt::IntersectsItemShape;
    QList<QGraphicsItem *> itemsInRect = view.items(x, y, w, h, mode);

    for (QGraphicsItem *item : itemsInRect) {
        qDebug() << "Item in rectangle: " << item;
    }

    return app.exec();
}

在这个示例中，我们创建了三个矩形图形项，然后通过调用 view.items(x, y, w, h, mode) 获取与指定矩形区域相交的所有图形项，并打印出它们的地址。运行程序，你会看到输出了与矩形区域相交的蓝色和绿色矩形的地址。

39、QList<QGraphicsItem *> QGraphicsView::items(const QPolygon &polygon, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const

QList<QGraphicsItem *> QGraphicsView::items(const QPolygon &polygon, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const 是Qt GUI框架中 QGraphicsView 类的一个成员函数，它返回与视图关联的 QGraphicsScene 中与指定多边形相交的所有图形项的列表。函数接受两个参数：

  1. const QPolygon &polygon：表示一个多边形区域，相对于视图坐标系。
  2. Qt::ItemSelectionMode mode：一个枚举值，用于指定选择模式，默认值为 Qt::IntersectsItemShape。此模式表示返回与多边形形状相交的所有图形项。还有其他选项，如 Qt::ContainsItemShape（返回完全包含在多边形内的图形项）、Qt::IntersectsItemBoundingRect（返回多边形与图形项边界矩形相交的图形项）等。

返回值：

  • QList<QGraphicsItem *>：返回与指定多边形区域相交的所有图形项的指针列表。

示例代码：

#include <QApplication>
#include <QGraphicsView>
#include <QGraphicsScene>
#include <QGraphicsRectItem>
#include <QPolygon>
#include <QList>
#include <QDebug>

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

    QGraphicsView view;
    QGraphicsScene *scene = new QGraphicsScene(&view);

    // 添加几个图形项
    QGraphicsRectItem *item1 = scene->addRect(50, 50, 100, 100, QPen(Qt::black), QBrush(Qt::blue));
    QGraphicsRectItem *item2 = scene->addRect(150, 150, 50, 50, QPen(Qt::black), QBrush(Qt::red));
    QGraphicsRectItem *item3 = scene->addRect(100, 100, 50, 50, QPen(Qt::black), QBrush(Qt::green));

    view.setScene(scene);
    view.show();

    // 创建一个多边形区域
    QPolygon polygon;
    polygon << QPoint(75, 75) << QPoint(125, 75) << QPoint(125, 125) << QPoint(75, 125);

    // 获取并打印与指定多边形区域相交的所有图形项
    Qt::ItemSelectionMode mode = Qt::IntersectsItemShape;
    QList<QGraphicsItem *> itemsInPolygon = view.items(polygon, mode);

    for (QGraphicsItem *item : itemsInPolygon) {
        qDebug() << "Item in polygon: " << item;
    }

    return app.exec();
}

在这个示例中，我们创建了三个矩形图形项和一个四边形多边形区域，然后通过调用 view.items(polygon, mode) 获取与指定多边形区域相交的所有图形项，并打印出它们的地址。运行程序，你会看到输出了与多边形区域相交的蓝色和绿色矩形的地址。

40、QList<QGraphicsItem *> QGraphicsView::items(const QPainterPath &path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const

QList<QGraphicsItem *> QGraphicsView::items(const QPainterPath &path, Qt::ItemSelectionMode mode = Qt::IntersectsItemShape) const 是Qt GUI框架中 QGraphicsView 类的一个成员函数，它返回与视图关联的 QGraphicsScene 中与指定 QPainterPath 路径相交的所有图形项的列表。函数接受两个参数：

  1. const QPainterPath &path：表示一个绘图路径，相对于视图坐标系。
  2. Qt::ItemSelectionMode mode：一个枚举值，用于指定选择模式，默认值为 Qt::IntersectsItemShape。此模式表示返回与绘图路径相交的所有图形项。还有其他选项，如 Qt::ContainsItemShape（返回完全包含在路径内的图形项）、Qt::IntersectsItemBoundingRect（返回路径与图形项边界矩形相交的图形项）等。

返回值：

  • QList<QGraphicsItem *>：返回与指定 QPainterPath 路径相交的所有图形项的指针列表。

示例代码：

#include <QApplication>
#include <QGraphicsView>
#include <QGraphicsScene>
#include <QGraphicsRectItem>
#include <QPainterPath>
#include <QList>
#include <QDebug>

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

    QGraphicsView view;
    QGraphicsScene *scene = new QGraphicsScene(&view);

    // 添加几个图形项
    QGraphicsRectItem *item1 = scene->addRect(50, 50, 100, 100, QPen(Qt::black), QBrush(Qt::blue));
    QGraphicsRectItem *item2 = scene->addRect(150, 150, 50, 50, QPen(Qt::black), QBrush(Qt::red));
    QGraphicsRectItem *item3 = scene->addRect(100, 100, 50, 50, QPen(Qt::black), QBrush(Qt::green));

    view.setScene(scene);
    view.show();

    // 创建一个绘图路径
    QPainterPath path;
    path.addEllipse(75, 75, 150, 150); // 创建一个圆形路径

    // 获取并打印与指定路径相交的所有图形项
    Qt::ItemSelectionMode mode = Qt::IntersectsItemShape;
    QList<QGraphicsItem *> itemsInPath = view.items(path, mode);

    for (QGraphicsItem *item : itemsInPath) {
        qDebug() << "Item in path: " << item;
    }

    return app.exec();
}

在这个示例中，我们创建了三个矩形图形项和一个圆形路径，然后通过调用 view.items(path, mode) 获取与指定路径相交的所有图形项，并打印出它们的地址。运行程序，你会看到输出了与路径相交的蓝色和绿色矩形的地址。

41、void QGraphicsView::keyPressEvent(QKeyEvent *event)

void QGraphicsView::keyPressEvent(QKeyEvent *event) 是Qt GUI框架中 QGraphicsView 类的一个重载函数，它处理键盘按键按下事件。当用户在 QGraphicsView 上按下某个键时，这个函数会被自动调用。

该函数接收一个指向 QKeyEvent 对象的指针作为参数，QKeyEvent 包含了关于按键事件的具体信息，比如按下的是哪个键、按下的状态（是否带有修饰键如Shift、Ctrl等）等。

当需要自定义 QGraphicsView 的键盘响应行为时，通常会覆盖（override）这个函数，在其中编写相应的处理逻辑。例如，你可以决定在按下特定键时移动场景中的图形项、改变视图的缩放级别、或者执行其他任何与应用相关的操作。

下面是一个简单的覆盖示例：

class MyGraphicsView : public QGraphicsView {
protected:
    void keyPressEvent(QKeyEvent *event) override {
        switch (event->key()) {
        case Qt::Key_Left:
            // 按下左箭头键时，平移视图向左
            horizontalScrollBar()->setValue(horizontalScrollBar()->value() - 10);
            break;
        case Qt::Key_Right:
            // 按下右箭头键时，平移视图向右
            horizontalScrollBar()->setValue(horizontalScrollBar()->value() + 10);
            break;
        case Qt::Key_Up:
            // 按上箭头键时，平移视图向上
            verticalScrollBar()->setValue(verticalScrollBar()->value() - 10);
            break;
        case Qt::Key_Down:
            // 按下箭头键时，平移视图向下
            verticalScrollBar()->setValue(verticalScrollBar()->value() + 10);
            break;
        default:
            // 如果不是特殊处理的键，则传递给父类处理
            QGraphicsView::keyPressEvent(event);
            break;
        }
    }
};

在这个例子中，当我们按下方向键时，视图的内容会按照相应方向平移一定的像素距离。如果接收到的按键事件不是我们特别处理的，那么就将其交给基类的 keyPressEvent 函数来处理默认的行为。

42、void QGraphicsView::keyReleaseEvent(QKeyEvent *event)

void QGraphicsView::keyReleaseEvent(QKeyEvent *event) 是Qt GUI框架中 QGraphicsView 类的一个重载函数，它处理键盘按键释放事件。当用户在 QGraphicsView 上释放某个键时，这个函数会被自动调用。

该函数同样接收一个指向 QKeyEvent 对象的指针作为参数，QKeyEvent 对象包含了按键释放的相关信息，如释放的是哪个键以及释放时的按键状态等。

在一些应用场景中，可能需要监听键盘按键释放的时刻来执行特定的操作，这时就需要重写（override）keyReleaseEvent 函数。例如，当用户长按某个键时，可能在按下期间执行一种操作，在释放时结束该操作：

class MyGraphicsView : public QGraphicsView {
protected:
    bool isMoving = false;
    QPointF moveStartPos;

    void keyPressEvent(QKeyEvent *event) override {
        if (event->key() == Qt::Key_Space) {
            // 按下空格键开始移动操作
            isMoving = true;
            moveStartPos = mapToScene(event->pos());
        } else {
            QGraphicsView::keyPressEvent(event);
        }
    }

    void keyReleaseEvent(QKeyEvent *event) override {
        if (event->key() == Qt::Key_Space) {
            // 释放空格键结束移动操作
            isMoving = false;
            // 在这里执行移动结束后需要做的清理工作
        } else {
            QGraphicsView::keyReleaseEvent(event);
        }
    }

    void mouseMoveEvent(QMouseEvent *event) override {
        if (isMoving) {
            QPointF moveEndPos = mapToScene(event->pos());
            // 在这里计算并执行视图的平移操作
        }
        QGraphicsView::mouseMoveEvent(event);
    }
};

在这个示例中，我们监听空格键的释放事件，并在释放时结束视图的移动操作。同时，在 mouseMoveEvent 中根据 isMoving 的状态判断是否进行视图的平移。这只是一个简化的示例，实际应用可能会更复杂。

43、QPoint QGraphicsView::mapFromScene(const QPointF &point) const

QPoint QGraphicsView::mapFromScene(const QPointF &point) const 是Qt GUI框架中 QGraphicsView 类的一个成员函数。该函数用于将给定的场景坐标系中的点（QPointF 类型）映射到视图（viewport）的坐标系中，并返回对应的视图坐标系中的点（QPoint 类型）。

参数说明：

  • const QPointF &point：表示场景坐标系中的一个点。

示例代码：

QGraphicsView view;
QGraphicsScene *scene = new QGraphicsScene(&view);

// 假设我们在场景中有一个点
QPointF scenePoint(100, 100);

// 将场景中的点转换为视图坐标系中的点
QPoint viewPoint = view.mapFromScene(scenePoint);

// 现在viewPoint就是scenePoint在视图坐标系中的位置

通过这个函数，您可以根据场景中的坐标得到视图窗口中对应的坐标，这对于处理鼠标事件、图形项与视图间的相对位置等问题非常有用。

44、QPolygon QGraphicsView::mapFromScene(const QRectF &rect) const

QPolygon QGraphicsView::mapFromScene(const QRectF &rect) const 是Qt GUI框架中 QGraphicsView 类的一个成员函数。该函数用于将给定的场景坐标系中的矩形（QRectF 类型）映射到视图（viewport）的坐标系中，并返回对应的视图坐标系中的多边形（QPolygon 类型）。

参数说明：

  • const QRectF &rect：表示场景坐标系中的一个矩形区域。

示例代码：

QGraphicsView view;
QGraphicsScene *scene = new QGraphicsScene(&view);

// 假设我们在场景中有一个矩形区域
QRectF sceneRect(100, 100, 200, 150);

// 将场景中的矩形区域转换为视图坐标系中的多边形
QPolygon viewPolygon = view.mapFromScene(sceneRect);

// 现在viewPolygon就是sceneRect在视图坐标系中的顶点序列

通过这个函数，您可以根据场景中的矩形区域得到视图窗口中对应的顶点序列，这对于将场景中的图形区域转换为视图坐标以便进一步处理非常有用，比如绘制、选区操作等。

重载函数：

1、QPolygon QGraphicsView::mapFromScene(const QPolygonF &polygon) const

2、QPainterPath QGraphicsView::mapFromScene(const QPainterPath &path) const

45、QPoint QGraphicsView::mapFromScene(qreal x, qreal y) const

QPoint QGraphicsView::mapFromScene(qreal x, qreal y) const 是Qt GUI框架中 QGraphicsView 类的一个成员函数。该函数用于将给定的场景坐标系中的坐标（x, y，均为 qreal 类型）映射到视图（viewport）的坐标系中，并返回对应的视图坐标系中的点（QPoint 类型）。

参数说明：

  • qreal x：表示场景坐标系中的X坐标值。
  • qreal y：表示场景坐标系中的Y坐标值。

示例代码：

QGraphicsView view;
QGraphicsScene *scene = new QGraphicsScene(&view);

// 假设我们在场景中有一个点 (100.5, 100.5)
qreal sceneX = 100.5;
qreal sceneY = 100.5;

// 将场景中的点转换为视图坐标系中的点
QPoint viewPoint = view.mapFromScene(sceneX, sceneY);

// 现在viewPoint就是(100.5, 100.5)在视图坐标系中的位置

通过这个函数，您可以根据场景中的坐标得到视图窗口中对应的坐标，这对于处理鼠标事件、图形项与视图间的相对位置等问题非常有用。

46、QPolygon QGraphicsView::mapFromScene(qreal x, qreal y, qreal w, qreal h) const

函数功能类似于QPolygon QGraphicsView::mapFromScene(const QRectF &rect) const成员函数，都是将场景坐标映射到视图坐标系当中

47、QPointF QGraphicsView::mapToScene(const QPoint &point) const

QPointF QGraphicsView::mapToScene(const QPoint &point) const 是Qt GUI框架中 QGraphicsView 类的一个成员函数。该函数用于将给定的视图（viewport）坐标系中的点（QPoint 类型）映射到场景坐标系中，并返回对应的场景坐标系中的点（QPointF 类型）。

参数说明：

  • const QPoint &point：表示视图坐标系中的一个点。

示例代码：

QGraphicsView view;
QGraphicsScene *scene = new QGraphicsScene(&view);

// 假设我们在视图窗口中有一个点 (100, 100)
QPoint viewPoint(100, 100);

// 将视图中的点转换为场景坐标系中的点
QPointF scenePoint = view.mapToScene(viewPoint);

// 现在scenePoint就是(100, 100)在场景坐标系中的位置

通过这个函数，您可以根据视图中的坐标得到场景中的对应坐标，这对于处理视图与场景之间的交互，如鼠标事件的处理，图形项在场景中的放置等操作非常有用。

48、QPolygonF QGraphicsView::mapToScene(const QRect &rect) const

QPolygonF QGraphicsView::mapToScene(const QRect &rect) const 是Qt GUI框架中 QGraphicsView 类的一个成员函数。该函数用于将给定的视图（viewport）坐标系中的矩形区域（QRect 类型）映射到场景坐标系中，并返回对应的场景坐标系中的点集合（QPolygonF 类型）。

参数说明：

  • const QRect &rect：表示视图坐标系中的一个矩形区域。

示例代码：

QGraphicsView view;
QGraphicsScene *scene = new QGraphicsScene(&view);

// 假设我们在视图窗口中有一个矩形区域 (100, 100, 200, 150)
QRect viewRect(100, 100, 200, 150);

// 将视图中的矩形区域转换为场景坐标系中的点集合
QPolygonF scenePolygon = view.mapToScene(viewRect);

// 现在scenePolygon就是视图矩形区域在场景坐标系中的各个顶点

通过这个函数，您可以根据视图中的矩形区域得到场景中的对应顶点集合，这对于将视图空间的选区、绘制区域等转换到场景空间进行处理非常有用。

重载函数：

1、QPolygonF QGraphicsView::mapToScene(const QPolygon &polygon) const

2、QPolygonF QGraphicsView::mapToScene(const QPainterPath &path) const

3、QPolygonF QGraphicsView::mapToScene(int x, int y) const

4、QPolygonF QGraphicsView::mapToScene(int x, int y, int w, int h) const

49、void QGraphicsView::mouseDoubleClickEvent(QMouseEvent *event)

void QGraphicsView::mouseDoubleClickEvent(QMouseEvent *event) 是Qt GUI框架中 QGraphicsView 类的一个重载函数，用于处理视图上的鼠标双击事件。当用户在 QGraphicsView 视图区域内双击鼠标时，这个函数会被自动调用。

函数参数：

  • QMouseEvent *event：这是一个指向 QMouseEvent 对象的指针，包含了关于鼠标双击事件的详细信息，如鼠标按键、点击位置、事件发生的全局和局部坐标等。

示例代码：

class CustomGraphicsView : public QGraphicsView
{
protected:
    void mouseDoubleClickEvent(QMouseEvent *event) override
    {
        // 获取鼠标双击事件发生的位置
        QPointF scenePos = mapToScene(event->pos());

        // 打印鼠标双击的场景坐标位置
        qDebug() << "Mouse double-clicked at scene position:" << scenePos;

        // 根据需求在此处添加自定义的双击事件处理逻辑
        // ...

        // 调用父类的mouseDoubleClickEvent以保持默认行为
        QGraphicsView::mouseDoubleClickEvent(event);
    }
};

在这个示例中，我们重写了 mouseDoubleClickEvent 函数，首先将视图坐标转换为场景坐标，然后可以根据需要处理双击事件，如放大视图、选择图形项等。最后，为了保留 QGraphicsView 的默认双击事件处理逻辑（如有），可以选择调用父类的 mouseDoubleClickEvent 函数。

50、void QGraphicsView::mouseMoveEvent(QMouseEvent *event)

void QGraphicsView::mouseMoveEvent(QMouseEvent *event) 是Qt GUI框架中 QGraphicsView 类的一个重载函数，它用于处理视图上的鼠标移动事件。当用户在 QGraphicsView 视图区域内移动鼠标时，这个函数会被连续调用，直到鼠标按键被释放为止。

函数参数：

  • QMouseEvent *event：这是一个指向 QMouseEvent 对象的指针，包含了关于鼠标移动事件的详细信息，如鼠标按键状态、鼠标当前位置、事件发生的全局和局部坐标等。

示例代码：

class CustomGraphicsView : public QGraphicsView
{
protected:
    void mouseMoveEvent(QMouseEvent *event) override
    {
        // 获取鼠标当前位置
        QPointF currentPos = event->pos();
        QPointF scenePos = mapToScene(currentPos);

        // 打印鼠标当前位置的场景坐标
        qDebug() << "Mouse moved to scene position:" << scenePos;

        // 可以根据鼠标移动进行自定义操作，例如拖动图形项、滚动视图内容等
        // ...

        // 若需要保留 QGraphicsView 的默认鼠标移动事件处理逻辑，可以调用父类的函数
        QGraphicsView::mouseMoveEvent(event);
    }
};

在这个示例中，我们重写了 mouseMoveEvent 函数，首先将视图坐标转换为场景坐标，然后可以根据需要处理鼠标移动事件，如跟随鼠标移动更新图形项位置、实现平移视图等。如果希望同时保持 QGraphicsView 的默认鼠标移动事件处理逻辑，可以调用父类的 mouseMoveEvent 函数。

51、void QGraphicsView::mousePressEvent(QMouseEvent *event)

void QGraphicsView::mousePressEvent(QMouseEvent *event) 是Qt GUI框架中 QGraphicsView 类的一个重载函数，它用于处理视图上的鼠标按下事件。当用户在 QGraphicsView 视图区域内按下鼠标按钮时，这个函数会被调用。

函数参数：

  • QMouseEvent *event：这是一个指向 QMouseEvent 对象的指针，包含了关于鼠标按下事件的各种信息，例如按下的是哪个鼠标按钮、按下的位置、事件发生的全局和局部坐标等。

示例代码：

class CustomGraphicsView : public QGraphicsView
{
protected:
    void mousePressEvent(QMouseEvent *event) override
    {
        // 获取鼠标按下事件的位置
        QPointF scenePos = mapToScene(event->pos());

        // 打印鼠标按下位置的场景坐标
        qDebug() << "Mouse pressed at scene position:" << scenePos;

        // 根据需要在此处添加自定义的鼠标按下事件处理逻辑
        // 例如：选择图形项、开始拖拽操作等

        // 若需要保留 QGraphicsView 的默认鼠标按下事件处理逻辑，可以调用父类的函数
        QGraphicsView::mousePressEvent(event);
    }
};

在这个示例中，我们重写了 mousePressEvent 函数，首先将视图坐标转换为场景坐标，然后可以根据需要处理鼠标按下事件，如选择图形项、启动平移或缩放操作等。如果不希望阻止 QGraphicsView 的默认鼠标按下事件处理逻辑，可以调用父类的 mousePressEvent 函数。

52、void QGraphicsView::mouseReleaseEvent(QMouseEvent *event)

void QGraphicsView::mouseReleaseEvent(QMouseEvent *event) 是Qt GUI框架中 QGraphicsView 类的一个重载函数，它用于处理视图上的鼠标释放事件。当用户在 QGraphicsView 视图区域内释放鼠标按钮时，这个函数会被调用。

函数参数：

  • QMouseEvent *event：这是一个指向 QMouseEvent 对象的指针，包含了关于鼠标释放事件的详细信息，如释放的是哪个鼠标按钮、释放位置、事件发生的全局和局部坐标等。

示例代码：

class CustomGraphicsView : public QGraphicsView
{
protected:
    void mouseReleaseEvent(QMouseEvent *event) override
    {
        // 获取鼠标释放事件的位置
        QPointF scenePos = mapToScene(event->pos());

        // 打印鼠标释放位置的场景坐标
        qDebug() << "Mouse released at scene position:" << scenePos;

        // 根据需要在此处添加自定义的鼠标释放事件处理逻辑
        // 例如：结束拖拽操作、确认图形项的选择、触发单击事件等

        // 若需要保留 QGraphicsView 的默认鼠标释放事件处理逻辑，可以调用父类的函数
        QGraphicsView::mouseReleaseEvent(event);
    }
};

在这个示例中，我们重写了 mouseReleaseEvent 函数，首先将视图坐标转换为场景坐标，然后可以根据需要处理鼠标释放事件，例如结束拖拽操作、执行单击操作的后续逻辑等。如果不希望阻止 QGraphicsView 的默认鼠标释放事件处理逻辑，可以在处理完自定义逻辑后调用父类的 mouseReleaseEvent 函数。

53、void QGraphicsView::paintEvent(QPaintEvent *event)

void QGraphicsView::paintEvent(QPaintEvent *event) 是Qt GUI框架中 QGraphicsView 类的一个重载函数，它是Qt事件处理机制的一部分，用于响应视图需要重新绘制的请求。当视图需要更新其内容时，操作系统会发送一个 QPaintEvent 事件，然后 paintEvent 函数会被调用。

函数参数：

  • QPaintEvent *event：这是一个指向 QPaintEvent 对象的指针，包含了关于这次绘制事件的信息，如需要绘制的区域等。

在 QGraphicsView 中，paintEvent 函数主要负责调度场景（QGraphicsScene）的内容进行绘制。通常情况下，开发者不需要直接重写这个函数，因为 QGraphicsView 已经提供了默认的绘制逻辑，即自动将关联的 QGraphicsScene 内容绘制到视图中。

然而，在某些高级定制场景下，你可能需要自定义视图的绘制行为，此时可以重写 paintEvent 函数：

class CustomGraphicsView : public QGraphicsView
{
protected:
    void paintEvent(QPaintEvent *event) override
    {
        // 在这里可以添加自定义的绘制代码
        // ...

        // 若要保持 QGraphicsView 默认的绘制行为，还需要调用 base class 的 paintEvent
        QGraphicsView::paintEvent(event);
    }
};

在重写的 paintEvent 函数中，可以添加额外的绘制指令，比如绘制背景、叠加效果等，但在大多数情况下，最好是在调用父类的 paintEvent 函数之后进行这些操作，以确保场景内容能够正确绘制出来。

54、void QGraphicsView::render(QPainter *painter, const QRectF &target = QRectF(), const QRect &source = QRect(), Qt::AspectRatioMode aspectRatioMode = Qt::KeepAspectRatio)

void QGraphicsView::render(QPainter *painter, const QRectF &target = QRectF(), const QRect &source = QRect(), Qt::AspectRatioMode aspectRatioMode = Qt::KeepAspectRatio) 是Qt库中 QGraphicsView 类的一个成员函数，它主要用于将 QGraphicsView 所显示的 QGraphicsScene 内容渲染到一个指定的 QPainter 上。

这个函数的具体功能和参数含义如下：

  • QPainter *painter：一个指向 QPainter 对象的指针，QPainter 用于在任何支持的设备上进行二维图形绘制，这里的设备可以是屏幕、窗口、打印机或者其他输出设备。通过这个参数，你可以将场景的内容“画”到画家所关联的设备上。

  • const QRectF &target：目标矩形区域，定义了在 painter 的坐标系统中想要渲染的区域。如果不指定，则默认整个画家的目标区域都会被使用。

  • const QRect &source：源矩形区域，定义了从 QGraphicsView 中选取要复制的部分，也就是场景中要渲染的子区域。如果未指定，默认会渲染整个视图可见区域的内容。

  • Qt::AspectRatioMode aspectRatioMode：指定在缩放时如何处理原始内容的比例关系，可选值包括但不限于：

    • Qt::KeepAspectRatio（默认）：保持原图像的宽高比不变。
    • Qt::IgnoreAspectRatio：不考虑比例，直接拉伸填充目标区域。
    • 其他模式，如 Qt::KeepAspectRatioByExpanding 等。

此函数常用于将 QGraphicsView 中的图形内容截图、打印或者复制到其他绘图表面，而不仅仅是局限于视图自身的刷新和绘制。

#include <QGraphicsView>
#include <QPainter>
#include <QPixmap>

// 假设已有一个已经设置了scene的QGraphicsView实例view
QGraphicsView view;

// 创建一个QPixmap作为存储渲染结果的位图
QPixmap pixmap(view.width(), view.height());

// 创建并初始化一个QPainter
QPainter painter(&pixmap);
painter.setRenderHint(QPainter::Antialiasing); // 可选，启用抗锯齿等渲染提示

// 设置需要渲染的源和目标区域（这里假设我们想要渲染整个视图）
QRect target(0, 0, pixmap.width(), pixmap.height()); // 目标区域与pixmap大小一致
QRect source = view.sceneRect(); // 源区域为整个场景区域

// 调用render函数进行渲染
view.render(&painter, target, source, Qt::KeepAspectRatio);

// 渲染完成后，现在pixmap包含了QGraphicsView内容的副本
// 如果需要保存为图片文件，可以这样做
pixmap.save("screenshot.png");

// 或者将其显示在一个 QLabel 上
QLabel label;
label.setPixmap(pixmap);

这段代码首先创建了一个足够大的 QPixmap 来存储渲染的结果，然后创建了一个 QPainter 并设置其关联到 QPixmap 上。接着调用 view.render() 方法，将 QGraphicsView 的内容渲染到 QPainter 中，从而保存到了 QPixmap 中。最后，你可以选择将 QPixmap 保存为图片文件或显示在用户界面组件上。

55、void QGraphicsView::resetCachedContent()

void QGraphicsView::resetCachedContent() 是Qt框架中 QGraphicsView 类的一个成员函数。在 QGraphicsView 中，为了提高性能，部分内容会缓存起来，尤其是当场景内容很大，而视图窗口只能显示其中一部分时。这个函数的作用是清除所有已经缓存的视图内容，强制视图下次重绘时重新计算和渲染场景。

调用 resetCachedContent() 通常发生在以下情况：

  1. 当场景内容发生重大变化，而这些变化无法通过简单地更新缓存内容反映出来时。
  2. 场景变换（如缩放、旋转等）后，为了避免显示旧的、不符合新变换状态的缓存内容，需要更新缓存。

示例代码：

QGraphicsView view;
// ... 设置场景和内容 ...

// 场景内容发生变化或其他需要更新缓存的情况
view.resetCachedContent();

注意：频繁调用 resetCachedContent() 可能会影响性能，因为它会导致视图重新渲染全部内容，所以应在必要的时候才调用此函数。

56、void QGraphicsView::resetTransform()

void QGraphicsView::resetTransform() 是Qt GUI库中的 QGraphicsView 类的一个方法，用于重置视图的变换矩阵，包括任何应用到视图上的缩放、旋转和平移操作。

当你调用 resetTransform() 函数时，它会恢复视图到初始状态，即没有进行任何几何变换的状态，这意味着视图将直接按1:1的比例显示其关联的 QGraphicsScene 内容，且视图中心点与场景的原点对齐（默认情况下）。

示例代码：

QGraphicsView view;
// 假设已经设置了scene并进行了各种变换操作
view.scale(2.0, 2.0); // 对视图内容进行缩放
view.rotate(45);      // 对视图内容进行旋转
view.translate(50, 50); // 对视图内容进行平移

// 重置所有变换操作，视图将恢复到初始状态
view.resetTransform();

通过调用 resetTransform() 方法，你可以确保视图总是回到一个已知的、无任何额外几何变换的基础状态。这对于实现视图复位功能或者在需要重新设置视图布局时非常有用。

57、void QGraphicsView::resizeEvent(QResizeEvent *event)

void QGraphicsView::resizeEvent(QResizeEvent *event) 是Qt GUI框架中 QGraphicsView 类的一个重载函数，用于处理视图的大小更改事件。当 QGraphicsView 组件的大小发生改变时，系统会自动触发这个事件。

函数参数：

  • QResizeEvent *event：这是一个指向 QResizeEvent 对象的指针，该对象包含了视图的新尺寸（新的宽度和高度）。

示例代码：

class CustomGraphicsView : public QGraphicsView
{
protected:
    void resizeEvent(QResizeEvent *event) override
    {
        // 更新视图相关的数据或设置，例如适应视图大小调整
        // ...
        
        // 调用父类的resizeEvent，以保持QGraphicsView的默认处理逻辑
        QGraphicsView::resizeEvent(event);
    }
};

// 示例使用
CustomGraphicsView view;
// 当视图大小改变时，会调用resizeEvent函数

在自定义的 resizeEvent 函数中，你可以根据视图的新尺寸做出相应的调整，例如调整场景的可视区域、适配视图的背景图片大小、调整布局等。调用父类的 resizeEvent 函数是为了保证 QGraphicsView 内部的一些基本功能（如视口与场景的适配）也能正确处理视图大小的变化。

58、void QGraphicsView::rotate(qreal angle)

void QGraphicsView::rotate(qreal angle) 是Qt GUI框架中 QGraphicsView 类的一个成员函数，用于围绕视图中心点对视图内容进行旋转。给定的角度 angle 以度为单位，正角度表示逆时针旋转，负角度表示顺时针旋转。

示例代码：

QGraphicsView view;
view.setScene(new QGraphicsScene());

// 旋转视图内容45度
view.rotate(45.0);

调用这个函数后，QGraphicsView 中显示的 QGraphicsScene 内容将会按照指定角度旋转，而视图本身的窗口并不会旋转，仅仅是视图内容发生了旋转变化。如果你需要同时保持视图窗口的旋转效果，可能需要配合视图的其他变换方法，如 setTransform() 或 translate() 和 scale() 等一起使用。

59、QRect QGraphicsView::rubberBandRect() const

QRect QGraphicsView::rubberBandRect() const 是Qt GUI框架中 QGraphicsView 类的一个成员函数，它返回当前橡皮筋选择框（rubber band rectangle）的矩形区域。橡皮筋选择框通常在用户按下鼠标并在视图区域内拖动时出现，用于指示即将选定的区域。

返回值：

  • QRect：表示当前橡皮筋选择框的矩形区域，如果橡皮筋选择框尚未激活或者未定义，则返回一个无效的矩形（通常为空矩形）。

示例代码：

QGraphicsView view;
// ... 初始化视图及关联场景等 ...

// 用户进行橡皮筋选择操作后...
if (!view.rubberBandRect().isEmpty()) {
    // 获取橡皮筋选择框的矩形区域
    QRect rect = view.rubberBandRect();
    // 然后你可以使用这个矩形区域做一些操作，如选择场景中位于该区域内的所有图形项等
    // ...
}

需要注意的是，QGraphicsView 本身并不自动开启橡皮筋选择功能，你需要通过自定义事件处理函数（如 mousePressEvent、mouseMoveEvent 和 mouseReleaseEvent）来实现这一功能。

60、void QGraphicsView::scale(qreal sx, qreal sy)

void QGraphicsView::scale(qreal sx, qreal sy) 是Qt GUI框架中 QGraphicsView 类的一个成员函数，用于对视图内容进行缩放操作。

参数说明：

  • qreal sx：水平方向的缩放因子，大于1代表放大，小于1代表缩小。
  • qreal sy：垂直方向的缩放因子，大于1代表放大，小于1代表缩小。

调用此函数时，视图内容将根据给定的缩放因子进行缩放，缩放操作是以视图的中心点为基准进行的。如果只想沿一个方向缩放（保持另一个方向的比例不变），可以将sx和sy设置为相同的值。

示例代码：

QGraphicsView view;
view.setScene(new QGraphicsScene());

// 缩放视图内容，使其在水平方向缩小一半，垂直方向也缩小一半
view.scale(0.5, 0.5);

通过连续调用 scale() 函数，可以逐步调整视图内容的缩放级别。此外，缩放操作不影响 QGraphicsScene 的实际内容，仅影响其在 QGraphicsView 中的显示效果。

61、QGraphicsScene *QGraphicsView::scene() const

QGraphicsScene *QGraphicsView::scene() const 是Qt GUI框架中 QGraphicsView 类的一个成员函数，用于获取与当前 QGraphicsView 关联的 QGraphicsScene 指针。QGraphicsScene 是一个用于存放图形项（如线条、形状、图片等）的容器，而 QGraphicsView 则是用来显示和控制这些图形项的视图。

返回值：

  • 返回类型为 QGraphicsScene *，即一个指向 QGraphicsScene 对象的指针。如果没有设置关联的场景，返回值为 nullptr。

示例代码：

QGraphicsView view;
QGraphicsScene *scene = new QGraphicsScene(&view);
view.setScene(scene); // 将场景与视图关联

// 稍后可以从视图中获取关联的场景
QGraphicsScene *currentScene = view.scene();
if (currentScene) {
    // 对当前关联的场景进行操作
    // ...
}

通过调用此函数，您可以访问和操作与视图关联的场景，比如添加或删除图形项、处理场景中的事件等。如果视图尚未关联任何场景，需要先调用 QGraphicsView::setScene() 方法来设置关联的场景。

62、void QGraphicsView::scrollContentsBy(int dx, int dy)

void QGraphicsView::scrollContentsBy(int dx, int dy) 是Qt GUI框架中 QGraphicsView 类的一个成员函数，用于在当前视图中进行滚动操作，使视图内容相对于当前显示位置平移指定的水平和垂直偏移量。

参数说明：

  • int dx：表示水平方向上的滚动偏移量，正值表示向右滚动，负值表示向左滚动。
  • int dy：表示垂直方向上的滚动偏移量，正值表示向下滚动，负值表示向上滚动。

调用此函数时，视图中的内容将按照指定的偏移量进行滚动，而不是直接改变视图的视口位置。这对于实现平滑滚动或动画滚动效果非常有用。

示例代码：

通过调用 scrollContentsBy() 函数，视图中的内容将向右滚动10个像素，向下滚动20个像素。注意，这不会改变视图本身的大小或位置，而是改变了视图中内容的相对位置。

63、void QGraphicsView::setOptimizationFlag(QGraphicsView::OptimizationFlag flag, bool enabled = true)

void QGraphicsView::setOptimizationFlag(QGraphicsView::OptimizationFlag flag, bool enabled = true) 是Qt图形视图框架（QGraphicsView）中的一个方法，用于设置优化标志，从而影响图形视图的渲染和更新行为，以提高性能或者满足特定需求。

参数说明：

  • QGraphicsView::OptimizationFlag flag：这是枚举类型，定义了多种优化选项，比如：

    • QGraphicsView::DontAdjustForAntialiasing：是否禁用针对抗锯齿的额外像素调整。
    • QGraphicsView::DontSavePainterState：是否允许画家状态的保存以减少开销。
    • QGraphicsView::IndirectPainting：启用间接绘制，可以提升复杂场景的性能，但可能会影响即时交互响应速度等。

  • bool enabled：决定是否启用指定的优化标志，true 表示启用该优化，false 表示禁用。

使用这个函数可以根据应用的具体情况开启或关闭某些优化特性，以平衡视觉质量和性能之间的关系。例如，如果你想要禁用抗锯齿相关的优化，可以这样做：

view.setOptimizationFlag(QGraphicsView::DontAdjustForAntialiasing, false);

这样会确保视图在渲染时考虑到抗锯齿效果，尽管这可能会增加渲染的计算成本。

64、void QGraphicsView::setRenderHint(QPainter::RenderHint hint, bool enabled = true)

void QGraphicsView::setRenderHint(QPainter::RenderHint hint, bool enabled = true) 是Qt的QGraphicsView类中的另一个方法，它用来设置视图中绘图引擎（QPainter）的渲染提示，这些提示能够影响到QPainter在绘制图形内容时的行为和质量。

参数说明：

  • QPainter::RenderHint hint：这是一个枚举类型，包含了多种渲染提示选项，如：

    • QPainter::Antialiasing：是否启用抗锯齿，使线条和形状边缘更加平滑。
    • QPainter::SmoothPixmapTransform：是否启用平滑图像变换，当缩放或旋转图像时保持高质量。
    • QPainter::HighQualityAntialiasing：启用高质量抗锯齿，可能更消耗资源但效果更好。
    • 等等其他多种渲染提示...

  • bool enabled：决定是否启用给定的渲染提示，true 表示启用该提示，false 表示禁用。

通过调用此函数并传入相应的渲染提示及其开关状态，您可以控制视图内部绘图过程的细节。例如，要启用抗锯齿功能，可以这样操作：

view.setRenderHint(QPainter::Antialiasing, true);

这样一来，在QGraphicsView所展示的内容上进行绘制时，将会采用抗锯齿技术来提升视觉效果。

65、void QGraphicsView::setScene(QGraphicsScene *scene)

void QGraphicsView::setScene(QGraphicsScene *scene) 是Qt框架中的一个函数，它是QGraphicsView类的一个成员方法。该函数用于将一个QGraphicsScene实例与QGraphicsView关联起来，即将场景设置到视图中显示。

参数说明：

  • QGraphicsScene *scene：指向QGraphicsScene对象的指针。这个场景包含了所有的二维图形项，如矩形、椭圆、图片、文本和其他自定义图形项。

使用此方法后，QGraphicsView会开始显示指定的QGraphicsScene中的所有内容，并且后续对场景中图形项的所有添加、删除或修改都会反映在视图上。

例如，如果你有一个已经创建好的QGraphicsScene对象 myScene，你可以将其设置为QGraphicsView myView 的显示场景：

QGraphicsScene *myScene = new QGraphicsScene();
// 对myScene添加元素或做其他配置...
myView.setScene(myScene);

这样，myView 将会显示 myScene 中的所有内容。

66、void QGraphicsView::setTransform(const QTransform &matrix, bool combine = false)

void QGraphicsView::setTransform(const QTransform &matrix, bool combine = false) 是Qt框架中 QGraphicsView 类的一个成员函数，用于设置视图的变换矩阵，从而实现对视图内容的缩放、旋转和平移等操作。

参数说明：

  • const QTransform &matrix：一个QTransform对象，它是一个3x3的矩阵，用于表示组合了缩放、旋转和平移等多种变换的操作。

  • bool combine = false：一个布尔值，表示是否将新指定的变换矩阵与当前视图的现有变换矩阵相结合。如果为 true，则新矩阵会与现有的视图变换相乘；如果为 false（默认值），则会完全替换掉现有的视图变换。

示例代码：

QGraphicsView view;
QTransform transform;
transform.rotate(45); // 旋转45度
transform.scale(0.5, 0.5); // 缩小为原来的一半
view.setTransform(transform, false); // 替换视图的现有变换，只应用旋转和缩放

通过调用 setTransform 函数，你可以直接操控视图内容的整体变换，而不必分别调用 rotate、scale 和 translate 等方法。如果需要连续应用多个变换，可以设置 combine 参数为 true，以组合多次变换的效果。

67、void QGraphicsView::shear(qreal sh, qreal sv)

void QGraphicsView::shear(qreal sh, qreal sv) 是Qt GUI框架中 QGraphicsView 类的一个成员函数，用于对视图内容进行剪切（Shear）变换操作。

参数说明：

  • qreal sh：水平剪切因子，表示水平方向上的剪切程度。正值会使视图内容在水平方向上产生倾斜效果，负值会产生相反方向的倾斜。
  • qreal sv：垂直剪切因子，表示垂直方向上的剪切程度。正值会使视图内容在垂直方向上产生倾斜效果，负值会产生相反方向的倾斜。

示例代码：

QGraphicsView view;
// 假设已经设置了scene并显示了一些内容...

// 应用剪切变换，水平方向剪切因子为0.5，垂直方向剪切因子为-0.2
view.shear(0.5, -0.2);

通过调用 shear() 函数，视图中的内容将在水平和/或垂直方向上发生倾斜。请注意，剪切变换并不会改变视图本身的大小或位置，而是改变了视图中内容的形状和方向。

68、void QGraphicsView::showEvent(QShowEvent *event)

void QGraphicsView::showEvent(QShowEvent *event) 是Qt GUI框架中 QGraphicsView 类的一个重载函数，它属于Qt事件处理系统的一部分。当 QGraphicsView 对象变为可见状态时（例如，通过调用 show() 函数或其父窗口变为可见时），系统会自动发送一个 QShowEvent 事件，然后调用这个 showEvent 函数。

这个函数的主要作用是提供一个钩子，让你有机会在视图变得可见时执行一些自定义操作，例如初始化视图内容、调整视图大小或更新视图状态等。

示例代码：

class CustomGraphicsView : public QGraphicsView
{
protected:
    void showEvent(QShowEvent *event) override
    {
        // 在视图显示之前进行一些初始化或更新操作
        // ...
        
        // 调用父类的showEvent处理默认逻辑
        QGraphicsView::showEvent(event);
    }
};

在上述代码中，CustomGraphicsView 类重写了 showEvent 函数，在视图显示前添加了自定义逻辑，然后调用了父类 QGraphicsView 的 showEvent 函数，以确保默认的事件处理逻辑得以执行。

69、QSize QGraphicsView::sizeHint() const

QSize QGraphicsView::sizeHint() const 是Qt GUI框架中 QGraphicsView 类的一个成员函数，它返回一个建议的视图大小（QSize 类型）。这个大小是视图在布局管理器中没有明确指定大小时的理想大小，通常是根据视图内容和布局自动计算得出的。

返回值：

  • QSize 类型的对象，表示视图的最佳尺寸建议。

这个函数在视图需要自动调整大小或者需要根据内容生成合理尺寸时非常有用，例如在布局中使用动态大小的控件时。布局管理器会参考这个大小来安排视图的位置和尺寸。

虽然 sizeHint() 提供了一个默认的建议大小，但在实际开发中，你也可以通过覆盖这个函数来自定义视图的大小提示，以更好地适应你的程序需求。

#include <QApplication>
#include <QGraphicsView>
#include <QGraphicsScene>
#include <QVBoxLayout>
#include <QWidget>

// 自定义QGraphicsView类，重写sizeHint()
class CustomGraphicsView : public QGraphicsView {
public:
    QSize sizeHint() const override {
        // 假设我们基于视图中的内容大小给出一个自定义的sizeHint
        int contentWidth = scene()->itemsBoundingRect().width() + 20; // 加上一些额外边距
        int contentHeight = scene()->itemsBoundingRect().height() + 20;
        return QSize(contentWidth, contentHeight);
    }
};

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

    QWidget window;
    QVBoxLayout layout(&window);

    // 创建自定义视图
    CustomGraphicsView graphicsView;
    QGraphicsScene *scene = new QGraphicsScene(&graphicsView);
    
    // 添加一些内容到场景中，假设这会影响视图的sizeHint
    QGraphicsRectItem *item = scene->addRect(0, 0, 300, 200);
    
    graphicsView.setScene(scene);

    // 将视图添加到布局中，并且由于我们没有明确设置大小，布局将会询问视图的sizeHint
    layout.addWidget(&graphicsView);

    window.show();

    return app.exec();
}

在这个例子中，我们创建了一个继承自 QGraphicsView 的 CustomGraphicsView 类，并重写了 sizeHint() 函数。这个函数返回的是当前场景中所有项目边界框大小加上一定边距后的尺寸。当视图被添加到布局中而没有显式设置大小时，窗口会根据这个提示调整视图的大小。如果场景的内容发生变化，视图的大小也将相应更新，前提是布局允许其动态调整。

70、QTransform QGraphicsView::transform() const

QTransform QGraphicsView::transform() const 是Qt GUI框架中 QGraphicsView 类的一个成员函数，它返回一个表示当前应用于视图内容的变换矩阵（QTransform 类型）。这个变换矩阵可以包含缩放、旋转和平移等复合变换。

返回值：

  • QTransform 类型的对象，表示当前视图的总变换矩阵。

这个函数可以帮助你获取视图当前的变换状态，以便于在需要的时候还原或复制视图的变换效果。例如，如果你在视图上执行了一系列的缩放、旋转和平移操作，可以通过调用 transform() 函数获取当前的变换矩阵，然后在其他地方应用同样的变换。

QGraphicsView view;
//... 对view执行一系列的变换操作...

// 获取当前的变换矩阵
QTransform currentTransform = view.transform();

// 打印出变换矩阵的元素
qDebug() << "Current Transform Matrix:"
         << "\nScale X: " << currentTransform.m11()
         << "\nScale Y: " << currentTransform.m22()
         << "\nRotation: " << currentTransform.rotation()
         << "\nTranslation X: " << currentTransform.dx()
         << "\nTranslation Y: " << currentTransform.dy();

请注意，实际应用中可能需要根据具体的变换内容来解析和利用 QTransform 对象的属性。

71、void QGraphicsView::translate(qreal dx, qreal dy)

void QGraphicsView::translate(qreal dx, qreal dy) 是Qt GUI框架中 QGraphicsView 类的一个成员函数，它用于在当前视图的变换矩阵中添加一个平移变换。这个函数会使得视图内容在水平方向上平移 dx 个单位长度，在垂直方向上平移 dy 个单位长度。

参数说明：

  • qreal dx：表示在水平方向上的平移距离。
  • qreal dy：表示在垂直方向上的平移距离。

示例代码：

QGraphicsView view;
// 假设已经设置了scene并显示了一些内容...

// 向右平移50个单位长度，向下平移100个单位长度
view.translate(50, 100);

通过调用 translate() 函数，视图中的所有内容（包括图形项、背景等）都将按照指定的距离进行平移，但视图本身的大小和位置不会改变。这种变换是可以累加的，每次调用 translate() 都会在之前的变换基础上继续平移。

72、bool QGraphicsView::viewportEvent(QEvent *event)

bool QGraphicsView::viewportEvent(QEvent *event) 是Qt GUI框架中 QGraphicsView 类的一个重载函数，它处理与视口相关的事件。视口是 QGraphicsView 中实际显示 QGraphicsScene 内容的区域。

参数说明：

  • QEvent *event：指向事件对象的指针，这个事件是发生在视口区域内的。

当视口接收到一个事件时，该函数会被调用。它可以处理的事件类型包括但不限于键盘事件、鼠标事件、触控事件以及其他与视口有关的事件。

通过重写这个函数，你可以自定义对这些事件的处理方式。例如，如果你想要在视口接收到特定事件时执行特定操作，可以在 viewportEvent() 函数中添加相应的代码。

示例代码：

class CustomGraphicsView : public QGraphicsView
{
protected:
    bool viewportEvent(QEvent *event) override
    {
        if (event->type() == QEvent::MouseButtonPress)
        {
            QMouseEvent *mouseEvent = static_cast<QMouseEvent*>(event);
            // 处理鼠标按下事件
            // ...
        }

        // 如果你不处理这个事件，或者处理完毕后还想让Qt继续处理这个事件，
        // 则应该调用父类的viewportEvent函数
        return QGraphicsView::viewportEvent(event);
    }
};

在这个示例中，我们捕获了鼠标按下事件并对之进行处理。如果需要的话，还可以根据事件类型处理其他类型的事件。如果事件已经被处理，则返回 true；否则，返回 false，以便Qt框架进一步处理该事件。

73、QTransform QGraphicsView::viewportTransform() const

QTransform QGraphicsView::viewportTransform() const 是Qt GUI框架中 QGraphicsView 类的一个成员函数，它返回一个表示当前视图的视口变换矩阵（QTransform 类型）。这个矩阵描述了视口（即 QGraphicsView 的绘图区域）与场景之间的坐标映射关系，包括缩放、旋转和平移等变换。

返回值：

  • QTransform 类型的对象，表示当前视图的视口变换矩阵。

示例代码：

QGraphicsView view;
// 对视图进行一系列的缩放、旋转和平移操作...

// 获取当前视口变换矩阵
QTransform viewportTransform = view.viewportTransform();

// 打印出变换矩阵的元素
qDebug() << "Viewport Transform Matrix:"
         << "\nScale X: " << viewportTransform.m11()
         << "\nScale Y: " << viewportTransform.m22()
         << "\nRotation: " << viewportTransform.rotation()
         << "\nTranslation X: " << viewportTransform.dx()
         << "\nTranslation Y: " << viewportTransform.dy();

这个函数返回的变换矩阵可用于理解视图是如何展示场景内容的，也可以用于在不同视图间同步变换效果或者进行其他复杂的坐标转换计算。

74、void QGraphicsView::wheelEvent(QWheelEvent *event)

void QGraphicsView::wheelEvent(QWheelEvent *event) 是Qt GUI框架中的 QGraphicsView 类的一个重载事件处理函数。当用户在 QGraphicsView 视图上滚动鼠标滚轮时，会触发此事件。

参数说明：

  • QWheelEvent *event：指向一个 QWheelEvent 对象的指针，该对象包含了关于鼠标滚轮滚动事件的所有相关信息，如滚动的方向（向前还是向后）、滚动的角度数以及事件发生的坐标位置等。

默认情况下，QGraphicsView 会使用滚轮事件来实现视图的缩放功能。如果你想要自定义滚轮滚动行为，比如实现自己的缩放逻辑、平移或其他交互，可以通过覆盖这个函数并编写自定义事件处理代码来实现：

void MyGraphicsView::wheelEvent(QWheelEvent *event)
{
    // 默认处理，保持缩放功能
    QGraphicsView::wheelEvent(event);

    // 或者自定义处理
    if (event->delta() > 0) {
        // 滚轮向上滚动时的处理
        // 可能实现缩小视图、滚动页面或其他功能
    } else if (event->delta() < 0) {
        // 滚轮向下滚动时的处理
        // 可能实现放大视图、反向滚动或其他功能
    }

    // 阻止Qt应用默认的滚轮缩放行为（如果需要）
    event->accept();
}

请注意，当你接受（accept()）这个事件并提供了自定义处理逻辑后，Qt将不会执行默认的滚轮缩放行为。若不调用父类的 wheelEvent() 函数，则需要自己处理视图的缩放和平移等相关操作。

# qt # 开发语言
Logo
西安城市开发者社区

欢迎加入西安开发者社区！我们致力于为西安地区的开发者提供学习、合作和成长的机会。参与我们的活动，与专家分享最新技术趋势，解决挑战，探索创新。加入我们，共同打造技术社区！

更多推荐

cover

ChatGPT的Mac客户端正式发布了！Mac用户有福了

avatar 西安城市开发者社区
cover

微信公众号写作时必备的AI提示词（也称为指令或Prompt）

avatar 西安城市开发者社区
cover

猫头虎 最新 Linux 系统查看服务器温度的方法大全

avatar 西安城市开发者社区