devbox
Li_阴宅
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

QT自定义无边框窗口（可移动控制和窗口大小调整）_qt自定义标题栏无边框窗口

作者：Li_阴宅 | 2024-08-01 00:48:33

赞

踩

qt自定义标题栏无边框窗口

         QT是一个功能强大的跨平台开发框架，它提供了丰富的界面设计工具和组件。在界面开发中，QT窗口自带的标题栏无法满足我们的需求。我们就需要自定义无边框窗口，包括自定义标题栏和窗口大小调整功能。本文将介绍如何在QT中实现这些功能。

一、简述

         本文介绍了如何使用Qt框架创建一个无边框窗口，并提供了详细的源码，包括窗口样式设置、移动区域控制和窗口大小调整功能。用于设置窗口为无边框窗口。可为窗口添加自定义标题栏、边框和系统菜单按钮。

二、 设计思路             

        首先，在QT中，我们可以通过设置窗口属性为Qt::FramelessWindowHint来实现无边框窗口BaseWindow（由于系统窗口被设置为Qt::FramelessWindowHint会导致窗口不能被拖动，需要通过捕获鼠标移动事件从而实现窗口移动。）。

        然后，我们可以通过一个自定义的QWidget来扮演标题栏的角色BaseTitleBar。在这个自定义的QWidget中，我们可以添加一些控件，比如窗口标题，关闭按钮等。我们通过自定义的标题栏和边框样式来实现无边框窗口的外观。使用titleBar类来定义标题栏的样式，其中包括标题文本和关闭按钮。通过重写QWidget的mousePressEvent、mouseMoveEvent和mouseReleaseEvent函数，我们可以实现拖动窗口的功能。

        最后，自定义FramelessHelper一个辅助类，我们可以自定义窗口的行为，如设置窗口的可移动和可缩放属性。

三、效果 

四、核心代码  
1、头文件

