QT 自定义可拖动缩放的无边框窗口，可用于mainmindow, widget

🕗 发布于 2024-09-25 04:22 qt 开发语言

1. 用于拖动，缩放的工具类

“WindowControl.h”

#ifndef WINDOWCONTROL_H
#define WINDOWCONTROL_H

#include <QObject>
#include <QRubberBand>
#include <QStyleOptionFocusRect>
#include <QStylePainter>

class RubberBand;
class CursorPosCalculator;

/**
 * 窗口控制类
 * 存储界面对应的数据集合，及是否可移动、可缩放属性
 * 进行缩放等相关操作
 */
class WindowControl : public QObject {
    Q_OBJECT

  public:
    explicit WindowControl(QObject *parent = nullptr);
    ~WindowControl();
    void activeWindow(QWidget *window);         // 激活窗体
    void removeWindow(QWidget *window);         // 移除窗口
    void setWindowMove(bool moveAble);          // 窗体移动
    void setWindowResize(bool resizeAble);      // 窗体缩放
    void setRubberBandOnMove(bool movable);     // 设置橡皮筋移动
    void setRubberBandOnResize(bool resizable); // 设置橡皮筋缩放

    void handleWidgetEvent(QEvent *event); // 处理鼠标划过、按下、按下、释放、移动事件
    void updateRubberBandStatus();         // 更新橡皮筋状态

  protected:
    virtual bool eventFilter(QObject *obj,
                             QEvent *event); // 事件过滤， 移动，缩放

  private:
    /** 状态 **/
    // QHash<QWidget*, WindowData*> windowDataHash;    // 缓存要控制的窗口
    bool windowMoveAble;           // 可以移动
    bool windowResizeAble;         // 可以缩放
    bool windowRubberBandOnResize; // 可以橡皮筋移动
    bool windowRubberBandOnMove;   // 可以橡皮筋缩放

    /** 窗口及其操作 **/
    RubberBand *m_pRubberBand; // 橡皮筋选择框
    QWidget *m_pWidget;        // 被控制的窗口
    QPoint m_ptDragPos;        // 拖动时坐标
    CursorPosCalculator *m_pressedMousePos;
    CursorPosCalculator *m_moveMousePos;
    bool m_bLeftButtonPressed;      // 鼠标左键是否按下
    bool m_bCursorShapeChanged;     // 鼠标形状是否改变
    bool m_bLeftButtonTitlePressed; // 标题区域是否按下鼠标
    Qt::WindowFlags m_windowFlags;

    void updateCursorShape(const QPoint &gMousePos);  // 更新鼠标样式
    void resizeWidget(const QPoint &gMousePos);       // 重置窗体大小
    void moveWidget(const QPoint &gMousePos);         // 移动窗体
    void handleMousePressEvent(QMouseEvent *event);   // 处理鼠标按下
    void handleMouseReleaseEvent(QMouseEvent *event); // 处理鼠标释放
    void handleMouseMoveEvent(QMouseEvent *event);    // 处理鼠标移动
    void handleLeaveEvent(QEvent *event);             // 处理鼠标离开
    void handleHoverMoveEvent(QHoverEvent *event);    // 处理鼠标进入
};

// ================================================================
/**
 * 窗口控制，
 */
class WindowData {};

// ==================================================================
/**
 * 自定义的橡皮筋选择框
 * @brief The RubberBand class
 */
class RubberBand : public QRubberBand {
  public:
    RubberBand(Shape s, QWidget *p = nullptr) : QRubberBand(s, p) {
        QPalette palette;
        palette.setBrush(QPalette::WindowText, QBrush(Qt::lightGray));
        setPalette(palette); // 调色板应用到当前的橡皮筋对象上
        repaint();
    }

  protected:
    virtual void paintEvent(QPaintEvent *) {
        QStylePainter painter(this);
        QStyleOptionFocusRect option;
        option.initFrom(this);

        QPen pen;
        pen.setStyle(Qt::DashLine);
        pen.setWidth(1);
        pen.setColor(QColor(Qt::red));
        painter.setPen(pen);
        painter.drawControl(QStyle::CE_FocusFrame, option);
    }
};

// ==================================================================
/**
 * 计算鼠标是否位于左、上、右、下、左上角、左下角、右上角、右下角
 */

class CursorPosCalculator {
  public:
    explicit CursorPosCalculator();
    void reset();
    void recalculate(const QPoint &globalMousePos, const QRect &frameRect);

