精华内容
下载资源
问答
  • QT设置窗体标题及背景颜色

    万次阅读 2019-03-17 10:05:38
    1.设置标题* 在widget.cpp文件下的 Widget::Widget(QWidget *parent) : QWidget(parent), ui(new Ui::Widget){ } 这个函数加上setWindowTitle(“标题”); 如:把标题设为计算器 setWindowTitle(“计算器”); ** 2...

    1.设置标题*

    在widget.cpp文件下的
    Widget::Widget(QWidget *parent) :
    QWidget(parent),
    ui(new Ui::Widget){ }
    这个函数中加上setWindowTitle(“标题”);
    如:把标题设为计算器
    setWindowTitle(“计算器”);

    **

    2.设置窗体背景颜色

    **
    在同样的函数中加上
    this->setStyleSheet(“background-color:颜色;”);
    this->show();

    如:要把背景设为粉色
    this->setStyleSheet(“background-color:pink;”);
    this->show();

    如下是我的代码:

     Widget::Widget(QWidget *parent) :
        QWidget(parent),
        ui(new Ui::Widget)
        {
        ui->setupUi(this);
        setWindowTitle("计算器");
        this->setStyleSheet("background-color:pink;");
        this->show();
        }
           
    

    计算器程序是提前写好的
    如下是运行结果:
    在这里插入图片描述

    展开全文
  • qt5 自定义标题栏

    2015-03-20 18:16:39
    qt5写的自定义标题栏,做相应的改变也可以在其他版本运行,去掉了系统默认的标题栏,自己实现关闭,最大化,最小化,双击最大化最小化功能,这对标题栏的美化有帮助
  • Qt对话框标题栏修改技巧 包括隐藏标题栏标题栏透明等。
  • Qt 之 自定义窗口标题栏

    万次阅读 多人点赞 2016-12-06 23:20:44
    今天晚上就如何用Qt自定义窗口标题栏,写了一个小例子,比较基础,实用。在此分享一下。 首先Qt是跨平台的,所以在不同的平台上窗口的外观是不一样的。比如在windows平台上,用Qt显示的一个窗口就跟一般windows程序...

    Qt技术学习班开始了,更多精彩、好玩的内容等着你,赶紧报名吧! 群号:655815739


    一、简述

    今天晚上就如何用Qt自定义窗口标题栏,写了一个小例子,比较基础,实用。在此分享一下。

    首先Qt是跨平台的,所以在不同的平台上窗口的外观是不一样的。比如在windows平台上,用Qt显示的一个窗口就跟一般windows程序窗口的外观一致,如下图。

    这里写图片描述 这里写图片描述

    同时不同windows系统,窗口外观显示也不一致,上面左边是我在win8系统上显示的窗口右边是win7下显示的窗口。可以看出两个窗口外观差别很大,同时在win8系统中标题内容居中了,win7标题则靠左。为了 解决窗口外观在不同系统下不一致的问题,我们干脆去掉窗口自带的边框,Qt中直接用一下代码即可去除窗口边框效果

    this->setWindowFlags(Qt::FramelessWindowHint);

    这里写图片描述

    上图就是去除窗口边框后的效果图。这样是不是看起来奇怪,是不是没有了标题栏。

    一般情况下一个标题栏提供了窗口图标、窗口标题、最小化、最大化、关闭按钮等几个部分,这些对于一个窗口来说是十分重要的,窗口图标标志着这是一个什么程序,标题就表明这个窗口是干什么的,最小化、最大化、关闭等按钮则是用户对该窗口的操作。


    下图是QQ的几个窗口标题栏。可以看出QQ的窗口都用了同一个窗口图标,一看到这个标志就知道是QQ程序的窗口,同时每个窗口标题栏不同,代表着这个窗口的作用以及用户可以在窗口中进行什么样的操作。

    这里写图片描述


    QQ音乐的标题栏

    这里写图片描述

    有道词典的标题栏

    这里写图片描述

    PS软件的标题栏

    这里写图片描述

    以上几款软件的标题栏都涵盖了以上几个重要的组成部分。


    自定义标题栏的好处

    • 首先自定义标题栏解决了我们程序在不同平台乃至同一平台不同的版本中样式不同的问题,使用自定义标题栏,能够保证外观的一致性,这也是为什么像QQ、有道词典、360等软件都没有使用系统标题栏,都是自定义标题栏了。

    • 正是因为自定义标题栏,我们可以自定义不再受约束,想怎么设计就怎么设计。

    • 自定义标题栏可以使用自己设计的图标,当然比系统的图标要美观了,颜值当然更高了。

    下面就讲一讲如何用Qt实现自定义窗口标题栏。

    二、代码之路

    这个是之前模仿QQ做的一个登录界面窗口。

    这里写图片描述


    这里我们先看一下本程序中简单一点的效果图:

    这里写图片描述

    注意:

    本程序的BaseWindow是继承于QWidget,如果大家想要继承QMainWindow,则需要把BaseWindow的基类改为QMainWindow。


    // 标题栏类;

    mytitlebar.h

    #include <QWidget>
    #include <QLabel>
    #include <QPushButton>
    #include <QTimer>
    
    enum ButtonType
    {
        MIN_BUTTON = 0,         // 最小化和关闭按钮;
        MIN_MAX_BUTTON ,        // 最小化、最大化和关闭按钮;
        ONLY_CLOSE_BUTTON       // 只有关闭按钮;
    };
    
    class MyTitleBar : public QWidget
    {
        Q_OBJECT
    
    public:
        MyTitleBar(QWidget *parent);
        //这里parent没有给默认值NULL,保证在创建MyTitleBar对象时父指针必须得赋值;且赋值不为NULL;
        ~MyTitleBar();
    
        // 设置标题栏背景色及是否设置标题栏背景色透明;
        void setBackgroundColor(int r, int g, int b , bool isTransparent = false);
        // 设置标题栏图标;
        void setTitleIcon(QString filePath , QSize IconSize = QSize(25 , 25));
        // 设置标题内容;
        void setTitleContent(QString titleContent , int titleFontSize = 9);
        // 设置标题栏长度;
        void setTitleWidth(int width);
        // 设置标题栏上按钮类型;
        void setButtonType(ButtonType buttonType);
        // 设置标题栏中的标题是否会滚动;具体可以看效果;
        void setTitleRoll();
        // 设置窗口边框宽度;
        void setWindowBorderWidth(int borderWidth);
    
        // 保存/获取 最大化前窗口的位置及大小;
        void saveRestoreInfo(const QPoint point, const QSize size);
        void getRestoreInfo(QPoint& point, QSize& size);
    
    private:
        void paintEvent(QPaintEvent *event);
        void mouseDoubleClickEvent(QMouseEvent *event);
        void mousePressEvent(QMouseEvent *event);
        void mouseMoveEvent(QMouseEvent *event);
        void mouseReleaseEvent(QMouseEvent *event);
    
        // 初始化控件;
        void initControl();
        // 信号槽的绑定;
        void initConnections();
        // 加载样式文件;
        void loadStyleSheet(const QString &sheetName);
    
    signals:
        // 按钮触发的信号;
        void signalButtonMinClicked();
        void signalButtonRestoreClicked();
        void signalButtonMaxClicked();
        void signalButtonCloseClicked();
    
    private slots:
        // 按钮触发的槽;
        void onButtonMinClicked();
        void onButtonRestoreClicked();
        void onButtonMaxClicked();
        void onButtonCloseClicked();
        void onRollTitle();
    
    private:
        QLabel* m_pIcon;                    // 标题栏图标;
        QLabel* m_pTitleContent;            // 标题栏内容;
        QPushButton* m_pButtonMin;          // 最小化按钮;
        QPushButton* m_pButtonRestore;      // 最大化还原按钮;
        QPushButton* m_pButtonMax;          // 最大化按钮;
        QPushButton* m_pButtonClose;        // 关闭按钮;
    
        // 标题栏背景色;
        int m_colorR;
        int m_colorG;
        int m_colorB;
    
        // 最大化,最小化变量;
        QPoint m_restorePos;
        QSize m_restoreSize;
        // 移动窗口的变量;
        bool m_isPressed;
        QPoint m_startMovePos;
        // 标题栏跑马灯效果时钟;
        QTimer m_titleRollTimer;
        // 标题栏内容;
        QString m_titleContent;
        // 按钮类型;
        ButtonType m_buttonType;
        // 窗口边框宽度;
        int m_windowBorderWidth;
        // 标题栏是否透明;
        bool m_isTransparent;
    };
    

    mytitlebar.cpp

    #include "mytitlebar.h"
    #include <QHBoxLayout>
    #include <QPainter>
    #include <QFile>
    #include <QMouseEvent>
    
    #define BUTTON_HEIGHT 30        // 按钮高度;
    #define BUTTON_WIDTH 30         // 按钮宽度;
    #define TITLE_HEIGHT 30         // 标题栏高度;
    
    MyTitleBar::MyTitleBar(QWidget *parent)
        : QWidget(parent)
        , m_colorR(153)
        , m_colorG(153)
        , m_colorB(153)
        , m_isPressed(false)
        , m_buttonType(MIN_MAX_BUTTON)
        , m_windowBorderWidth(0)
        , m_isTransparent(false)
    {
        // 初始化;
        initControl();
        initConnections();
        // 加载本地样式 MyTitle.css文件;
        loadStyleSheet("MyTitle");
    }
    
    MyTitleBar::~MyTitleBar()
    {
    
    }
    
    // 初始化控件;
    void MyTitleBar::initControl()
    {
        m_pIcon = new QLabel;
        m_pTitleContent = new QLabel;
    
        m_pButtonMin = new QPushButton;
        m_pButtonRestore = new QPushButton;
        m_pButtonMax = new QPushButton;
        m_pButtonClose = new QPushButton;
    
        m_pButtonMin->setFixedSize(QSize(BUTTON_WIDTH, BUTTON_HEIGHT));
        m_pButtonRestore->setFixedSize(QSize(BUTTON_WIDTH, BUTTON_HEIGHT));
        m_pButtonMax->setFixedSize(QSize(BUTTON_WIDTH, BUTTON_HEIGHT));
        m_pButtonClose->setFixedSize(QSize(BUTTON_WIDTH, BUTTON_HEIGHT));
    
        m_pTitleContent->setObjectName("TitleContent");
        m_pButtonMin->setObjectName("ButtonMin");
        m_pButtonRestore->setObjectName("ButtonRestore");
        m_pButtonMax->setObjectName("ButtonMax");
        m_pButtonClose->setObjectName("ButtonClose");
    
        m_pButtonMin->setToolTip(QStringLiteral("最小化"));
        m_pButtonRestore->setToolTip(QStringLiteral("还原"));
        m_pButtonMax->setToolTip(QStringLiteral("最大化"));
        m_pButtonClose->setToolTip(QStringLiteral("关闭"));
    
        QHBoxLayout* mylayout = new QHBoxLayout(this);
        mylayout->addWidget(m_pIcon);
        mylayout->addWidget(m_pTitleContent);
    
        mylayout->addWidget(m_pButtonMin);
        mylayout->addWidget(m_pButtonRestore);
        mylayout->addWidget(m_pButtonMax);
        mylayout->addWidget(m_pButtonClose);
    
        mylayout->setContentsMargins(5, 0, 0, 0);
        mylayout->setSpacing(0);
    
        m_pTitleContent->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
        this->setFixedHeight(TITLE_HEIGHT);
        this->setWindowFlags(Qt::FramelessWindowHint);
    }
    
    // 信号槽的绑定;
    void MyTitleBar::initConnections()
    {
        connect(m_pButtonMin, SIGNAL(clicked()), this, SLOT(onButtonMinClicked()));
        connect(m_pButtonRestore, SIGNAL(clicked()), this, SLOT(onButtonRestoreClicked()));
        connect(m_pButtonMax, SIGNAL(clicked()), this, SLOT(onButtonMaxClicked()));
        connect(m_pButtonClose, SIGNAL(clicked()), this, SLOT(onButtonCloseClicked()));
    }
    
    // 设置标题栏背景色,在paintEvent事件中进行绘制标题栏背景色;
    // 在构造函数中给了默认值,可以外部设置颜色值改变标题栏背景色;
    void MyTitleBar::setBackgroundColor(int r, int g, int b, bool isTransparent)
    {
        m_colorR = r;
        m_colorG = g;
        m_colorB = b;
        m_isTransparent = isTransparent;
        // 重新绘制(调用paintEvent事件);
        update();
    }
    
    // 设置标题栏图标;
    void MyTitleBar::setTitleIcon(QString filePath, QSize IconSize)
    {
        QPixmap titleIcon(filePath);
        m_pIcon->setPixmap(titleIcon.scaled(IconSize));
    }
    
    // 设置标题内容;
    void MyTitleBar::setTitleContent(QString titleContent, int titleFontSize)
    {
        // 设置标题字体大小;
        QFont font = m_pTitleContent->font();
        font.setPointSize(titleFontSize);
        m_pTitleContent->setFont(font);
        // 设置标题内容;
        m_pTitleContent->setText(titleContent);
        m_titleContent = titleContent;
    }
    
    // 设置标题栏长度;
    void MyTitleBar::setTitleWidth(int width)
    {
        this->setFixedWidth(width);
    }
    
    // 设置标题栏上按钮类型;
    // 由于不同窗口标题栏上的按钮都不一样,所以可以自定义标题栏中的按钮;
    // 这里提供了四个按钮,分别为最小化、还原、最大化、关闭按钮,如果需要其他按钮可自行添加设置;
    void MyTitleBar::setButtonType(ButtonType buttonType)
    {
        m_buttonType = buttonType;
    
        switch (buttonType)
        {
        case MIN_BUTTON:
            {
                m_pButtonRestore->setVisible(false);
                m_pButtonMax->setVisible(false);
            }
            break;
        case MIN_MAX_BUTTON:
            {
                m_pButtonRestore->setVisible(false);
            }
            break;
        case ONLY_CLOSE_BUTTON:
            {
                m_pButtonMin->setVisible(false);
                m_pButtonRestore->setVisible(false);
                m_pButtonMax->setVisible(false);
            }
            break;
        default:
            break;
        }
    }
    
    // 设置标题栏中的标题是否会自动滚动,跑马灯的效果;
    // 一般情况下标题栏中的标题内容是不滚动的,但是既然自定义就看自己需要嘛,想怎么设计就怎么搞O(∩_∩)O!
    void MyTitleBar::setTitleRoll()
    {
        connect(&m_titleRollTimer, SIGNAL(timeout()), this, SLOT(onRollTitle()));
        m_titleRollTimer.start(200);
    }
    
    // 设置窗口边框宽度;
    void MyTitleBar::setWindowBorderWidth(int borderWidth)
    {
        m_windowBorderWidth = borderWidth;
    }
    
    // 保存窗口最大化前窗口的位置以及大小;
    void MyTitleBar::saveRestoreInfo(const QPoint point, const QSize size)
    {
        m_restorePos = point;
        m_restoreSize = size;
    }
    
    // 获取窗口最大化前窗口的位置以及大小;
    void MyTitleBar::getRestoreInfo(QPoint& point, QSize& size)
    {
        point = m_restorePos;
        size = m_restoreSize;
    }
    
    // 绘制标题栏背景色;
    void MyTitleBar::paintEvent(QPaintEvent *event)
    {
        // 是否设置标题透明;
        if (!m_isTransparent)
        {
            //设置背景色;
            QPainter painter(this);
            QPainterPath pathBack;
            pathBack.setFillRule(Qt::WindingFill);
            pathBack.addRoundedRect(QRect(0, 0, this->width(), this->height()), 3, 3);
            painter.setRenderHint(QPainter::Antialiasing, true);
            painter.fillPath(pathBack, QBrush(QColor(m_colorR, m_colorG, m_colorB)));
        }   
    
        // 当窗口最大化或者还原后,窗口长度变了,标题栏的长度应当一起改变;
        // 这里减去m_windowBorderWidth ,是因为窗口可能设置了不同宽度的边框;
        // 如果窗口有边框则需要设置m_windowBorderWidth的值,否则m_windowBorderWidth默认为0;
        if (this->width() != (this->parentWidget()->width() - m_windowBorderWidth))
        {
            this->setFixedWidth(this->parentWidget()->width() - m_windowBorderWidth);
        }
        QWidget::paintEvent(event);
    }
    
    // 双击响应事件,主要是实现双击标题栏进行最大化和最小化操作;
    void MyTitleBar::mouseDoubleClickEvent(QMouseEvent *event)
    {
        // 只有存在最大化、还原按钮时双击才有效;
        if (m_buttonType == MIN_MAX_BUTTON)
        {
            // 通过最大化按钮的状态判断当前窗口是处于最大化还是原始大小状态;
            // 或者通过单独设置变量来表示当前窗口状态;
            if (m_pButtonMax->isVisible())
            {
                onButtonMaxClicked();
            }
            else
            {
                onButtonRestoreClicked();
            }
        }   
    
        return QWidget::mouseDoubleClickEvent(event);
    }
    
    // 以下通过mousePressEvent、mouseMoveEvent、mouseReleaseEvent三个事件实现了鼠标拖动标题栏移动窗口的效果;
    void MyTitleBar::mousePressEvent(QMouseEvent *event)
    {
        if (m_buttonType == MIN_MAX_BUTTON)
        {
            // 在窗口最大化时禁止拖动窗口;
            if (m_pButtonMax->isVisible())
            {
                m_isPressed = true;
                m_startMovePos = event->globalPos();
            }
        }
        else
        {
            m_isPressed = true;
            m_startMovePos = event->globalPos();
        }
    
        return QWidget::mousePressEvent(event);
    }
    
    void MyTitleBar::mouseMoveEvent(QMouseEvent *event)
    {
        if (m_isPressed)
        {
            QPoint movePoint = event->globalPos() - m_startMovePos;
            QPoint widgetPos = this->parentWidget()->pos();
            m_startMovePos = event->globalPos();
            this->parentWidget()->move(widgetPos.x() + movePoint.x(), widgetPos.y() + movePoint.y());
        }
        return QWidget::mouseMoveEvent(event);
    }
    
    void MyTitleBar::mouseReleaseEvent(QMouseEvent *event)
    {
        m_isPressed = false;
        return QWidget::mouseReleaseEvent(event);
    }
    
    // 加载本地样式文件;
    // 可以将样式直接写在文件中,程序运行时直接加载进来;
    void MyTitleBar::loadStyleSheet(const QString &sheetName)
    {
        QFile file(":/Resources/" + sheetName + ".css");
        file.open(QFile::ReadOnly);
        if (file.isOpen())
        {
            QString styleSheet = this->styleSheet();
            styleSheet += QLatin1String(file.readAll());
            this->setStyleSheet(styleSheet);
        }
    }
    
    // 以下为按钮操作响应的槽;
    void MyTitleBar::onButtonMinClicked()
    {
        emit signalButtonMinClicked();
    }
    
    void MyTitleBar::onButtonRestoreClicked()
    {
        m_pButtonRestore->setVisible(false);
        m_pButtonMax->setVisible(true);
        emit signalButtonRestoreClicked();
    }
    
    void MyTitleBar::onButtonMaxClicked()
    {
        m_pButtonMax->setVisible(false);
        m_pButtonRestore->setVisible(true);
        emit signalButtonMaxClicked();
    }
    
    void MyTitleBar::onButtonCloseClicked()
    {
        emit signalButtonCloseClicked();
    }
    
    // 该方法主要是让标题栏中的标题显示为滚动的效果;
    void MyTitleBar::onRollTitle()
    {
        static int nPos = 0;
        QString titleContent = m_titleContent;
        // 当截取的位置比字符串长时,从头开始;
        if (nPos > titleContent.length())
            nPos = 0;
    
        m_pTitleContent->setText(titleContent.mid(nPos));
        nPos++;
    }
    

    // 窗口基类;

    basewindow.h

    #include <QWidget>
    #include "mytitlebar.h"
    
    class BaseWindow : public QWidget
    {
        Q_OBJECT
    
    public:
        BaseWindow(QWidget *parent = 0);
        ~BaseWindow();
    
    private:
        void initTitleBar();
        void paintEvent(QPaintEvent *event);
        void loadStyleSheet(const QString &sheetName);
    
    private slots:
        void onButtonMinClicked();
        void onButtonRestoreClicked();
        void onButtonMaxClicked();
        void onButtonCloseClicked();
    
    protected:
        MyTitleBar* m_titleBar;
    
    };

    basewindow.cpp

    #include "basewindow.h"
    #include <QDesktopWidget>
    #include <QApplication>
    #include <QPainter>
    #include <QFile>
    
    BaseWindow::BaseWindow(QWidget *parent)
        : QWidget(parent)
    {
        // FramelessWindowHint属性设置窗口去除边框;
        // WindowMinimizeButtonHint 属性设置在窗口最小化时,点击任务栏窗口可以显示出原窗口;
        this->setWindowFlags(Qt::FramelessWindowHint | Qt::WindowMinimizeButtonHint);
        // 设置窗口背景透明;
        setAttribute(Qt::WA_TranslucentBackground);
    
        // 注意!!!如果是主窗口不要设置WA_DeleteOnClose属性;
        // 关闭窗口时释放资源;
        setAttribute(Qt::WA_DeleteOnClose);
        // 初始化标题栏;
        initTitleBar();
    }
    
    BaseWindow::~BaseWindow()
    {
    
    }
    
    void BaseWindow::initTitleBar()
    {
        m_titleBar = new MyTitleBar(this);
        m_titleBar->move(0, 0);
    
        connect(m_titleBar, SIGNAL(signalButtonMinClicked()), this, SLOT(onButtonMinClicked()));
        connect(m_titleBar, SIGNAL(signalButtonRestoreClicked()), this, SLOT(onButtonRestoreClicked()));
        connect(m_titleBar, SIGNAL(signalButtonMaxClicked()), this, SLOT(onButtonMaxClicked()));
        connect(m_titleBar, SIGNAL(signalButtonCloseClicked()), this, SLOT(onButtonCloseClicked()));
    
    }
    
    void BaseWindow::paintEvent(QPaintEvent* event)
    {
        //设置背景色;
        QPainter painter(this);
        QPainterPath pathBack;
        pathBack.setFillRule(Qt::WindingFill);
        pathBack.addRoundedRect(QRect(0, 0, this->width(), this->height()), 3, 3);
        painter.setRenderHint(QPainter::SmoothPixmapTransform, true);
        painter.fillPath(pathBack, QBrush(QColor(238, 223, 204)));
    
        return QWidget::paintEvent(event);
    }
    
    void BaseWindow::loadStyleSheet(const QString &sheetName)
    {
        QFile file(":/Resources/" + sheetName + ".css");
        file.open(QFile::ReadOnly);
        if (file.isOpen())
        {
            QString styleSheet = this->styleSheet();
            styleSheet += QLatin1String(file.readAll());
            this->setStyleSheet(styleSheet);
        }
    }
    
    void BaseWindow::onButtonMinClicked()
    {
        showMinimized();
    }
    
    void BaseWindow::onButtonRestoreClicked()
    {
        QPoint windowPos;
        QSize windowSize;
        m_titleBar->getRestoreInfo(windowPos, windowSize);
        this->setGeometry(QRect(windowPos, windowSize));
    }
    
    void BaseWindow::onButtonMaxClicked()
    {
        m_titleBar->saveRestoreInfo(this->pos(), QSize(this->width(), this->height()));
        QRect desktopRect = QApplication::desktop()->availableGeometry();
        QRect FactRect = QRect(desktopRect.x() - 3, desktopRect.y() - 3, desktopRect.width() + 6, desktopRect.height() + 6);
        setGeometry(FactRect);
    }
    
    void BaseWindow::onButtonCloseClicked()
    {
        close();
    }

    以上代码实现了自定义标题栏,新建的窗口类直接继承BaseWindow类,并对标题栏进行设置即可,下面就测试一下吧!

    测试代码

    NoFocusWidget.cpp

    #include "nofocuswidget.h"
    
    NoFocusWidget::NoFocusWidget(QWidget *parent)
        : BaseWindow(parent)
    {
        ui.setupUi(this);
        // 初始化标题栏;
        initTitleBar();
    }
    
    NoFocusWidget::~NoFocusWidget()
    {
    
    }
    
    void NoFocusWidget::initTitleBar()
    {
        // 设置标题栏跑马灯效果,可以不设置;
        m_titleBar->setTitleRoll();
    
        m_titleBar->setTitleIcon(":/Resources/titleicon.png");
        m_titleBar->setTitleContent(QStringLiteral("前行中的小猪-前行之路还需前行"));
        m_titleBar->setButtonType(MIN_MAX_BUTTON);
        m_titleBar->setTitleWidth(this->width());
    }
    

    main.cpp

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

    NoFocusWidget为新建的窗口类,通过继承了BaseWindow类,并在initTitleBar()方法中对标题栏进行设置即可。下图为NoFocusWidget窗口的设计图

    这里写图片描述


    动态效果图

    这里写图片描述


    最大化、还原效果图

    这里写图片描述


    注意

    如果在设置窗口属性时不加上Qt::FramelessWindowHint 就是左图效果。

    this->setWindowFlags(Qt::FramelessWindowHint | Qt::WindowMinimizeButtonHint);

    这里写图片描述

    如果不加上 Qt::WindowMinimizeButtonHint 就是左图效果。加上之后可以看右图效果。

    这里写图片描述 这里写图片描述


    以上代码用Qt实现了自定义窗口标题栏,代码很简单,但是很实用,可以应用到每一个窗口中去,保持每个窗口外观的一致性,同时自定义的标题栏也比系统自带的漂亮很多,所以还是非常实用的。

    目前我们在MyTitleBar类以及BaseWindow类中只添加了一些基础功能,小伙伴们可以根据需要添加更多自定义的功能,而其他窗口只需继承BaseWindow类即可。

    欢迎大家一起交流 O(∩_∩)O!

    #代码下载

    Qt 实现 自定义窗口标题栏

    展开全文
  • 本源代码是用Qt5.9的Creator编译和构建,主要功能是实现自定义标题栏,而屏蔽系统自带的标题栏。具体的讲解和用法可以参考我的博客:https://blog.csdn.net/naibozhuan3744/article/details/81120544
  • 没有显示效果 显示效果 原因 将类的Q_OBJECT这个宏给注释掉。

    没有显示效果

    在这里插入图片描述

    显示效果

    在这里插入图片描述

    原因

    将类中的Q_OBJECT这个宏给注释掉。
    在这里插入图片描述

    展开全文
  • Qt在win10自定义标题栏,应用主题颜色到...截图实现了标题栏颜色和拖动改变窗口位置。 关键点 QtWin 在.pro文件加入 QT += winextras 就可以使用QtWin命名空间的API。这里我们使用 QColor QtWin::realColoriz

    前言

    Qt自定义标题栏的资料很多了,但是百度来github去,没找到应用win10的主题颜色到标题栏,就自己折腾了一下。弄了个Demo。没什么技术含量,献丑了。

    先看效果

    顺手绘制了按钮
    在这里插入图片描述
    在这里插入图片描述

    设置应用颜色到标题栏

    截图中实现了标题栏颜色和拖动改变窗口位置。

    关键点

    QtWin

    在.pro文件中加入

    QT   += winextras
    

    就可以使用QtWin命名空间中的API。这里我们使用

    QColor QtWin::realColorizationColor()
    

    根据文档描述:
    在这里插入图片描述
    这玩意儿返回的是带有Alpha的标题栏颜色。OK这样就是真实的颜色了。另外一个函数:

    QColor QtWin::colorizationColor(bool *opaqueBlend = Q_NULLPTR)
    

    返回的颜色有色差。

    注册表获取是否应用了颜色到标题栏

    这个东西好像不是公开的,经过我一番折腾,发现了在注册表的这个位置:

    HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\DWM
    

    的这个key对应了上面我们开启的“应用颜色到标题栏和窗口边框”
    在这里插入图片描述
    有了这两个东西就好办了,就算是热更改,只需要在需要显示颜色的窗口的绘制事件中绘制上这个颜色就搞定了。

    代码

    头文件:captionwidget.h

    // captionwidget.h
    #ifndef CAPTIONWIDGET_H
    #define CAPTIONWIDGET_H
    
    #include <QWidget>
    
    #ifdef Q_OS_WIN
    class CaptionWidget : public QWidget
    {
        Q_OBJECT
    public:
        explicit CaptionWidget(QWidget *parent = 0);
    
        bool event(QEvent *e) override;
    signals:
        void btnMinClicked();
        void btnMaxNormalClicked();
        void btnCloseClicked();
        void DwmCompsitionChanged();
    
    protected:
        // QWidget interface
        bool nativeEvent(const QByteArray &eventType, void *message, long *result) override;
        void paintEvent(QPaintEvent *event) override;
        void mouseMoveEvent(QMouseEvent *event) override;
        void mousePressEvent(QMouseEvent *event) override;
        void mouseReleaseEvent(QMouseEvent *event) override;
        void mouseDoubleClickEvent(QMouseEvent *event) override;
        void leaveEvent(QEvent *event) override;
    
    private:
        enum RectType{
            Rect_Other = -1,
            Rect_Mini,
            Rect_NormalMax,
            Rect_Close,
        };
    
        enum IconType{
            Icon_Mini,
            Icon_Max,
            Icon_Restore,
            Icon_Close,
        };
    
        bool mini_hover_;
        bool max_hover_;
        bool close_hover_;
    
        void setTopLevelWidget();
    
        QRectF getRect(RectType type);
        QPixmap getPixmap(IconType type,const QColor &color);
        QColor getIconColor(bool isClose = false);
        int itemAt(const QPoint &pos);
    
        static QColor getForgroundColor(const QColor &backgroundColor);
    
        /// \brief windows8以上版本,获取是否将主题颜色应用到标题栏和边框
        /// \return
        ///
        static bool dwmColorPrevalence();
    };
    #else
    class CaptionWidget : public QWidget
    {
        Q_OBJECT
    public:
        CaptionWidget(QWidget *parent = nullptr, Qt::WindowFlags f = Qt::WindowFlags())
            : QWidget(parent, f)
        {
        }
    };
    #endif // Q_OS_WIN
    
    #endif // CAPTIONWIDGET_H
    
    

    源文件:captionwidget.cpp

    // captionwidget.cpp
    #include "captionwidget.h"
    #include <QSettings>
    #include <QtGlobal>
    
    #ifdef Q_OS_WIN
    #include <QPaintEvent>
    #include <QMouseEvent>
    #include <QHelpEvent>
    #include <QPainter>
    #include <QtDebug>
    #include <QToolTip>
    #include <QtWin>
    #include <QToolTip>
    #include <QStyle>
    
    #include <Windows.h>
    #pragma comment(lib, "User32.lib")
    
    CaptionWidget::CaptionWidget(QWidget *parent)
        : QWidget(parent)
        , mini_hover_(false)
        , max_hover_(false)
        , close_hover_(false)
    {
        setMouseTracking(true);
    
        setTopLevelWidget();
    }
    
    void CaptionWidget::setTopLevelWidget()
    {
        auto w = this->window();
        connect(this, &CaptionWidget::btnMinClicked, w, &QWidget::showMinimized);
        connect(this, &CaptionWidget::btnMaxNormalClicked, w, [=](){
            auto state = w->windowState();
            if(state.testFlag(Qt::WindowMaximized)){
                w->showNormal();
            }else if(state.testFlag(Qt::WindowNoState)){
                w->showMaximized();
            }
    
        });
        connect(this, &CaptionWidget::btnCloseClicked, w, &QWidget::close);
    }
    
    /// QWidget在鼠标移动后停留的短暂时间内,会触发一次QEvent::ToolTip
    /// 如果自绘制的按钮,可以在event中显示tooltip
    bool CaptionWidget::event(QEvent *e)
    {
        if (e->type() == QEvent::ToolTip) {
            QHelpEvent *helpEvent = static_cast<QHelpEvent *>(e);
            int index = itemAt(helpEvent->pos());
            if (index != -1) {
                QString str;
                switch (index) {
                case Rect_Mini:
                    str = tr("minimize");
                    break;
                case Rect_NormalMax:
    
                    str = this->window()->isMaximized()
                            ? tr("restore")
                            : tr("maximize");
                    break;
                case Rect_Close:
                    str = tr("close");
                    break;
                default:
                    Q_UNREACHABLE();
                }
                QToolTip::showText(helpEvent->globalPos(), str);
            } else {
                QToolTip::hideText();
                e->ignore();
            }
    
            return true;
        }
        return QWidget::event(e);
    }
    
    bool CaptionWidget::nativeEvent(const QByteArray &eventType, void *message, long *result)
    {
        //Workaround for known bug -> check Qt forum : https://forum.qt.io/topic/93141/qtablewidget-itemselectionchanged/13
        #if (QT_VERSION == QT_VERSION_CHECK(5, 11, 1))
        MSG* msg = *reinterpret_cast<MSG**>(message);
        #else
        MSG* msg = reinterpret_cast<MSG*>(message);
        #endif
    
        switch (msg->message)
        {
        case WM_DWMCOLORIZATIONCOLORCHANGED:
        {
            // notify dwm composition changed
            emit DwmCompsitionChanged();
            return false;
        }
        default:
            return QWidget::nativeEvent(eventType, message, result);
        }
    }
    
    void CaptionWidget::paintEvent(QPaintEvent *event)
    {
        QWidget::paintEvent(event);
    
        if( this->window()->isFullScreen()){
            return QWidget::paintEvent(event);
        }
    
        QRectF rectMini = getRect(Rect_Mini);
        QRectF rectMaxNormal = getRect(Rect_NormalMax);
        QRectF rectClose = getRect(Rect_Close);
    
        QPainter p(this);
        p.save();
        // draw background
    
        int height = this->style()->pixelMetric(QStyle::PM_TitleBarHeight);
        height += 8;
        QRect titleBarRect(0,
                           0,
                           width(),
                           height);
    
        QColor color{Qt::white};
        if(dwmColorPrevalence())
        {
            color = QtWin::realColorizationColor();
        }
    
        if(this->isActiveWindow()){
            color.setAlphaF(1);
        }else{
            color.setAlphaF(0.7);
        }
        p.fillRect(titleBarRect, color);
        p.restore();
    
        // draw icons
        p.save();
    
        if(mini_hover_ ){
            QColor color("#B9B9B9");
            color.setAlphaF(0.5);
            p.fillRect(rectMini, color);
        }
    
        if(max_hover_ ){
            QColor color("#B9B9B9");
            color.setAlphaF(0.3);
            p.fillRect(rectMaxNormal, color);
        }
    
        if(close_hover_){
            p.fillRect(rectClose, QColor("#E81123"));
        }
    
        // draw minimum icon
        auto pix = getPixmap(Icon_Mini, this->getIconColor());
        p.drawPixmap(QPointF(rectMini.x() + (rectMini.width() - pix.width()) / 2,
                             rectMini.y() + (rectMini.height() - pix.height()) / 2),
                     pix);
        // draw maximum and resore icon
        IconType type = this->window()->isMaximized()
                ? Icon_Restore
                : Icon_Max;
        pix = getPixmap(type, this->getIconColor());
        p.drawPixmap(QPointF(rectMaxNormal.x() + (rectMaxNormal.width() - pix.width()) / 2,
                             rectMaxNormal.y() + (rectMaxNormal.height() - pix.height()) / 2),
                    pix);
    
        // draw close icon
        if(close_hover_){
            pix = getPixmap(Icon_Close, Qt::white);
        }else{
            pix = getPixmap(Icon_Close, this->getIconColor());
        }
    
        p.drawPixmap(QPointF(rectClose.x() + (rectClose.width() - pix.width()) / 2,
                             rectClose.y() + (rectClose.height() - pix.height()) / 2),
                     pix);
        p.restore();
    }
    
    void CaptionWidget::mouseMoveEvent(QMouseEvent *event)
    {
        QWidget::mouseMoveEvent(event);
    
        QPoint p = event->pos();
        mini_hover_ = getRect(Rect_Mini).contains(p);
        max_hover_ = getRect(Rect_NormalMax).contains(p);
        close_hover_ = getRect(Rect_Close).contains(p);
    
        update();
    }
    
    void CaptionWidget::mousePressEvent(QMouseEvent *event)
    {
        QWidget::mousePressEvent(event);
    
        QPoint p = event->pos();
        if(event->button() == Qt::LeftButton)
        {
            if(getRect(Rect_Other).contains(p)){
    
                if(::ReleaseCapture()){
                    SendMessage(HWND(this->window()->winId()), WM_SYSCOMMAND, SC_MOVE + HTCAPTION, 0);
                    event->ignore();
                }
    
            }
        }
    }
    
    void CaptionWidget::mouseReleaseEvent(QMouseEvent *event)
    {
        QWidget::mouseReleaseEvent(event);
    
        QPoint p = event->pos();
        if(event->button() == Qt::LeftButton)
        {
            if(getRect(Rect_Mini).contains(p) ){
                emit btnMinClicked();
                mini_hover_ = false;
                update();
            }
            if(getRect(Rect_NormalMax).contains(p)){
                emit btnMaxNormalClicked();
                max_hover_ = false;
                update();
                const QSignalBlocker blocker(this);
            }
            if(getRect(Rect_Close).contains(p)){
                emit btnCloseClicked();
            }
        }
    }
    
    void CaptionWidget::mouseDoubleClickEvent(QMouseEvent *event)
    {
        QWidget::mouseDoubleClickEvent(event);
        auto w = this->window();
        auto p = event->pos();
        if(getRect(Rect_Other).contains(p)){
            if(event->button() == Qt::LeftButton){
                if(w->isMaximized()){
                    w->showNormal();
                }else{
                    w->showMaximized();
                }
            }
        }
    }
    
    void CaptionWidget::leaveEvent(QEvent *event)
    {
        mini_hover_ = false;
        max_hover_ = false;
        close_hover_ = false;
        update();
        QWidget::leaveEvent(event);
    }
    
    QRectF CaptionWidget::getRect(CaptionWidget::RectType type)
    {
        //96 45,28
        // 120 58,42
        //144 70,45
        // 168 80,54
    
        int BtnWidth = 45;
        int BtnHeight = 28;
        int BtnSpacing = 1;
        int dpi = this->window()->logicalDpiX();
        switch (dpi) {
        case 96:
            BtnWidth = 45;
            BtnHeight = 30;
            break;
        case 120:
            BtnWidth = 56;
            BtnHeight = 40;
            break;
        case 144:
            BtnWidth = 68;
            BtnHeight = 42;
            break;
        case 168:
            BtnWidth = 78;
            BtnHeight = 52;
            break;
        default:
            BtnWidth = 45;
            BtnHeight = 28;
            break;
        }
    
    
        int x = 0;
        int y = 1;
        int w = this->width();
    
        QRectF rectClose(x + w - BtnWidth,
                         y,
                         BtnWidth,
                         BtnHeight);
        QRectF rectMax(rectClose.x() - BtnSpacing - BtnWidth,
                       y,
                       BtnWidth,
                       BtnHeight);
        QRectF rectMini(rectMax.x() - BtnSpacing - BtnWidth,
                        y,
                        BtnWidth,
                        BtnHeight);
    
        QRectF rectOther(x,
                         y,
                         x + rectMini.x(),
                         42);
    
        switch (type) {
        case Rect_Close:
            return rectClose;
        case Rect_NormalMax:
            return rectMax;
        case Rect_Mini:
            return rectMini;
        case Rect_Other:
            return rectOther;
        default:
            return QRectF();
        }
    }
    
    QPixmap CaptionWidget::getPixmap(CaptionWidget::IconType type, const QColor &color)
    {
        QSize size(10, 10);
        int rr;
        int dpi = this->window()->logicalDpiX();
        switch (dpi) {
        case 96:
            rr = 30 / 3;
            break;
        case 120:
            rr = 40 / 3;
            break;
        case 144:
            rr = 42 /3;
            break;
        case 168:
            rr = 52 / 3;
            break;
        default:
            rr = 28 /3;
            break;
        }
        size.setWidth(rr);
        size.setHeight(rr);
    
        QPixmap pix(size);
        pix.fill(Qt::transparent);
    
        QSizeF sizeF(size.width() *1.0,  size.height() * 1.0);
        QPainter p(&pix);
        switch (type) {
        case Icon_Mini:
        {
            p.save();
            QPen pen(QBrush(color), 1.0);
            p.setPen(pen);
    
            p.drawLine(QPointF(0, sizeF.height() / 2),
                        QPointF(sizeF.width(), sizeF.height() / 2));
    
            p.restore();
        }
            break;
        case Icon_Max:
        {
            p.save();
            QPen pen(QBrush(color), 1.0);
            p.setPen(pen);
    
            p.drawRect(QRectF(0.0, 0.0, sizeF.width() - 1.0, sizeF.height() - 1.0));
    
            p.restore();
        }
            break;
        case Icon_Restore:
        {
            p.save();
            p.setRenderHint(QPainter::Antialiasing);
            QPen pen(QBrush(color), 1.0);
            p.setPen(pen);
    
            QRectF rect(0,0,size.width(), size.height());
            QRectF r1(rect.x(),
                      rect.y() + rect.height() / 4,
                      rect.width() * 3 / 4,
                      rect.width() * 3 / 4);
    
            p.drawRect(r1);
    
            QVector<QLineF> lines;
            QLineF line1(QPointF(rect.x() + rect.width() * 1 / 4, rect.y() + rect.width() * 1 / 4),
                      QPointF(rect.x() + rect.width() * 1 / 4, rect.y())
                      );
            QLineF line2(QPointF(rect.x() + rect.width() * 1 / 4, rect.y()),
                      QPointF(rect.x() + rect.width(), rect.y())
                      );
            QLineF line3(QPointF(rect.x() + rect.width(), rect.y()),
                      QPointF(rect.x() + rect.width(), rect.y() + rect.width() * 3 / 4)
                      );
            QLineF line4(QPointF(rect.x() + rect.width(), rect.y() + rect.width() * 3 / 4),
                      QPointF(rect.x() + rect.width() * 3 / 4, rect.y() + rect.width() * 3 / 4)
                      );
    
            lines.append(line1);
            lines.append(line2);
            lines.append(line3);
            lines.append(line4);
    
            p.drawLines(lines);
    
            p.restore();
        }
            break;
        case Icon_Close:
        {
            p.save();
            p.setRenderHint(QPainter::Antialiasing);
            QPen pen(QBrush(color), 1.0);
            p.setPen(pen);
    
            QRectF rect(0,0,size.width(), size.height());
            p.drawLine(QPointF(rect.x(), rect.y()),
                        QPointF(rect.x() + rect.width(), rect.y() + rect.height())
                       );
            p.drawLine(QPointF(rect.x() + rect.width(), rect.y()),
                        QPointF(rect.x(), rect.y() + rect.height())
                       );
    
            p.restore();
        }
            break;
        default:
            break;
        }
    
        return pix;
    }
    
    QColor CaptionWidget::getIconColor(bool isClose)
    {
        if(!isClose){
            QColor color(Qt::black);
            if(dwmColorPrevalence() && this->isActiveWindow()){
                color = getForgroundColor(QtWin::colorizationColor());
            }
    
            return color;
        }else{
            return Qt::white;
        }
    }
    
    int CaptionWidget::itemAt(const QPoint &pos)
    {
        if(getRect(Rect_Mini).contains(pos)){
            return Rect_Mini;
        }else if(getRect(Rect_NormalMax).contains(pos)){
            return Rect_NormalMax;
        }
        else if(getRect(Rect_Close).contains(pos)){
            return Rect_Close;
        }
        return -1;
    }
    
    QColor CaptionWidget::getForgroundColor(const QColor &backgroundColor)
    {
        auto color = backgroundColor;
        double gray = (0.299 * color.red() + 0.587 * color.green() + 0.114 * color.blue()) / 255;
        return gray > 0.5 ? Qt::black : Qt::white;
    }
    
    bool CaptionWidget::dwmColorPrevalence()
    {
    #ifdef Q_OS_WIN
        const QString path = "HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\DWM";
        const QString key = "ColorPrevalence";
        QSettings settings(path, QSettings::NativeFormat);
    
        auto value = settings.value(key, false).toBool();
        return value;
    #else
        return false;
    #endif
    }
    
    #endif  // Q_OS_WIN
    

    main.cpp

    // main.cpp
    #include "captionwidget.h"
    
    #include <QApplication>
    
    int main(int argc, char *argv[])
    {
        QApplication a(argc, argv);
        CaptionWidget w;
        w.show();
        return a.exec();
    }
    
    

    其它功能

    最小化、最大化/还原、关闭按钮

    1.顺便绘制了一下这个几个按钮,效果一般,要用的朋友自己重绘。
    2.这三个按钮支持tooltip提示。
    3.按钮会根据背景色深浅自动变为灰色或者白色。

    窗口拖动

    这个很简单,在mousePressEvent事件中发个win32消息:

    void CaptionWidget::mousePressEvent(QMouseEvent *event)
    {
       QWidget::mousePressEvent(event);
    
       QPoint p = event->pos();
       if(event->button() == Qt::LeftButton)
       {
           if(getRect(Rect_Other).contains(p)){
    
               if(::ReleaseCapture()){
                   SendMessage(HWND(this->window()->winId()), WM_SYSCOMMAND, SC_MOVE + HTCAPTION, 0);
                   event->ignore();
               }
    
           }
       }
    }
    

    参考资料

    win32获取标题栏颜色

    最后

    大冬天的打字手冷jio冷的,如果对你有帮助,点个赞不过分撒。😀

    展开全文
  • Qt5窗口标题栏高度

    千次阅读 2016-11-08 09:49:00
     // 获取标题栏高度  setGeometry(0, iTitleBarHeight, desktopRect.width(), desktopRect.height() - iTitleBarHeight); // 设置窗体充满桌面客户区  setFixedSize(desktopRect.width(), desktopRect.height() ...
  • 设置窗口标题的方法: w.setWindowTitle(QObject::tr("关机程序")); //设置窗口的标题。 w.setWindowFlags(Qt::WindowCloseButtonHint); //设置窗体的样式。 更多窗体样式,可以参见Qt ...
  • 1.在paintEvent事件绘制图片 void Widget::paintEvent(QPaintEvent * ev) { QPainter painter(this); painter.drawPixmap(rect(),QPixmap(":/bg.jpg"),QRect()); } drawPixmap在Widget的整个矩形区域绘制背景...
  • qt 设置菜单栏颜色

    万次阅读 2016-08-22 19:36:59
    如果只设置QMenuBar样式,会出现菜单的后面部分颜色不变 不仅要设置QMenuBar的样式,还要设置item,如 "QMenuBar:item{background-color:#999999;}QMenuBar{background-color:#999999;}
  • QT设置窗口颜色

    千次阅读 2017-11-26 10:08:59
    Qt中窗口背景如何设置?下面介绍三种方法:一、QPalette设置背景二、实现paintEvent,使用QPainter来绘制背景三、使用QSS来设置背景 关于QSS的使用不想多说,一般我不用QSS设置窗口背景,也不建议使用。(注意:这里...
  • 而想要自绘样式的朋友可能会有将窗口背景进行透明化设置的风格需求,比如: 经过一番百度博文的搜索也能找到实现方法,即在主窗口的构造函数(或者你自己定义的界面初始化函数里)写上下面这句: this->...
  • 如果你想在标题栏上增加/减少控件,或改变布局、颜色、Size 就必须抛弃Windows提供的嗟来之食 蹴尔而与之,乞人不屑也 じゃあ、どうする 使用无边框窗口即可 setWindowFlags(Qt::FramelessWindowHint);//Qt 这样...
  • 自定义QT标题栏和背景·边框

    万次阅读 2017-11-06 13:14:18
    考虑到QT界面不是很美观,我们可以自己定义QT界面的标题栏,以及设置背景和边框根据自己的喜好,下图是正常的界面。现在在项目的构造函数里ui.setupUi(this);后面添加如下几句代码,就可以去除标题栏,边框和背景。 ...
  • QMainWindow通过setWindowFlags(Qt::FramelessWindowHint)该函数隐藏掉标题栏以后,就不能通过窗口四周来拖动大小了,所以必须要重写,重写两种方法:第一种重写是:mouseMoveEvent,该方法要设置以下两点(1)...
  • 总结qt 常见设置QWidget 类型窗口背景色几种方式 setStyleSheet ui.widget->setStyleSheet("QWidget{background: black;}"); setPalette setPalette(QPalette(Qt::white)); setAutoFillBackground(true)); ...
  • Qt自定义标题栏

    2021-09-19 13:52:17
    1.设置为无边框窗口后拉伸、移动、放大缩小等事件需要自己重新实现,我只实现标题栏拖动、双击放大/还原、窗体边缘可拉伸等基本功能,有其他需求的小伙伴可参考和修改源码 2.拉伸右、下、右下这三个方向不会抖动,...
  • Qt Dialog窗体使用自定义标题栏

    千次阅读 2017-01-03 11:25:00
    运行效果如下图: ...setWindowFlags(Qt::CustomizeWindowHint|Qt::FramelessWindowHint); //将主窗体设置为这样的样式 uTitleBar = new UTitleBar(this); uTitleBar->setAutoFillBackgr...
  • 前言使用Qt自带的标题栏可能没有办法适合我们的需求,例如标题栏颜色标题栏的宽度、高度,标题栏的放大、缩小、还原、关闭按钮等都没有办法发生改变。因为默认的标题栏是和操作系统相关的、它会根据操作系统的...
  • 打开注册表
  • 因开发界面需要,Qtdesigner设计...一、窗口设计无标题栏,基础美化过程 下面这里是窗口设计界面 # coding:utf-8 from PyQt5 import QtCore,QtGui,QtWidgets import sys class MainUi(QtWidgets.QMainWindow): de...
  • Qt重画标题栏

    千次阅读 2017-07-13 22:16:51
    //鼠标点击标题栏,重新实现拖动操作 void mouseMoveEvent(QMouseEvent*event); void mousePressEvent(QMouseEvent*event); void mouseReleaseEvent(QMouseEvent*event);   2. 在头文件添加下列三个槽函数
  •   我们经常需要自定义标题栏,那么去掉标题栏是非常有必要。但是去掉标题栏之后边框阴影也会消失,感觉光秃秃的,不太舒服。接下来我们将讨论添加边框阴影的几种解决方案。 解决方案 如果是Windows平台,那么可以...
  • qt自定义标题栏和边框Would you like to tweak your title bar and menu fonts in Windows 7? Here’s how you can change those little settings you may have enjoyed tweaking in older versions of Windows. 您...
  • Qt 扁平化MainWindow以及自定义标题栏

    万次阅读 2015-11-10 02:32:04
    为了构建出自己认为优雅的界面,需要将Qt自带标题栏啥的去掉。 首先使用Qt Designer创建一个MainWindow的类。mainwindow.h#ifndef MAINWINDOW_H #define MAINWINDOW_H#include <QMainWindow>namespace Ui { class ...
  • Qt 基于QMainWindow自定义标题栏

    千次阅读 2018-05-17 00:23:24
    网上也有很多自定义标题栏的实现,在这里主要讲下怎么把自定义标题栏和QMainWindow怎么结合起来,由于无法获取QMainWindow的布局,所以无法再QMainWindow窗口上加自定义标题栏,要懒重写菜单栏等工具外,可以把...
  • 先上代码随后说明,为了这个全屏真是折磨死人...//问题在import QtQuick.Window 2.0,如果用其他版本Window都没法全屏,太坑人了 import QtQuick.Window 2.0 Window { visible: true width: Screen.width height: Sc
  • 在开发工作需要设置隐藏主界面的窗口标题栏,于是在网上找到了代码: this-&gt;setWindowFlags(Qt::FramelessWindowHint);//去掉标题栏 但是在主界面构造函数添加该行代码之后发现主...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,849
精华内容 739
关键字:

qt设置窗口标题栏颜色