BaseWindow.h 

  1. #ifndef BASEWINDOW_H
  2. #define BASEWINDOW_H
  3.  
  4. #include <QWidget>
  5. #include <QMainWindow>
  6. #include "BaseTitleBar.h"
  7.  
  8. class BaseWindow : public QWidget
  9. {
  10. 	Q_OBJECT
  11.  
  12. public:
  13. 	BaseWindow(QWidget *parent = 0);
  14. 	~BaseWindow();
  15.  
  16. private:
  17. 	void initTitleBar();
  18. 	void paintEvent(QPaintEvent *event);
  19. 	void loadStyleSheet(const QString &sheetName);
  20.  
  21.  
  22. private slots:
  23. 	void onButtonMinClicked();
  24. 	void onButtonRestoreClicked();
  25. 	void onButtonMaxClicked();
  26. 	void onButtonCloseClicked();
  27.  
  28. protected:
  29.     BaseTitleBar* m_titleBar;
  30. 	
  31. };
  32.  
  33. #endif // BASEWINDOW_H

 BaseTitleBar.h

  1. #ifndef BASETITLEBAR_H
  2. #define BASETITLEBAR_H
  3.  
  4. #include <QWidget>
  5. #include <QLabel>
  6. #include <QPushButton>
  7. #include <QTimer>
  8.  
  9. enum ButtonType
  10. {
  11. 	MIN_BUTTON = 0,			// 最小化和关闭按钮;
  12. 	MIN_MAX_BUTTON ,		// 最小化、最大化和关闭按钮;
  13. 	ONLY_CLOSE_BUTTON		// 只有关闭按钮;
  14. };
  15.  
  16. class BaseTitleBar : public QWidget
  17. {
  18. 	Q_OBJECT
  19.  
  20. public:
  21. 	BaseTitleBar(QWidget *parent = NULL);
  22. 	~BaseTitleBar();
  23.  
  24. 	// 设置标题栏背景色;
  25. 	void setBackgroundColor(int r, int g, int b);
  26. 	// 设置标题栏图标;
  27. 	void setTitleIcon(QString filePath);
  28. 	// 设置标题内容;
  29. 	void setTitleContent(QString titleContent);
  30. 	// 设置标题栏长度;
  31. 	void setTitleWidth(int width);
  32. 	// 设置标题栏上按钮类型;
  33. 	void setButtonType(ButtonType buttonType);
  34. 	// 设置标题栏中的标题是否会滚动;具体可以看效果;
  35. 	void setTitleRoll();
  36.  
  37. 	// 保存/获取 最大化前窗口的位置及大小;
  38. 	void saveRestoreInfo(const QPoint point, const QSize size);
  39. 	void getRestoreInfo(QPoint& point, QSize& size);
  40.  
  41. private:
  42. 	void paintEvent(QPaintEvent *event);
  43. 	void mouseDoubleClickEvent(QMouseEvent *event);
  44. 	void mousePressEvent(QMouseEvent *event);
  45. 	void mouseMoveEvent(QMouseEvent *event);
  46. 	void mouseReleaseEvent(QMouseEvent *event);
  47.  
  48. 	// 初始化控件;
  49. 	void initControl();
  50. 	// 信号槽的绑定;
  51. 	void initConnections();
  52. 	// 加载样式文件;
  53. 	void loadStyleSheet(const QString &sheetName);
  54.  
  55. signals:
  56. 	// 按钮触发的信号;
  57. 	void signalButtonMinClicked();
  58. 	void signalButtonRestoreClicked();
  59. 	void signalButtonMaxClicked();
  60. 	void signalButtonCloseClicked();
  61.  
  62. private slots:
  63. 	// 按钮触发的槽;
  64. 	void onButtonMinClicked();
  65. 	void onButtonRestoreClicked();
  66. 	void onButtonMaxClicked();
  67. 	void onButtonCloseClicked();
  68. 	void onRollTitle();
  69.  
  70. private:
  71. 	QLabel* m_pIcon;					// 标题栏图标;
  72. 	QLabel* m_pTitleContent;			// 标题栏内容;
  73. 	QPushButton* m_pButtonMin;			// 最小化按钮;
  74. 	QPushButton* m_pButtonRestore;		// 最大化还原按钮;
  75. 	QPushButton* m_pButtonMax;			// 最大化按钮;
  76. 	QPushButton* m_pButtonClose;		// 关闭按钮;
  77. 	
  78. 	// 标题栏背景色;
  79. 	int m_colorR;
  80. 	int m_colorG;
  81. 	int m_colorB;
  82.  
  83. 	// 最大化，最小化变量;
  84. 	QPoint m_restorePos;
  85. 	QSize m_restoreSize;
  86. 	// 移动窗口的变量;
  87. 	bool m_isPressed;
  88. 	QPoint m_startMovePos;
  89. 	// 标题栏跑马灯效果时钟;
  90. 	QTimer m_titleRollTimer;
  91. 	// 标题栏内容;
  92. 	QString m_titleContent;
  93. 	// 按钮类型;
  94. 	ButtonType m_buttonType;
  95. };
  96.  
  97. #endif // BASETITLEBAR_H

 framelesshelper.h

  1. #ifndef FRAMELESSHELPER_H
  2. #define FRAMELESSHELPER_H
  3.  
  4. #include <QtGui>
  5. #include <QRubberBand>
  6. #include <QStylePainter>
  7. #include <QStyleOptionFocusRect>
  8.  
  9. class WidgetData;
  10. /*****
  11.  * FramelessHelperPrivate
  12.  * 存储界面对应的数据集合，以及是否可移动、可缩放属性
  13. *****/
  14. class FramelessHelperPrivate
  15. {
  16. public:
  17.     QHash<QWidget*, WidgetData*> m_widgetDataHash;
  18.     bool m_bWidgetMovable        : true;
  19.     bool m_bWidgetResizable      : true;
  20.     bool m_bRubberBandOnResize   : true;
  21.     bool m_bRubberBandOnMove     : true;
  22. };
  23.  
  24. class FramelessHelper : public QObject
  25. {
  26.     Q_OBJECT
  27.  
  28. public:
  29.     explicit FramelessHelper(QObject *parent = 0);
  30.     ~FramelessHelper();
  31.     // 激活窗体
  32.     void activateOn(QWidget *topLevelWidget);
  33.     // 移除窗体
  34.     void removeFrom(QWidget *topLevelWidget);
  35.     // 设置窗体移动
  36.     void setWidgetMovable(bool movable);
  37.     // 设置窗体缩放
  38.     void setWidgetResizable(bool resizable);
  39.     // 设置橡皮筋移动
  40.     void setRubberBandOnMove(bool movable);
  41.     // 设置橡皮筋缩放
  42.     void setRubberBandOnResize(bool resizable);
  43.     // 设置边框的宽度
  44.     void setBorderWidth(uint width);
  45.     // 设置标题栏高度
  46.     void setTitleHeight(uint height);
  47.  
  48.     bool widgetResizable();
  49.     bool widgetMovable();
  50.     bool rubberBandOnMove();
  51.     bool rubberBandOnResisze();
  52.     uint borderWidth();
  53.     uint titleHeight();
  54.  
  55. protected:
  56.     // 事件过滤，进行移动、缩放等
  57.     virtual bool eventFilter(QObject *obj, QEvent *event);
  58.  
  59. private:
  60.     FramelessHelperPrivate *d;
  61. };
  62.  
  63. class LinuxRubberBand : public QRubberBand
  64. {
  65. public:
  66.     LinuxRubberBand(Shape s, QWidget * p = 0 )
  67.         : QRubberBand( s, p )
  68.     {
  69.         QPalette palette;
  70.         palette.setBrush( QPalette::WindowText, QBrush(Qt::lightGray) );
  71.         setPalette(palette);
  72.         repaint();
  73.     }
  74.  
  75. protected:
  76.     virtual void paintEvent( QPaintEvent * )
  77.     {
  78.         QStylePainter painter(this);
  79.         QStyleOptionFocusRect option;
  80.         option.initFrom(this);
  81.  
  82.         QPen pen;
  83.         pen.setStyle(Qt::DashLine);
  84.         pen.setWidth(1);
  85.         pen.setColor(QColor(Qt::red));
  86.         painter.setPen(pen);
  87.         painter.drawControl(QStyle::CE_FocusFrame, option);
  88.     }
  89.  
  90. };
  91.  
  92. /*****
  93.  * CursorPosCalculator
  94.  * 计算鼠标是否位于左、上、右、下、左上角、左下角、右上角、右下角
  95. *****/
  96. class CursorPosCalculator
  97. {
  98. public:
  99.     explicit CursorPosCalculator();
  100.     void reset();
  101.     void recalculate(const QPoint &globalMousePos, const QRect &frameRect);
  102.  
  103. public:
  104.     bool m_bOnEdges              : true;
  105.     bool m_bOnLeftEdge           : true;
  106.     bool m_bOnRightEdge          : true;
  107.     bool m_bOnTopEdge            : true;
  108.     bool m_bOnBottomEdge         : true;
  109.     bool m_bOnTopLeftEdge        : true;
  110.     bool m_bOnBottomLeftEdge     : true;
  111.     bool m_bOnTopRightEdge       : true;
  112.     bool m_bOnBottomRightEdge    : true;
  113.  
  114.     static int m_nBorderWidth;
  115.     static int m_nTitleHeight;
  116. };
  117.  
  118. /*****
  119.  * WidgetData
  120.  * 更新鼠标样式、移动窗体、缩放窗体
  121. *****/
  122. class WidgetData
  123. {
  124. public:
  125.     explicit WidgetData(FramelessHelperPrivate *d, QWidget *pTopLevelWidget);
  126.     ~WidgetData();
  127.     QWidget* widget();
  128.     // 处理鼠标事件-划过、厉害、按下、释放、移动
  129.     void handleWidgetEvent(QEvent *event);
  130.     // 更新橡皮筋状态
  131.     void updateRubberBandStatus();
  132.  
  133. private:
  134.     // 更新鼠标样式
  135.     void updateCursorShape(const QPoint &gMousePos);
  136.     // 重置窗体大小
  137.     void resizeWidget(const QPoint &gMousePos);
  138.     // 移动窗体
  139.     void moveWidget(const QPoint &gMousePos);
  140.     // 处理鼠标按下
  141.     void handleMousePressEvent(QMouseEvent *event);
  142.     // 处理鼠标释放
  143.     void handleMouseReleaseEvent(QMouseEvent *event);
  144.     // 处理鼠标移动
  145.     void handleMouseMoveEvent(QMouseEvent *event);
  146.     // 处理鼠标离开
  147.     void handleLeaveEvent(QEvent *event);
  148.     // 处理鼠标进入
  149.     void handleHoverMoveEvent(QHoverEvent *event);
  150.  
  151. private:
  152.     FramelessHelperPrivate *d;
  153.     LinuxRubberBand *m_pRubberBand;
  154.     QWidget *m_pWidget;
  155.     QPoint m_ptDragPos;
  156.     CursorPosCalculator m_pressedMousePos;
  157.     CursorPosCalculator m_moveMousePos;
  158.     bool m_bLeftButtonPressed;
  159.     bool m_bCursorShapeChanged;
  160.     bool m_bLeftButtonTitlePressed;
  161.     Qt::WindowFlags m_windowFlags;
  162. };
  163.  
  164. #endif // FRAMELESSHELPER_H
