Qt的QPainter详细介绍

这篇文章来源于自己在学习Qt的QPainter的过程中自己总结的QPainter的知识点。本人文笔有限，如有错误，大家评论区评论，一起学习，共同成长。

一、QPainter介绍

QPainter是Qt框架中的一个类，主要用于在各种设备上进行2D图形绘制，如窗口、位图、打印设备等。它提供了一系列绘图函数，可以实现绘制点、线、曲线、形状、文本、图像以及复杂的绘画操作。

使用QPainter进行绘图的基本步骤如下：

1. 创建一个QPainter对象。
2. 将QPainter与要绘图的设备（如QPixmap、QImage或QWidget）关联起来，通过调用begin()函数。
3. 使用QPainter提供的绘图函数进行绘图，如drawLine()、drawRect()、drawText()等。
4. 绘制完毕后，调用end()函数结束绘图并释放相关资源。

当你需要在自己定义的界面上面执行各种绘画操作时，使用这个类就行绘制，毕竟QT直接提供的Ui控件里面还是比较少的，如果你想实现自己的控件，可是重写里面的虚函数，进行绘制自己的控件。

使用方法：

QPainter painter(this); // 如果是在QWidget上绘图
painter.begin(myPixmap); // 如果是在QPixmap上绘图
painter.setPen(Qt::red); // 设置画笔颜色为红色
painter.drawRect(10, 10, 100, 100); // 绘制一个矩形
painter.drawText(50, 50, "Hello, Qt!"); // 绘制文本
painter.end();

二、构造函数

1、QPainter::QPainter(QPaintDevice *device)

QPainter::QPainter(QPaintDevice *device) 是 QPainter 类的一个构造函数，用于初始化一个新的 QPainter 对象，并将其与指定的 QPaintDevice 相关联。QPaintDevice 是所有可被 QPainter 绘制的设备的基类，它可以是一个窗口（例如 QWidget）、一个位图 (QPixmap 或 QImage) 或其他可绘制表面。当创建一个 QPainter 对象时，通过传入一个指向 QPaintDevice 的指针作为参数，就可以准备在这个设备上进行绘图操作了。然而，这只是准备阶段，实际的绘图工作（即上下文的激活）需要通过调用 QPainter::begin() 函数来开始。

示例：

// 假设我们有一个 QWidget 或 QPixmap 对象
QPixmap pixmap(width, height);
// 创建 QPainter 并关联到 QPixmap 上
QPainter painter(&pixmap);
// 确保绘图上下文已打开
if (!painter.isActive()) {
    painter.begin(&pixmap);
}
// 开始绘图操作...
painter.fillRect(0, 0, width, height, Qt::white);
painter.drawLine(0, 0, width, height);
// ...完成绘图后，关闭绘图上下文
painter.end();

注意，在Qt5之后，通常情况下可以直接在构造函数中初始化并开始绘图，但如果遇到设备不可用或者其他情况，仍然需要检查 painter.isActive() 的返回值并在必要时显式调用 begin() 函数。

2、QPainter::QPainter()

QPainter::QPainter() 是 QPainter 类的一个默认构造函数，它创建了一个没有关联任何 QPaintDevice 的画家对象。这个构造函数主要用于临时存储绘图状态或者在确定绘图设备之前先设置绘图属性等用途。

由于没有关联具体的绘图设备，使用此构造函数创建的 QPainter 对象并不能直接进行绘图操作。若要进行实际的绘图，必须后续调用 QPainter::begin(QPaintDevice*) 函数，将 QPainter 对象与一个有效的 QPaintDevice（如 QWidget、QPixmap 或 QImage）相关联。

// 创建一个未关联绘图设备的 QPainter 对象
QPainter painter;
// 获取绘图设备，比如一个 QWidget 或 QPixmap
QPixmap pixmap(width, height);
// 将 QPainter 与绘图设备关联并开始绘图
painter.begin(&pixmap);
// 开始执行绘图操作...
painter.fillRect(0, 0, width, height, Qt::white);
painter.drawLine(0, 0, width, height);
// 完成绘图后，结束绘图上下文
painter.end();

注意，如果可能，通常建议在构造 QPainter 时直接关联绘图设备，这样能简化代码且更直观地表达意图。上述例子中的构造方式常用于需要动态决定绘图设备或者在构造时绘图设备尚未准备好等情况。

3、QPainter::~QPainter()

析构函数就不讲了，就是为了销毁对象，防止出现内存泄漏和其他情况。

4、const QBrush &QPainter::background() const

const QBrush &QPainter::background()用于获取当前 QPainter 对象的背景刷（brush）。

在Qt的图形绘制系统中，QPainter 用于在各种 QPaintDevice（如窗口、视图、位图等）上执行绘画操作。背景刷定义了绘画区域的填充样式，例如纯色、渐变或者图案。

这个函数原型表明它返回的是一个指向 QBrush 的常量引用，这意味着你可以读取当前画笔的背景样式，但不能通过此函数修改背景刷。如果你想设置 QPainter 的背景刷，应该使用 QPainter::setBackground() 函数。

注意，不是所有的 QPaintDevice 都支持设置或获取背景刷，这主要取决于具体的绘图设备及其用途。在某些情况下，可能需要直接设置绘图设备本身的背景属性而非画笔的背景属性。

QPainter painter(this); // 创建一个在Widget 上绘图的 QPainter 对象

 // 设置画笔的背景颜色为蓝
 QBrush backgroundBrush(QColor(0, 0, 255)); // 蓝色背景刷
 painter.setBackground(backgroundBrush);

  // 获取当前设置的背景刷并验证
  const QBrush &currentBackground = painter.background();
  if (currentBackground.color() == QColor(0, 0, 255))
 {
     qDebug() << "当前背景刷颜色确实是蓝色";
 }

在这个例子中，我们首先创建了一个 QPainter 对象，并设置了它的背景刷为蓝色。然后，我们调用 painter.background() 来获取当前画笔的背景刷，并检查其颜色是否与预期一致。由于之前刚设置了蓝色背景刷，因此这里的检查应当返回正确的背景颜色。不过，在实际应用中，这样的验证步骤通常是多余的，除非你在代码的其他部分对背景刷进行了更改，需要确认当前设置的状态。

5、Qt::BGMode QPainter::backgroundMode() const

在Qt库中的QPainter类中，backgroundMode()函数用于获取画家（painter）对象当前的背景模式。这个模式决定了当进行绘画操作时，背景是如何处理的。Qt::BGMode 是一个枚举类型，包含了两种可能的背景模式：

• Qt::TransparentMode: 表示画家在绘画时不使用任何背景，即绘画区域下的像素将保持不变，呈现透明效果。

• Qt::OpaqueMode: 表示画家在绘画时会先填充一个背景色或者使用背景刷来填充绘画区域，然后再进行绘画操作。

QPainter painter(this);

    Qt::BGMode bgMode = painter.backgroundMode();

    if (bgMode == Qt::TransparentMode) {
        qDebug() << "The painter's background mode is set to transparent.";
    } else if (bgMode == Qt::OpaqueMode) {
        qDebug() << "The painter's background mode is set to opaque.";
    }

    // 若要更改背景模式
    painter.setBackgroundMode(Qt::OpaqueMode);

在上述代码中，backgroundMode()函数用于获取painter对象的背景模式，而setBackgroundMode()函数则用于设置新的背景模式。通过调整背景模式，可以控制绘画时如何处理底层已有的像素信息。

6、bool QPainter::begin(QPaintDevice *device)

在Qt框架中，QPainter::begin(QPaintDevice *device) 是一个成员函数，用于初始化并开始在一个指定的绘图设备（QPaintDevice）上进行绘画操作。QPainter 类是用来在各种支持绘图的设备（如窗口、位图、打印设备等）上进行二维图形绘制的核心类。

参数说明：

• QPaintDevice *device：指向绘图设备的指针。QPaintDevice 可以是QWidget、QPixmap、QImage或其他支持绘图的Qt对象。

函数功能：

• 开始一个新的绘图操作周期。在对任何设备进行绘图之前，必须首先调用 begin() 函数，这会将 QPainter 对象与指定的绘图设备关联起来。

返回值：

• 返回布尔值，如果成功开始绘图，则返回 true；否则返回 false，这通常意味着提供的绘图设备无效或者当前环境不支持绘图

QPixmap pixmap(200, 200);
QPainter painter;
if (!painter.begin(&pixmap)) {
    // 处理错误，无法开始绘图
} else {
    // 在这里进行绘图操作...
    painter.drawLine(0, 0, pixmap.width(), pixmap.height());
    painter.end(); // 绘制完成后，记得调用end()来结束绘画周期，并释放资源
}

在这个例子中，我们创建了一个 QPixmap 对象作为绘图设备，并尝试用 QPainter 在其上开始绘画。如果 begin() 成功，就可以执行绘图操作，最后别忘了调用 painter.end() 来结束绘图周期。

7、void QPainter::beginNativePainting()

QPainter::beginNativePainting() 是Qt库中的一个函数，它允许开发者直接访问底层绘图系统（例如Windows GDI、Mac OS X Quartz或者X11），进行原生的、非Qt抽象层的绘图操作。

功能描述： 当在QPainter对象上调用此函数后，Qt将暂时停止自身的绘图管理，进入“原生绘图模式”。这意味着你可以使用操作系统特定的API来进行绘图，从而利用这些API可能提供的额外性能或特性。一旦调用了 beginNativePainting()，直到调用 endNativePainting() 之前，所有通过Qt QPainter 进行的标准绘图操作都将被忽略。

使用场景：

• 当需要进行大量数据的高速渲染，且Qt的绘图引擎不足以满足性能需求时；
• 当需要使用特定于平台的功能或效果，而Qt API并未提供时。

注意点：

• 使用原生绘图时，要确保你知道如何正确使用目标平台的绘图API，并负责处理绘图状态和资源的管理。
• 必须配对调用 beginNativePainting() 和 endNativePainting() 函数，以确保Qt绘图系统的正常恢复。

QPainter painter(this); // 假设"this"是一个继承自QPaintDevice的Qt窗口组件
painter.beginNativePainting();

// 在这里进行原生绘图操作，例如使用Win32 GDI、Cocoa或XLib等
// ...

painter.endNativePainting();

8、QRectF QPainter::boundingRect(const QRectF &rectangle, int flags, const QString &text)

注：里面参数的QRectF、QRect等都是为了描述绘画区域的矩形。下面多个成员函数皆是如此，就不单独的拎出来解释了。

①QRect QPainter::boundingRect(const QRect &rectangle, int flags, const QString &text）

②QRect QPainter::boundingRect(int x, int y, int w, int h, int flags, const QString &text)

x:绘画矩形的左上角X轴坐标，y:绘画矩形的左上角Y轴坐标

w:绘画矩形的宽度。 h：绘画矩形的高度

③QRectF QPainter::boundingRect(const QRectF &rectangle, const QString &text, const QTextOption &option = QTextOption())

与上面的相同，重载函数，实现的功能是一样的，只不过是传参不一样，

 QTextOption &option = QTextOption()

QTextOption &option = QTextOption() 是一个函数参数的默认值设定。QTextOption 是 Qt 中的一个类，用于存储和控制文本布局的各种选项，如对齐方式、换行模式、阅读方向等。

在调用函数时，如果没有显式传入 QTextOption 对象，就会使用默认构造函数 QTextOption() 创建一个空的文本选项对象，其默认设置通常包括左对齐和无换行等。

QTextOption option;
option.setAlignment(Qt::AlignCenter);

QRectF rect = boundingRect("Hello, World!", option);

此函数用于计算你在一个矩形里面绘制文字需要的矩形范围，你需要传入目标矩形的位置和大小，文字的对齐标志，以及所要绘制的文字。

flags主要标志：

• Qt::AlignLeft
• Qt::AlignRight
• Qt::AlignHCenter
• Qt::AlignTop
• Qt::AlignBottom
• Qt::AlignVCenter
• Qt::AlignCenter
• Qt::TextSingleLine
• Qt::TextExpandTabs
• Qt::TextShowMnemonic
• Qt::TextWordWrap
• Qt::TextIncludeTrailingSpaces

// 创建或获取一个QPainter实例
QPainter painter;

// 设置字体和其他绘图属性
QFont font;
font.setFamily("Arial");
font.setPointSize(12);
painter.setFont(font);

// 要计算边界的文本
QString text = "Sample Text";

// 获取字体测量信息


// 计算文本的边界矩形，根据flags调整对齐方式
QRectF rectangle(QPoint(0, 0), QSize(200, 100)); // 假设的矩形区域
Qt::AlignmentFlag alignmentFlag = Qt::AlignCenter; // 示例对齐标志
QRectF boundingRect = painter.boundingRect(rectangle, alignmentFlag, text);

// boundingRect现在包含了文本在指定矩形内按照指定对齐方式绘制时所需的最小边界矩形

9、const QBrush &QPainter::brush() const

const QBrush &QPainter::brush() const 是Qt库中的一个成员函数，该函数属于 QPainter 类。QPainter 是Qt中的一个核心图形类，用于在各种设备上（如窗口、位图等）进行2D绘图操作。

函数解释：

此函数为只读（const）成员函数，其作用是从当前的 QPainter 对象中获取当前设置的画刷（brush）。QBrush 在Qt中是用来定义填充形状内部颜色和纹理的图形对象，它可以是纯色、渐变色或者图案

• 返回的是一个指向 QBrush 对象的常量引用，表示当前画家所使用的画刷属性。

这意味着当你调用此函数时，不会修改 QPainter 对象的状态，而是仅仅获取并返回当前正在使用的画刷设置，以便开发者能够检查或复制当前的填充样式。

10、QPoint QPainter::brushOrigin() const

QPoint QPainter::brushOrigin() const 是Qt库中的另一个 QPainter 类的成员函数。这个函数同样为只读（const）成员函数，它用于获取当前画刷（brush）的原点位置。

函数解释：

在Qt的图形系统中，QPainter 的 brushOrigin() 函数允许开发者获取当前画刷起始点的位置，这对于某些复杂的绘图操作比如使用自定义纹理或图案进行填充时非常有用。当设置了非默认的画刷原点后，画刷的纹理或图案会从该点开始应用到被绘制的形状上。

• 返回的是一个 QPoint 对象，表示当前画刷相对于绘图区域的原点坐标。

通过调用此函数，开发者可以了解或改变绘制时画刷起点的位置，进而影响图形的填充效果。

11、QRectF QPainter::clipBoundingRect() const

QRectF QPainter::clipBoundingRect() const 是Qt图形视图框架中 QPainter 类的一个成员函数。这个函数用于获取当前剪裁区域的有效边界矩形。

函数解释：

在图形绘制过程中，QPainter 提供了剪裁区域的功能，即只有在剪裁区域内才进行实际的绘图操作。clipBoundingRect() 函数是用来查询当前设置在 QPainter 上的剪裁区域所限定的最大边界矩形。

• 返回一个 QRectF 对象，表示当前剪裁区域的有效边界矩形。这个矩形是所有当前剪裁路径组合起来形成的最小包围矩形。

通过调用此函数，开发者能够了解到当前绘图上下文中的有效绘图区域大小和位置，这对于管理复杂绘图场景中的可见区域特别有用。如果你之前设置了剪裁区域，例如通过 QPainter::setClipRect() 或 QPainter::setClipPath() 等函数，则可以通过 clipBoundingRect() 来获取实际生效的剪裁范围。

#include <QPainter>
#include <QRectF>
#include <QDebug>

void drawClippedRectangle(QPainter &painter, QPointF center, qreal width, qreal height) {
    // 创建一个矩形并居中于给定坐标
    QRectF rect(center.x() - width / 2, center.y() - height / 2, width, height);

    // 设置剪裁区域，这里假设我们只允许在一个大矩形内绘制
    QRectF clippingRect(0, 0, 500, 500);
    painter.setClipRect(clippingRect);

    // 绘制矩形
    painter.fillRect(rect, Qt::red);

    // 获取当前剪裁区域的有效边界矩形
    QRectF clippedBounds = painter.clipBoundingRect();

    qDebug() << "Clipped bounding rectangle: " << clippedBounds;

    // 如果rect矩形部分或全部在剪裁区域内，则clippedBounds会反映这一情况
}

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

    // 假设我们有一个QWidget或者QPixmap等可以绘图的对象
    QWidget widget;
    widget.resize(800, 600);

    QPainter painter(&widget);

    // 调用函数来演示clipBoundingRect()的使用
    drawClippedRectangle(painter, QPointF(400, 300), 200, 150);

    widget.show();

    return app.exec();
}

在这个例子中，我们首先创建了一个 QPainter 对象并在一个窗口上绘图。然后定义了一个要绘制的矩形，并设定一个全局剪裁矩形。通过调用 painter.setClipRect(clippingRect)，我们限制了绘图的有效区域。最后，我们调用 painter.clipBoundingRect() 来获取当前剪裁后的有效边界矩形，并打印出来。这有助于理解实际被剪裁后能显示图形的区域大小。注意，在真实程序中，剪裁区域和绘制区域可能会动态变化。

12、QPainterPath QPainter::clipPath() const

QPainter::clipPath() 是Qt库中的一个方法，它用于获取当前QPainter对象的剪裁路径（而不是设置剪裁区域）。剪裁路径允许更复杂的不规则形状作为剪裁区域，而不局限于简单的矩形。