  public:
    bool m_bOnEdges;
    bool m_bOnLeftEdge;
    bool m_bOnRightEdge;
    bool m_bOnTopEdge;
    bool m_bOnBottomEdge;
    bool m_bOnTopLeftEdge;
    bool m_bOnBottomLeftEdge;
    bool m_bOnTopRightEdge;
    bool m_bOnBottomRightEdge;

    static int m_nBorderWidth;
    static int m_nTitleHeight;
};

#endif // WINDOWCONTROL_H

WindowControl.cpp

#include "utils/WindowControl.h"
#include "qcoreevent.h"

#include <QMouseEvent>

/**
 * @brief WindowControl::WindowControl
 */
WindowControl::WindowControl(QObject *parent) : QObject(parent) {
    // 初始化状态
    windowMoveAble = true;
    windowResizeAble = true;
    windowRubberBandOnMove = false;
    windowRubberBandOnResize = false;

    m_pressedMousePos = new CursorPosCalculator;
    m_moveMousePos = new CursorPosCalculator;
}

WindowControl::~WindowControl() {
    m_pWidget->setMouseTracking(false);           // 禁用鼠标跟踪
    m_pWidget->setWindowFlags(m_windowFlags);     // 还原窗口标志
    m_pWidget->setAttribute(Qt::WA_Hover, false); // 禁用鼠标指针悬停事件

    delete m_pRubberBand;
    m_pRubberBand = NULL;
    delete m_pressedMousePos;
    m_pressedMousePos = NULL;
    delete m_moveMousePos;
    m_moveMousePos = NULL;
}

bool WindowControl::eventFilter(QObject *obj, QEvent *event) {
    switch (event->type()) {
    case QEvent::MouseMove:
    case QEvent::HoverMove:
    case QEvent::MouseButtonPress:
    case QEvent::MouseButtonRelease:
    case QEvent::Leave: {
        if (obj == m_pWidget) {
            handleWidgetEvent(event);
            return true;
        }
    }
    default:
        return QObject::eventFilter(obj, event);
    }
}

void WindowControl::activeWindow(QWidget *window) {
    m_pWidget = window;
    window->installEventFilter(this); // 安装事件过滤器

    m_bLeftButtonPressed = false;
    m_bCursorShapeChanged = false;
    m_bLeftButtonTitlePressed = false;
    m_pRubberBand = NULL;

    m_windowFlags = m_pWidget->windowFlags();
    m_pWidget->setMouseTracking(true);           // 鼠标追踪
    m_pWidget->setAttribute(Qt::WA_Hover, true); // 启用鼠标指针悬停事件

    updateRubberBandStatus();
}

void WindowControl::removeWindow(QWidget *window) {
    if (m_pWidget) {
        delete this;
    }
}

void WindowControl::setWindowMove(bool moveAble) { windowMoveAble = moveAble; }

void WindowControl::setWindowResize(bool resizeAble) { windowResizeAble = resizeAble; }

void WindowControl::setRubberBandOnMove(bool movable) {
    windowRubberBandOnMove = movable;
    updateRubberBandStatus();
}

void WindowControl::setRubberBandOnResize(bool resizable) {
    windowRubberBandOnResize = resizable;
    updateRubberBandStatus();
}

void WindowControl::updateRubberBandStatus() {
    if (windowRubberBandOnResize || windowRubberBandOnMove) {
        if (NULL == m_pRubberBand) {
            m_pRubberBand = new RubberBand(QRubberBand::Rectangle);
        }
    } else {
        delete m_pRubberBand;
        m_pRubberBand = NULL;
    }
}

void WindowControl::handleWidgetEvent(QEvent *event) {
    switch (event->type()) {
    default:
        break;
    case QEvent::MouseButtonPress:
        handleMousePressEvent(static_cast<QMouseEvent *>(event));
        break;
    case QEvent::MouseButtonRelease:
        handleMouseReleaseEvent(static_cast<QMouseEvent *>(event));
        break;
    case QEvent::MouseMove:
        handleMouseMoveEvent(static_cast<QMouseEvent *>(event));
        break;
    case QEvent::Leave:
        handleLeaveEvent(event);
        break;
    case QEvent::HoverMove:
        handleHoverMoveEvent(static_cast<QHoverEvent *>(event));
        break;
    }
}