2、实现代码

BaseWindow.cpp 

  1. #include "BaseWindow.h"
  2. #include <QDesktopWidget>
  3. #include <QApplication>
  4. #include <QPainter>
  5. #include <QFile>
  6.  
  7. BaseWindow::BaseWindow(QWidget *parent)
  8.     : QWidget(parent)
  9. {
  10. 	// FramelessWindowHint属性设置窗口去除边框;
  11. 	// WindowMinimizeButtonHint 属性设置在窗口最小化时，点击任务栏窗口可以显示出原窗口;
  12. 	this->setWindowFlags(Qt::FramelessWindowHint | Qt::WindowMinimizeButtonHint);
  13. 	// 设置窗口背景透明;
  14.     setAttribute(Qt::WA_TranslucentBackground);
  15. 	// 初始化标题栏;
  16. 	initTitleBar();
  17. }
  18.  
  19. BaseWindow::~BaseWindow()
  20. {
  21.  
  22. }
  23.  
  24. void BaseWindow::initTitleBar()
  25. {
  26.     m_titleBar = new BaseTitleBar(this);
  27. 	m_titleBar->move(0, 0);
  28.  
  29. 	connect(m_titleBar, SIGNAL(signalButtonMinClicked()), this, SLOT(onButtonMinClicked()));
  30. 	connect(m_titleBar, SIGNAL(signalButtonRestoreClicked()), this, SLOT(onButtonRestoreClicked()));
  31. 	connect(m_titleBar, SIGNAL(signalButtonMaxClicked()), this, SLOT(onButtonMaxClicked()));
  32. 	connect(m_titleBar, SIGNAL(signalButtonCloseClicked()), this, SLOT(onButtonCloseClicked()));
  33.  
  34. }
  35.  
  36. void BaseWindow::paintEvent(QPaintEvent* event)
  37. {
  38. 	//设置背景色;
  39.     QPainter painter(this);
  40.     QPainterPath pathBack;
  41.     pathBack.setFillRule(Qt::WindingFill);
  42.     pathBack.addRoundedRect(QRect(0, 0, this->width(), this->height()), 3, 3);
  43.     painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
  44.     painter.fillPath(pathBack, QBrush(QColor(127, 127, 127)));
  45.  
  46.  
  47. 	return QWidget::paintEvent(event);
  48. }
  49.  
  50. void BaseWindow::loadStyleSheet(const QString &sheetName)
  51. {
  52. 	QFile file(":/Resources/" + sheetName + ".css");
  53. 	file.open(QFile::ReadOnly);
  54. 	if (file.isOpen())
  55. 	{
  56. 		QString styleSheet = this->styleSheet();
  57. 		styleSheet += QLatin1String(file.readAll());
  58. 		this->setStyleSheet(styleSheet);
  59.     }
  60. }
  61.  
  62.  
  63. void BaseWindow::onButtonMinClicked()
  64. {
  65. 	if (Qt::Tool == (windowFlags() & Qt::Tool))
  66. 	{
  67. 		hide();    //设置了Qt::Tool 如果调用showMinimized()则窗口就销毁了？？？
  68. 	}
  69. 	else
  70. 	{
  71. 		showMinimized();
  72. 	}
  73. }
  74.  
  75. void BaseWindow::onButtonRestoreClicked()
  76. {
  77. 	QPoint windowPos;
  78. 	QSize windowSize;
  79. 	m_titleBar->getRestoreInfo(windowPos, windowSize);
  80. 	this->setGeometry(QRect(windowPos, windowSize));
  81. }
  82.  
  83. void BaseWindow::onButtonMaxClicked()
  84. {
  85. 	m_titleBar->saveRestoreInfo(this->pos(), QSize(this->width(), this->height()));
  86. 	QRect desktopRect = QApplication::desktop()->availableGeometry();
  87. 	QRect FactRect = QRect(desktopRect.x() - 3, desktopRect.y() - 3, desktopRect.width() + 6, desktopRect.height() + 6);
  88. 	setGeometry(FactRect);
  89. }
  90.  
  91. void BaseWindow::onButtonCloseClicked()
  92. {
  93. 	close();
  94. }

