QC++ / Qt 学习之路

案例:屏幕截图工具

全屏遮罩框选截图,自绘手柄调整、保存复制与托盘热键

实战第 48 / 48 章第六篇 · 案例实战

#这个案例做什么

写一个常驻托盘的截图工具:按下热键,整个屏幕瞬间被半透明遮罩盖住,鼠标变成十字线并跟随一个放大镜;按住左键拖出一个矩形,松手时矩形内保持清晰、矩形外变暗,矩形四周出现八个可拖动的手柄,可以直接把边缘拖到准确位置;双击或按回车确认,图片自动存到图片目录并复制到剪贴板,可以直接粘进聊天窗口;按 Esc 取消。这个案例是事件处理与无边框窗口技巧的集大成者:命中判定、坐标原点、高 DPI 换算、鼠标捕获,一个都少不了。

屏幕截图工具 640 × 360 矩形 箭头 文字 保存 取消 已选择 640 × 360 · Enter 保存,Esc 取消 QScreen::grabWindow() QToolBar 浮动工具条 遮罩 QLabel 半透明 QRubberBand · 选框 QLabel 尺寸提示
截图工具界面结构——全屏遮罩 + 自绘选择框 + 八手柄 + 放大镜提示

功能清单:

  • 全屏截图:QScreen::grabWindow(0) 抓取整个屏幕,多显示器时拼接成完整桌面;
  • 全屏遮罩:无边框、置顶、半透明背景的 QWidget,高 DPI 下按设备像素处理;
  • 框选:按住左键拖出矩形,选区内清晰、选区外压暗,实时显示像素尺寸;
  • 手柄调整:八个手柄(四角 + 四边)拖动改变大小,选区内部拖动整体移动;
  • 十字线与放大镜:跟随光标显示 5 倍放大的局部像素,便于对齐边缘;
  • 输出:自动保存到图片目录(Shot-时间戳.png),同时写入系统剪贴板;
  • 托盘常驻:QSystemTrayIcon + 右键菜单,支持延时截图与全局热键唤起。

#用到的知识点

知识点出处
QScreen::grabWindow 与 QPixmap 设备像素第四篇第 5 章 绘图系统 QPainter
无边框、置顶、WA_TranslucentBackground 窗口第四篇第 4 章 自定义控件与 QSS
鼠标事件、键盘事件与 grabMouse第三篇第 9 章 事件系统
QPainter 裁剪、十字线、圆角矩形第四篇第 5 章 绘图系统 QPainter
QClipboard 与 QMimeData第四篇第 1 章 对话框与交互
QFileDialog、QStandardPaths、QSystemTrayIcon第四篇第 1、6 章
QTimer::singleShot 延时截图第三篇第 6 章 常用基础控件
QShortcut 与原生事件 nativeEvent第三篇第 9 章 事件系统
QRect::normalized / intersected 矩形运算第三篇第 5 章 Qt 核心数据类型
高 DPI 与 devicePixelRatio第四篇第 5 章 绘图系统 QPainter

#项目结构

Text
screenshot/
├── CMakeLists.txt
└── src/
    ├── main.cpp               # 托盘、热键、应用入口
    ├── captureoverlay.h
    └── captureoverlay.cpp     # 遮罩窗口:截图、框选、自绘

整个程序没有传统意义上的主窗口:它平时只有一个托盘图标,唤起时才创建全屏遮罩,遮罩结束后自动销毁。这种"用的时候才存在"的结构,是系统工具类程序的典型形态。

CMake
cmake_minimum_required(VERSION 3.16)

project(ScreenShot LANGUAGES CXX)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_AUTOMOC ON)

find_package(Qt6 REQUIRED COMPONENTS Widgets)

qt_add_executable(ScreenShot
    src/main.cpp
    src/captureoverlay.cpp
    src/captureoverlay.h
)

target_link_libraries(ScreenShot PRIVATE Qt6::Widgets)

if(MSVC)
    target_compile_options(ScreenShot PRIVATE /utf-8)
endif()

if(APPLE)
    set_target_properties(ScreenShot PROPERTIES MACOSX_BUNDLE TRUE)
endif()

#核心实现

#遮罩窗口:抓取屏幕并铺满全屏