下面是一个使用 QPainter::clipPath() 和 QPainter::setClipPath() 的基本示例：

#include <QPainter>
#include <QPainterPath>
#include <QRectF>
#include <QDebug>

void drawClippedShape(QPainter &painter, QPointF center, qreal radius) {
    // 创建一个圆形路径
    QPainterPath circlePath;
    circlePath.addEllipse(center, radius, radius);

    // 设置剪裁路径
    painter.setClipPath(circlePath);

    // 创建一个矩形并居中于给定坐标
    QRectF rect(center.x() - 100, center.y() - 50, 200, 100);
    
    // 绘制矩形，超出圆形的部分将不会被绘制
    painter.fillRect(rect, Qt::red);

    // 获取当前剪裁路径的有效边界
    QPainterPath clippedPath = painter.clipPath();

    // 打印出剪裁路径的信息
    qDebug() << "Clipped path: " << clippedPath;
}

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

    QWidget widget;
    widget.resize(800, 600);

    QPainter painter(&widget);

    drawClippedShape(painter, QPointF(400, 300), 150);

    widget.show();

    return app.exec();
}

在这个例子中，我们首先创建了一个 QPainterPath 对象并添加了一个圆形路径。接着，我们使用 painter.setClipPath() 将该路径设置为绘图器的剪裁区域。当我们在剪裁区域内绘制矩形时，只有与剪裁路径（圆形）相交的部分会被绘制出来。最后，我们调用 painter.clipPath() 来获取当前的剪裁路径，并打印其信息。由于clipPath()是获取操作而非设置，所以通常在需要检查或重用当前剪裁区域的情况下使用它。

13、QRegion QPainter::clipRegion() const

QPainter::clipRegion() 是Qt图形框架中的一个函数，它返回当前 QPainter 对象的剪裁区域作为一个 QRegion 对象。剪裁区域定义了在后续绘图操作中可见的部分，即所有绘图操作仅限于剪裁区域内部。

当你在 QPainter 上设置了剪裁路径 (QPainter::setClipPath()) 或直接设置了剪裁区域 (QPainter::setClipRegion()) 后，可以调用此函数来获取当前生效的剪裁区域。这个剪裁区域可以是任意形状，但 QRegion 通常用来表示由多个矩形构成的复杂区域。

以下是使用 QPainter::clipRegion() 的简单示例：

#include <QPainter>
#include <QRegion>
#include <QRect>
#include <QDebug>

void printClipRegion(QPainter &painter) {
    // 获取当前的剪裁区域
    QRegion clipRegion = painter.clipRegion();

    // 输出剪裁区域包含的矩形数量和总面积
    qDebug() << "Clip region contains" << clipRegion.rectCount() << "rectangles";
    foreach (const QRect &rect, clipRegion.rects()) {
        qDebug() << "Rectangle: " << rect;
    }

    // 可以进一步处理clipRegion，例如合并其他区域或者应用到新的画布上
}

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

    QWidget widget;
    widget.resize(800, 600);

    QPainter painter(&widget);

    // 假设设置了一个剪裁区域
    QRegion customRegion({{100, 100}, {300, 300}}, QRegion::Ellipse);
    painter.setClipRegion(customRegion);

    // 获取并打印当前的剪裁区域
    printClipRegion(painter);

    widget.show();

    return app.exec();
}

在这个示例中，我们首先创建了一个 QRegion 对象并设置为圆形剪裁区域，然后通过 QPainter::clipRegion() 获取这个剪裁区域，并打印出其中包含的矩形信息。请注意，尽管我们设置的是一个圆形剪裁，但在 QRegion 中它将被近似表达为一系列矩形。

QRegion 是Qt框架中的一个类，它在Qt GUI模块中用于表示屏幕上的一个区域或一组相连的不规则区域。QRegion 主要用于窗口管理、绘图剪裁以及视图更新等场景，它可以精确地描述屏幕上任意形状和大小的区域，这些区域通常是通过合并、相减或相交矩形来构建的。

在Qt应用程序中，QRegion 类的主要用途包括：

1. 绘图剪裁：

   • 使用 QPainter::setClipRegion() 方法可以将 QRegion 设置为 QPainter 的剪裁区域，这样之后所有的绘图操作都将被限制在该区域内，超出区域的部分将不会被绘制。

2. 窗口管理：

   • 在窗口系统级别，QRegion 可用于定义窗口的可见部分，比如窗口的一部分需要透明或特殊处理时。

3. 视图刷新：

   • 当只需要更新窗口或控件的部分区域时，可以通过 QWidget::repaint() 函数传递一个 QRegion 对象，指定需要重新绘制的确切区域，从而提高性能，避免不必要的全窗口重绘。

4. 形状构建：

   • QRegion 可以从简单的矩形、多边形或者更复杂的几何形状构建，支持非矩形区域的描述，如圆形、椭圆或其他复合形状。

5. 区域操作：

   • 提供了一系列区域操作的方法，如合并 (unite()), 交集 (intersect()), 相减 (subtract()) 和异或 (eor()) 等，允许对多个区域进行组合和运算。

例如，你可以创建一个 QRegion 来代表一个窗口或控件内需要重绘的特定形状区域，或者限制 QPainter 在某个复杂形状内进行绘制，这些都是 QRegion 在实际开发中常见的应用场景。

14、QTransform QPainter::combinedTransform() const

在Qt图形视图框架中，QPainter::combinedTransform() 是一个成员函数，它返回当前QPainter对象的组合变换矩阵。这个组合变换包含了所有应用到画笔上的平移、缩放、旋转等几何变换效果。

当你使用 QPainter 进行绘制时，可能已经调用了诸如 translate(), scale(), 或 rotate() 等方法对画布进行了变换操作。每次调用这些方法都会累加到 QPainter 内部的变换矩阵上。combinedTransform() 就是用来获取并返回这个累加后的整体变换矩阵的，返回类型是 QTransform。

QTransform 是 Qt 中用于描述2D几何变换的类，它可以用来做各种线性和平面仿射变换。

QPainter painter(this); // 假设正在给一个 QWidget 绘制
painter.translate(50, 50); // 平移坐标系
painter.rotate(45); // 旋转坐标系
QTransform transform = painter.combinedTransform(); // 获取当前的组合变换矩阵

15、QPainter::CompositionMode QPainter::compositionMode() const

在Qt图形库中，QPainter::compositionMode() 是一个成员函数，用于获取当前QPainter对象的合成模式（Composition Mode）。合成模式决定了当新的像素颜色被绘入目标表面时，新颜色如何与已存在的背景颜色结合的方式。

QPainter::CompositionMode 枚举类型定义了一系列不同的合成模式，例如：

• CompositionMode_SourceOver（默认模式）：新像素颜色覆盖在原有颜色之上，但允许原背景透过新像素的透明部分。
• CompositionMode_Clear：清除目标区域的颜色。
• CompositionMode_Source：仅绘制源像素，忽略目标像素。
• CompositionMode_Destination：保留目标像素，忽略源像素。
• CompositionMode_SourceIn：只显示源像素与目标像素重叠的部分。
• 等等...

通过调用 QPainter::compositionMode() 函数，你可以得到当前设置的合成模式

16、QPaintDevice *QPainter::device() const

Painter::device() 是Qt框架中的一个成员函数，它是从 QPainter 类调用的，其作用是返回当前 QPainter 对象关联的 QPaintDevice 指针。

QPaintDevice 是所有可被 QPainter 绘制的设备的基类，它可以是一个窗口、图像、打印机或其他任何能够接受和展示图形输出的实体。当你创建一个 QPainter 对象并开始在某个设备上绘图时，这个设备就会与 QPainter 关联起来。

具体代码示例

QPainter painter;
// 假设我们正在一个QWidget或者QImage上绘图
QWidget *widget = new QWidget();
painter.begin(widget); // 或者 painter.begin(&image);

// 获取当前QPainter关联的绘图设备
QPaintDevice *device = painter.device();

// 使用完后记得结束绘图操作
painter.end();

在这个例子中，painter.device() 将会返回与 painter 相关联的 QWidget 的指针。这一功能在需要了解绘图上下文或者需要对绘图设备本身进行特定操作时十分有用。

17、const QTransform &QPainter::deviceTransform() const

QPainter::deviceTransform() 是Qt库中的一个成员函数，它属于 QPainter 类。这个函数用于获取当前 QPainter 对象在其关联的 QPaintDevice（绘图设备）上的设备转换矩阵。

当我们在不同的坐标系统之间绘图或者应用了各种变换（如缩放、旋转、平移等）时，deviceTransform() 返回的是当前绘图环境相对于底层绘图设备的实际坐标变换。这意味着它反映了所有应用于 QPainter 的累积变换效果。

使用此函数可以获取并分析当前绘图操作的几何变换状态，这对于复杂的图形处理和理解图形最终如何显示在屏幕上是非常有帮助的。返回值是一个常量引用到 QTransform 对象，因此不能直接修改，但可以用来复制或者进一步分析变换矩阵。

下面进入绘画的成员函数，你可以完成各种各样的绘画操作。

有些重载函数，只介绍一种方法就行，其他的只是传参不一样而已，比如QRect、QRectF、(int x,int y int width,int height)其目的都是为了传入一个矩形范围供使用。

18、void QPainter::drawArc(const QRectF &rectangle, int startAngle, int spanAngle)

QPainter::drawArc(const QRectF &rectangle, int startAngle, int spanAngle) 是 Qt 图形视图框架中 QPainter 类的一个成员函数，用于在给定矩形区域内绘制一段圆弧。

函数参数说明：

• const QRectF &rectangle： 指定要绘制圆弧的矩形区域。这个矩形框定了圆弧所在的椭圆边界，其中椭圆的中心位于矩形的中心，矩形的宽高分别对应椭圆的两个半径。

• int startAngle： 圆弧的起始角度，以度数表示，逆时针方向为正。0度代表从水平右侧开始（3点钟方向），角度会按照逆时针方向增加。

• int spanAngle： 圆弧所跨越的角度范围，同样以度数表示。正值表示逆时针方向，负值表示顺时针方向。例如，如果 spanAngle 为 90，则将绘制四分之一圆形的圆弧。

通过调用此函数，QPainter 将在指定矩形内按指定的起始角度和跨度角度绘制一段椭圆弧。这个功能通常用于创建饼状图、进度条或其他需要部分圆弧形状的用户界面元素。

QRectF rectangle(10.0, 20.0, 80.0, 60.0);
int startAngle = 30 * 16;
int spanAngle = 120 * 16;

QPainter painter(this);
painter.drawArc(rectangle, startAngle, spanAngle);

注：为什么要乘以16.你可以理解为QT当中将1度划分了16份，为了便于更加精确的绘画。

重载函数：

①void QPainter::drawArc(const QRect &rectangle, int startAngle, int spanAngle)

②void QPainter::drawArc(int x, int y, int width, int height, int startAngle, int spanAngle)

19、void QPainter::drawChord(const QRectF &rectangle, int startAngle, int spanAngle)

QPainter::drawChord(const QRectF &rectangle, int startAngle, int spanAngle) 同样是 Qt 图形视图框架中 QPainter 类的一个成员函数，它与 drawArc() 函数类似，但在绘制圆弧的基础上还会闭合这段圆弧，形成一个和弦（chord）形状。

参数含义与 drawArc() 函数相同：

• const QRectF &rectangle： 定义了要绘制和弦的矩形区域，该矩形框定了包含和弦的椭圆边界。

• int startAngle： 和弦起始的角度，单位是度，逆时针方向为正。起点同样是从矩形对应的椭圆水平右侧开始（即3点钟位置）。

• int spanAngle： 和弦所覆盖的角度范围，同样以度数表示，正负值决定了角度的旋转方向。

当调用此函数时，QPainter 不仅会在指定矩形内按指定的起始角度和跨度角度绘制一段椭圆弧，而且还会连接弧线的两端，形成一个闭合的多边形形状。这种图形常用于制作仪表盘指示器、图形按钮等具有封闭扇形区域的可视化组件。

QRectF rectangle(10.0, 20.0, 80.0, 60.0);
int startAngle = 30 * 16;
int spanAngle = 120 * 16;

QPainter painter(this);
painter.drawChord(rect, startAngle, spanAngle);

重载函数：

①、void QPainter::drawChord(int x, int y, int width, int height, int startAngle, int spanAngle)

②、void QPainter::drawChord(const QRect &rectangle, int startAngle, int spanAngle)

20、void QPainter::drawConvexPolygon(const QPointF *points, int pointCount)

QPainter::drawConvexPolygon(const QPointF *points, int pointCount) 是Qt图形库中的 QPainter 类的一个成员函数，用于绘制凸多边形。

参数说明如下：

• *const QPointF points： 这是一个指向 QPointF 对象数组的指针，其中包含了构成凸多边形的所有顶点坐标。QPointF 是Qt中的一个类，用来表示二维空间中的点，包含两个浮点数成员变量（x和y坐标）。

• int pointCount： 表示顶点的数量，即构成多边形的点有多少个。这些点按照顺序连接起来，形成了一个多边形，且这个多边形必须是凸的，即任意两点之间的连线都在多边形内部。

调用此函数时，QPainter 将会按照给定的点序列连续地绘制直线段，并自动闭合最后一个点到第一个点的边，从而完成整个凸多边形的绘制。这个函数在需要自定义形状、尤其是构建复杂的几何图形界面时非常有用。

static const QPointF points[4] = {
    QPointF(10.0, 80.0),
    QPointF(20.0, 10.0),
    QPointF(80.0, 30.0),
    QPointF(90.0, 70.0)
};

QPainter painter(this);
painter.drawConvexPolygon(points, 4);

重载函数：

①void QPainter::drawConvexPolygon(const QPolygonF &polygon)

②void QPainter::drawConvexPolygon(const QPoint *points, int pointCount)

③void QPainter::drawConvexPolygon(const QPolygon &polygon)

21、void QPainter::drawEllipse(const QRectF &rectangle)

QPainter::drawEllipse(const QRectF &rectangle) 是Qt图形框架中的 QPainter 类的一个成员函数，用于在绘图设备上绘制一个椭圆或者圆形。

参数说明：

• const QRectF &rectangle： 这是一个引用到 QRectF 对象，它定义了要绘制椭圆的边界矩形区域。QRectF 是Qt中的一个类，表示一个具有浮点坐标值的矩形区域，由左上角点的坐标 (x, y) 和矩形的宽度、高度决定。

当调用此函数时，QPainter 会在指定的矩形区域内绘制一个内切于该矩形的椭圆。如果矩形是正方形，则绘制出的是一个完美的圆形。通过这种方式，开发者可以灵活地定义椭圆的中心位置及其外接矩形的大小来精确控制所绘制椭圆的尺寸和位置。

QRectF rectangle(10.0, 20.0, 80.0, 60.0);

QPainter painter(this);
painter.drawEllipse(rectangle);

重载函数：

①void QPainter::drawEllipse(const QRect &rectangle)

②void QPainter::drawEllipse(int x, int y, int width, int height)

③void QPainter::drawEllipse(const QPointF &center, qreal rx, qreal ry)

④void QPainter::drawEllipse(const QPoint &center, int rx, int ry)

22、void QPainter::drawGlyphRun(const QPointF &position, const QGlyphRun &glyphs)

QPainter::drawGlyphRun(const QPointF &position, const QGlyphRun &glyphs) 是Qt图形库中 QPainter 类的一个成员函数，用于在绘图设备上绘制一系列预定义的字形（glyphs）。

参数说明：

• const QPointF &position： 这是一个二维浮点数点，代表所要绘制字形集合的起点位置。字形会从这个位置开始按照其内部定义的布局方式进行排列和绘制。

• const QGlyphRun &glyphs： 这是一个 QGlyphRun 类型的对象引用，包含了要绘制的一系列字形及其属性信息。QGlyphRun 结构体中存储了字体、字形索引、字形的位置偏移以及其它如颜色、笔刷等与字形绘制相关的属性数据。通常这些字形来自同一个字体，并且可能包含复杂的文本布局信息，比如连字、方向调整等。

当调用此函数时，QPainter 将依据提供的 QGlyphRun 对象中的具体字形信息，在指定的起始位置处绘制相应的字符形状。这通常用于更底层、更精细的文本绘制操作，尤其是在需要对单个字形有特殊控制需求的情况下。

#include <QPainter>
#include <QFont>
#include <QGlyphRun>
#include <QPointF>

// 创建一个QPainter实例
QPainter painter(yourPaintDevice); // yourPaintDevice 是你要在其上绘图的对象，可以是QPixmap、QWidget等

// 设置绘图字体
QFont font("Arial", 16);
painter.setFont(font);

// 创建QGlyphRun对象，例如我们想要绘制"Hello"这个词，但每个字母都有不同的颜色
QVector<QGlyphRun> glyphRuns;
for (int i = 0; i < 5; ++i) {
    QRawFont rawFont = font.toRawFont();
    QVector<quint32> glyphIndexes { 'H', 'e', 'l', 'l', 'o' }[i]; // 获取每个字母对应的字形索引
    QPointF offset(i * 10.0, 0); // 每个字形之间有一定间距
    QPen pen(QColor(qrand() % 256, qrand() % 256, qrand() % 256)); // 随机颜色
    QBrush brush(Qt::NoBrush); // 不填充字形内部
    QGlyphRun glyphRun(rawFont, glyphIndexes, offset, brush, pen);
    glyphRuns.append(glyphRun);
}