void WindowControl::updateCursorShape(const QPoint &gMousePos) {
    // 检查全屏或最大化状态
    if (m_pWidget->isFullScreen() || m_pWidget->isMaximized()) {
        if (m_bCursorShapeChanged) {
            m_pWidget->unsetCursor(); // 光标设置为默认
        }
        return;
    }

    m_moveMousePos->recalculate(gMousePos, m_pWidget->frameGeometry());

    if (m_moveMousePos->m_bOnTopLeftEdge || m_moveMousePos->m_bOnBottomRightEdge) {
        m_pWidget->setCursor(Qt::SizeFDiagCursor); // 对角线大小调整光标
        m_bCursorShapeChanged = true;
    } else if (m_moveMousePos->m_bOnTopRightEdge || m_moveMousePos->m_bOnBottomLeftEdge) {
        m_pWidget->setCursor(Qt::SizeBDiagCursor); // 反对角线大小调整光标
        m_bCursorShapeChanged = true;
    } else if (m_moveMousePos->m_bOnLeftEdge || m_moveMousePos->m_bOnRightEdge) {
        m_pWidget->setCursor(Qt::SizeHorCursor); // 水平调整大小光标
        m_bCursorShapeChanged = true;
    } else if (m_moveMousePos->m_bOnTopEdge || m_moveMousePos->m_bOnBottomEdge) {
        m_pWidget->setCursor(Qt::SizeVerCursor); // 垂直调整大小光标
        m_bCursorShapeChanged = true;
    } else {
        if (m_bCursorShapeChanged) {
            m_pWidget->unsetCursor(); // 恢复默认
            m_bCursorShapeChanged = false;
        }
    }
}

void WindowControl::resizeWidget(const QPoint &gMousePos) {
    QRect origRect;

    if (windowRubberBandOnResize)
        origRect = m_pRubberBand->frameGeometry();
    else
        origRect = m_pWidget->frameGeometry();

    int left = origRect.left();
    int top = origRect.top();
    int right = origRect.right();
    int bottom = origRect.bottom();
    origRect.getCoords(&left, &top, &right, &bottom);

    // int minWidth = m_pWidget->minimumWidth();
    // int minHeight = m_pWidget->minimumHeight();
    int minWidth = 40;
    int minHeight = 40;

    if (m_pressedMousePos->m_bOnTopLeftEdge) {
        left = gMousePos.x();
        top = gMousePos.y();
    } else if (m_pressedMousePos->m_bOnBottomLeftEdge) {
        left = gMousePos.x();
        bottom = gMousePos.y();
    } else if (m_pressedMousePos->m_bOnTopRightEdge) {
        right = gMousePos.x();
        top = gMousePos.y();
    } else if (m_pressedMousePos->m_bOnBottomRightEdge) {
        right = gMousePos.x();
        bottom = gMousePos.y();
    } else if (m_pressedMousePos->m_bOnLeftEdge) {
        left = gMousePos.x();
    } else if (m_pressedMousePos->m_bOnRightEdge) {
        right = gMousePos.x();
    } else if (m_pressedMousePos->m_bOnTopEdge) {
        top = gMousePos.y();
    } else if (m_pressedMousePos->m_bOnBottomEdge) {
        bottom = gMousePos.y();
    }

    QRect newRect(QPoint(left, top), QPoint(right, bottom));

    if (newRect.isValid()) {
        if (minWidth > newRect.width()) {
            if (left != origRect.left())
                newRect.setLeft(origRect.left());
            else
                newRect.setRight(origRect.right());
        }
        if (minHeight > newRect.height()) {
            if (top != origRect.top())
                newRect.setTop(origRect.top());
            else
                newRect.setBottom(origRect.bottom());
        }

        if (windowRubberBandOnResize) {
            m_pRubberBand->setGeometry(newRect);
        } else {
            m_pWidget->setGeometry(newRect);
        }
    }
}

void WindowControl::moveWidget(const QPoint &gMousePos) {
    if (windowRubberBandOnMove) {
        m_pRubberBand->move(gMousePos - m_ptDragPos);
    } else {
        m_pWidget->move(gMousePos - m_ptDragPos);
    }
}

void WindowControl::handleMousePressEvent(QMouseEvent *event) {
    if (event->button() == Qt::LeftButton) {
        m_bLeftButtonPressed = true;

        m_bLeftButtonTitlePressed = event->pos().y() < 30;

        QRect frameRect = m_pWidget->frameGeometry();
        QRect moveRect(frameRect.x(), frameRect.y(), frameRect.width(), 30);
        m_pressedMousePos->recalculate(event->globalPos(), frameRect);

        m_ptDragPos = event->globalPos() - frameRect.topLeft();

        if (m_pressedMousePos->m_bOnEdges) {
            if (windowRubberBandOnResize) {
                m_pRubberBand->setGeometry(frameRect);
                m_pRubberBand->show();
            }
        } else if (windowRubberBandOnMove) {
            if (moveRect.contains(event->globalPos())) {
                m_pRubberBand->setGeometry(frameRect);
                m_pRubberBand->show();
            }
        }
    }
}