遮罩窗口的三件套属性是:Qt::FramelessWindowHint(无边框)、Qt::WindowStaysOnTopHint(置顶)、Qt::WA_TranslucentBackground(半透明背景)。再加上 Qt::Tool 可以避免它在任务栏上出现。注意 showFullScreen() 之后窗口尺寸才是屏幕尺寸,抓屏必须在显示之前完成,否则会把自己的遮罩也拍进去。

高 DPI 是这里的硬骨头。屏幕的 size() 是逻辑像素,而 grabWindow 返回的 QPixmap 是物理像素(比如 Retina 上 2 倍大小),并且它自带 devicePixelRatio。所以在逻辑坐标系里绘制这张图时用 drawPixmap(0, 0, pixmap) 即可自动缩放;但用 QPixmap::copy() 裁剪时必须换算成物理像素,否则截出来的图会小一半。

多显示器的处理是把各屏的图按各自的 geometry() 位置画到一张大画布上,画布尺寸取所有屏幕几何的并集。

C++
// src/captureoverlay.h
#pragma once

#include <QPixmap>
#include <QPoint>
#include <QRect>
#include <QWidget>

class CaptureOverlay : public QWidget
{
    Q_OBJECT
public:
    explicit CaptureOverlay();

signals:
    void regionSelected(const QPixmap &pixmap);
    void canceled();

protected:
    void paintEvent(QPaintEvent *event) override;
    void mousePressEvent(QMouseEvent *event) override;
    void mouseMoveEvent(QMouseEvent *event) override;
    void mouseReleaseEvent(QMouseEvent *event) override;
    void mouseDoubleClickEvent(QMouseEvent *event) override;
    void keyPressEvent(QKeyEvent *event) override;

private:
    enum Mode { Idle, Drawing, Moving, Resizing };
    enum Edge { Left = 1, Top = 2, Right = 4, Bottom = 8 };

    static QPixmap grabDesktop();
    int     hitTest(const QPoint &pos) const;
    void    finish();
    QVector<QRect> handleRects() const;

    QPixmap m_desktop;
    QRect   m_selection;        // 当前选区(逻辑坐标)
    QRect   m_originRect;       // 按下瞬间的选区,用于增量计算
    QPoint  m_pressPos;
    QPoint  m_cursor;
    int     m_edges    = 0;     // 正在拖动的边
    Mode    m_mode     = Idle;
    bool    m_hasSelection = false;
    qreal   m_dpr      = 1.0;
};
C++
// src/captureoverlay.cpp(构造与绘制)
#include "captureoverlay.h"

#include <QApplication>
#include <QClipboard>
#include <QDateTime>
#include <QGuiApplication>
#include <QKeyEvent>
#include <QMouseEvent>
#include <QPainter>
#include <QScreen>
#include <QStandardPaths>

namespace {
constexpr int kHandleSize = 8;    // 手柄边长
constexpr int kHitMargin  = 6;    // 命中判定的宽容半径
}

QPixmap CaptureOverlay::grabDesktop()
{
    const QList<QScreen *> screens = QGuiApplication::screens();
    if (screens.isEmpty()) return {};

    // 1. 求所有屏幕几何的并集,作为虚拟桌面画布
    QRect vg = screens.first()->geometry();
    for (QScreen *s : screens)
        vg = vg.united(s->geometry());

    // 取最大屏的 dpr 作为整张画布的 dpr
    qreal dpr = 1.0;
    for (QScreen *s : screens)
        dpr = qMax(dpr, s->devicePixelRatio());

    QPixmap canvas(QSize(vg.width() * dpr, vg.height() * dpr));
    canvas.setDevicePixelRatio(dpr);   // 关键:不设置的话裁剪尺寸会错
    canvas.fill(Qt::black);

    QPainter p(&canvas);
    for (QScreen *s : screens) {
        // 抓屏时要连拼接位置一起算:屏幕位置可能是负数(左侧排列的副屏)
        const QRect g = s->geometry();
        // WId 传 0 表示抓取整块屏幕;抓到的图自带该屏的 dpr
        p.drawPixmap(g.topLeft() - vg.topLeft(), s->grabWindow(0));
    }
    return canvas;
}