// 确定绘制起始位置
QPointF position(50, 50);

// 绘制字形集合
for (const auto &glyphRun : glyphRuns) {
    painter.drawGlyphRun(position, glyphRun);
    position += QPointF(10 + glyphRunAdvance(glyphRun), 0); // 假设glyphRunAdvance是一个获取字形宽度的方法
}

// 注意：这里glyphRunAdvance是一个假设存在的方法，实际代码中可能需要通过其他方式获取每个字形的宽度并更新位置

23、void QPainter::drawImage(const QRectF &target, const QImage &image, const QRectF &source, Qt::ImageConversionFlags flags = Qt::AutoColor)

QPainter::drawImage 是Qt库中的一个方法，它用于在指定的目标区域内绘制一个 QImage（即图像）的一部分或者全部。这个方法允许您将源图像的部分内容缩放、裁剪后复制到目标矩形区域中。

• const QRectF &target: 这是指定的目标矩形区域，在该区域内绘制图像。它是相对于当前画布坐标系的。

• const QImage &image: 这是要绘制的源图像对象。

• const QRectF &source: 可选参数，指定了从源图像中要使用的子区域。如果未提供，那么默认绘制整个图像。它的坐标是基于源图像的坐标系。

• Qt::ImageConversionFlags flags: 可选参数，用于指定图像转换时的选项，如颜色空间转换规则等。默认值是 Qt::AutoColor，这意味着Qt会尝试自动调整图像的颜色模式以适应当前画布。

Qt::ImageConversionFlags：

Qt::ImageConversionFlags 是Qt框架中的一个枚举类型，用于指定在图像转换或绘制过程中应用的特定行为，例如颜色空间转换、Alpha通道处理等。在 QPainter::drawImage() 函数或者其他涉及图像操作的方法中，可以使用这个标志来控制图像如何适应新的上下文。

以下是 Qt::ImageConversionFlag 枚举的一些常见成员：

1. Qt::AutoColor (默认值)：

   • 自动选择最佳的颜色转换方式。对于大多数情况，这是个合理的选择。

2. Qt::ColorOnly：

   • 只保留颜色信息，丢弃Alpha通道（透明度）。

3. Qt::MonoOnly：

   • 将图像转换为单色（黑白）。

4. Qt::PremultipliedAlpha：

   • 指示图像的像素颜色已预乘Alpha通道。在某些图形API中，这能提高性能和正确性。

5. Qt::IgnoreAspectRatio：

   • 在缩放图像时不保持原始宽高比，可能导致图像变形。

6. Qt::SmoothTransformation：

   • 如果需要对图像进行缩放，启用平滑插值算法，产生更高质量但可能更慢的缩放效果。

7. Qt::InvertRgb：

   • 反转RGB色彩分量。

结合这些标志，可以根据实际需求调整图像的显示和处理方式。在 QPainter::drawImage() 的调用中，通过设置合适的 flags 参数可以改变图像绘制的行为。

QImage sourceImage("path_to_your_image.jpg");
QRectF targetArea(10, 10, 200, 200); // 在画布上定位的目标区域
QRectF sourceRect(0, 0, sourceImage.width(), sourceImage.height()); // 源图像的全区域

QPainter painter(this); // 假设 "this" 是一个能够被绘图的QWidget或QPaintDevice子类
painter.drawImage(targetArea, sourceImage, sourceRect); // 将整个源图像绘制到目标区域内

// 或者只绘制源图像的一部分
QRectF partialSource(50, 50, 100, 100); // 只选取源图像中50,50坐标开始的100x100像素区域
painter.drawImage(targetArea, sourceImage, partialSource); 

在这个例子中，drawImage 方法首先会在目标矩形区域内绘制源图像的全尺寸内容或者部分区域的内容。如果源矩形与目标矩形大小不同，则图像会被相应地缩放以适应目标矩形的尺寸。

重载函数：

①void QPainter::drawImage(const QRect &target, const QImage &image, const QRect &source, Qt::ImageConversionFlags flags = Qt::AutoColor)

②void QPainter::drawImage(const QPoint &point, const QImage &image, const QRect &source, Qt::ImageConversionFlags flags = Qt::AutoColor)

③void QPainter::drawImage(const QRectF &rectangle, const QImage &image)

④void QPainter::drawImage(const QRect &rectangle, const QImage &image)

⑤void QPainter::drawImage(const QPointF &point, const QImage &image)

⑥void QPainter::drawImage(const QPoint &point, const QImage &image)

⑦void QPainter::drawImage(int x, int y, const QImage &image, int sx = 0, int sy = 0, int sw = -1, int sh = -1, Qt::ImageConversionFlags flags = Qt::AutoColor)

24、void QPainter::drawLine(const QLineF &line)

Painter::drawLine(const QLineF &line) 是Qt库中QPainter类的一个成员函数，用于在当前画布上绘制一条线段。该函数接受一个QLineF类型的参数，该参数代表了一条从起点到终点的线段。

• QLineF 是Qt中的一个类，它封装了二维坐标系中的浮点数线段，包括两个端点坐标。

例如，如果你有一个 QLineF 对象 myLine，其定义了两个点（起点和终点），你可以这样使用 drawLine 函数：

QLineF myLine(QPointF(10.0, 20.0), QPointF(50.0, 80.0)); // 创建一个从(10, 20)到(50, 80)的线段
QPainter painter(this); // 假设“this”是一个QWidget指针或其他支持绘画的对象
painter.drawLine(myLine); // 绘制这条线段

在这个例子中，QPainter 会在关联的窗口或者设备上下文中绘制出一条从坐标 (10.0, 20.0) 到 (50.0, 80.0) 的线段。在调用 drawLine 之前，通常需要确保已经正确初始化并开启了 QPainter，并且目标区域是可以进行绘画的。

重载函数：

①void QPainter::drawLine(const QLine &line)

②void QPainter::drawLine(int x1, int y1, int x2, int y2)

③void QPainter::drawLine(const QPoint &p1, const QPoint &p2)

④void QPainter::drawLine(const QPointF &p1, const QPointF &p2)

25、void QPainter::drawLines(const QLineF *lines, int lineCount)

QPainter::drawLines(const QLineF *lines, int lineCount) 是Qt图形视图框架中 QPainter 类提供的另一个成员函数，这个函数允许你一次性绘制多条线段。它接受两个参数：

1. const QLineF *lines：这是一个指向 QLineF 对象数组的指针，数组中的每个元素都代表一条线段，包含了每条线段的起点和终点坐标。

2. int lineCount：这是要绘制的线段数量。

通过调用此函数，你可以高效地连续绘制多条独立的线段。下面是一个示例：

QLineF lineArray[] = {
    QLineF(QPointF(10.0, 20.0), QPointF(50.0, 30.0)),
    QLineF(QPointF(60.0, 40.0), QPointF(80.0, 60.0)),
    // 更多线段...
};

const int numberOfLines = sizeof(lineArray) / sizeof(QLineF);

QPainter painter(this); // 假设“this”是一个QWidget指针或其他支持绘画的对象
painter.drawLines(lineArray, numberOfLines); // 绘制所有线段

在此示例中，lineArray 数组包含了几条 QLineF 对象，然后通过传递数组首地址和线段总数给 drawLines 函数，将这些线段一次性全部绘制在关联的画布上。

重载函数：

①void QPainter::drawLines(const QVector<QLineF> &lines)

②void QPainter::drawLines(const QPointF *pointPairs, int lineCount)

③void QPainter::drawLines(const QVector<QPointF> &pointPairs)

④void QPainter::drawLines(const QLine *lines, int lineCount)

⑤void QPainter::drawLines(const QVector<QLine> &lines)

⑥void QPainter::drawLines(const QPoint *pointPairs, int lineCount)

⑦void QPainter::drawLines(const QVector<QPoint> &pointPairs)

26、void QPainter::drawPath(const QPainterPath &path)

QPainter::drawPath(const QPainterPath &path) 是Qt库中的 QPainter 类的一个成员函数，用于在当前画布上绘制一个复杂的路径形状。QPainterPath 是 Qt 中用来定义任意形状（包括直线、曲线、椭圆等）的类，它可以组合成一个完整的路径。

当你调用 drawPath() 函数时，传入的是一个 QPainterPath 对象引用，该对象可能包含了多个子路径或图形元素。QPainterPath 可以构建非常复杂的矢量图形，包括填充区域、描边路径等。

下面是一个简单的使用示例：

// 创建一个QPainterPath对象，并添加一些路径元素
QPainterPath path;
path.moveTo(10, 10);
path.lineTo(100, 100);
path.quadTo(200, 0, 300, 100);
path.arcTo(250, 50, 100, 100, 90, -180);

// 创建并初始化一个QPainter对象
QPainter painter(this); // 假设“this”是一个QWidget指针或其他支持绘画的对象

// 开始绘画
painter.beginNativePainting(); // 如果需要原生绘图支持的话
// 或者 painter.begin(); // 对于标准Qt绘图

// 设置颜色和线宽等属性（如果需要）
painter.setPen(QPen(Qt::black, 2));

// 绘制路径
painter.drawPath(path);

// 结束绘画
painter.endNativePainting(); // 如果之前调用了 beginNativePainting()
// 或者 painter.end(); // 对于标准Qt绘图

在这个例子中，我们首先创建了一个 QPainterPath 并添加了几个路径元素，如移动到某点、画直线、画二次贝塞尔曲线和画弧线等。然后我们创建一个 QPainter 实例，并调用其 drawPath() 方法来把之前定义好的路径绘制到界面上。

27、void QPainter::drawPicture(const QPointF &point, const QPicture &picture)

QPainter::drawPicture(const QPointF &point, const QPicture &picture) 是Qt GUI框架中的一个函数，它允许在一个 QPainter 对象所关联的目标设备（如窗口、位图或者打印机）上绘制一个已记录的 QPicture 对象。

• const QPointF &point: 这是指定绘图起始位置的坐标点，QPointF 是Qt中的二维浮点数点类型，包含X和Y坐标值。在这里，drawPicture() 将按照给定点作为参考，将整个图片从该点开始绘制。

• const QPicture &picture: 这是一个引用类型的 QPicture 对象，它存储了一组图形命令序列，这些命令可以被回放以再现之前的绘图操作。你可以先用 QPainter 将一系列绘图操作记录到 QPicture 中，然后在任何地方通过 drawPicture() 函数一次性重播这些操作。

使用这个函数的一个典型场景可能是为了提高性能，预先记录下复杂的绘图过程，然后在需要显示时快速重绘，或者是在多个位置重复绘制相同的内容。例如：

// 创建并初始化一个QPicture对象
QPicture picture;
{
    QPainter painter(&picture);
    // 在painter上执行一系列绘图操作，例如：
    painter.drawRect(0, 0, 100, 100);
    painter.drawLine(0, 0, 100, 100);
}

// 创建一个QPainter并在目标设备上绘图
QPainter painter(this); // 假设“this”是一个支持绘画的QWidget指针
QPointF position(50, 50); // 指定绘图的起始位置

// 绘制已记录的QPicture
painter.drawPicture(position, picture);

在这个例子中，我们首先创建并初始化了一个 QPicture 对象，通过一个临时的 QPainter 对象在其上记录了一系列绘图命令。接着，在实际绘图阶段，我们创建了一个新的 QPainter 对象并指定了绘图的目标位置，最后调用 drawPicture() 函数将预记录的图形内容绘制到指定的位置。

重载函数：

①void QPainter::drawPicture(int x, int y, const QPicture &picture)

②void QPainter::drawPicture(const QPoint &point, const QPicture &picture)

28、void QPainter::drawPie(const QRectF &rectangle, int startAngle, int spanAngle)

void QPainter::drawPie(const QRectF &rectangle, int startAngle, int spanAngle) 是Qt图形框架中的一个方法，用于在指定的矩形区域内绘制饼图或者扇形区域。该函数接受三个参数：

• const QRectF &rectangle: 这个参数定义了要绘制饼图或扇形所在的矩形区域，包括其位置和大小。

• int startAngle: 开始角度，表示从矩形中心点顺时针方向起始的角度，单位是度数。在Qt中，角度是以16点制顺时针方向计量的，即0度位于3点钟方向，90度位于12点钟方向，以此类推。

• int spanAngle: 扇形的跨度角度，表示从开始角度到结束角度之间的角度范围。如果spanAngle等于360，则会绘制出一个完整的圆形饼图；如果spanAngle小于360，则会绘制出一个扇形。

示例代码：

QPainter painter(this);
QRectF rect(50, 50, 200, 200); // 创建一个中心在(50,50)，宽高为200的矩形区域
int startingAngle = 90*16; // 从90度（12点钟方向）开始
int arcSpan = 270*16; // 绘制一个跨越270度的扇形

painter.drawPie(rect, startingAngle, arcSpan);

上述代码将在指定的矩形区域内绘制一个起始于12点钟方向、跨越270度的扇形。

重载函数：