void WindowControl::handleMouseReleaseEvent(QMouseEvent *event) {
    if (event->button() == Qt::LeftButton) {
        m_bLeftButtonPressed = false;
        m_bLeftButtonTitlePressed = false;
        m_pressedMousePos->reset();
        if (m_pRubberBand && m_pRubberBand->isVisible()) {
            m_pRubberBand->hide();
            m_pWidget->setGeometry(m_pRubberBand->geometry());
        }
    }
}

void WindowControl::handleMouseMoveEvent(QMouseEvent *event) {
    if (m_bLeftButtonPressed) {
        if (windowResizeAble && m_pressedMousePos->m_bOnEdges) {
            resizeWidget(event->globalPos());
        } else if (windowMoveAble && m_bLeftButtonTitlePressed) {
            moveWidget(event->globalPos());
        }
    } else if (windowResizeAble) {
        updateCursorShape(event->globalPos());
    }
}

void WindowControl::handleLeaveEvent(QEvent *event) {
    Q_UNUSED(event)
    if (!m_bLeftButtonPressed) {
        m_pWidget->unsetCursor();
    }
}

void WindowControl::handleHoverMoveEvent(QHoverEvent *event) {
    if (windowResizeAble) {
        updateCursorShape(m_pWidget->mapToGlobal(event->pos())); // 局部坐标转全局屏幕坐标
    }
}

// CursorPosCalculator==========================================

int CursorPosCalculator::m_nBorderWidth = 5;
int CursorPosCalculator::m_nTitleHeight = 30;

CursorPosCalculator::CursorPosCalculator() { reset(); }

void CursorPosCalculator::reset() {
    m_bOnEdges = false;
    m_bOnLeftEdge = false;
    m_bOnRightEdge = false;
    m_bOnTopEdge = false;
    m_bOnBottomEdge = false;
    m_bOnTopLeftEdge = false;
    m_bOnBottomLeftEdge = false;
    m_bOnTopRightEdge = false;
    m_bOnBottomRightEdge = false;
}

void CursorPosCalculator::recalculate(const QPoint &gMousePos, const QRect &frameRect) {
    int globalMouseX = gMousePos.x();
    int globalMouseY = gMousePos.y();

    int frameX = frameRect.x();
    int frameY = frameRect.y();

    int frameWidth = frameRect.width();
    int frameHeight = frameRect.height();

    m_bOnLeftEdge = (globalMouseX >= frameX && globalMouseX <= frameX + m_nBorderWidth);

    m_bOnRightEdge = (globalMouseX >= frameX + frameWidth - m_nBorderWidth && globalMouseX <= frameX + frameWidth);

    m_bOnTopEdge = (globalMouseY >= frameY && globalMouseY <= frameY + m_nBorderWidth);

    m_bOnBottomEdge = (globalMouseY >= frameY + frameHeight - m_nBorderWidth && globalMouseY <= frameY + frameHeight);

    m_bOnTopLeftEdge = m_bOnTopEdge && m_bOnLeftEdge;
    m_bOnBottomLeftEdge = m_bOnBottomEdge && m_bOnLeftEdge;
    m_bOnTopRightEdge = m_bOnTopEdge && m_bOnRightEdge;
    m_bOnBottomRightEdge = m_bOnBottomEdge && m_bOnRightEdge;

    m_bOnEdges = m_bOnLeftEdge || m_bOnRightEdge || m_bOnTopEdge || m_bOnBottomEdge;
}

2. 使用示例

定义基类：

#ifndef WINDOW_H
#define WINDOW_H

#include <QMainWindow>

/**
 * 自定义无边框mainwindow
 */
class Window : public QMainWindow {
    Q_OBJECT

  public:
    Window(QWidget *parent = nullptr);
    ~Window();

  private:
    void framelesshelperInit();
};

#endif // WINDOW_H

#include "component/window.h"
#include "utils/WindowControl.h"

Window::Window(QWidget *parent) : QMainWindow(parent) {
    resize(1200, 740);
    setWindowFlags(Qt::FramelessWindowHint);

    framelesshelperInit();
}

Window::~Window() {}