CaptureOverlay::CaptureOverlay()
    : QWidget(nullptr, Qt::Window | Qt::FramelessWindowHint
                     | Qt::WindowStaysOnTopHint | Qt::Tool)
{
    // 抓屏必须在自己显示出来之前完成
    m_desktop = grabDesktop();
    m_dpr = m_desktop.devicePixelRatioF();
    if (m_dpr <= 0) m_dpr = qGuiApp->primaryScreen()->devicePixelRatio();

    setAttribute(Qt::WA_TranslucentBackground);
    setAttribute(Qt::WA_DeleteOnClose, false);
    setMouseTracking(true);          // 不选鼠标也要能拿到移动位置画十字线
    setCursor(Qt::CrossCursor);
    setWindowState(Qt::WindowFullScreen);
    showFullScreen();
}

QVector<QRect> CaptureOverlay::handleRects() const
{
    const QRect r = m_selection;
    const int h = kHandleSize;
    const auto at = [&](int x, int y) { return QRect(x - h / 2, y - h / 2, h, h); };

    return { at(r.left(),  r.top()),    at(r.center().x(), r.top()),
             at(r.right(), r.top()),    at(r.right(), r.center().y()),
             at(r.right(), r.bottom()), at(r.center().x(), r.bottom()),
             at(r.left(),  r.bottom()), at(r.left(),  r.center().y()) };
}

void CaptureOverlay::paintEvent(QPaintEvent *)
{
    QPainter p(this);
    p.setRenderHint(QPainter::Antialiasing, false);

    // 1. 铺满桌面快照(逻辑坐标绘制,QPixmap 自带 dpr 会自动缩放)
    p.drawPixmap(0, 0, m_desktop);

    // 2. 整体压暗
    p.fillRect(rect(), QColor(0, 0, 0, 110));

    // 3. 选区内重新画一遍桌面图,恢复清晰
    if (m_hasSelection && m_selection.width() > 1 && m_selection.height() > 1) {
        p.save();
        p.setClipRect(m_selection);   // 只在这个矩形内生效
        p.drawPixmap(0, 0, m_desktop);
        p.restore();

        // 选区边框:向内缩 1 像素,否则右下角会被裁掉看不见
        p.setPen(QPen(QColor(58, 150, 255), 1));
        p.drawRect(m_selection.adjusted(0, 0, -1, -1));

        // 八个手柄:白底 + 蓝色描边
        p.setPen(QPen(QColor(58, 150, 255), 1));
        p.setBrush(Qt::white);
        for (const QRect &hr : handleRects())
            p.drawRect(hr);

        // 尺寸提示:贴着选区左上角外侧,选区太靠上时放到内侧
        const QString size = QStringLiteral("%1 × %2")
                                 .arg(m_selection.width()).arg(m_selection.height());
        QRect label(m_selection.left(), m_selection.top() - 22,
                    p.fontMetrics().horizontalAdvance(size) + 12, 18);
        if (label.top() < 0)
            label.moveTop(m_selection.top() + 4);
        p.setPen(Qt::NoPen);
        p.setBrush(QColor(0, 0, 0, 170));
        p.drawRoundedRect(label, 3, 3);
        p.setPen(Qt::white);
        p.drawText(label, Qt::AlignCenter, size);
    }

    // 4. 十字准线,方便对齐边缘
    p.setPen(QPen(QColor(58, 150, 255, 150), 1, Qt::DashLine));
    p.drawLine(m_cursor.x(), 0, m_cursor.x(), height());
    p.drawLine(0, m_cursor.y(), width(), m_cursor.y());

    // 5. 放大镜:取光标周围 20×20 逻辑像素,放大到 100×100
    const int extent = 20;
    const QRect src(m_cursor.x() - extent / 2, m_cursor.y() - extent / 2,
                    extent, extent);
    const QPoint devTopLeft(src.topLeft().x() * m_dpr, src.topLeft().y() * m_dpr);
    const QPixmap tile = m_desktop.copy(
        QRect(devTopLeft, QSize(int(extent * m_dpr), int(extent * m_dpr))));

    QRect zoom(m_cursor.x() + 20, m_cursor.y() + 20, 100, 100);
    if (zoom.right() > width())  zoom.moveRight(m_cursor.x() - 20);
    if (zoom.bottom() > height()) zoom.moveBottom(m_cursor.y() - 20);

    p.fillRect(zoom, QColor(20, 20, 24));
    p.drawPixmap(zoom, tile.scaled(zoom.size(), Qt::KeepAspectRatio,
                                   Qt::FastTransformation));  // 放大用最近邻才不糊
    p.setPen(QColor(58, 150, 255));
    p.drawRect(zoom);
    // 中心十字,指出当前像素
    p.drawLine(zoom.center().x(), zoom.top(), zoom.center().x(), zoom.bottom());
    p.drawLine(zoom.left(), zoom.center().y(), zoom.right(), zoom.center().y());
}