BaseTitleBar.cpp

  1. #include "BaseTitleBar.h"
  2. #include <QHBoxLayout>
  3. #include <QPainter>
  4. #include <QFile>
  5. #include <QMouseEvent>
  6.  
  7. #define BUTTON_HEIGHT 30		// 按钮高度;
  8. #define BUTTON_WIDTH 30			// 按钮宽度;
  9. #define TITLE_HEIGHT 30			// 标题栏高度;
  10.  
  11. BaseTitleBar::BaseTitleBar(QWidget *parent)
  12. 	: QWidget(parent)
  13. 	, m_colorR(153)
  14. 	, m_colorG(153)
  15. 	, m_colorB(153)
  16. 	, m_isPressed(false)
  17. 	, m_buttonType(MIN_MAX_BUTTON)
  18. {
  19. 	// 初始化;
  20. 	initControl();
  21. 	initConnections();
  22.     loadStyleSheet("MyTitle");
  23. }
  24.  
  25. BaseTitleBar::~BaseTitleBar()
  26. {
  27.  
  28. }
  29.  
  30. // 初始化控件;
  31. void BaseTitleBar::initControl()
  32. {
  33. 	m_pIcon = new QLabel;
  34. 	m_pTitleContent = new QLabel;
  35.  
  36. 	m_pButtonMin = new QPushButton;
  37. 	m_pButtonRestore = new QPushButton;
  38. 	m_pButtonMax = new QPushButton;
  39. 	m_pButtonClose = new QPushButton;
  40.  
  41. 	m_pButtonMin->setFixedSize(QSize(BUTTON_WIDTH, BUTTON_HEIGHT));
  42. 	m_pButtonRestore->setFixedSize(QSize(BUTTON_WIDTH, BUTTON_HEIGHT));
  43. 	m_pButtonMax->setFixedSize(QSize(BUTTON_WIDTH, BUTTON_HEIGHT));
  44. 	m_pButtonClose->setFixedSize(QSize(BUTTON_WIDTH, BUTTON_HEIGHT));
  45.  
  46. 	m_pTitleContent->setObjectName("TitleContent");
  47. 	m_pButtonMin->setObjectName("ButtonMin");
  48. 	m_pButtonRestore->setObjectName("ButtonRestore");
  49. 	m_pButtonMax->setObjectName("ButtonMax");
  50. 	m_pButtonClose->setObjectName("ButtonClose");
  51.  
  52. 	QHBoxLayout* mylayout = new QHBoxLayout(this);
  53. 	mylayout->addWidget(m_pIcon);
  54. 	mylayout->addWidget(m_pTitleContent);
  55.  
  56. 	mylayout->addWidget(m_pButtonMin);
  57. 	mylayout->addWidget(m_pButtonRestore);
  58. 	mylayout->addWidget(m_pButtonMax);
  59. 	mylayout->addWidget(m_pButtonClose);
  60.  
  61. 	mylayout->setContentsMargins(5, 0, 0, 0);
  62.  
  63. 	m_pTitleContent->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
  64. 	this->setFixedHeight(TITLE_HEIGHT);
  65. 	this->setWindowFlags(Qt::FramelessWindowHint);
  66. }
  67.  
  68. // 信号槽的绑定;
  69. void BaseTitleBar::initConnections()
  70. {
  71. 	connect(m_pButtonMin, SIGNAL(clicked()), this, SLOT(onButtonMinClicked()));
  72. 	connect(m_pButtonRestore, SIGNAL(clicked()), this, SLOT(onButtonRestoreClicked()));
  73. 	connect(m_pButtonMax, SIGNAL(clicked()), this, SLOT(onButtonMaxClicked()));
  74. 	connect(m_pButtonClose, SIGNAL(clicked()), this, SLOT(onButtonCloseClicked()));
  75. }
  76.  
  77. // 设置标题栏背景色,在paintEvent事件中进行绘制标题栏背景色;
  78. //在构造函数中给了默认值，可以外部设置颜色值改变标题栏背景色;
  79. void BaseTitleBar::setBackgroundColor(int r, int g, int b)
  80. {
  81. 	m_colorR = r;
  82. 	m_colorG = g;
  83. 	m_colorB = b;
  84. 	// 重新绘制（调用paintEvent事件）;
  85. 	update();
  86. }
  87.  
  88. // 设置标题栏图标;
  89. void BaseTitleBar::setTitleIcon(QString filePath)
  90. {
  91. 	QPixmap titleIcon(filePath);
  92.     m_pIcon->setPixmap(titleIcon.scaled(25 , 25));
  93. }
  94.  
  95. // 设置标题内容;
  96. void BaseTitleBar::setTitleContent(QString titleContent)
  97. {
  98. 	m_pTitleContent->setText(titleContent);
  99. 	m_titleContent = titleContent;
  100. }
  101.  
  102. // 设置标题栏长度;
  103. void BaseTitleBar::setTitleWidth(int width)
  104. {
  105. 	this->setFixedWidth(width);
  106. }
  107.  
  108. // 设置标题栏上按钮类型;
  109. // 由于不同窗口标题栏上的按钮都不一样，所以可以自定义标题栏中的按钮;
  110. // 这里提供了四个按钮，分别为最小化、还原、最大化、关闭按钮，如果需要其他按钮可自行添加设置;
  111. void BaseTitleBar::setButtonType(ButtonType buttonType)
  112. {
  113. 	m_buttonType = buttonType;
  114.  
  115. 	switch (buttonType)
  116. 	{
  117. 	case MIN_BUTTON:
  118. 		{
  119. 			m_pButtonRestore->setVisible(false);
  120. 			m_pButtonMax->setVisible(false);
  121. 		}
  122. 		break;
  123. 	case MIN_MAX_BUTTON:
  124. 		{
  125. 			m_pButtonRestore->setVisible(false);
  126. 		}
  127. 		break;
  128. 	case ONLY_CLOSE_BUTTON:
  129. 		{
  130. 			m_pButtonMin->setVisible(false);
  131. 			m_pButtonRestore->setVisible(false);
  132. 			m_pButtonMax->setVisible(false);
  133. 		}
  134. 		break;
  135. 	default:
  136. 		break;
  137. 	}
  138. }
  139.  
  140. // 设置标题栏中的标题是否会自动滚动，跑马灯的效果;
  141. // 一般情况下标题栏中的标题内容是不滚动的，但是既然自定义就看自己需要嘛，想怎么设计就怎么搞O(∩_∩)O！
  142. void BaseTitleBar::setTitleRoll()
  143. {
  144. 	connect(&m_titleRollTimer, SIGNAL(timeout()), this, SLOT(onRollTitle()));
  145. 	m_titleRollTimer.start(200);
  146. }
  147.  
  148. // 保存窗口最大化前窗口的位置以及大小;
  149. void BaseTitleBar::saveRestoreInfo(const QPoint point, const QSize size)
  150. {
  151. 	m_restorePos = point;
  152. 	m_restoreSize = size;
  153. }
  154.  
  155. // 获取窗口最大化前窗口的位置以及大小;
  156. void BaseTitleBar::getRestoreInfo(QPoint& point, QSize& size)
  157. {
  158. 	point = m_restorePos;
  159. 	size = m_restoreSize;
  160. }
  161.  
  162. // 绘制标题栏背景色;
  163. void BaseTitleBar::paintEvent(QPaintEvent *event)
  164. {
  165. 	//设置背景色;
  166. 	QPainter painter(this);
  167. 	QPainterPath pathBack;
  168. 	pathBack.setFillRule(Qt::WindingFill);
  169. 	pathBack.addRoundedRect(QRect(0, 0, this->width(), this->height()), 3, 3);
  170. 	painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
  171. 	painter.fillPath(pathBack, QBrush(QColor(m_colorR, m_colorG, m_colorB)));
  172.  
  173. 	// 当窗口最大化或者还原后，窗口长度变了，标题栏的长度应当一起改变;
  174. 	if (this->width() != this->parentWidget()->width())
  175. 	{
  176. 		this->setFixedWidth(this->parentWidget()->width());
  177. 	}
  178. 	QWidget::paintEvent(event);
  179. }
  180.  
  181. // 双击响应事件，主要是实现双击标题栏进行最大化和最小化操作;
  182. void BaseTitleBar::mouseDoubleClickEvent(QMouseEvent *event)
  183. {
  184. 	// 只有存在最大化、还原按钮时双击才有效;
  185. 	if (m_buttonType == MIN_MAX_BUTTON)
  186. 	{
  187. 		// 通过最大化按钮的状态判断当前窗口是处于最大化还是原始大小状态;
  188. 		// 或者通过单独设置变量来表示当前窗口状态;
  189. 		if (m_pButtonMax->isVisible())
  190. 		{
  191. 			onButtonMaxClicked();
  192. 		}
  193. 		else
  194. 		{
  195. 			onButtonRestoreClicked();
  196. 		}
  197. 	}	
  198.  
  199. 	return QWidget::mouseDoubleClickEvent(event);
  200. }
  201.  
  202. // 以下通过mousePressEvent、mouseMoveEvent、mouseReleaseEvent三个事件实现了鼠标拖动标题栏移动窗口的效果;
  203. void BaseTitleBar::mousePressEvent(QMouseEvent *event)
  204. {
  205.  
  206.     return QWidget::mousePressEvent(event);
  207.  
  208.     if (m_buttonType == MIN_MAX_BUTTON)
  209.     {
  210.         // 在窗口最大化时禁止拖动窗口;
  211.         if (m_pButtonMax->isVisible())
  212.         {
  213.             m_isPressed = true;
  214.             m_startMovePos = event->globalPos();
  215.         }
  216.     }
  217.     else
  218.     {
  219.         m_isPressed = true;
  220.         m_startMovePos = event->globalPos();
  221.     }
  222.  
  223. //	return QWidget::mousePressEvent(event);
  224. }
  225.  
  226. void BaseTitleBar::mouseMoveEvent(QMouseEvent *event)
  227. {
  228. 	if (m_isPressed)
  229. 	{
  230. 		QPoint movePoint = event->globalPos() - m_startMovePos;
  231. 		QPoint widgetPos = this->parentWidget()->pos();
  232. 		m_startMovePos = event->globalPos();
  233. 		this->parentWidget()->move(widgetPos.x() + movePoint.x(), widgetPos.y() + movePoint.y());
  234. 	}
  235. 	return QWidget::mouseMoveEvent(event);
  236. }
  237.  
  238. void BaseTitleBar::mouseReleaseEvent(QMouseEvent *event)
  239. {
  240. 	m_isPressed = false;
  241. 	return QWidget::mouseReleaseEvent(event);
  242. }
  243.  
  244. // 加载本地样式文件;
  245. // 可以将样式直接写在文件中，程序运行时直接加载进来;
  246. void BaseTitleBar::loadStyleSheet(const QString &sheetName)
  247. {
  248.     QFile file(":/TitleBarRc/" + sheetName + ".css");
  249. 	file.open(QFile::ReadOnly);
  250. 	if (file.isOpen())
  251. 	{
  252. 		QString styleSheet = this->styleSheet();
  253. 		styleSheet += QLatin1String(file.readAll());
  254. 		this->setStyleSheet(styleSheet);
  255. 	}
  256. }
  257.  
  258. // 以下为按钮操作响应的槽;
  259. void BaseTitleBar::onButtonMinClicked()
  260. {
  261. 	emit signalButtonMinClicked();
  262. }
  263.  
  264. void BaseTitleBar::onButtonRestoreClicked()
  265. {
  266. 	m_pButtonRestore->setVisible(false);
  267.  	m_pButtonMax->setVisible(true);
  268. 	emit signalButtonRestoreClicked();
  269. }
  270.  
  271. void BaseTitleBar::onButtonMaxClicked()
  272. {
  273.  	m_pButtonMax->setVisible(false);
  274. 	m_pButtonRestore->setVisible(true);
  275. 	emit signalButtonMaxClicked();
  276. }
  277.  
  278. void BaseTitleBar::onButtonCloseClicked()
  279. {
  280. 	emit signalButtonCloseClicked();
  281. }
  282.  
  283. // 该方法主要是让标题栏中的标题显示为滚动的效果;
  284. void BaseTitleBar::onRollTitle()
  285. {
  286. 	static int nPos = 0;
  287. 	QString titleContent = m_titleContent;
  288. 	// 当截取的位置比字符串长时，从头开始;
  289. 	if (nPos > titleContent.length())
  290. 		nPos = 0;
  291.  
  292. 	m_pTitleContent->setText(titleContent.mid(nPos));
  293. 	nPos++;
  294. }

 framelesshelper.cpp

  1. #include "framelesshelper.h"
  2.  
  3. int CursorPosCalculator::m_nBorderWidth = 5;
  4. int CursorPosCalculator::m_nTitleHeight = 30;
  5. /***** CursorPosCalculator *****/
  6. CursorPosCalculator::CursorPosCalculator()
  7. {
  8.     reset();
  9. }
  10.  
  11. void CursorPosCalculator::reset()
  12. {
  13.     m_bOnEdges = false;
  14.     m_bOnLeftEdge = false;
  15.     m_bOnRightEdge = false;
  16.     m_bOnTopEdge = false;
  17.     m_bOnBottomEdge = false;
  18.     m_bOnTopLeftEdge = false;
  19.     m_bOnBottomLeftEdge = false;
  20.     m_bOnTopRightEdge  = false;
  21.     m_bOnBottomRightEdge = false;
  22. }
  23.  
  24. void CursorPosCalculator::recalculate(const QPoint &gMousePos, const QRect &frameRect)
  25. {
  26.     int globalMouseX = gMousePos.x();
  27.     int globalMouseY = gMousePos.y();
  28.  
  29.     int frameX = frameRect.x();
  30.     int frameY = frameRect.y();
  31.  
  32.     int frameWidth = frameRect.width();
  33.     int frameHeight = frameRect.height();
  34.  
  35.     m_bOnLeftEdge = (globalMouseX >= frameX &&
  36.                   globalMouseX <= frameX + m_nBorderWidth );
  37.  
  38.  
  39.     m_bOnRightEdge = (globalMouseX >= frameX + frameWidth - m_nBorderWidth &&
  40.                    globalMouseX <= frameX + frameWidth);
  41.  
  42.     m_bOnTopEdge = (globalMouseY >= frameY &&
  43.                  globalMouseY <= frameY + m_nBorderWidth );
  44.  
  45.     m_bOnBottomEdge = (globalMouseY >= frameY + frameHeight - m_nBorderWidth &&
  46.                     globalMouseY <= frameY + frameHeight);
  47.  
  48.     m_bOnTopLeftEdge = m_bOnTopEdge && m_bOnLeftEdge;
  49.     m_bOnBottomLeftEdge = m_bOnBottomEdge && m_bOnLeftEdge;
  50.     m_bOnTopRightEdge = m_bOnTopEdge && m_bOnRightEdge;
  51.     m_bOnBottomRightEdge = m_bOnBottomEdge && m_bOnRightEdge;
  52.  
  53.     m_bOnEdges = m_bOnLeftEdge || m_bOnRightEdge || m_bOnTopEdge || m_bOnBottomEdge;
  54. }
  55.  
  56. /***** WidgetData *****/
  57. WidgetData::WidgetData(FramelessHelperPrivate *_d, QWidget *pTopLevelWidget)
  58. {
  59.     d = _d;
  60.     m_pWidget = pTopLevelWidget;
  61.     m_bLeftButtonPressed = false;
  62.     m_bCursorShapeChanged = false;
  63.     m_bLeftButtonTitlePressed = false;
  64.     m_pRubberBand = NULL;
  65.  
  66.     m_windowFlags = m_pWidget->windowFlags();
  67.     m_pWidget->setMouseTracking(true);
  68.     m_pWidget->setAttribute(Qt::WA_Hover, true);
  69.  
  70.     updateRubberBandStatus();
  71. }
  72.  
  73. WidgetData::~WidgetData()
  74. {
  75.     m_pWidget->setMouseTracking(false);
  76.     m_pWidget->setWindowFlags(m_windowFlags);
  77.     m_pWidget->setAttribute(Qt::WA_Hover, false);
  78.  
  79.     delete m_pRubberBand;
  80.     m_pRubberBand = NULL;
  81. }
  82.  
  83. QWidget* WidgetData::widget()
  84. {
  85.     return m_pWidget;
  86. }
  87.  
  88. void WidgetData::handleWidgetEvent(QEvent *event)
  89. {
  90.     switch (event->type())
  91.     {
  92.     default:
  93.         break;
  94.     case QEvent::MouseButtonPress:
  95.         handleMousePressEvent(static_cast<QMouseEvent*>(event));
  96.         break;
  97.     case QEvent::MouseButtonRelease:
  98.         handleMouseReleaseEvent(static_cast<QMouseEvent*>(event));
  99.         break;
  100.     case QEvent::MouseMove:
  101.         handleMouseMoveEvent(static_cast<QMouseEvent*>(event));
  102.         break;
  103.     case QEvent::Leave:
  104.         handleLeaveEvent(static_cast<QMouseEvent*>(event));
  105.         break;
  106.     case QEvent::HoverMove:
  107.         handleHoverMoveEvent(static_cast<QHoverEvent*>(event));
  108.         break;
  109.     }
  110. }
  111.  
  112. void WidgetData::updateRubberBandStatus()
  113. {
  114.     if (d->m_bRubberBandOnMove || d->m_bRubberBandOnResize)
  115.     {
  116.         if (NULL == m_pRubberBand) {
  117.             m_pRubberBand = new LinuxRubberBand(QRubberBand::Rectangle);
  118.         }
  119.     }
  120.     else
  121.     {
  122.         delete m_pRubberBand;
  123.         m_pRubberBand = NULL;
  124.     }
  125. }
  126.  
  127. void WidgetData::updateCursorShape(const QPoint &gMousePos)
  128. {
  129.     if (m_pWidget->isFullScreen() || m_pWidget->isMaximized())
  130.     {
  131.         if (m_bCursorShapeChanged)
  132.         {
  133.             m_pWidget->unsetCursor();
  134.         }
  135.         return;
  136.     }
  137.  
  138.     m_moveMousePos.recalculate(gMousePos, m_pWidget->frameGeometry());
  139.  
  140.     if(m_moveMousePos.m_bOnTopLeftEdge || m_moveMousePos.m_bOnBottomRightEdge)
  141.     {
  142.         m_pWidget->setCursor( Qt::SizeFDiagCursor );
  143.         m_bCursorShapeChanged = true;
  144.     }
  145.     else if(m_moveMousePos.m_bOnTopRightEdge || m_moveMousePos.m_bOnBottomLeftEdge)
  146.     {
  147.         m_pWidget->setCursor( Qt::SizeBDiagCursor );
  148.         m_bCursorShapeChanged = true;
  149.     }
  150.     else if(m_moveMousePos.m_bOnLeftEdge || m_moveMousePos.m_bOnRightEdge)
  151.     {
  152.         m_pWidget->setCursor( Qt::SizeHorCursor );
  153.         m_bCursorShapeChanged = true;
  154.     }
  155.     else if(m_moveMousePos.m_bOnTopEdge || m_moveMousePos.m_bOnBottomEdge)
  156.     {
  157.         m_pWidget->setCursor( Qt::SizeVerCursor );
  158.         m_bCursorShapeChanged = true;
  159.     }
  160.     else
  161.     {
  162.         if (m_bCursorShapeChanged)
  163.         {
  164.             m_pWidget->unsetCursor();
  165.             m_bCursorShapeChanged = false;
  166.         }
  167.     }
  168. }
  169.  
  170. void WidgetData::resizeWidget(const QPoint &gMousePos)
  171. {
  172.     QRect origRect;
  173.  
  174.     if (d->m_bRubberBandOnResize)
  175.         origRect = m_pRubberBand->frameGeometry();
  176.     else
  177.         origRect = m_pWidget->frameGeometry();
  178.  
  179.     int left = origRect.left();
  180.     int top = origRect.top();
  181.     int right = origRect.right();
  182.     int bottom = origRect.bottom();
  183.     origRect.getCoords(&left, &top, &right, &bottom);
  184.  
  185.     //int minWidth = m_pWidget->minimumWidth();
  186.     //int minHeight = m_pWidget->minimumHeight();
  187.     int minWidth = 40;
  188.     int minHeight = 40;
  189.  
  190.     if (m_pressedMousePos.m_bOnTopLeftEdge)
  191.     {
  192.         left = gMousePos.x();
  193.         top = gMousePos.y();
  194.     }
  195.     else if (m_pressedMousePos.m_bOnBottomLeftEdge)
  196.     {
  197.         left = gMousePos.x();
  198.         bottom = gMousePos.y();
  199.     }
  200.     else if (m_pressedMousePos.m_bOnTopRightEdge)
  201.     {
  202.         right = gMousePos.x();
  203.         top = gMousePos.y();
  204.     }
  205.     else if (m_pressedMousePos.m_bOnBottomRightEdge)
  206.     {
  207.         right = gMousePos.x();
  208.         bottom = gMousePos.y();
  209.     }
  210.     else if (m_pressedMousePos.m_bOnLeftEdge)
  211.     {
  212.         left = gMousePos.x();
  213.     }
  214.     else if (m_pressedMousePos.m_bOnRightEdge)
  215.     {
  216.         right = gMousePos.x();
  217.     }
  218.     else if (m_pressedMousePos.m_bOnTopEdge)
  219.     {
  220.         top = gMousePos.y();
  221.     }
  222.     else if (m_pressedMousePos.m_bOnBottomEdge)
  223.     {
  224.         bottom = gMousePos.y();
  225.     }
  226.  
  227.     QRect newRect(QPoint(left, top), QPoint(right, bottom));
  228.  
  229.     if (newRect.isValid())
  230.     {
  231.         if (minWidth > newRect.width())
  232.         {
  233.             if (left != origRect.left())
  234.                 newRect.setLeft(origRect.left());
  235.             else
  236.                 newRect.setRight(origRect.right());
  237.         }
  238.         if (minHeight > newRect.height())
  239.         {
  240.             if (top != origRect.top())
  241.                 newRect.setTop(origRect.top());
  242.             else
  243.                 newRect.setBottom(origRect.bottom());
  244.         }
  245.  
  246.         if (d->m_bRubberBandOnResize)
  247.         {
  248.             m_pRubberBand->setGeometry(newRect);
  249.         }
  250.         else
  251.         {
  252.             m_pWidget->setGeometry(newRect);
  253.         }
  254.     }
  255. }
  256.  
  257. void WidgetData::moveWidget(const QPoint& gMousePos)
  258. {
  259.     if (d->m_bRubberBandOnMove)
  260.     {
  261.         m_pRubberBand->move(gMousePos - m_ptDragPos);
  262.     }
  263.     else
  264.     {
  265.         m_pWidget->move(gMousePos - m_ptDragPos);
  266.     }
  267. }
  268.  
  269. void WidgetData::handleMousePressEvent(QMouseEvent *event)
  270. {
  271.     if (event->button() == Qt::LeftButton)
  272.     {
  273.         m_bLeftButtonPressed = true;
  274.         m_bLeftButtonTitlePressed = event->pos().y() < m_moveMousePos.m_nTitleHeight;
  275.  
  276.         QRect frameRect = m_pWidget->frameGeometry();
  277.         QRect moveRect(frameRect.x(), frameRect.y(), frameRect.width(), 30);
  278.         m_pressedMousePos.recalculate(event->globalPos(), frameRect);
  279.  
  280.         m_ptDragPos = event->globalPos() - frameRect.topLeft();
  281.  
  282.         if (m_pressedMousePos.m_bOnEdges)
  283.         {
  284.             if (d->m_bRubberBandOnResize)
  285.             {
  286.                 m_pRubberBand->setGeometry(frameRect);
  287.                 m_pRubberBand->show();
  288.             }
  289.         }
  290.         else if (d->m_bRubberBandOnMove)
  291.         {
  292.             if (moveRect.contains(event->globalPos())) {
  293.                 m_pRubberBand->setGeometry(frameRect);
  294.                 m_pRubberBand->show();
  295.             }
  296.         }
  297.     }
  298. }
  299.  
  300. void WidgetData::handleMouseReleaseEvent(QMouseEvent *event)
  301. {
  302.     if (event->button() == Qt::LeftButton)
  303.     {
  304.         m_bLeftButtonPressed = false;
  305.         m_bLeftButtonTitlePressed = false;
  306.         m_pressedMousePos.reset();
  307.         if (m_pRubberBand && m_pRubberBand->isVisible())
  308.         {
  309.             m_pRubberBand->hide();
  310.             m_pWidget->setGeometry(m_pRubberBand->geometry());
  311.         }
  312.     }
  313. }
  314.  
  315. void WidgetData::handleMouseMoveEvent(QMouseEvent *event)
  316. {
  317.     if (m_bLeftButtonPressed)
  318.     {
  319.         if (d->m_bWidgetResizable && m_pressedMousePos.m_bOnEdges)
  320.         {
  321.             resizeWidget(event->globalPos());
  322.         }
  323.         else if (d->m_bWidgetMovable && m_bLeftButtonTitlePressed)
  324.         {
  325.             moveWidget(event->globalPos());
  326.         }
  327.     }
  328.     else if (d->m_bWidgetResizable)
  329.     {
  330.         updateCursorShape(event->globalPos());
  331.     }
  332. }
  333.  
  334. void WidgetData::handleLeaveEvent(QEvent *event)
  335. {
  336.     Q_UNUSED(event)
  337.     if (!m_bLeftButtonPressed)
  338.     {
  339.         m_pWidget->unsetCursor();
  340.     }
  341. }
  342.  
  343. void WidgetData::handleHoverMoveEvent(QHoverEvent *event)
  344. {
  345.     if (d->m_bWidgetResizable)
  346.     {
  347.         updateCursorShape(m_pWidget->mapToGlobal(event->pos()));
  348.     }
  349. }
  350.  
  351. /*****FramelessHelper*****/
  352. FramelessHelper::FramelessHelper(QObject *parent)
  353.     : QObject(parent),
  354.       d(new FramelessHelperPrivate())
  355. {
  356.     d->m_bWidgetMovable = true;
  357.     d->m_bWidgetResizable = true;
  358.     d->m_bRubberBandOnResize = false;
  359.     d->m_bRubberBandOnMove = false;
  360. }
  361.  
  362. FramelessHelper::~FramelessHelper()
  363. {
  364.     QList<QWidget*> keys = d->m_widgetDataHash.keys();
  365.     int size = keys.size();
  366.     for (int i = 0; i < size; ++i) {
  367.         delete d->m_widgetDataHash.take(keys[i]);
  368.     }
  369.  
  370.     delete d;
  371. }
  372.  
  373. bool FramelessHelper::eventFilter(QObject *obj, QEvent *event)
  374. {
  375.     switch (event->type())
  376.     {
  377.     case QEvent::MouseMove:
  378.     case QEvent::HoverMove:
  379.     case QEvent::MouseButtonPress:
  380.     case QEvent::MouseButtonRelease:
  381.     case QEvent::Leave:
  382.     {
  383.         WidgetData *data = d->m_widgetDataHash.value(static_cast<QWidget*>(obj));
  384.         if (data)
  385.         {
  386.             data->handleWidgetEvent(event);
  387.             return true;
  388.         }
  389.     }
  390.     }
  391.     return QObject::eventFilter(obj, event);
  392. }
  393.  
  394. void FramelessHelper::activateOn(QWidget *topLevelWidget)
  395. {
  396.     if (!d->m_widgetDataHash.contains(topLevelWidget))
  397.     {
  398.         WidgetData *data = new WidgetData(d, topLevelWidget);
  399.         d->m_widgetDataHash.insert(topLevelWidget, data);
  400.         topLevelWidget->installEventFilter(this);
  401.     }
  402. }
  403.  
  404. void FramelessHelper::removeFrom(QWidget *topLevelWidget)
  405. {
  406.     WidgetData *data = d->m_widgetDataHash.take(topLevelWidget);
  407.     if (data)
  408.     {
  409.         topLevelWidget->removeEventFilter(this);
  410.         delete data;
  411.     }
  412. }
  413.  
  414. void FramelessHelper::setRubberBandOnMove(bool movable)
  415. {
  416.     d->m_bRubberBandOnMove = movable;
  417.     QList<WidgetData*> list = d->m_widgetDataHash.values();
  418.     foreach (WidgetData *data, list)
  419.     {
  420.         data->updateRubberBandStatus();
  421.     }
  422. }
  423.  
  424. void FramelessHelper::setWidgetMovable(bool movable)
  425. {
  426.     d->m_bWidgetMovable = movable;
  427. }
  428.  
  429. void FramelessHelper::setWidgetResizable(bool resizable)
  430. {
  431.     d->m_bWidgetResizable = resizable;
  432. }
  433.  
  434. void FramelessHelper::setRubberBandOnResize(bool resizable)
  435. {
  436.     d->m_bRubberBandOnResize = resizable;
  437.     QList<WidgetData*> list = d->m_widgetDataHash.values();
  438.     foreach (WidgetData *data, list)
  439.     {
  440.         data->updateRubberBandStatus();
  441.     }
  442. }
  443.  
  444. void FramelessHelper::setBorderWidth(uint width)
  445. {
  446.     if (width > 0)
  447.     {
  448.         CursorPosCalculator::m_nBorderWidth = width;
  449.     }
  450. }
  451.  
  452. void FramelessHelper::setTitleHeight(uint height)
  453. {
  454.     if (height > 0)
  455.     {
  456.         CursorPosCalculator::m_nTitleHeight = height;
  457.     }
  458. }
  459.  
  460. bool FramelessHelper::widgetMovable()
  461. {
  462.     return d->m_bWidgetMovable;
  463. }
  464.  
  465. bool FramelessHelper::widgetResizable()
  466. {
  467.     return d->m_bWidgetResizable;
  468. }
  469.  
  470. bool FramelessHelper::rubberBandOnMove()
  471. {
  472.     return d->m_bRubberBandOnMove;
  473. }
  474.  
  475. bool FramelessHelper::rubberBandOnResisze()
  476. {
  477.     return d->m_bRubberBandOnResize;
  478. }
  479.  
  480. uint FramelessHelper::borderWidth()
  481. {
  482.     return CursorPosCalculator::m_nBorderWidth;
  483. }
  484.  
  485. uint FramelessHelper::titleHeight()
  486. {
  487.     return CursorPosCalculator::m_nTitleHeight;
  488. }
  489.

        通过以上代码，我们可以实现一个具有自定义标题栏、窗口大小调整和可移动、可缩放属性的无边框窗口。这段代码提供了一种简单而有效的方法来实现自定义外观和交互方式的无边框窗口。可以根据自己的需求进行修改和定制，以满足不同应用程序的需要。