①void QPainter::drawPie(int x, int y, int width, int height, int startAngle, int spanAngle）

②void QPainter::drawPie(const QRect &rectangle, int startAngle, int spanAngle)

29、void QPainter::drawPixmap(const QRectF &target, const QPixmap &pixmap, const QRectF &source)

QPainter::drawPixmap 是Qt库中的一个方法，用于在当前QPainter所关联的QPaintDevice（如QWidget、QPixmap或QImage）上绘制一个QPixmap。该方法允许您将源QPixmap的部分或全部内容复制到目标区域。

• const QRectF &target: 指定要在目标设备上绘制QPixmap的目标矩形区域。这个矩形坐标是相对于目标设备的坐标系统的。

• const QPixmap &pixmap: 需要被绘制的QPixmap对象。

• const QRectF &source: （可选）指定从pixmap中需要被复制的源矩形区域。如果不指定或者设置为空矩形，则会默认复制整个pixmap的内容。这个矩形坐标是相对于pixmap自身的坐标系统的。

例如，如果您想要将一个QPixmap的一部分绘制到QWidget的特定区域内，可以这样使用：

QPixmap sourcePixmap("image.png");
QRectF targetRect(50, 50, 200, 200); // 目标区域在Widget上的位置和大小
QRectF sourceRect(0, 0, 100, 100);    // 源Pixmap中要使用的部分，左上角坐标为(0, 0)，宽高为100

QPainter painter(this); // 假设 "this" 是指向一个QWidget的指针
painter.drawPixmap(targetRect, sourcePixmap, sourceRect);

painter.end(); // 结束绘制

在这个例子中，我们将sourcePixmap中的一个100x100像素的区域绘制到了this（即QWidget）上的(50, 50)坐标开始的200x200像素的目标区域中。

重载函数：

①void QPainter::drawPixmap(const QRect &target, const QPixmap &pixmap, const QRect &source)

②void QPainter::drawPixmap(int x, int y, int w, int h, const QPixmap &pixmap, int sx, int sy, int sw, int sh)

③void QPainter::drawPixmap(int x, int y, const QPixmap &pixmap, int sx, int sy, int sw, int sh)

④void QPainter::drawPixmap(const QPointF &point, const QPixmap &pixmap, const QRectF &source)

⑤void QPainter::drawPixmap(const QPoint &point, const QPixmap &pixmap, const QRect &source)

⑥void QPainter::drawPixmap(const QPointF &point, const QPixmap &pixmap)

⑦void QPainter::drawPixmap(const QPoint &point, const QPixmap &pixmap)

⑧void QPainter::drawPixmap(int x, int y, const QPixmap &pixmap)

⑨void QPainter::drawPixmap(int x, int y, int width, int height, const QPixmap &pixmap)

30、void QPainter::drawPixmapFragments(const QPainter::PixmapFragment *fragments, int fragmentCount, const QPixmap &pixmap, QPainter::PixmapFragmentHints hints = PixmapFragmentHints())

QPainter::drawPixmapFragments() 函数是Qt图形库中用于精细控制 QPixmap 片段在画布上绘制方式的方法。它允许您将一个 QPixmap 拆分成多个片段，并分别指定每个片段的位置、大小和旋转角度等属性进行绘制。

• const QPainter::PixmapFragment *fragments：这是一个指向 QPainter::PixmapFragment 结构体数组的指针，其中包含了要绘制的 pixmap 的各个片段的属性（如位置、尺寸、旋转角度等）。每个片段都有自己的独立变换设置。

• int fragmentCount：表示 fragments 数组中的元素个数，即待绘制的 QPixmap 片段数量。

• const QPixmap &pixmap：要被拆分并按照片段属性绘制的原始图像。

• QPainter::PixmapFragmentHints hints（可选）：提供了额外的提示信息，影响片段绘制的行为。默认情况下不提供任何特殊提示。

QPainter::PixmapFragment 结构体可能包含的属性包括但不限于：

• rect：片段矩形区域，在 pixmap 中的相对位置和大小。
• source：在 pixmap 中的源区域，定义了实际从 pixmap 中取样的部分。
• transform：应用于片段的变换矩阵，可以包括平移、缩放和旋转。

通过 drawPixmapFragments() 方法，您可以实现复杂的图像拼接、变形以及动画效果，而不仅仅局限于简单的全图或矩形区域的绘制。

31、void QPainter::drawPoint(const QPointF &position)

QPainter::drawPoint() 是 Qt 图形视图框架中的一个函数，该函数用于在当前画布上绘制单个点。

• QPointF &position：这是 QPointF 类型的对象，它代表了要在画布上绘制点的二维坐标位置。QPointF 是 Qt 中的一个类，用来精确表示浮点坐标值。

使用此函数时，只需传入一个点的坐标，QPainter 就会在当前绘图设备（如 QWidget、QImage 或 QPrinter 等）上绘制一个像素点。这个点通常默认为单像素大小，颜色和样式取决于当前画笔 (QPen) 的设置。

QPainter painter(this); // 假设 this 是一个 QWidget 或者 QImage 等可绘图的对象
QPen pen(Qt::red); // 设置画笔颜色为红色
painter.setPen(pen); // 设置当前画笔
QPointF point(50.5, 75.3); // 创建一个浮点坐标点
painter.drawPoint(point); // 在 (50.5, 75.3) 位置绘制一个点

上述代码将在给定的QWidget或其他绘图表面的(50.5, 75.3)坐标处绘制一个红色的点。

重载函数：

①void QPainter::drawPoint(const QPoint &position)

②void QPainter::drawPoint(int x, int y)

32、void QPainter::drawPoints(const QPointF *points, int pointCount)

如果想在QPainter中一次性绘制多个可变大小的点，并且您有存储在QPointF数组中的点坐标及其对应大小（比如以某种方式关联了每个点的直径），您可以采取以下方式：

#include <QPainter>
#include <QPointF>

// 假设我们有一个点坐标数组以及对应的点大小数组
QVector<QPointF> points = {/*...*/};
QVector<int> pointSizes = {/*...*/};

// 确保点的数量和大小数量匹配
assert(points.size() == pointSizes.size());

QPainter painter(this);

for (int i = 0; i < points.size(); ++i) {
    painter.save();
    
    // 设置当前点的大小
    int size = pointSizes[i];
    painter.setBrush(Qt::red);
    painter.setPen(QPen(Qt::NoPen)); // 不画轮廓，只填充内部颜色
    painter.drawEllipse(points[i], size / 2, size / 2); // 绘制一个圆点，半径是点大小的一半

    painter.restore();
}

// 如果所有的点大小都相同，也可以先设置好画笔大小然后一次性绘制
// ...

请注意，在实际应用中，可能并没有直接提供给drawPoints()方法设置不同大小的功能。上述示例展示了如何遍历点坐标数组，并为每个点绘制一个具有相应大小的图形（这里以圆形为例）。如果需求是绘制固定大小而非可变大小的点，并且想要利用drawPoints()方法，那么它主要用于绘制等大小的标准像素点，无法改变单个点的尺寸。

重载函数：

①void QPainter::drawPoints(const QPolygonF &points)

②void QPainter::drawPoints(const QPoint *points, int pointCount)

③void QPainter::drawPoints(const QPolygon &points)

32、void QPainter::drawPolygon(const QPointF *points, int pointCount, Qt::FillRule fillRule = Qt::OddEvenFill)

QPainter::drawPolygon(const QPointF *points, int pointCount, Qt::FillRule fillRule = Qt::OddEvenFill) 是Qt库中的QPainter类的一个方法，该方法用于绘制并填充一个多边形。

• const QPointF *points：这是一个指向QPointF对象数组的指针，其中包含多边形顶点的坐标。每个QPointF对象都表示多边形的一个点，包含了x和y坐标。

• int pointCount：表示构成多边形的点的数量。数组中的前pointCount个QPointF对象将被用来定义多边形的边界。

• Qt::FillRule fillRule：这是可选参数，用于指定填充规则。默认值为Qt::OddEvenFill（奇偶填充规则）。另一个可能的值是Qt::WindingFill（非零环绕数填充规则）。这两种填充规则决定了如何确定多边形内部区域。

当调用此函数时，QPainter会根据给定的点集绘制出一个闭合的多边形，并且依据指定的填充规则对多边形内部进行填充。如果不需要填充只绘制轮廓，可以使用QPainter::drawPolyline()函数。

#include <QPainter>
#include <QPointF>
#include <QPaintEvent>

// 假设在某个QWidget子类（比如MyWidget）中重写paintEvent函数
void MyWidget::paintEvent(QPaintEvent *)
{
    // 创建一个QPainter对象，并设置其工作于本窗口
    QPainter painter(this);

    // 定义一个多边形的顶点
    QPointF polygonPoints[] = {
        QPointF(50, 50),
        QPointF(100, 100),
        QPointF(100, 30),
        QPointF(150, 50),
        QPointF(100, 70),
        QPointF(50, 50) // 最后一个点与第一个点相同，以闭合多边形
    };

    // 计算顶点数量
    int pointCount = sizeof(polygonPoints) / sizeof(polygonPoints[0]);

    // 使用默认的奇偶填充规则绘制并填充多边形
    painter.drawPolygon(polygonPoints, pointCount);

    // 或者，如果你要改变填充规则为非零环绕数填充
    // painter.drawPolygon(polygonPoints, pointCount, Qt::WindingFill);
}

// 注：实际应用中需要确保painter已经正确初始化且窗口已准备好绘图

在这个例子中，我们首先定义了一个六边形的顶点列表，并计算了顶点数量。然后，在paintEvent处理函数中创建一个QPainter实例，并使用drawPolygon函数绘制一个多边形，该多边形按照提供的点序列连接起来，并根据默认的奇偶填充规则（Qt::OddEvenFill）填充内部。如果你想使用非零环绕数填充规则，只需将最后一个参数改为Qt::WindingFill即可。

重载函数：

①void QPainter::drawPolygon(const QPolygonF &points, Qt::FillRule fillRule = Qt::OddEvenFill)

②void QPainter::drawPolygon(const QPoint *points, int pointCount, Qt::FillRule fillRule = Qt::OddEvenFill)

③void QPainter::drawPolygon(const QPolygon &points, Qt::FillRule fillRule = Qt::OddEvenFill)

33、void QPainter::drawPolyline(const QPointF *points, int pointCount)

同样地，对于QPainter::drawPolyline函数，它是用来绘制不封闭的折线段序列的，这里也给出一个C++代码示例：

#include <QPainter>
#include <QApplication>
#include <QPaintEvent>
#include <QPointF>
#include <QMainWindow>

class PolylineWidget : public QWidget
{
public:
    void paintEvent(QPaintEvent *)
    {
        QPainter painter(this);

        // 定义一系列QPointF对象作为折线的顶点
        QPointF polylinePoints[] = {
            QPointF(50, 50),
            QPointF(100, 100),
            QPointF(150, 50),
            QPointF(200, 80),
            QPointF(250, 120)
        };

        // 计算顶点数量
        int pointCount = sizeof(polylinePoints) / sizeof(polylinePoints[0]);

        // 设置线条颜色和宽度
        painter.setPen(QPen(Qt::black, 2)); 

        // 绘制折线
        painter.drawPolyline(polylinePoints, pointCount);
    }
};

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    PolylineWidget widget;
    widget.resize(300, 200); // 设置窗口大小以便能看见整个折线
    widget.show();
    return app.exec();
}

在这个示例中，我们定义了一系列的QPointF对象来构成一条折线，然后通过QPainter::drawPolyline方法把这些点连接起来形成一条连续但不闭合的线段。程序运行后，将在窗口上显示一条由给定点构成的折线。

重载函数：

①void QPainter::drawPolyline(const QPolygonF &points)

②void QPainter::drawPolyline(const QPoint *points, int pointCount)

③void QPainter::drawPolyline(const QPolygon &points)

34、void QPainter::drawRect(const QRectF &rectangle)

QPainter::drawRect 是Qt库中的一个函数，用于在QPainter上下文中绘制矩形。这个函数接收一个QRectF类型的引用作为参数，该类型是Qt中的一个类，表示一个具有浮点坐标值的矩形区域。

下面是使用 QPainter::drawRect 函数的基本示例：

#include <QPainter>
#include <QRectF>
#include <QWidget>

// 假设我们正在重写一个QWidget子类的paintEvent函数
void MyWidget::paintEvent(QPaintEvent *event)
{
    QPainter painter(this); // 创建一个QPainter对象，并将其关联到当前的QWidget

    // 创建一个QRectF实例，指定矩形的左上角坐标以及宽度和高度
    QRectF rectangle(50.0, 50.0, 100.0, 50.0); // 这将创建一个左上角位于(50,50)，宽100，高50的矩形

    // 设置笔刷和画笔属性（如颜色、宽度等）
    painter.setPen(Qt::blue); // 设置边框颜色
    painter.setBrush(Qt::white); // 设置填充颜色

    // 绘制矩形
    painter.drawRect(rectangle); // 在绘图设备上绘制指定的矩形区域

    // 可选：可以设置矩形是否填充，如果不填充则只需画出矩形框
    // painter.setBrush(Qt::NoBrush); // 不填充颜色，只画矩形边框
}

// ...

在这个例子中，QPainter::drawRect会按照给定的QRectF对象所定义的边界，在屏幕上绘制一个矩形图形。你可以通过设置QPainter对象的画笔(pen)和笔刷(brush)属性来控制矩形的线条颜色、粗细及填充色。如果需要绘制无填充的矩形框，可以清除笔刷设置或者设置笔刷为Qt::NoBrush。

重载函数：

①void QPainter::drawRect(int x, int y, int width, int height)

②void QPainter::drawRect(const QRect &rectangle)

35、void QPainter::drawRects(const QRectF *rectangles, int rectCount)

QPainter::drawRects 是 Qt GUI 库中的一个方法，用于一次性绘制多个矩形。该函数接收两个参数：

• const QRectF *rectangles： 指向一个 QRectF 类型数组的指针，该数组包含了要绘制的矩形集合。QRectF 是一个浮点数坐标矩形类，允许精确到小数点的坐标和尺寸。

• int rectCount： 表示 rectangles 数组中矩形的数量。

使用 QPainter::drawRects 可以高效地绘制一系列矩形，例如：

#include <QPainter>
#include <QRectF>
#include <QWidget>

// 假设我们仍在重写一个QWidget子类的paintEvent函数
void MyWidget::paintEvent(QPaintEvent *event)
{
    QPainter painter(this);

    // 创建包含多个QRectF的数组
    QRectF rectangles[] = {
        {50.5, 50.5, 100.0, 50.0}, // 第一个矩形
        {150.5, 75.5, 75.0, 100.0}, // 第二个矩形
        // 更多矩形...
    };
    int rectCount = sizeof(rectangles) / sizeof(rectangles[0]); // 计算矩形数量

    // 设置画笔属性
    painter.setPen(Qt::blue);
    painter.setBrush(Qt::white);

    // 一次性绘制所有矩形
    painter.drawRects(rectangles, rectCount);
}

// ...

在这个例子中，drawRects 方法将会按照给定的顺序和属性绘制数组中指定数量的矩形。每个矩形都有其独立的位置和大小信息。这种方法对于需要批量绘制大量矩形时非常有用，可以提高绘图效率。

重载函数：

①void QPainter::drawRects(const QVector<QRectF> &rectangles)

②void QPainter::drawRects(const QRect *rectangles, int rectCount)

③void QPainter::drawRects(const QVector<QRect> &rectangles)

36、void QPainter::drawRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize)

QPainter::drawRoundedRect 是Qt图形框架中的一个方法，该方法用于在 QPainter 上绘制圆角矩形。此函数接收三个主要参数和一个可选参数：

• const QRectF &rect：

  • 这是一个 QRectF 对象引用，它定义了要绘制的矩形区域的边界，包括其位置（左上角坐标）和尺寸（宽度和高度）。

• qreal xRadius：

  • 这是一个 qreal 类型的值，代表矩形各边水平方向上的圆角半径。

• qreal yRadius：

  • 同样是 qreal 类型，指定矩形各边垂直方向上的圆角半径。

• Qt::SizeMode mode = Qt::AbsoluteSize（可选）：

  • 这是一个枚举值，用于指定圆角半径是以绝对像素值还是相对矩形尺寸计算。默认值为 Qt::AbsoluteSize，意味着传入的 xRadius 和 yRadius 是矩形圆角的绝对大小；如果设置为 Qt::RelativeSize，则这些半径会被解释为相对于矩形宽高的百分比。

示例代码：

#include <QPainter>
#include <QRectF>
#include <QWidget>

class MyWidget : public QWidget {
protected:
    void paintEvent(QPaintEvent *event) override {
        QPainter painter(this);
        painter.setPen(Qt::black);
        painter.setBrush(Qt::white);

        // 创建一个带有圆角的矩形
        QRectF rect(10, 10, 200, 100);
        qreal radius = 20.0; // 圆角半径为20像素
        painter.drawRoundedRect(rect, radius, radius); // 使用默认的 AbsoluteSize 模式

        // 或者使用相对大小
        QRectF rect2(300, 10, 200, 100);
        qreal relativeRadius = 0.2; // 相对圆角半径为矩形宽度或高度的20%
        painter.drawRoundedRect(rect2, relativeRadius, relativeRadius, Qt::RelativeSize);
    }
};

// ...

通过调用 drawRoundedRect 方法，可以很方便地在屏幕上绘制出具有指定圆角半径的矩形。

重载函数：

①void QPainter::drawRoundedRect(int x, int y, int w, int h, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize)

②void QPainter::drawRoundedRect(const QRect &rect, qreal xRadius, qreal yRadius, Qt::SizeMode mode = Qt::AbsoluteSize)

37、void QPainter::drawStaticText(const QPointF &topLeftPosition, const QStaticText &staticText)

QPainter::drawStaticText() 是Qt框架中的一个函数，用于在画布上绘制预处理过的静态文本。这个函数可以帮助提高大量重复绘制相同文本时的性能，因为QStaticText对象会在创建时预先分析并优化字体和布局信息。

• topLeftPosition：这是一个QPointF对象，表示要绘制的静态文本左上角的位置坐标。

• staticText：这是一个QStaticText对象，它包含了要绘制的文本内容以及相关的字体、颜色和其他样式属性。在创建QStaticText对象时就已经完成了文本的预处理工作，这样当通过drawStaticText()函数绘制时，能够更高效地渲染文本。

// 创建一个QStaticText对象
QStaticText staticText("Hello, World!");
staticText.setFont(QFont("Arial", 16));
staticText.setColor(Qt::blue);

// 创建一个QPainter对象，并假设已设置好绘图设备等信息
QPainter painter(this);

// 绘制静态文本到窗口的某个位置，如(10, 20)
QPointF topLeft(10, 20);
painter.drawStaticText(topLeft, staticText);

重载函数：

①void QPainter::drawStaticText(const QPoint &topLeftPosition, const QStaticText &staticText)

②void QPainter::drawStaticText(int left, int top, const QStaticText &staticText)

38、void QPainter::drawText(const QRectF &rectangle, int flags, const QString &text, QRectF *boundingRect = nullptr)

QPainter::drawText() 是Qt中的一个方法，用于在一个指定的矩形区域内绘制纯文本字符串。

• const QRectF &rectangle: 这个参数指定了要绘制文本的矩形区域。
• int flags: 这是一个标志位集合，可以包含如Qt::Alignment这样的对齐方式，用于控制文本在矩形内的位置和方向。
  • Qt::AlignLeft
  • Qt::AlignRight
  • Qt::AlignHCenter
  • Qt::AlignJustify
  • Qt::AlignTop
  • Qt::AlignBottom
  • Qt::AlignVCenter
  • Qt::AlignCenter
  • Qt::TextDontClip
  • Qt::TextSingleLine
  • Qt::TextExpandTabs
  • Qt::TextShowMnemonic
  • Qt::TextWordWrap
  • Qt::TextIncludeTrailingSpaces

• const QString &text: 这是要绘制的文本字符串。
• QRectF *boundingRect = nullptr: 可选参数，如果提供了非空指针，则该方法会在绘制文本后填充该矩形变量，存储实际绘制文本所占据的边界框。

例如，如果你想要在窗口中央水平居中绘制一段文本，你可以这样做：

QPainter painter(this);
QString text = "Hello, World!";
QRectF rect(QPoint(0, 0), QSize(width(), height()));
rect.adjust(width() / 4, height() / 4, -width() / 4, -height() / 4); // 调整矩形使其居中
painter.drawText(rect, Qt::AlignCenter, text);

重载函数：

①void QPainter::drawText(const QPointF &position, const QString &text)

②void QPainter::drawText(const QPoint &position, const QString &text)

③void QPainter::drawText(int x, int y, const QString &text)

④void QPainter::drawText(const QRect &rectangle, int flags, const QString &text, QRect *boundingRect = nullptr)

⑤void QPainter::drawText(int x, int y, int width, int height, int flags, const QString &text, QRect *boundingRect = nullptr)

⑥void QPainter::drawText(const QRectF &rectangle, const QString &text, const QTextOption &option = QTextOption())

他与drawStaticText区别：

Painter::drawText() 和 QPainter::drawStaticText() 都是Qt库中用于在画布上绘制文本的方法，但它们之间有一些重要的区别：