#框选与拖动:命中判定与原点重算

鼠标交互的全部难点在两个地方:判断点到了哪里,以及拖动时怎么算新矩形。

命中判定用位标志:把选区四条边各赋予一个 bit(Left/Right/Top/Bottom),判断光标到每条边的距离是否小于容差,把落在范围内的边按位或起来,角的判定自然就是两条边的组合。都不满足时,再看是否落在选区内部(移动)或者外部(新框选)。

拖动计算的关键技巧是基于按下瞬间的原始矩形做增量,而不是在当前矩形上累加位移。前者无论怎么拖都不会累积误差,越过对边时 normalized() 直接翻转即可;后者在边界处会抖动,还容易越缩越小。

C++
// src/captureoverlay.cpp(鼠标交互)
int CaptureOverlay::hitTest(const QPoint &pos) const
{
    if (!m_hasSelection) return 0;

    const QRect r = m_selection.adjusted(-kHitMargin, -kHitMargin,
                                          kHitMargin,  kHitMargin);
    if (r.contains(pos)) {
        int edges = 0;
        if (qAbs(pos.x() - m_selection.left())   <= kHitMargin) edges |= Left;
        if (qAbs(pos.x() - m_selection.right())  <= kHitMargin) edges |= Right;
        if (qAbs(pos.y() - m_selection.top())    <= kHitMargin) edges |= Top;
        if (qAbs(pos.y() - m_selection.bottom()) <= kHitMargin) edges |= Bottom;
        return edges;                    // 角 = 两条边的组合,天然成立
    }
    return m_selection.contains(pos) ? 16 : 0;   // 16 = 内部(移动)
}

void CaptureOverlay::mousePressEvent(QMouseEvent *event)
{
    if (event->button() != Qt::LeftButton) {
        if (event->button() == Qt::RightButton) { emit canceled(); return; }
        QWidget::mousePressEvent(event);
        return;
    }

    m_pressPos   = event->pos();
    m_originRect = m_selection;

    if (m_hasSelection) {
        const int hit = hitTest(event->pos());
        if (hit == 16) { m_mode = Moving; }
        else if (hit != 0) { m_mode = Resizing; m_edges = hit; }
        else { m_mode = Drawing; m_hasSelection = false; m_selection = QRect(); }
    } else {
        m_mode = Drawing;
    }
    event->accept();
}

void CaptureOverlay::mouseMoveEvent(QMouseEvent *event)
{
    m_cursor = event->pos();

    if (m_mode == Idle) {
        // 只更新十字线与放大镜,光标形状随位置变化(也可以直接用十字线)
        update();
        return;
    }

    if (m_mode == Drawing) {
        // 起点固定为按下点,向任意方向拖动都能得到正确矩形
        m_selection = QRect(m_pressPos, event->pos()).normalized();
        m_hasSelection = true;
    } else if (m_mode == Moving) {
        QRect r = m_originRect;
        r.translate(event->pos() - m_pressPos);
        // 限制在屏幕内,避免把选区拖出去
        m_selection = r.intersected(rect());
    } else if (m_mode == Resizing) {
        QRect r = m_originRect;                  // 永远从原始矩形重算
        if (m_edges & Left)   r.setLeft(event->pos().x());
        if (m_edges & Right)  r.setRight(event->pos().x());
        if (m_edges & Top)    r.setTop(event->pos().y());
        if (m_edges & Bottom) r.setBottom(event->pos().y());
        m_selection = r.normalized().intersected(rect());
    }

    update();
    event->accept();
}

void CaptureOverlay::mouseReleaseEvent(QMouseEvent *event)
{
    if (event->button() == Qt::LeftButton && m_mode != Idle) {
        // 双击之外,太小的选区(误点)直接取消,不要生成 1×1 的图
        if (m_selection.width() < 3 || m_selection.height() < 3) {
            m_hasSelection = false;
            m_selection = QRect();
        }
        m_mode = Idle;
        if (m_hasSelection)
            finish();
    }
    update();
    event->accept();
}

void CaptureOverlay::mouseDoubleClickEvent(QMouseEvent *event)
{
    if (m_hasSelection && m_selection.contains(event->pos()))
        finish();
    else
        emit canceled();
}