void Window::framelesshelperInit() {
    // this指的是要处理的窗体
    WindowControl *control = new WindowControl(this);
    control->activeWindow(this);          //激活当前窗体
    control->setWindowMove(true);         //设置窗体可移动
    control->setWindowResize(true);       //设置窗体可缩放
    control->setRubberBandOnMove(true);   //设置橡皮筋效果-可移动
    control->setRubberBandOnResize(true); //设置橡皮筋效果-可缩放
}

继承可拖动缩放的窗口：

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include "component/window.h"

#include <QMainWindow>

class MainWindow : public Window {
    Q_OBJECT

  public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();
};
#endif // MAINWINDOW_H

#include "mainwindow.h"
#include <QLabel>

MainWindow::MainWindow(QWidget *parent) : Window(parent) {
    resize(1200, 740);
    setWindowFlags(Qt::FramelessWindowHint);

    // 创建自定义标题栏
    QLabel *customTitleBar = new QLabel("自定义标题栏", this);
    customTitleBar->setStyleSheet("background-color: blue; color: white;");

    // 设置自定义标题栏
    setMenuWidget(customTitleBar);

  
}

MainWindow::~MainWindow() {}

使用：

#include "mainwindow.h"

#include "component/window.h"

#include <QApplication>

int main(int argc, char *argv[]) {
    QApplication a(argc, argv);
    MainWindow w;
    w.show();
    return a.exec();
}

控制类引用自： https://blog.csdn.net/u012959478/article/details/140658545

上述测试工程代码： https://download.csdn.net/download/qq_51355375/89783077

原文地址：https://blog.csdn.net/qq_51355375/article/details/142435365

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：C#核心（1）概述面向对象
下一篇：Taro多端统一开发解决方案

macOS开发环境配置与应用
在本文中，我们详细介绍了如何在macOS上配置一个强大的开发环境，并通过实际案例展示了如何创建和运行一个简单的Node.js Web应用。通过安装和使用各类工具，您能够实现高效的开发流程。
阅读更多2024-09-27
mac 上配置Jmeter代理进行web脚本录制过程&容易踩坑的点
jmeter启动代理服务器录制脚本、jmeter证书问题
阅读更多2024-09-27
电脑usb接口封禁如何实现？5种禁用USB接口的方法分享！(第一种你GET了吗？）
通过BIOS设置、设备管理器、注册表编辑器、专业的USB端口管理软件以及物理移除USB接口等方法，企业可以根据自身需求和实际情况，选择适合的方法来禁用USB接口。因此，对USB接口进行封闭管理，可以有
阅读更多2024-09-27
Hadoop FileSystem Shell 常用操作命令
HDFS 常用命令
阅读更多2024-09-27
java 解析excel （网络资源）
以下是一个简单的Java程序，用于读取Excel文件中的数据（参数类型为文件路径网络资源如：http://192.168.xx.xx:8080/upload/gjcTemporarySt
阅读更多2024-09-27
Fabric V2.5 通用溯源系统——使用Hyperledger Caliper压力测试
Caliper是一款测试区块链性能的工具，支持Hyperledger Fabric、Ethereum等，支持丰富的测试配置参数，测试完成后将直接输出报告，相较于tape更加专业，但是配置稍微有些复杂。
阅读更多2024-09-27
tauri中加载本地文件图片或者下载网络文件图片后存储到本地，然后通过前端页面展示
有一个需求是需要将本地上传的文件或者网络下载的文件存储到本地，并展示在前端页面上的。要想实现上述需求，需要三个步骤，配置相应的文件和文件夹访问权限，然后将文件存储到软件的相应目录中，再从目录中加载这个
阅读更多2024-09-27
CVE-2024-44902 Thinkphp反序列化漏洞
Thinkphp v6.1.3至v8.0.4版本中存在反序列化漏洞，攻击者可利用此漏洞执行任意代码。
阅读更多2024-09-27
SpringBoot 项目打成 jar 后加载外部的配置文件
其实配置项的动态刷新是通过不断的轮询Consul的HTTP API，检测相关的配置目录是否发生了变化来实现的，轮询的间隔时间可以通过spring.cloud.consul.config.watch.d
阅读更多2024-09-27
【Linux】部署 flask
这样的命令在ssh终端退出后，python进程也会被杀掉需要创建一个自定义的系统服务，来保证python程序能够在后台运行。1.创建系统服务内容如下：[Unit][Service][Install]E
阅读更多2024-09-27

QT 自定义可拖动缩放的无边框窗口，可用于mainmindow, widget

1. 用于拖动，缩放的工具类

2. 使用示例

相关文章