QPainter::drawText()

• 动态绘制：每次调用都会重新计算文本布局，包括字体、大小、颜色以及基于给定参数（如矩形区域、对齐方式等）的文本排版。
• 支持高级特性：能够处理复杂的文本布局，比如自动换行、文本方向调整、多行文本绘制、以及通过标志来设定对齐方式等。
• 性能：对于频繁变化的文本内容，尤其是内容、样式或尺寸经常变动的情况下，性能可能不如drawStaticText()。

QPainter::drawStaticText()

• 静态绘制：用于绘制预先计算好布局的文本，即QStaticText对象。当创建QStaticText对象时，会预编译文本格式并优化布局，从而提高绘制性能。
• 提高性能：特别适合那些内容、样式和布局不变，需要大量重复绘制的情况，因为它避免了每次绘制时的布局计算开销。
• 不支持所有drawText()的复杂特性：例如，不支持动态改变文本属性（如颜色或字体），也不支持完全的自动换行（虽然可以通过手动分段来模拟）。其优势在于一旦设置了文本和相关属性，后续绘制将非常高效。

总结来说，如果你需要绘制的内容每次都可能变化或者需要更灵活的文本布局选项，应该使用drawText()；而在场景中存在大量不变的静态文本，为了提升性能，可以选择使用drawStaticText()

39、void QPainter::drawTiledPixmap(const QRectF &rectangle, const QPixmap &pixmap, const QPointF &position = QPointF())

QPainter::drawTiledPixmap() 是Qt图形视图框架中的一个方法，它用于在一个指定的矩形区域内重复绘制一个给定的 QPixmap 图像，以达到平铺效果。

• const QRectF &rectangle：这是要在画布上绘制平铺图像的目标矩形区域。

• const QPixmap &pixmap：要平铺的 QPixmap 对象，这个图像会被重复填充到目标矩形内，直到填满整个矩形区域。

• const QPointF &position = QPointF()：可选参数，表示相对于矩形左上角开始平铺的起始位置。默认值为 (0, 0)，这意味着从矩形的左上角开始平铺。

该函数会按照 pixmap 的原始大小作为单元格，无缝地重复排列这些单元格以填充指定的 rectangle 区域。这对于背景图案填充、制作纹理背景等场景非常有用。

// 首先，创建一个包含背景图案的 QPixmap
QPixmap tile(32, 32); // 假设这是一个 32x32 像素的方格图案
tile.fill(QColor("lightgray")); // 假设图案是一个浅灰色背景，也可以加载自文件或其他方式创建更复杂的图案

// 然后，在重写 QWidget 的 paintEvent 中进行绘制
void MyWidget::paintEvent(QPaintEvent *event)
{
    QPainter painter(this); // 创建 QPainter 对象并关联到当前窗口

    // 定义需要填充的大矩形区域，这里假设窗口大小为 640x480
    QRectF rect(0, 0, width(), height());

    // 使用 drawTiledPixmap 方法平铺背景图案
    painter.drawTiledPixmap(rect, tile); // 默认从左上角开始平铺

    // 继续绘制其他组件...
}

// 或者，如果想从特定的位置开始平铺
QPointF startPosition(10, 10);
painter.drawTiledPixmap(rect, tile, startPosition); // 从(10, 10)位置开始平铺

重载函数：

①void QPainter::drawTiledPixmap(int x, int y, int width, int height, const QPixmap &pixmap, int sx = 0, int sy = 0)

②void QPainter::drawTiledPixmap(const QRect &rectangle, const QPixmap &pixmap, const QPoint &position = QPoint())

40、bool QPainter::end()

bool QPainter::end() 是Qt GUI库中 QPainter 类的一个成员函数，它的作用是结束当前的绘图操作，并从与之关联的绘图设备（如 QWidget、QPixmap 或 QImage）分离 QPainter 对象。一旦调用了 end() 函数，就不能再通过同一个 QPainter 对象在该绘图设备上继续进行绘图，直到再次调用 begin() 并重新关联。

此函数的返回值类型为布尔型，一般情况下，它会返回 true 表示成功结束了绘图操作并正确释放了资源。如果在结束绘图时发生错误，可能会返回 false，但这在正常情况下是比较少见的。

使用示例：

QPainter painter;
if (painter.begin(myPixmap)) {
    // 在myPixmap上进行绘图操作...
    
    // 完成绘图后关闭画家
    if (!painter.end()) {
        // 处理结束绘图失败的情况
        qDebug() << "Error ending the painter operation.";
    }
} else {
    // 如果未能开始绘图，处理相应错误
    qDebug() << "Failed to begin painting on the pixmap.";
}

41、void QPainter::endNativePainting()

QPainter::endNativePainting() 是Qt库中的一个函数，它主要用于结束原生平台相关的绘画操作。在某些情况下，当您需要混合使用Qt的图形引擎和底层操作系统提供的原生绘图功能时，这个函数就显得非常重要。

当你调用 QPainter::beginNativePainting() 后，Qt的图形系统暂时停止管理画布，并允许你直接对底层窗口或设备上下文进行原生API级别的绘画。执行完原生绘图后，你应该调用 QPainter::endNativePainting() 来恢复Qt的图形引擎对绘图操作的控制。

使用这两个函数的典型场景是在跨平台应用开发中，需要利用特定平台（如Windows、Mac OS X或Linux）的特殊图形特性或硬件加速能力的时候。调用 endNativePainting() 后，Qt将继续跟踪所有后续的QPainter绘图操作，确保与之前非原生绘图部分无缝衔接。

42、void QPainter::eraseRect(const QRectF &rectangle)

QPainter::eraseRect(int x, int y, int width, int height) 是Qt库中的一个函数，用于清除指定矩形区域内的像素。当在一个已有的绘图设备（如QPixmap、QImage或QWidget）上使用QPainter进行绘图时，你可以调用此函数来擦除一块特定的矩形区域，将其填充为当前背景色（即QPainter::background()所返回的颜色）。

• x：矩形左上角的X坐标。
• y：矩形左上角的Y坐标。
• width：待擦除矩形区域的宽度。
• height：待擦除矩形区域的高度。

通过调用该函数，可以快速清空或重置指定区域，以便于后续的绘图操作。如果你想要清除到透明或者其他特定颜色，可能需要先设置好背景模式或者填充相应的颜色。

#include <QPainter>
#include <QWidget>

// 假设CustomWidget是一个继承自QWidget的类
class CustomWidget : public QWidget {
public:
    void clearRectangle(int x, int y, int w, int h) {
        // 获取当前窗口的画布
        QPainter painter(this);

        // 设置背景色，这里假设背景色是白色
        painter.setBackground(QColor("white"));

        // 擦除指定矩形区域
        painter.eraseRect(x, y, w, h);

        // 画家结束工作，自动提交所有更改
        painter.end();
    }
};

// 使用示例
int main(int argc, char *argv[]) {
    QApplication app(argc, argv);

    CustomWidget widget;
    widget.show();

    // 清除窗口内(50, 50)位置开始，宽高为100像素的矩形区域
    widget.clearRectangle(50, 50, 100, 100);

    return app.exec();
}

在这个例子中，clearRectangle 方法在 CustomWidget 上使用 QPainter 对象来擦除指定的矩形区域，使其变为背景色（这里是白色）。这样，在窗口显示时，该矩形区域内的原有内容会被背景色覆盖掉。

重载函数：

①void QPainter::eraseRect(int x, int y, int width, int height)

②void QPainter::eraseRect(const QRect &rectangle)

43、void QPainter::fillPath(const QPainterPath &path, const QBrush &brush)

QPainter::fillPath(const QPainterPath &path, const QBrush &brush) 是Qt图形框架中的一个函数，用于填充指定的QPainterPath路径区域，所使用的填充颜色或者图案由QBrush对象决定。QPainterPath可以包含任何复杂的矢量形状，如直线、曲线、多边形等。

下面是一个使用QPainter::fillPath()方法的基本示例：

#include <QPainter>
#include <QPainterPath>
#include <QBrush>
#include <QWidget>

// 假设我们有一个自定义的QWidget子类
class CustomWidget : public QWidget {
public:
    CustomWidget(QWidget *parent = nullptr) : QWidget(parent) {}

protected:
    void paintEvent(QPaintEvent *) override {
        QPainter painter(this);

        // 创建一个路径，例如一个圆形
        QPainterPath path;
        path.addEllipse(50, 50, 100, 100); // 在(50,50)坐标处创建一个半径为50的圆

        // 创建一个画刷，例如设置为红色纯色填充
        QBrush brush(Qt::red);

        // 使用画刷填充路径区域
        painter.fillPath(path, brush);
    }
};

// 主程序部分...
int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    
    CustomWidget widget;
    widget.show();

    return app.exec();
}

在这个例子中，当CustomWidget组件需要重绘时（例如窗口初次显示或发生重绘事件），paintEvent方法会被调用。在此方法内部，我们首先创建了一个QPainter对象，并定义了一个圆形的QPainterPath。然后，我们创建了一个红色的QBrush，最后通过painter.fillPath()方法将这个圆形路径区域填充为红色。这样，在窗口上就会显示出一个红色的圆形。

44、void QPainter::fillRect(const QRectF &rectangle, const QBrush &brush)

QPainter::fillRect(const QRectF &rectangle, const QBrush &brush) 是Qt库中 QPainter 类的一个成员函数，用于在给定的矩形区域内填充颜色或图案。这个函数接受两个参数：

1. const QRectF &rectangle： 这个参数是指定要填充的矩形区域，它是一个浮点数版本的矩形（QRectF 类型），允许更精确的坐标和尺寸，尤其适用于高DPI环境或需要更高精度的情况。

2. const QBrush &brush： 这个参数是用来填充矩形区域的画刷对象，QBrush 可以设置为纯色、渐变色、纹理或者其他模式。当你用不同的画刷填充矩形时，矩形区域内的颜色或图案将会根据画刷的设定来表现。

#include <QPainter>
#include <QBrush>
#include <QRectF>
#include <QWidget>

// 假设我们有一个自定义的QWidget子类
class CustomWidget : public QWidget {
public:
    CustomWidget(QWidget *parent = nullptr) : QWidget(parent) {}

protected:
    void paintEvent(QPaintEvent *) override {
        QPainter painter(this);

        // 定义一个矩形区域
        QRectF rectangle(50.0, 50.0, 100.0, 100.0); // (50,50)坐标处，宽100，高100的矩形

        // 创建一个画刷，例如绿色纯色填充
        QBrush brush(Qt::green);

        // 使用画刷填充矩形区域
        painter.fillRect(rectangle, brush);
    }
};

// 主程序部分...
int main(int argc, char *argv[]) {
    QApplication app(argc, argv);
    
    CustomWidget widget;
    widget.resize(300, 300); // 设置窗口大小以便看到效果
    widget.show();

    return app.exec();
}

在这个示例中，当自定义的 CustomWidget 组件重绘时，会在其内部创建一个从(50,50)开始，宽高均为100的矩形，并使用绿色画刷填充该矩形区域。最终在窗口上会显示出一个绿色的正方形。

重载函数：

①void QPainter::fillRect(int x, int y, int width, int height, const QBrush &brush)

②void QPainter::fillRect(const QRect &rectangle, const QBrush &brush)

③void QPainter::fillRect(const QRectF &rectangle, const QColor &color)

④void QPainter::fillRect(int x, int y, int width, int height, const QColor &color)

⑤void QPainter::fillRect(const QRect &rectangle, const QColor &color)

⑥void QPainter::fillRect(int x, int y, int width, int height, Qt::GlobalColor color)

⑦void QPainter::fillRect(const QRect &rectangle, Qt::GlobalColor color)

⑧void QPainter::fillRect(const QRectF &rectangle, Qt::GlobalColor color)

⑨void QPainter::fillRect(int x, int y, int width, int height, Qt::BrushStyle style)