void CaptureOverlay::keyPressEvent(QKeyEvent *event)
{
    if (event->key() == Qt::Key_Escape) { emit canceled(); return; }
    if (event->key() == Qt::Key_Return || event->key() == Qt::Key_Enter) {
        if (m_hasSelection) finish();
        return;
    }
    // 方向键微调一像素,Shift 加速
    if (m_hasSelection && event->key() >= Qt::Key_Left && event->key() <= Qt::Key_Down) {
        const int d = (event->modifiers() & Qt::ShiftModifier) ? 10 : 1;
        switch (event->key()) {
        case Qt::Key_Left:  m_selection.translate(-d, 0); break;
        case Qt::Key_Right: m_selection.translate(d, 0);  break;
        case Qt::Key_Up:    m_selection.translate(0, -d); break;
        case Qt::Key_Down:  m_selection.translate(0, d);  break;
        }
        m_selection = m_selection.intersected(rect());
        update();
        return;
    }
    QWidget::keyPressEvent(event);
}

void CaptureOverlay::finish()
{
    // QPixmap::copy 用的是设备像素,必须把逻辑坐标乘 dpr
    const QRect devRect(QPoint(int(m_selection.left()   * m_dpr),
                               int(m_selection.top()    * m_dpr)),
                        QSize(int(m_selection.width()  * m_dpr),
                              int(m_selection.height() * m_dpr)));
    QPixmap shot = m_desktop.copy(devRect);
    shot.setDevicePixelRatio(m_dpr);    // 保持逻辑尺寸,粘贴到聊天软件才不会被放大

    emit regionSelected(shot);
}

#保存、复制到剪贴板与托盘热键

截好的图要同时做两件事:存盘和进剪贴板。剪贴板用 QClipboard::setPixmap,Qt 会自动提供标准的图像 MIME 类型,粘贴到微信、Word、画图里都能用。

托盘程序的生命周期和常规窗口不同:必须 setQuitOnLastWindowClosed(false),否则遮罩窗口关闭时应用会直接退出。热键方面,QShortcut 只在本应用有焦点时有效,做不到全局;真正的全局热键要调系统 API——Windows 用 RegisterHotKey 并在 nativeEvent 里处理 WM_HOTKEY,X11 用 XGrabKey,macOS 用 NSEvent 全局监听或 CGEventTap。下面给出 Windows 的实现作为参考,其它平台思路一致。

C++
// src/main.cpp
#include <QApplication>
#include <QClipboard>
#include <QDateTime>
#include <QFileDialog>
#include <QMenu>
#include <QMessageBox>
#include <QObject>
#include <QStandardPaths>
#include <QSystemTrayIcon>
#include <QTimer>

#include "captureoverlay.h"

class ShotApp : public QObject
{
    Q_OBJECT
public:
    explicit ShotApp(QObject *parent = nullptr) : QObject(parent)
    {
        m_tray = new QSystemTrayIcon(
            QIcon(QStringLiteral(":/icons/camera.svg")), this);
        m_tray->setToolTip(QStringLiteral("截图工具(Ctrl+Alt+S)"));

        auto *menu = new QMenu;
        menu->addAction(QStringLiteral("截取屏幕"), this, &ShotApp::shoot);
        menu->addAction(QStringLiteral("延时 3 秒"), this, [this] {
            QTimer::singleShot(3000, this, &ShotApp::shoot);
        });
        menu->addSeparator();
        menu->addAction(QStringLiteral("退出"), qApp, &QApplication::quit);

        m_tray->setContextMenu(menu);
        connect(m_tray, &QSystemTrayIcon::activated,
                this, [this](QSystemTrayIcon::ActivationReason reason) {
            if (reason == QSystemTrayIcon::Trigger) shoot();
        });
        m_tray->show();
    }

public slots:
    void shoot()
    {
        if (m_overlay) return;                 // 已经在截图状态

        m_overlay = new CaptureOverlay;
        connect(m_overlay, &CaptureOverlay::regionSelected,
                this, &ShotApp::onCaptured);
        connect(m_overlay, &CaptureOverlay::canceled,
                this, &ShotApp::onCanceled);
    }

private:
    void onCanceled()
    {
        m_overlay->deleteLater();
        m_overlay = nullptr;
    }