五、使用示例

以下是一个简单的示例代码，演示了如何在Qt中使用此控件：

CustomMainWindow.h
  1. #ifndef CUSTOMMAINWINDOW_H
  2. #define CUSTOMMAINWINDOW_H
  3.  
  4. #include <QWidget>
  5.  
  6. #include "BaseWindow.h"
  7. #include "framelesshelper.h"
  8.  
  9. namespace Ui {
  10. class CustomMainWindow;
  11. }
  12.  
  13. class CustomMainWindow : public BaseWindow
  14. {
  15.     Q_OBJECT
  16.  
  17. public:
  18.     explicit CustomMainWindow(QWidget *parent = 0);
  19.     ~CustomMainWindow();
  20.  
  21. private:
  22.     void initTitleBar();
  23.     void framelesshelperInit();
  24.  
  25.     Ui::CustomMainWindow *ui;
  26. };
  27.  
  28. #endif // CUSTOMMAINWINDOW_H
CustomMainWindow.cpp
  1. #include "CustomMainWindow.h"
  2. #include "ui_CustomMainWindow.h"
  3.  
  4. CustomMainWindow::CustomMainWindow(QWidget *parent) :
  5.     BaseWindow(parent),
  6.     ui(new Ui::CustomMainWindow)
  7. {
  8.     initTitleBar();
  9.     framelesshelperInit();
  10.     ui->setupUi(this);
  11. }
  12.  
  13. CustomMainWindow::~CustomMainWindow()
  14. {
  15.     delete ui;
  16. }
  17.  
  18. void CustomMainWindow::initTitleBar()
  19. {
  20.     m_titleBar->setBackgroundColor(71,76,78);
  21.     m_titleBar->setTitleIcon(":/TitleBarRc/icon.png");
  22.     m_titleBar->setTitleContent(QStringLiteral("这是一个可以滚动的标题！"));
  23.     m_titleBar->setTitleRoll();
  24.     m_titleBar->setButtonType(MIN_MAX_BUTTON);
  25.     m_titleBar->setTitleWidth(this->width());
  26. }
  27.  
  28. void CustomMainWindow::framelesshelperInit()
  29. {
  30.     //this指的是要处理的窗体
  31.     FramelessHelper *pHelper = new FramelessHelper(this);
  32.     pHelper->activateOn(this);  //激活当前窗体
  33.     pHelper->setWidgetMovable(true);  //设置窗体可移动
  34.     pHelper->setWidgetResizable(true);  //设置窗体可缩放
  35.     pHelper->setRubberBandOnMove(false);  //设置橡皮筋效果-可移动
  36.     pHelper->setRubberBandOnResize(true);  //设置橡皮筋效果-可缩放
  37. }

        现在，我们可以编译和运行该项目。当窗口显示出来时，您将会看到一个自定义的无边框窗口，包含自定义的标题栏和窗口大小调整按钮。您可以尝试拖动标题栏或点击窗口大小调整按钮来调整窗口的大小和位置。需要注意的是，使用自定义标题栏时需留够空间，不要被窗口内控件遮挡。

        通过以上步骤，我们成功地实现了在QT中创建自定义无边框窗口的目标，包括自定义标题栏和窗口大小调整功能。这使得我们可以根据自己的需要创建独特和个性化的窗口界面。

        谢谢您的阅读，希望本文能为您带来一些帮助和启发。如果您有任何问题或意见，请随时与我联系。祝您度过美好的一天！

六、源代码下载

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Li_阴宅/article/detail/911546
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号