⑩void QPainter::fillRect(const QRect &rectangle, Qt::BrushStyle styhiyivoid QPainter::fillRect(const QRectF &rectangle, Qt::BrushStyle style)

11、void QPainter::fillRect(int x, int y, int width, int height, QGradient::Preset preset)

12、void QPainter::fillRect(const QRect &rectangle, QGradient::Preset preset)

13、void QPainter::fillRect(const QRectF &rectangle, QGradient::Preset preset)

Qt::GlobalColor 并不是一个类，而是一个枚举类型（enum），它是 Qt 框架中的一个预定义枚举，位于 Qt 命名空间内，用来表示一组标准的、全局通用的颜色。这些颜色包括基本颜色（如红、绿、蓝）、系统颜色（比如窗体背景、文本颜色等）、以及一些常见的灰阶和强调色。

例如，在 Qt 中，你可以直接使用 Qt::GlobalColor 枚举成员来指定颜色，无需每次都创建 QColor 对象。以下是 Qt::GlobalColor 枚举的一些典型值：

enum Qt::GlobalColor {
    Qt::black,
    Qt::white,
    Qt::darkGray,
    Qt::gray,
    Qt::lightGray,
    Qt::red,
    Qt::green,
    Qt::blue,
    Qt::cyan,
    Qt::magenta,
    Qt::yellow,
    // ... 更多颜色常量 ...
    Qt::transparent,
};

45、const QFont &QPainter::font() const

QPainter::font() 是Qt库中的一个函数，它是QPainter类的一个成员函数，用于获取当前关联到该QPainter对象的字体设置。这个函数是常量成员函数，意味着它不会改变QPainter对象的状态，并且返回的是一个指向QFont对象的常量引用。

当您在一个QPainter实例上调用font()时，它会返回当前在绘图操作中使用的字体描述符。QFont对象包含了字体的名称、大小、风格（斜体、粗体、下划线等）以及其他相关属性。

46、QFontInfo QPainter::fontInfo() const

QFontInfo 类在 Qt 库中用于提供有关字体的详细信息，而 QPainter::fontInfo() 是 QPainter 类的一个成员函数，其作用是获取与当前 QPainter 对象关联的字体的详细信息。

当在 QPainter 实例上调用 fontInfo() 函数时，它会返回一个 QFontInfo 对象，该对象包含了当前设置在 QPainter 上的字体的所有具体属性，如字体家族名称、点大小、是否为粗体、斜体、下划线等。

QPainter painter;
// 假设已经设置了 painter 的字体
// ...
QFontInfo fontInfo = painter.fontInfo();

// 现在你可以访问字体的各种信息
QString familyName = fontInfo.family(); // 获取字体家族名称
int pointSize = fontInfo.pointSize(); // 获取字体点大小
bool isBold = fontInfo.bold(); // 检查字体是否为粗体
bool isItalic = fontInfo.italic(); // 检查字体是否为斜体

这样，通过 QFontInfo 对象，您可以更加细致地了解和操作绘图时所使用的字体属性。

47、QFontMetrics QPainter::fontMetrics() const

QPainter::fontMetrics() 是 QPainter 类的一个常量成员函数，它返回一个 QFontMetrics 对象，该对象包含了与当前 QPainter 对象关联的字体的度量数据。

当你在使用 QPainter 进行图形绘制时，特别是涉及文字绘制时，调用 fontMetrics() 函数非常有用。这个函数不改变 QPainter 的状态，而是基于当前设置在 QPainter 上的字体返回相应的字体度量信息。

QFontMetrics 提供了一系列方法，例如：

• width(const QString &text)：返回指定字符串 text 在当前字体下的总宽度（像素）。
• height()：返回当前字体的总高度，通常是指一行文本的高度。
• ascent()：返回字体的上伸部高度，即从基线到字符最高点的距离。
• descent()：返回字体的下延部深度，即从基线到字符最低点的距离。
• boundingRect(const QString &text)：返回包含整个字符串的最小矩形区域，这对于确定文本绘制时所需的空间很有帮助。

QPainter painter(this);
painter.setFont(QFont("Arial", 12)); // 设置绘图字体和大小
QFontMetrics fm = painter.fontMetrics(); // 获取当前字体的度量信息

// 计算并绘制文本
int textWidth = fm.width("Hello, World!");
int textHeight = fm.height();
painter.drawText(10, 10, textWidth, textHeight, Qt::AlignLeft | Qt::AlignTop, "Hello, World!");

在这个例子中，首先设置了 QPainter 的字体，然后通过 fontMetrics() 获取字体的相关度量信息，接着利用这些信息来精确地定位和绘制文本。

48、bool QPainter::hasClipping() const

bool QPainter::hasClipping() const 是 QPainter 类的一个成员函数，用于检查当前 QPainter 对象是否启用了剪辑区域（clipping region）。当在 QPainter 上设置了剪辑区域后，所有后续的绘图操作都将限制在这个区域内，超出该区域的部分不会被绘制。

函数签名中的 const 表明这是一个只读操作，不会改变 QPainter 的内部状态。调用此函数会返回一个布尔值：

• 如果返回 true，表示当前 QPainter 对象已经设置了剪辑区域，并且正在进行剪辑操作。
• 如果返回 false，则表示当前没有启用任何剪辑区域，绘图操作将不受限制地在整个绘图设备（如 QWidget 或 QImage）上进行。

设置剪辑区域可以使用如 setClipRect()、setClipPath() 等函数实现，这对于精细控制绘图输出的位置和范围非常有用。

例如：

QPainter painter(widget);
QRect rect(10, 10, 100, 100); // 假设我们想要限制绘图在一个矩形区域内
painter.setClipRect(rect);

// 绘制某个形状，但只会显示在剪辑区域内
painter.drawLine(0, 0, 200, 200);

if (painter.hasClipping()) {
    qDebug() << "Clipping is enabled.";
} else {
    qDebug() << "Clipping is disabled.";
}

在此代码段中，我们首先设置了 QPainter 的剪辑区域为一个矩形，然后绘制了一条线，这条线只有部分会在剪辑区域内可见。最后，我们通过 hasClipping() 检查剪辑功能是否已启用。

49、bool QPainter::isActive() const

bool QPainter::isActive() const 是Qt GUI库中的 QPainter 类的一个成员函数，它用于检查当前的 QPainter 对象是否处于活动状态，也就是说，该画家对象是否关联到一个有效的绘图设备并且能够进行绘图操作。

在使用 QPainter 进行图形绘制时，只有当调用 begin() 成功关联到一个绘图表面（如 QWidget、QPixmap 或 QImage）后，isActive() 才会返回 true。如果画家对象未初始化或者已调用过 end() 结束绘图，则 isActive() 将返回 false。

这个函数常被用来作为安全检查，确保在进行任何绘图操作前，QPainter 实例是有效且可用的。例如：

QPainter painter;
if (painter.begin(myWidget)) {
    if (painter.isActive()) {
        // 现在可以安全地进行绘图操作
        painter.drawRect(0, 0, 100, 100);
    } else {
        // 处理无法激活画家的情况
        qDebug() << "Painter could not be activated.";
    }
    painter.end();
}

虽然通常情况下，在成功调用 begin() 方法后，isActive() 都会返回 true，但在某些特定情况下（比如绘图设备已经被销毁），即使调用了 begin()，也可能不活跃。因此，尽管在大多数实际应用中直接依赖 begin() 的返回值就足够了，但在需要更严谨错误检查的情况下，仍可使用 isActive() 来进一步验证。

50、Qt::LayoutDirection QPainter::layoutDirection() const

Qt::LayoutDirection QPainter::layoutDirection() const 是 QPainter 类的一个成员函数，用于获取当前 QPainter 对象的布局方向。

在国际化和本地化环境中，布局方向对于文本和控件的显示顺序至关重要。Qt::LayoutDirection 是一个枚举类型，它可以是以下两种值之一：

1. Qt::LeftToRight：表示从左到右的布局方向，这是大多数西方语言（如英语）的标准布局方向。
2. Qt::RightToLeft：表示从右到左的布局方向，适用于阿拉伯语、希伯来语等从右向左书写的语言。

当你需要知道当前绘图上下文的布局方向时，可以调用此函数，它将返回一个 Qt::LayoutDirection 枚举值，表明当前的布局方向。这对于正确绘制文本、按钮标签等内容十分必要，确保它们符合用户界面的语言习惯。例如：

QPainter painter(this);
Qt::LayoutDirection layoutDirection = painter.layoutDirection();
if (layoutDirection == Qt::LeftToRight) {
    // 执行针对从左到右布局的绘图操作
} else if (layoutDirection == Qt::RightToLeft) {
    // 执行针对从右到左布局的绘图操作
}

51、qreal QPainter::opacity() const

qreal QPainter::opacity() const 是 QPainter 类的一个成员函数，该函数用于获取当前 QPainter 对象的不透明度设置。

在 Qt 图形绘制系统中，QPainter 提供了控制绘图透明度的功能。opacity() 函数会返回一个 qreal 类型的数值，范围通常是从 0.0 到 1.0，其中：

• 0.0 表示完全透明，即任何通过 QPainter 绘制的内容都不会被看到。
• 1.0 表示完全不透明，绘图内容将以其原始颜色无损地显示。

调用这个函数可以帮助开发者了解当前绘图器在绘制图形或图像时的透明度设置，以便于调整后续的绘制效果或者进行相应的逻辑判断。例如：

QPainter painter(this);
painter.setOpacity(0.5); // 设置画家的不透明度为50%
qreal currentOpacity = painter.opacity(); // 获取当前的不透明度

52、QPaintEngine *QPainter::paintEngine() const

QPaintEngine *QPainter::paintEngine() const 是Qt框架中的 QPainter 类的一个成员函数。该函数用于获取与当前 QPainter 对象关联的 QPaintEngine 指针。

在Qt的图形系统中，QPainter 是高层的绘图抽象类，它负责处理所有绘图命令，而 QPaintEngine 是更低层的实现，具体负责将这些绘图命令转化为特定平台和硬件能够理解的形式并执行。

当你创建了一个 QPainter 对象并开始绘图操作时，Qt会自动为你分配一个合适的 QPaintEngine 实例。调用 paintEngine() 函数可以获取到这个底层引擎的指针，尽管在大多数情况下，开发者并不需要直接操作 QPaintEngine，但在某些复杂的自定义绘图需求或优化场景下，可能需要对绘图引擎进行更深入的定制和操控。例如，如果你想要扩展Qt的绘图能力或者调试底层绘图行为时，可能会用到此函数。

53、const QPen &QPainter::pen() const

const QPen &QPainter::pen() const 是Qt库中 QPainter 类的一个成员函数，其作用是从当前的 QPainter 对象获取当前设置的画笔（pen）。

在Qt的图形渲染系统中，QPainter 类用于在各种设备上（如窗口、位图、打印机等）进行二维图形绘制。画笔（QPen）决定了绘制线条的颜色、宽度、样式（如实线、虚线等）以及其他属性。

调用此函数不会改变 QPainter 的状态，它返回的是一个指向当前画笔配置的常量引用，这意味着你可以读取但不能通过这个引用修改画笔属性。若要更改 QPainter 使用的画笔，可以使用 QPainter::setPen(const QPen &pen) 函数来设置新的画笔属性。

54、QPainter::RenderHints QPainter::renderHints() const

Painter::renderHints() 是Qt框架中的 QPainter 类的一个成员函数，其功能是获取当前 QPainter 对象所设置的所有渲染提示（render hints）。

渲染提示是用来告知 QPainter 如何优化绘图操作的一系列标志。这些标志可以通过 setRenderHint() 函数进行设置，比如提高抗锯齿效果、使用文本平滑、实现OpenGL加速等。调用 renderHints() 函数会返回一个 QPainter::RenderHints 枚举类型的组合值，该值代表了当前已启用的所有渲染提示。

例如，可能的渲染提示包括：

• QPainter::Antialiasing：是否启用抗锯齿绘制。
• QPainter::TextAntialiasing：是否对文本启用抗锯齿绘制。
• QPainter::SmoothPixmapTransform：是否对平移或缩放的像素图启用高质量变换。
• QPainter::HighQualityAntialiasing：是否启用高质量抗锯齿。
• 等等。

#include <QPainter>

// 假设我们有一个QWidget的实例叫做myWidget
void setAndRetrieveRenderHints(QWidget *myWidget) {
    // 创建一个QPainter对象与myWidget关联
    QPainter painter(myWidget);

    // 设置渲染提示，例如启用抗锯齿和文本平滑
    painter.setRenderHint(QPainter::Antialiasing);
    painter.setRenderHint(QPainter::TextAntialiasing);

    // 获取当前设置的所有渲染提示
    QPainter::RenderHints currentHints = painter.renderHints();

    // 检查某个特定提示是否已启用
    bool isAntialiasingEnabled = (currentHints & QPainter::Antialiasing) != 0;

    // 继续进行绘画操作...
}

55、void QPainter::resetTransform()

QPainter::resetTransform() 是Qt库中的一个方法，它是QPainter类的一个成员函数，用于重置当前画笔的图形变换矩阵到单位矩阵，即撤销所有之前应用到画布上的缩放、旋转和平移等变换操作。

当你在使用 QPainter 对象绘制图形时，可能会对坐标系统进行各种变换以适应不同的布局或视角需求。一旦完成一组相关的变换和绘制后，调用 resetTransform() 函数能够确保后续的绘图操作将在原始未变换的坐标系中进行。

简单来说，该函数的作用就是将绘图环境恢复到初始状态，即将坐标系还原到默认状态，不带有任何额外的几何变换影响。

56、void QPainter::restore()

QPainter::restore() 是Qt图形视图框架中 QPainter 类的一个方法，它用于恢复 QPainter 的状态至最近保存的状态。

在 QPainter 中，你可以通过调用 save() 方法来保存当前画笔的所有状态信息，包括但不限于当前的绘图变换（transform）、画刷（brush）、笔（pen）、字体（font）以及剪裁区域（clipping region）等设置。每当调用 save() 后，都可以随后调用 restore() 来恢复到保存时的状态。

因此，QPainter::restore() 主要用于撤销自最后一次 save() 调用以来对 QPainter 所做的所有更改，这对于需要临时修改绘图属性并确保在绘制完成后能恢复到原始状态的场景非常有用。例如，在嵌套绘制或者复杂图形处理中经常需要用到这一对方法来管理和维护绘图环境的状态栈。

57、void QPainter::rotate(qreal angle)

QPainter::rotate(qreal angle) 是Qt库中的一个函数，它是 QPainter 类的一个成员方法，用于在当前坐标系下旋转绘图坐标轴。

当你调用 QPainter::rotate(qreal angle) 时，会按照给定的角度 angle （通常是以度为单位）逆时针旋转当前的绘图坐标系统。这个旋转操作会影响之后使用当前 QPainter 对象所绘制的所有图形元素的位置和方向。

例如，如果你设置了一个 angle 为 45 度，那么接下来绘制的所有图形都会相对于原始坐标系旋转了45度。注意，此旋转是在当前已经应用的所有其他变换（如缩放和平移）的基础上进行的。

在实际应用场景中，QPainter::rotate() 方法常用于创建复杂的二维图形效果，比如动态旋转文字、图像或其他用户界面元素。如果需要还原旋转前的状态，可以配合 QPainter::save() 和 QPainter::restore() 方法来保存和恢复绘图状态。

58、void QPainter::save()

void QPainter::save() 是Qt GUI库中 QPainter 类的一个重要成员函数，主要用于保存当前绘图环境的状态。在进行复杂绘图操作时，可能需要临时更改绘图的各种属性，比如画笔颜色、画刷样式、变换矩阵等。save() 函数的作用就是记录当前绘图器的所有状态信息，包括但不限于：

• 画笔（QPen）
• 画刷（QBrush）
• 绘图变换（如缩放、旋转和平移）
• 全局画布剪切区域
• 抗锯齿和渲染模式设置
• 字体和其他文本属性

当你调用 save() 后，可以对绘图环境进行任意修改，如果之后想要恢复到保存前的状态，只需调用 QPainter::restore() 函数。这对处理嵌套绘图操作非常有用，确保每次 restore() 调用后都能恢复到之前保存的状态。

QPainter painter(widget);

// 保存原始绘图状态
painter.save();

// 修改绘图环境（例如，改变画笔颜色）
painter.setPen(Qt::red);

// 在新的状态下进行绘图...
painter.drawLine(0, 0, 100, 100);

// 恢复到保存前的状态
painter.restore();

// 继续绘图，此时画笔颜色已经恢复为保存前的状态
painter.drawLine(100, 0, 0, 100);

在这个例子中，我们首先保存了绘图器的状态，接着改变了画笔颜色并在这种状态下绘制了一条线。当调用 restore() 后，画笔的颜色就回到了保存时的状态，从而保证后续绘图不受前面修改的影响。

59、void QPainter::scale(qreal sx, qreal sy)

QPainter::scale(qreal sx, qreal sy) 是Qt库中 QPainter 类的一个成员函数，用于对当前绘图坐标系进行缩放操作。

当调用 QPainter::scale(qreal sx, qreal sy) 时，它会按指定的比例因子 sx 和 sy 来缩放后续的绘图操作。其中：

• sx 表示沿X轴的缩放比例；
• sy 表示沿Y轴的缩放比例。

如果 sx 和 sy 都大于1，则图形会被放大；如果小于1，则图形会被缩小；若两者相等，则实现的是等比例缩放。

例如，若 sx = 2.0 和 sy = 1.5，则后续所有绘制的内容将会在水平方向上放大两倍，在垂直方向上放大1.5倍。

与 QPainter::rotate() 类似，QPainter::scale() 的效果也是基于当前已应用的所有其他变换（包括平移、旋转等）。通过连续调用这些变换方法，你可以构建复杂的2D图形变换序列。同样，为了能够恢复到变换前的状态，可以使用 QPainter::save() 和 QPainter::restore() 方法来保存和恢复绘图状态栈。

60、void QPainter::setBackground(const QBrush &brush)

QPainter::setBackground(const QBrush &brush) 是Qt库中 QPainter 类的一个成员函数，用于设置画布（或目标设备）的背景刷（background brush）。

当调用此函数时，传递给它的 QBrush 参数定义了画布背景的填充样式。QBrush 对象可以包含颜色、渐变或者其他图案，用来描绘背景区域的样式。

然而，需要注意的是，这个函数并不直接改变目标设备（比如QWidget或QImage）的实际背景。在某些情况下，如打印或者自定义绘图设备上，这个背景可能不会立即可见。对于QWidget这样的可视组件，通常需要调用其 setPalette() 或者 setStyleSheet() 函数来更改背景。

如果你是在绘制一个临时的离屏图像（QPixmap或QImage），然后将其作为背景或其他用途，setBackground() 则会在绘制过程中影响到那些未被覆盖的区域（即，当你没有完全填充整个图像时）。在进行透明度混合或者其他高级绘图操作时，背景刷的设置可能会变得尤为重要。

61、void QPainter::setBackgroundMode(Qt::BGMode mode)

QPainter::setBackgroundMode(Qt::BGMode mode) 是 Qt 绘图框架中的另一个 QPainter 类的成员函数，它用于设置画家对象（QPainter）的背景模式（background mode）。这个背景模式决定着画家对象在绘制时如何处理背景色或背景刷与新绘制内容之间的相互作用。

Qt::BGMode 枚举类型提供了两种可能的值：

Qt::TransparentMode： 当背景模式设置为透明时，新绘制的内容将会与背景混合，考虑到了每个像素的 alpha 通道（透明度）。这意味着，如果正在绘制的内容有透明区域，则这些区域会显示出底层已经存在的内容。

QPainter painter(this);
painter.setBackgroundMode(Qt::TransparentMode);
painter.fillRect(0, 0, width(), height(), QColor(0, 255, 0, 128)); // 填充半透明绿色

在这个例子中，即使填充的是半透明的绿色，也会透过这个颜色看到窗口或者图像的原有背景。

Qt::OpaqueMode： 默认情况下，QPainter 的背景模式就是不透明（Opaque）。这意味着，当使用 QPainter 绘制任何东西时，都会完全遮盖住底层的内容，不管绘制的内容是否透明。

QPainter painter(this);
painter.setBackgroundMode(Qt::OpaqueMode);
painter.fillRect(0, 0, width(), height(), QColor(0, 255, 0)); // 填充不透明绿色

在这个例子中，填充的绿色区域会完全遮盖住原来窗口或图像的任何内容，无论原内容是什么颜色或是否有透明度。

请注意，尽管设置了背景模式，但直接调用 setBackgroundMode() 并不能改变目标表面（如QWidget或QImage）本身的背景，而是影响到QPainter在绘制时如何处理背景。对于实际界面组件的背景设置，仍然需要通过其他方式如设置样式表或调用相应组件的背景设置函数来完成。

62、void QPainter::setBrush(const QBrush &brush)

void QPainter::setBrush(const QBrush &brush) 是Qt GUI库中 QPainter 类的一个成员函数，用于设置当前绘图器的画刷属性。QBrush 在Qt中代表一种图形填充样式，可以用来填充形状（如矩形、圆形等）或者路径内部的区域。

这个函数接受一个 QBrush 类型的引用作为参数：

• const QBrush &brush: 这是一个指向 QBrush 对象的引用，它定义了要使用的填充样式。QBrush 可以设置的颜色、渐变、纹理等各种样式决定了绘图时图形内部如何被填充。

QPainter painter(this); // 假设是在QWidget上创建一个QPainter实例
QColor fillColor(Qt::blue); // 创建一个蓝色填充颜色
QBrush brush(fillColor); // 创建一个基于此颜色的QBrush对象

// 设置画刷为刚才创建的蓝色填充样式
painter.setBrush(brush);

// 绘制一个矩形并应用刚才设置的填充样式
painter.drawRect(10, 10, 100, 100);

重载函数：void QPainter::setBrush(Qt::BrushStyle style)

63、void QPainter::setBrushOrigin(const QPointF &position)

QPainter::setBrushOrigin(const QPointF &position) 是Qt绘图框架中的一个QPainter类的成员函数，它用于设置画刷（brush）的原点位置。画刷通常用于填充形状和绘制纹理等操作，而原点位置决定了画刷图案相对于所绘制形状左上角的起始位置。

当你设置了一个非纯色的画刷，比如带有图案的画刷或者渐变画刷时，setBrushOrigin() 函数就显得尤为重要。它能让你控制画刷图案在整个填充区域内如何平移。

QPainter painter(this); // 假设“this”是一个可以被绘制的QWidget指针
QBrush brush(QPixmap("pattern.png")); // 创建一个基于图片的画刷
painter.setBrush(brush); // 设置画刷

// 设置画刷原点位置为 (50, 50)
painter.setBrushOrigin(QPointF(50, 50));

// 绘制一个矩形，此时画刷图案将在矩形左上角+（50,50）的位置开始填充
painter.drawRect(QRect(0, 0, 200, 100));

在这个例子中，如果“pattern.png”是一个小的重复图案，那么该图案将会从矩形左上角偏移50像素的地方开始填充，而不是从矩形的绝对左上角开始。这就允许你在填充图形时精确地定位画刷图案的起始位置。

重载函数：

①void QPainter::setBrushOrigin(int x, int y)

②void QPainter::setBrushOrigin(const QPoint &position)

64、void QPainter::setClipPath(const QPainterPath &path, Qt::ClipOperation operation = Qt::ReplaceClip)

QPainter::setClipPath(const QPainterPath &path, Qt::ClipOperation operation = Qt::ReplaceClip) 是Qt图形框架中的一个函数，用于设置当前画笔（QPainter）的剪切路径。这个函数可以帮助我们在绘图时限制画笔的有效绘图区域，即只有在指定路径内的区域才会被实际绘制。

• const QPainterPath &path: 这是要设置为剪切路径的对象，QPainterPath 可以表示任何复杂的矢量图形路径。

• Qt::ClipOperation operation: 这个参数决定了新剪切路径如何与已存在的剪切区域结合。默认值是 Qt::ReplaceClip，它会替换掉之前的所有剪切区域；还有其他选项：

  • Qt::IntersectClip: 新剪切路径与当前剪切区域相交的部分将会成为新的有效剪切区域。
  • Qt::UniteClip: 新剪切路径与当前剪切区域合并，形成一个新的联合区域作为有效剪切区域。
  • Qt::ExcludeClip: 从当前剪切区域中去除新剪切路径所在区域。

当设置了剪切路径后，后续的绘图指令都将受限于该剪切路径，超出路径范围的内容将不会被绘制。这对于实现复杂图形的叠加和裁剪功能非常有用。

#include <QPainter>
#include <QPainterPath>

// 假设我们有一个QWidget子类实例名为widget，并且已经在其上创建了QPainter实例painter
// ...

// 创建一个剪切路径，例如一个矩形区域
QPainterPath clipPath;
clipPath.addRect(50, 50, 200, 150); // 创建一个左上角坐标为(50, 50)，宽高分别为200和150的矩形路径

// 设置剪切路径
painter->setClipPath(clipPath);

// 绘制背景色填充整个widget
painter->fillRect(widget->rect(), Qt::white); // 只有在剪切区域内会被填充白色

// 绘制一个全屏的圆环
QPainterPath circlePath;
circlePath.addEllipse(widget->rect()); // 创建一个覆盖整个widget的圆形路径
painter->drawPath(circlePath); // 只有在剪切路径内部分的圆环会被绘制

// 或者绘制任意其他图形，这些图形也将只在剪切区域内显示
painter->drawLine(0, 0, widget->width(), widget->height()); // 只在剪切路径交叉的线段会被绘制

// 确保在绘画完成后清理 painter
painter->end();

在这个例子中，我们首先创建了一个限定在一定矩形区域内的剪切路径，然后将其应用于 QPainter 实例。之后对窗口进行的各种绘图操作都只会在这个剪切区域内生效，从而实现了在特定区域内限制绘图输出的效果。

65、 void QPainter::setClipRegion(const QRegion &region, Qt::ClipOperation operation = Qt::ReplaceClip)

QPainter::setClipRegion(const QRegion &region, Qt::ClipOperation operation = Qt::ReplaceClip) 是Qt库中的一个函数，用于设置当前画布（QPainter）上的剪切区域。这个函数允许你指定一个QRegion对象作为剪切区域，所有后续的绘图操作仅限于该区域之内。

• const QRegion &region: 这是你想要设置的剪切区域，它是一个包含多个不规则形状区域的集合，可以用来精确地定义哪些部分可见。

• Qt::ClipOperation operation: 这个参数指定了如何处理新剪切区域与现有剪切区域的关系。默认值是Qt::ReplaceClip，即完全替换现有的剪切区域。还有其他两种可能的操作：

  • Qt::IntersectClip: 新的剪切区域会与已存在的剪切区域做交集运算，结果是只有两个区域重叠的部分有效。
  • Qt::UniteClip: 新的剪切区域会与已存在的剪切区域做并集运算，结果是新的剪切区域包含了旧区域并且添加了新区域。

#include <QPainter>
#include <QRegion>

// 假设我们有一个QWidget子类实例名为widget，并且已经在其上创建了QPainter实例painter
// ...

// 创建一个QRegion对象，这里包含两个矩形区域
QRegion clipRegion;
clipRegion += QRect(50, 50, 200, 150);
clipRegion += QRect(100, 100, 100, 100);

// 设置剪切区域
painter->setClipRegion(clipRegion);

// 绘制背景色填充整个widget
painter->fillRect(widget->rect(), Qt::white); // 只在剪切区域内会被填充白色

// 绘制一个全屏的圆环或其他任何图形
QPainterPath circlePath;
circlePath.addEllipse(widget->rect());
painter->drawPath(circlePath); // 只有在剪切区域内的圆环部分会被绘制

painter->end();

在这个例子中，我们创建了一个包含两个矩形的剪切区域，然后将此区域应用到QPainter对象上。这样，所有的绘图操作就只会在这两个矩形重叠以及各自单独区域内部生效。

重载函数：

①void QPainter::setClipRect(const QRect &rectangle, Qt::ClipOperation operation = Qt::ReplaceClip)

②void QPainter::setClipRect(int x, int y, int width, int height, Qt::ClipOperation operation = Qt::ReplaceClip)

66、void QPainter::setClipRect(const QRectF &rectangle, Qt::ClipOperation operation = Qt::ReplaceClip)

void QPainter::setClipRect(const QRectF &rectangle, Qt::ClipOperation operation = Qt::ReplaceClip) 是Qt GUI库中 QPainter 类的一个方法，用于设置当前绘图器（QPainter 实例）的剪裁区域为指定的矩形区域，并可以选择性地指定剪裁操作的行为。

这个函数接受两个参数：

• const QRectF &rectangle: 这是一个浮点数矩形区域，它定义了新的剪裁区域的边界。QRectF 是 Qt 中定义的一个类，它可以精确到浮点数坐标，允许更精细的剪裁控制。

• Qt::ClipOperation operation: 这个枚举类型参数可选，默认值为 Qt::ReplaceClip。它指定了如何将新剪裁区域与现有的剪裁区域结合：

  • Qt::ReplaceClip：替换当前剪裁区域，只保留新矩形所定义的区域。
  • Qt::IntersectClip：与当前剪裁区域做交集，保留两者重叠的部分作为新的剪裁区域。

一旦设置了剪裁矩形后，在之后使用该 QPainter 对象进行的所有绘图操作都将只在剪裁区域内生效。

QPainter painter(this);
QRectF clipRect(50.0, 50.0, 200.0, 100.0); // 创建一个浮点数矩形

// 使用默认的 ReplaceClip 操作设置剪裁区域
painter.setClipRect(clipRect);

// 或者使用 IntersectClip 操作，如果已有剪裁区域存在
painter.setClipRect(clipRect, Qt::IntersectClip);

// 执行绘图操作，只在 clipRect 矩形区域内有效
painter.fillRect(0, 0, widgetWidth, widgetHeight, QColor("red"));

67、void QPainter::setClipping(bool enable)

void QPainter::setClipping(bool enable) 是Qt GUI库中 QPainter 类的一个成员函数，用于开启或关闭当前绘图区域的剪裁功能。当剪裁功能启用（enable 参数为 true）时，所有后续通过该 QPainter 对象执行的绘图操作都只会对当前剪裁区域内的部分生效。超出剪裁区域的部分将不会被绘制。

剪裁区域可以通过调用 QPainter::setClipRect()、QPainter::setClipPath() 等函数来设定具体的形状和大小。

QPainter painter(this); // 假设在一个QWidget上创建并初始化QPainter

// 设置一个矩形剪裁区域
QRect rect(10, 10, 100, 100);
painter.setClipRect(rect);

// 开启剪裁功能
painter.setClipping(true);

// 在整个窗口（假设大于rect）上尝试绘制一个大矩形
painter.fillRect(0, 0, width(), height(), Qt::blue);

// 只有在剪裁区域内（即rect内）的矩形部分会被绘制成蓝色
// 而剪裁区域外的部分则不受影响，保持原有背景

// 如果需要关闭剪裁功能
painter.setClipping(false);

68、void QPainter::setCompositionMode(QPainter::CompositionMode mode)

QPainter::setCompositionMode(QPainter::CompositionMode mode) 是Qt库中的一个函数，它允许你在使用QPainter进行绘图时改变图像合成模式。通过设置不同的组合模式，可以控制当新绘制的内容与已有内容叠加时的混合方式，这对于实现透明效果、阴影、颜色混合等复杂视觉效果非常有用。

QPainter::CompositionMode 枚举类型提供了多种预定义的组合模式，包括但不限于：

1. 源覆盖 (CompositionMode_SourceOver)：这是默认的模式，新像素的颜色基于源颜色和目标颜色的alpha通道来混合。

2. 清除 (CompositionMode_Clear)：清除目标像素，将其设置为完全透明。

3. 源 (CompositionMode_Source)：只保留源像素，忽略目标像素。

4. 目的地 (CompositionMode_Destination)：保留目标像素，忽略源像素。

5. 源在上 (CompositionMode_SourceIn)：只显示源像素与目标像素重叠的部分。

6. 源出 (CompositionMode_SourceOut)：显示源像素未与目标像素重叠的部分。

7. 目的地在上 (CompositionMode_DestinationIn)：显示目标像素与源像素重叠的部分，但采用源像素的alpha通道。

8. 目的地出 (CompositionMode_DestinationOut)：显示目标像素未与源像素重叠的部分。

9. 源在目的地之上 (CompositionMode_SourceOverDestination)：类似常规的alpha混合，但不考虑目标像素的alpha值。

10. 加法 (CompositionMode_Plus)：源像素和目标像素的RGB分量分别相加以产生最终颜色。

还有很多其他模式，具体可以根据需要选择合适的组合模式来达到预期的视觉效果。例如，如果要实现半透明效果，通常会选择CompositionMode_SourceOver模式。

69、void QPainter::setFont(const QFont &font)

void QPainter::setFont(const QFont &font) 是Qt图形视图框架中的一个成员函数，它用于设置当前绘图上下文中字体的属性。当在使用 QPainter 对象进行文本绘制或者任何依赖于字体的操作时，可以调用此函数更改字体样式。

给定一个 QFont 类型的对象作为参数，该函数会将 QPainter 的当前字体更改为指定的字体。QFont 可以用来定义字体系列、点大小、粗细、斜体等多种字体特性。

示例代码如下：

QPainter painter;
painter.begin(this); // 假设在一个QWidget上开始绘图

// 创建一个新的字体实例，设置字体系列和大小
QFont font("Arial", 14, QFont::Bold);

// 将当前画笔的字体设置为创建的字体
painter.setFont(font);

// 现在使用 painter 绘制的文本将采用 Arial 字体，14点大小，并且是粗体
painter.drawText(rect, Qt::AlignCenter, "Hello, World!");

painter.end(); // 结束绘图

70、void QPainter::setLayoutDirection(Qt::LayoutDirection direction)

void QPainter::setLayoutDirection(Qt::LayoutDirection direction) 是Qt库中的一个函数，用于设置 QPainter 对象的布局方向。这个函数对绘制文本和其他需要遵循特定书写方向（如从左到右或从右到左）的内容非常重要。

Qt::LayoutDirection 是一个枚举类型，它可以取以下两个值：

1. Qt::LeftToRight：指示布局方向是从左到右，这是大多数拉丁语系和许多其他语言的标准布局方式。
2. Qt::RightToLeft：指示布局方向是从右到左，这适用于阿拉伯语、希伯来语等从右向左书写的语言。

通过调用此函数并传入相应的方向值，您可以确保 QPainter 在绘制文本或其他布局相关元素时能够正确处理文本的排列顺序以及可能的视觉调整。这对于实现国际化和本地化应用程序非常关键。例如：

QPainter painter;
painter.begin(this);

// 设置布局方向为从右到左
painter.setLayoutDirection(Qt::RightToLeft);

// 绘制文本，此时文本将会按照从右到左的顺序排列
painter.drawText(rect, Qt::AlignCenter, tr("Hello World"));

painter.end();

71、void QPainter::setOpacity(qreal opacity)

void QPainter::setOpacity(qreal opacity) 是Qt图形视图框架中的一个函数，它允许您设置当前 QPainter 对象的不透明度。这个函数接收一个类型为 qreal（通常对应 double 或 float）的参数 opacity，其取值范围在 0.0 到 1.0 之间，其中：

• opacity = 0.0 表示完全透明。
• opacity = 1.0 表示完全不透明（默认值）。

当设置了不透明度后，使用该 QPainter 对象进行的所有后续绘图操作都会应用这一不透明度属性，也就是说，所绘制的内容会与背景按照指定的透明度混合。

例如：

QPainter painter;
painter.begin(this);

// 设置画笔颜色为红色，并设置不透明度为50%
painter.setPen(Qt::red);
painter.setOpacity(0.5);

// 绘制一个矩形，由于设置了不透明度，矩形会呈现半透明效果
painter.drawRect(10, 10, 100, 100);

painter.end();

72、void QPainter::setPen(const QPen &pen)

void QPainter::setPen(const QPen &pen) 是Qt GUI库中的一个方法，属于 QPainter 类。这个方法用于设置当前画笔（pen）的属性，从而影响使用该 QPainter 对象进行的所有后续绘图操作的颜色、宽度、样式等特性。

QPen 是Qt中的一个类，它定义了绘制轮廓线的属性，如颜色、宽度、线型（实线、虚线、点划线等）、端点样式和连接样式等。当你调用 setPen(const QPen &pen) 方法并传入一个 QPen 对象时，将会把该 QPen 的所有属性应用于当前的 QPainter 上。

QPainter painter;
QPen pen(Qt::blue, 2); // 创建一个蓝色、宽度为2像素的画笔
pen.setStyle(Qt::DashLine); // 设置线型为虚线
painter.setPen(pen); // 将此画笔设置给画家对象

painter.drawLine(0, 0, 100, 100); // 使用设置好的画笔绘制一条线段，其颜色、宽度和线型都将遵循之前设置的画笔属性

重载函数：

①void QPainter::setPen(const QColor &color)

②void QPainter::setPen(Qt::PenStyle style)

73、void QPainter::setRenderHint(QPainter::RenderHint hint, bool on = true)

QPainter::setRenderHint(QPainter::RenderHint hint, bool on = true) 是Qt图形视图框架中 QPainter 类的一个方法，用于设置绘图器的渲染提示（render hints）。这些提示是告知 QPainter 如何优化其输出，提升绘图质量或性能的选项。

QPainter::RenderHint 枚举类型包含了一系列可能的提示，常见的有：

• Antialiasing ( QPainter::Antialiasing)：启用抗锯齿功能，使线条和形状的边缘更加平滑，减少像素化效果。

• TextAntialiasing (QPainter::TextAntialiasing)：对绘制的文本启用抗锯齿，提高文字边缘的清晰度。

• SmoothPixmapTransform (QPainter::SmoothPixmapTransform)：启用平滑图像变换，使得缩放或旋转图像时得到更高质量的效果。

• HighQualityAntialiasing (QPainter::HighQualityAntialiasing)：在某些情况下启用高级别的抗锯齿技术。

• NonCosmeticDefaultPen (QPainter::NonCosmeticDefaultPen)：确保即使默认笔刷宽度为0，也会按照实际几何尺寸而非装饰性尺寸进行绘制。

使用该方法时，可以通过传入所需的QPainter::RenderHint枚举成员以及一个布尔值来开启或关闭相应的提示。默认情况下，第二个参数 on 设置为 true，即启用所指定的渲染提示；若设为 false，则禁用该提示。例如：

重载函数：

①void QPainter::setRenderHints(QPainter::RenderHints hints, bool on = true)

74、void QPainter::setTransform(const QTransform &transform, bool combine = false)

QPainter::setViewTransformEnabled(bool enable) 是Qt GUI库中的 QPainter 类的一个方法，它允许开发者控制是否启用视图转换（view transformation）。

当 enable 参数被设置为 true，QPainter 将会应用任何之前通过 QPainter::translate(), QPainter::scale(), 或其他相关方法设定的视图变换操作。这意味着后续的绘图操作将会基于这个变换矩阵进行坐标变换。

相反，如果将 enable 设置为 false，则所有的视图变换将被临时禁用，绘图操作将直接基于原始坐标系统进行，不受先前设置的任何视图变换影响。

这个方法对于那些需要暂时切换到无变换状态下的绘图操作或者在复杂变换场景中恢复原始视图坐标系时特别有用。例如：

QPainter painter(this);
painter.translate(50, 50); // 移动坐标原点
painter.drawRect(0, 0, 100, 100); // 在新坐标下绘制矩形

painter.setViewTransformEnabled(false); // 禁用视图变换
painter.drawRect(0, 0, 100, 100); // 直接在原始窗口坐标下绘制矩形

painter.setViewTransformEnabled(true); // 重新启用视图变换

75、void QPainter::setViewTransformEnabled(bool enable)

void QPainter::setViewTransformEnabled(bool enable) 是Qt框架中的 QPainter 类的一个成员函数，用来启用或禁用视图变换（view transformation）。

当 enable 参数为 true 时，视图变换被启用，这意味着任何应用到 QPainter 对象上的平移、缩放或旋转等变换将会改变绘图坐标系，影响后续绘图操作的结果。这对于创建复杂的图形效果、适应不同屏幕尺寸或调整视图比例非常有用。

而当 enable 参数为 false 时，视图变换将被禁用，绘图坐标系保持不变，所有的绘图指令将按照默认的坐标系统进行绘制，不考虑之前应用过的任何变换。

QPainter painter(this);
painter.setViewTransformEnabled(true); // 启用视图变换
// 进行一些平移、缩放或旋转等变换操作...
painter.translate(50, 50);
painter.scale(2.0, 2.0);
// 绘制的对象会受到上述变换的影响

// 若要恢复到无变换的状态
painter.resetTransform(); // 清除所有变换
painter.setViewTransformEnabled(false); // 禁用视图变换
// 此时绘制的对象将按照默认坐标系绘制

76、void QPainter::setViewport(const QRect &rectangle)

QPainter::setViewport(int x, int y, int width, int height) 是Qt图形视图框架中 QPainter 类的一个函数，它用于定义一个虚拟画布（viewport），即实际设备（如屏幕或打印机）上的某一矩形区域与当前画布（通常是 QPaintDevice 的一部分）之间的映射关系。

当你使用 QPainter 绘制到 QGraphicsView 或者类似的视窗组件时，setViewport 函数指定的是视窗内部用来显示绘图内容的实际像素区域。这个区域可以小于或等于整个视窗的大小，并且可以通过视口变换来控制绘图内容的缩放和平移显示。

调用该函数后，QPainter 对象将在给定的 (x, y) 坐标处开始，宽度为 width，高度为 height 的区域内绘制所有内容。任何超出这个区域的绘图都会被裁剪掉，而在这个区域内的内容则会被按照当前的视口变换映射到视窗上。

QPainter painter(viewport); // viewport 是 QGraphicsView 或其他 QPaintDevice 的某个部分
painter.setViewport(0, 0, viewport.width(), viewport.height()); // 设置视口与viewport尺寸一致

在上述代码中，视口被设置为与 viewport 组件本身的尺寸相同，确保整个组件都能被用于显示 QPainter 输出的内容。

QPainter::setViewport() 方法的主要用途在于实现二维图形的视图和视窗管理，特别是在使用 QGraphicsView 和 QGraphicsScene 构建复杂图形用户界面时，它可以带来以下功能和优势：

1. 坐标映射：

   • 它允许你在更大的逻辑坐标空间（通常是 QGraphicsScene）中进行绘图，然后将这些内容按比例缩放到视口（即窗口或控件的一部分）所限定的实际显示区域。
   • 这种映射机制使得你可以轻松地处理不同尺寸的视图窗口，同时保持场景内图形元素的比例不变。

2. 平移与缩放：

   • 通过结合 QPainter::setWindow() 方法（设置逻辑窗口坐标范围）和 setViewport() 方法，可以实现对场景的平移和缩放操作，这对于创建交互式图形应用非常有用，比如CAD软件、游戏地图视图等。

3. 视区更新：

   • 当视窗大小改变时，重新设置视口可以自动调整绘图内容在视窗中的显示效果，无需手动重绘整个场景。

4. 高效渲染：

   • 视口可以帮助优化渲染性能，因为只需要在视口范围内进行实际像素的绘制和刷新，而不是在整个设备上进行无差别的全屏刷新。

综上所述，QPainter::setViewport() 在 Qt 应用程序中对于实现灵活、可缩放和平移的图形视图以及提升图形性能具有重要作用。

重载函数：

①void QPainter::setViewport(int x, int y, int width, int height)

77、void QPainter::setWindow(const QRect &rectangle)

void QPainter::setWindow(const QRect &rectangle) 是Qt图形库中的 QPainter 类的一个方法，用于设置当前绘图窗口的视口区域。

这个函数定义了一个虚拟坐标系统，即“窗口”区域，在这个区域内进行绘图操作。给定的 QRect 对象 rectangle 定义了窗口的左上角坐标和右下角坐标，从而确定了在 QPainter 上绘图的有效范围。

通过调用 setWindow 方法，你可以控制绘图内容映射到实际设备（如屏幕、打印机或图像）上的哪个矩形区域，而不改变实际的绘图内容尺寸或形状。通常情况下，它和 QPainter::setViewport() 配合使用，可以实现绘图坐标系到物理坐标的映射转换。

QPainter painter(this); // 假设这是在QWidget或者其子类上初始化QPainter
QRect window(0, 0, 100, 100); // 设置一个从原点开始，宽高为100的窗口坐标系
painter.setWindow(window);

重载函数：

①void QPainter::setWindow(int x, int y, int width, int height)

78、void QPainter::setWorldMatrixEnabled(bool enable)

QPainter::setWorldMatrixEnabled(bool enable) 是 Qt 绘图框架中的一个方法，用于启用或禁用 QPainter 的世界矩阵（world matrix）。世界矩阵是用于对绘图坐标系统进行几何变换的一个工具，包括但不限于平移（translate）、旋转（rotate）、缩放（scale）等操作。

当 enable 参数设为 true 时，QPainter 将会应用当前设置的世界矩阵进行后续的所有绘图操作，这意味着所有绘制的对象都将按照世界矩阵所定义的变换规则进行处理。

如果 enable 设为 false，则会暂时忽略当前的世界矩阵，所有的绘图将以默认的坐标系统进行，即没有额外的几何变换。

通过控制世界矩阵的启用状态，开发者可以灵活地切换绘图的变换效果，实现复杂的图形变换和布局需求。

79、void QPainter::setWorldTransform(const QTransform &matrix, bool combine = false)

void QPainter::setWorldTransform(const QTransform &matrix, bool combine = false) 是Qt图形库中 QPainter 类的一个成员函数，用于设置当前画布上绘图操作的世界变换矩阵。

函数参数说明：

• const QTransform &matrix: 这是一个 QTransform 类型的对象引用，它代表了你想应用到 QPainter 上的新变换矩阵。QTransform 可以表示平移、旋转、缩放等二维几何变换。

• bool combine = false: 这是一个可选参数，默认值为 false。如果该参数为 true，新传入的变换矩阵会与当前已经存在的世界变换相组合；如果为 false，则会直接替换掉当前的世界变换矩阵。

QPainter painter;
// 创建一个变换矩阵
QTransform transform;
transform.rotate(45); // 旋转45度

// 应用变换到QPainter
painter.setWorldTransform(transform, false); // 直接替换现有的世界变换

// 或者
painter.setWorldTransform(transform, true); // 将新的旋转变换与现有变换相叠加

当 combine 设置为 true 时，新传入的变换矩阵会和现有的世界变换矩阵先执行复合（concatenate）操作，形成一个新的总变换矩阵，然后才将其设置为 QPainter 的世界变换。这对于需要逐步构建复杂变换序列的场景特别有用。

80、void QPainter::shear(qreal sh, qreal sv)

QPainter::shear(qreal sh, qreal sv) 是Qt库中的一个方法，它属于 QPainter 类，用于在当前坐标系统中应用剪切变换（shear transformation）。剪切变换是一种特殊的二维几何变换，它可以改变图形的相对位置但不改变其形状，而是沿着两个坐标轴方向产生错位的效果。

参数：

• sh：指定水平剪切因子。正值会使图形沿垂直方向发生错位，负值则反向错位。
• sv：指定垂直剪切因子。正值会使图形沿水平方向发生错位，负值则反向错位。

举例来说，调用 painter.shear(1.0, 0.0) 会让图形在垂直方向上每增加一个单位，水平方向也会相应增加一个单位，产生一种斜向拉伸的效果；而 painter.shear(0.0, 1.0) 则会在水平方向上产生类似的效果。

此函数直接修改当前 QPainter 对象的内部世界矩阵，从而影响到后续所有的绘图操作。通常情况下，剪切变换与旋转、缩放和平移等其他变换一起使用，以实现复杂的空间布局和视觉效果。

81、void QPainter::strokePath(const QPainterPath &path, const QPen &pen)

void QPainter::strokePath(const QPainterPath &path, const QPen &pen) 是Qt库中的一个函数，它属于QPainter类，用于描边指定的路径（QPainterPath 对象）。这个函数的作用是在绘图设备上沿着给定路径的轮廓线绘制线条，使用的笔刷属性由 const QPen &pen 参数决定。

• const QPainterPath &path: 这是一个引用类型的参数，表示要描边的路径。QPainterPath是用来存储矢量图形路径的对象，它可以包含直线、曲线、椭圆等复杂的几何形状。

• const QPen &pen: 这也是一个引用类型的参数，它代表了用来描边的笔刷属性。QPen包含了颜色、宽度、样式（如实线、虚线、点划线等）和其他影响描边效果的属性。

示例代码：

QPainter painter(this);
QPainterPath path;
path.moveTo(0, 0);
path.lineTo(100, 0);
path.quadTo(150, 50, 100, 100);
path.lineTo(0, 100);
path.closeSubpath();

QPen pen(Qt::blue, 3, Qt::DashLine); // 蓝色，宽度为3像素，虚线样式

painter.strokePath(path, pen);

上述代码首先创建了一个“L”形的闭合路径，然后设置了一个蓝色、宽度为3像素、样式为虚线的笔刷。最后通过 strokePath() 函数沿路径描边，最终在屏幕上显示的是该路径的轮廓线。

82、const QTransform &QPainter::transform() const

const QTransform &QPainter::transform() const 是Qt图形库中 QPainter 类的一个成员函数。该函数用于获取当前 QPainter 对象的绘图变换矩阵（即当前应用到所有绘图操作上的几何变换）。

当你在使用 QPainter 进行绘图时，可能会通过 translate()、scale()、rotate() 或者直接设置 QTransform 对象等方式对坐标系统进行变换。transform() 函数会返回一个常量引用指向当前的变换矩阵 QTransform。

返回类型 const QTransform & 表明此函数不会改变 QPainter 的内部状态，而是提供一个当前绘图变换的只读视图。你可以获取并查看这个变换矩阵，但不能通过这个引用修改它。

QPainter painter(someWidget);
painter.translate(50, 50); // 移动坐标原点
painter.rotate(45); // 旋转坐标系

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

// 打印变换矩阵的相关信息
qDebug() << "Matrix elements:"
         << currentTransform.m11() << ", "
         << currentTransform.m12() << ", "
         << currentTransform.m21() << ", "
         << currentTransform.m22() << ", "
         << currentTransform.dx() << ", "
         << currentTransform.dy();

这段代码首先对 QPainter 应用了一些变换，然后调用 transform() 函数获取并可能进一步处理或显示当前的变换矩阵信息。

83、void QPainter::translate(const QPointF &offset)

void QPainter::translate(const QPointF &offset) 是Qt GUI库中的一个成员函数，属于 QPainter 类。这个函数用于在当前的绘图坐标系统中执行平移操作。

当你调用 translate() 函数时，它会在当前的绘图坐标系基础上添加一个指定的偏移量（由 QPointF 对象给出，包含x和y坐标值）。这意味着后续的所有绘图操作都会基于新的坐标原点进行，原点会移动到原来的原点加上给定的偏移量的位置。

QPainter painter(someWidget);
// 在绘图之前先平移坐标系
painter.translate(QPointF(50, 50));

// 现在绘制的对象将会从(50, 50)位置开始，而不是原始窗口的左上角(0, 0)
painter.drawEllipse(0, 0, 100, 100); // 实际绘制的椭圆会位于(50, 50)处，半径为100

在这个例子中，我们首先创建了一个 QPainter 对象，并将其关联到某个QWidget（或其他可绘图表面）上。接着，我们调用 translate() 方法将坐标原点向右和向下分别平移了50个单位。因此，在之后的 drawEllipse() 绘制操作中，尽管我们指定了 (0, 0) 作为椭圆中心，但由于之前的平移变换，实际绘制出来的椭圆会出现在 (50, 50) 处。

重载函数：

①void QPainter::translate(const QPoint &offset)

②void QPainter::translate(qreal dx, qreal dy)

84、bool QPainter::viewTransformEnabled() const

bool QPainter::viewTransformEnabled() const 是Qt图形视图框架中的一个成员函数，用于查询当前 QPainter 对象是否启用了视图变换（View Transform）。

在Qt的绘图系统中，QPainter 提供了一系列用于改变坐标系统的函数，如缩放、旋转和平移等。当 viewTransformEnabled() 返回 true 时，表示当前 QPainter 对象的绘图坐标系统已经应用了某些变换，这些变换会影响所有通过该 QPainter 进行的绘图操作。

默认情况下，viewTransformEnabled() 的返回值可能是 false，即不启用额外的视图变换。如果调用了诸如 translate(), rotate(), 或 scale() 等方法来更改坐标系统，则此属性可能变为 true。

使用这个函数可以判断当前的绘图环境是否发生了坐标变换，这对于需要精确控制绘图行为的情况非常有用。例如，如果你想要恢复到无变换的绘图状态或者根据当前变换状态调整绘图逻辑，就可以检查此属性的值。

85、QRect QPainter::viewport() const

QRect QPainter::viewport() const 是Qt库中 QPainter 类的一个成员函数，它用于获取当前 QPainter 对象关联的视口区域（viewport）。

在Qt的绘图系统中，视口是指 QPainter 在实际设备上进行绘图的矩形区域，比如一个窗口或部件的部分区域。当你在一个 QWidget 或者 QPaintDevice 上进行绘图时，视口定义了绘图指令生效的具体范围。

函数返回的是一个 QRect 类型的对象，它包含了视口的左上角坐标和右下角坐标，从而描述了视口的几何尺寸。这对于了解绘图操作的实际输出位置以及与窗口坐标系统之间的关系非常重要。例如，在自定义绘图区域内进行缩放、平移时，通常需要考虑视口的位置和大小。

86、QRect QPainter::window() const

QRect QPainter::window() const 同样是Qt图形框架中的 QPainter 类的一个成员函数。这个函数用于获取当前 QPainter 对象关联的窗口区域（window）。

在Qt的绘图坐标系统中，窗口（window）是原始绘图坐标系所对应的矩形区域，它定义了一个不受任何变换影响的基础绘图空间。当对 QPainter 应用缩放、旋转和平移等变换时，这些变换都是相对于窗口坐标系进行的。

函数返回值类型为 QRect，它给出了窗口的原点及其尺寸，这个窗口坐标系下的坐标通过变换后映射到视口（viewport）中进行实际显示。

总结来说，QPainter::window() 获取的是未经过任何坐标变换前的绘图区域，而 QPainter::viewport() 则是获取当前实际用来显示绘图内容的屏幕区域。两者结合可以用来处理复杂的坐标变换和适应不同的显示需求。

87、bool QPainter::worldMatrixEnabled() const

bool QPainter::worldMatrixEnabled() const 是Qt图形库中 QPainter 类的一个成员函数。该函数用于查询当前 QPainter 对象是否启用了世界矩阵（world matrix）变换。

在Qt的绘图系统中，QPainter允许开发者对图形元素应用各种几何变换，如缩放、旋转和平移等，这些变换可以通过设置和操作一个3x3的世界矩阵来实现。当 worldMatrixEnabled() 返回 true 时，表示画家对象正在使用一个非单位矩阵进行绘图变换，这意味着所有的绘图操作都将受到此世界矩阵的影响。

通常情况下，如果不显式地改变世界矩阵，那么默认情况下它是单位矩阵，也就是说没有启用任何额外的变换。如果调用了诸如 setWorldTransform() 或者应用了其他变换方法，则 world 矩阵就被认为是启用的。

if (painter.worldMatrixEnabled()) {
    // 当前QPainter对象已启用世界矩阵变换
} else {
    // 当前QPainter对象未启用世界矩阵变换，绘图操作不受额外几何变换影响
}

88、const QTransform &QPainter::worldTransform() const

const QTransform &QPainter::worldTransform() const 是Qt图形库中 QPainter 类提供的另一个成员函数。这个函数用于获取当前 QPainter 对象的世界变换矩阵（world transform），并返回一个常量引用指向 QTransform 对象。

在Qt的二维绘图系统中，QTransform 类用来表示2D几何变换，包括平移、旋转、缩放以及更复杂的组合变换。通过调用 worldTransform() 方法，你可以获取当前作用于 QPainter 上的所有变换效果合并而成的最终变换矩阵。

QPainter painter;
// ... 进行一系列的绘图变换操作
const QTransform &transform = painter.worldTransform();
// 现在transform变量包含了当前QPainter的所有世界变换信息

利用返回的 QTransform 变换对象，你可以进一步检查或修改绘图环境中的变换状态，但需要注意的是，由于返回的是常量引用，所以不能直接修改这个引用的对象，只能用于读取变换信息。如果要修改世界变换，可以使用 setWorldTransform() 函数。