    void onCaptured(const QPixmap &pixmap)
    {
        m_overlay->hide();      // 先隐藏遮罩,避免截到自己的提示
        m_overlay->deleteLater();
        m_overlay = nullptr;

        // 1. 存盘:默认放在系统的图片目录
        const QString dir = QStandardPaths::writableLocation(
            QStandardPaths::PicturesLocation);
        const QString path = QStringLiteral("%1/Shot-%2.png")
            .arg(dir, QDateTime::currentDateTime()
                          .toString(QStringLiteral("yyyyMMdd-HHmmss")));

        if (pixmap.save(path))
            m_tray->showMessage(QStringLiteral("已保存"), path,
                                QSystemTrayIcon::NoIcon, 3000);

        // 2. 进剪贴板:setPixmap 会同时提供 image/bmp 等 MIME,粘贴到任何地方都行
        QApplication::clipboard()->setPixmap(pixmap);
    }

    QSystemTrayIcon *m_tray    = nullptr;
    CaptureOverlay  *m_overlay = nullptr;
};

#ifdef Q_OS_WIN
#include <windows.h>

// 全局热键必须走系统 API:QShortcut 只在本应用有焦点时有效
class HotkeyFilter : public QAbstractNativeEventFilter
{
public:
    explicit HotkeyFilter(ShotApp *app) : m_app(app) {}

    bool nativeEventFilter(const QByteArray &, void *message, qintptr *) override
    {
        auto *msg = static_cast<MSG *>(message);
        if (msg->message == WM_HOTKEY && msg->wParam == 1) {
            QMetaObject::invokeMethod(m_app, "shoot", Qt::QueuedConnection);
            return true;
        }
        return false;
    }

private:
    ShotApp *m_app;
};
#endif

int main(int argc, char *argv[])
{
    QApplication app(argc, argv);
    QApplication::setQuitOnLastWindowClosed(false);   // 关掉遮罩不退出程序

    QCoreApplication::setOrganizationName(QStringLiteral("QtTutorial"));
    QCoreApplication::setApplicationName(QStringLiteral("ScreenShot"));

    ShotApp shot;

#ifdef Q_OS_WIN
    // MOD_ALT=1, MOD_CONTROL=2, MOD_SHIFT=4, MOD_WIN=8
    RegisterHotKey(nullptr, 1, MOD_CONTROL | MOD_ALT, 'S');
    auto *filter = new HotkeyFilter(&shot);
    qApp->installNativeEventFilter(filter);
#endif

    // 无热键时的退路:用 QShortcut 也能在本应用内触发,方便调试
    return app.exec();
}

#include "main.moc"

#关键细节与踩坑

1. 截图里出现了自己的黑色遮罩。 抓屏必须发生在遮罩窗口显示之前。所以 grabDesktop() 在构造函数里、在 showFullScreen() 之前调用,而不是在 paintEvent 里现抓。另外 QScreen::grabWindow(0) 在某些平台(Wayland)上受限,需要走对应的门户接口或退回 X11。

2. Retina / 高 DPI 屏上截出来的图小了一半或者糊。 grabWindow 返回的是物理像素的 QPixmap,且自带 devicePixelRatio。两处必须保持一致:绘制时用逻辑坐标交给 drawPixmap 自动缩放;裁剪时用 QPixmap::copy() 必须传物理像素矩形(逻辑坐标乘 dpr)。同时给裁出来的图重新 setDevicePixelRatio(dpr),否则粘贴到别的程序里会变成两倍大。

3. 多屏截图位置错乱、副屏是黑的。 各屏幕的 geometry() 原点不一定是 (0, 0),往左排列的副屏 x 是负数。要先求所有屏幕几何的 united() 并集作为画布,再把每屏的图按 g.topLeft() - vg.topLeft() 这个偏移量画上去。另外不同屏幕的 dpr 可能不同,取整张画布的最大 dpr 才不会丢像素。

4. 拖动边缘时选区抖动、越缩越小。 不要在当前矩形上累加位移。正确做法是记下按下瞬间的 m_originRect,每次移动都从它重新计算边的位置,越界时用 normalized() 翻转。移动整个选区时同理,用 originRect.translate(delta) 而不是改 m_selection。

5. 手柄点不中,或者边框重影。 手柄的绘制矩形和命中判定必须用同一份坐标(本案例共用 handleRects() 的思路),建议直接把命中判定做成"到四条边的距离"的位运算。另外绘制边框要 adjusted(0, 0, -1, -1):1 像素宽的边框画在矩形边界上,右下那条边会正好落在矩形外被裁掉。

6. 关掉遮罩窗口程序就退出了。 托盘程序必须 setQuitOnLastWindowClosed(false),否则最后一个窗口销毁时 QApplication 会直接退出,托盘图标随之消失。同时遮罩要用 WA_DeleteOnClose = false 加 deleteLater() 手动管理,避免窗口还在处理事件时就被销毁。

7. 全局热键在本应用之外按了没反应。 QShortcut 依附于窗口,只能在本应用有焦点或该窗口有焦点时生效。真正的全局热键必须调用系统 API,并在 QAbstractNativeEventFilter 里处理(Windows 的 WM_HOTKEY)。注意不要在过滤器里直接操作控件,用 QMetaObject::invokeMethod(..., Qt::QueuedConnection) 把处理切回主线程队列。第三方库 QHotkey 封装了三个平台,可以直接用。

#还能怎么扩展

  • 贴图与标注:截完不直接保存,而是弹出一个标注窗口,用 QPainter 画矩形、箭头、文字、马赛克(马赛克做法是把区域缩小到 1/8 再放大回来),支持撤销重做(第四篇第 4 章的 QUndoStack)。
  • 窗口级截图:Windows 用 EnumWindows 枚举顶层窗口矩形,macOS 用 CGWindowListCopyWindowInfo,Linux 用 X11 的 _NET_CLIENT_LIST,鼠标移动时高亮当前窗口,点击直接截它——比手框精确得多。
  • 滚动长截图:连续定时抓取同一区域,用图像配准(比较相邻帧的像素差找到偏移)拼接成长图,这是很多截图工具"长截图"的原理。
  • 录制 GIF / 视频:用 QTimer 定时抓屏,累积若干帧后用 QImage 序列编码;Qt 6 没有内置编码器,可接 FFmpeg 或用 QMediaCaptureSession + QScreenCapture(Qt 6.5 起提供 QScreenCapture 与 QMediaRecorder,可以真正录屏)。
  • 贴图钉在屏幕上:把截好的图放到一个无边框置顶窗口里,支持鼠标穿透(Qt::WindowTransparentForInput)与半透明,就是常见的"钉图"功能。

#小结

  • 抓屏要在遮罩显示前完成;QScreen::grabWindow(0) 抓整屏,多屏按几何并集拼接。
  • 高 DPI 下 QPixmap::copy() 用的是物理像素,裁剪时必须乘 devicePixelRatio,并给结果重设 dpr。
  • 命中判定用四边的位标志(角 = 两位的组合),动手柄时从按下瞬间的原始矩形重算,配合 normalized() 处理翻转;自绘边框要向内缩 1 像素,setClipRect 用来实现"选区内清晰、选区外压暗"。
  • 托盘程序必须 setQuitOnLastWindowClosed(false);遮罩自己管理生命周期。
  • 全局热键不能靠 QShortcut,要走系统 API + QAbstractNativeEventFilter,并把处理切回主线程队列。

#练习

  1. 增加"另存为":截完不直接存,而是弹出 QFileDialog::getSaveFileName,按后缀选择 PNG/JPEG,JPEG 时用 save(&file, "JPG", 90) 传入质量参数;注意 QPixmap::save 的第二个参数是格式字符串 "PNG" / "JPG" 而不是后缀名 .png。
  2. 实现选区"固定尺寸"模式:按住 Shift 拖动时锁定长宽比为 1:1(正方形)或常见的 16:9,在 mouseMoveEvent 里检查 event->modifiers() & Qt::ShiftModifier,按较长边反算另一边。
  3. 加延时截图:托盘菜单里加"延时 5 秒",用 QTimer::singleShot(5000, ...) 先隐藏一切再唤起遮罩;期间用托盘的 showMessage 提示倒计时,注意 singleShot 的接收者要保证存活。
  4. 实现"截图后自动贴图":截完创建一个无边框置顶窗口显示该图,支持 Esc 关闭、鼠标滚轮缩放(复用第六篇第 2 章的 ImageView 的坐标变换思路),并加一个右键菜单项把它切换为鼠标穿透(setAttribute(Qt::WA_TransparentForMouseEvents))。
我的学习笔记笔记总览
笔记保存在本机浏览器(localStorage),换设备或清理缓存会丢失;重要内容请点「导出全部笔记」存成 .md 文件。