Qt 下的DPI问题解决

已于 2022-08-05 17:21:17 修改
阅读量7.6k 收藏 1
点赞数 1
分类专栏： Qt 文章标签： qt 开发语言
于 2020-08-05 16:17:32 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/quanhaoH/article/details/107817202
版权 
CBaseDlg
#ifndef BASEDLG_H
#define BASEDLG_H

#include <QDialog>

class CBaseDlg : public QDialog
{
    Q_OBJECT

    enum ResizeRegion
    {
        Default,
        North,
        NorthEast,
        East,
        SouthEast,
        South,
        SouthWest,
        West,
        NorthWest
    };

public:
    explicit CBaseDlg(QWidget *parent = nullptr);
    ~CBaseDlg() override;

    void setDragToolbarHeight(int height) {m_iDragToolbarHeight = height;}
    bool IsMoving() { return m_bDrag && m_bMove; }

signals:
    void sigDragPosChanged(QWidget * sender, int relativeX, int relativeY);

protected:
    void keyPressEvent(QKeyEvent *event) override;

    void mousePressEvent(QMouseEvent *event) override;
    void mouseMoveEvent(QMouseEvent *event) override;
    void mouseReleaseEvent(QMouseEvent *event) override;

    void showEvent(QShowEvent *event) override;
    bool nativeEvent(const QByteArray &eventType, void *message, long *result) override;

    virtual void onDpiChanged();

	virtual void setAllbtnDefautlFalse();
    void setCenterWindowOnShowFirstly(bool bCenterWindowOnShowFirstly) { m_bCenterWindowOnShowFirstly = bCenterWindowOnShowFirstly; }
    void centerWindow();

    bool                m_bFirstShow;
    double              m_fStretchFactor; // dpi stretch factor

    static const unsigned int DPI_BASE_VALUE = 96;

private:
    int                 m_iDragToolbarHeight;

    bool                m_bDrag;
    bool                m_bMove;
    QPoint              dragPos;
    QPoint              m_resizeDownPos;
    const int           m_resizeBorderWidth = 8;
    ResizeRegion        m_resizeRegion;
    QRect               m_mouseDownRect;
    bool                m_bCanResize;
    bool                m_bCenterWindowOnShowFirstly;
    unsigned int        m_uDpi;

    void setResizeCursor(ResizeRegion region);
    ResizeRegion getResizeRegion(QPoint clientPos);
    void handleMove(QPoint pt);
    void handleResize();
    void updateDpi(unsigned int uDpi);
    void changePosOnDrag(const QPoint & newPos);
};

#endif // BASEDLG_H

#include "base-dlg.h"

#if defined(WIN32)

#include <Windows.h>

#endif

#include <QMouseEvent>
#include <QIcon>
#include <QDesktopWidget>
#include <QDebug>
#include <QApplication>
#include <QScreen>
#include <QPushButton>
#include <QBitmap>
#include <QPainter>
#include <QDebug>

CBaseDlg::CBaseDlg(QWidget *parent) :
    QDialog(parent)
//    , m_bDrag(false)
    , m_bFirstShow(true)
    , m_fStretchFactor(0)
    , m_iDragToolbarHeight(0)
    , m_bDrag(false)
    , m_bMove(false)
    , m_bCanResize(false)
    , m_bCenterWindowOnShowFirstly(true)
    , m_uDpi(0)
{
    setWindowIcon(QIcon(":/resources/images/logo_about.png"));

    setWindowFlags(Qt::FramelessWindowHint);
    setMouseTracking(true);
}

CBaseDlg::~CBaseDlg()
{

}

void CBaseDlg::keyPressEvent(QKeyEvent *event)
{
    switch (event->key())
    {
    case Qt::Key_Escape:
        break;
    default:
        QDialog::keyPressEvent(event);
    }
}

void CBaseDlg::mousePressEvent(QMouseEvent *event)
{

    if (event->button() == Qt::LeftButton && Qt::WindowMaximized != windowState()) {
        this->m_bDrag = true;
        this->dragPos = event->pos();
        this->m_resizeDownPos = event->globalPos();
        this->m_mouseDownRect = this->rect();
    }

    QDialog::mousePressEvent(event);
}

void CBaseDlg::mouseMoveEvent(QMouseEvent *event)
{
    if (m_resizeRegion != Default)
    {
        handleResize();
        return;
    }
    if(m_bMove) {
        changePosOnDrag(event->globalPos() - dragPos);
        return;
    }
    QPoint clientCursorPos = event->pos();
    QRect r = this->rect();
    QRect resizeInnerRect(0, 0, r.width() - m_resizeBorderWidth, r.height() - m_resizeBorderWidth);
    if(r.contains(clientCursorPos) && !resizeInnerRect.contains(clientCursorPos)) { // adjust dialog size
        if (!m_bCanResize)
        {
            return;
        }
        ResizeRegion resizeReg = getResizeRegion(clientCursorPos);
        setResizeCursor(resizeReg);
        if (m_bDrag && (event->buttons() & Qt::LeftButton)) {
            m_resizeRegion = resizeReg;
            handleResize();
        }
    }
    else { // move dialog
        setCursor(Qt::ArrowCursor);
        if (event->y() > m_iDragToolbarHeight)
        {
            // the dialog can only be dragged on the tool bar
            return;
        }
        if (m_bDrag && (event->buttons() & Qt::LeftButton)) {
            m_bMove = true;
            changePosOnDrag(event->globalPos() - dragPos);
        }
    }

    QDialog::mouseMoveEvent(event);
}

void CBaseDlg::mouseReleaseEvent(QMouseEvent *event)
{
//    if(event->button() == Qt::LeftButton)
//    {
//        m_bDrag = false;
//    }


    m_bDrag = false;
    if(m_bMove) {
        m_bMove = false;
        handleMove(event->globalPos()); // bind to top/left/right of screen if out of screen on mouse release
    }
    m_resizeRegion = Default;
    setCursor(Qt::ArrowCursor);

    QDialog::mouseReleaseEvent(event);
}

void CBaseDlg::showEvent(QShowEvent *event)
{
    if (m_bFirstShow) {
        m_bFirstShow = false;
        if (m_bCenterWindowOnShowFirstly)
        {
            centerWindow();
        }
    }

    QScreen * pScreen = QGuiApplication::screenAt(QPoint(this->x() + this->width() / 2, this->y() + this->height() / 2));
    if (pScreen)
        updateDpi(static_cast<unsigned int>(pScreen->logicalDotsPerInchX()));

    QDialog::showEvent(event);
}

void CBaseDlg::centerWindow()
{
    qDebug() << this;
    QPoint point(this->x() + this->width() / 2, this->y() + this->height() / 2);
    QScreen * pScreen = QGuiApplication::screenAt(point);
    if (nullptr == pScreen)
    {
        qDebug() << "Failed to centerWindow for invalid screen, point:" << point;
        pScreen = QGuiApplication::primaryScreen();
        if (nullptr == pScreen)
        {
            qDebug() << "Failed to position screen by primaryScreen";
            return;
        }
    }
    qDebug() << "screen name:" << pScreen->name() << ", logicalDotsPerInchX: " << pScreen->logicalDotsPerInchX() << "logicalDotsPerInchY: " << pScreen->logicalDotsPerInchY();

    QRect rect = pScreen->availableGeometry();
    qDebug() << "Current screen availableGeometry:" << rect << ", geometry:" << pScreen->geometry();

    int ax = rect.left() + (rect.width() - this->width()) / 2;
    int ay = rect.top() + (rect.height() - this->height()) / 2;

    qDebug() << "Move window to " << ax << ay;
    move(ax, ay);
}

bool CBaseDlg::nativeEvent(const QByteArray &eventType, void *message, long *result)
{
#if defined(WIN32)
    MSG* pMsg = reinterpret_cast<MSG*>(message);

    switch (pMsg->message)
    {
    case WM_DPICHANGED:
    {
        WORD dpi = LOWORD(pMsg->wParam);
        qDebug() << "WM_DPICHANGED:" << dpi;
        updateDpi(dpi);
//        QRect rect = QApplication::desktop()->availableGeometry();
//        QGuiApplication::screens();
//        qInfo() << "availableGeometry:" << rect.width() << rect.height();
    }
    }
#endif
    return QDialog::nativeEvent(eventType, message, result);
}

//void CBaseDlg::onDpiChanged(unsigned int dpi)
//{
//    qDebug() << "dpi:" << dpi << ", objectName" << this->objectName();
    double dpiRatio = dpi / 96.0;
    QString qstrFileName;
    if (dpiRatio > 1)
    {
        qstrFileName = ":/resources/qss/dialog-1.5x.qss";
    }
    else{
        qstrFileName = ":/resources/qss/dialog.qss";
    }
    this->setFixedWidth(800 * dpiRatio);
    this->setFixedHeight(600 * dpiRatio);
    QString qss;
    QFile qssFile(qstrFileName);
    qssFile.open(QFile::ReadOnly);
    if(qssFile.isOpen()) {
        qss = QLatin1String(qssFile.readAll());
        this->setStyleSheet(qss);
        qssFile.close();

        qDebug() << __FUNCTION__ << __LINE__ << qssFile.fileName();
    }
    else
    {
        qDebug() << __FUNCTION__ << __LINE__ << qssFile.errorString();
    }

    ui->m_pLblText->adjustSize();
//}

void CBaseDlg::setAllbtnDefautlFalse()
{
	QList<QPushButton*> list = findChildren<QPushButton*>();
	for (int i = 0; i < list.size(); ++i)
	{
		QPushButton *pb = list.at(i);
		pb->setAutoDefault(false);
		pb->setDefault(false);
	}
}

void CBaseDlg::setResizeCursor(ResizeRegion region)
{
    switch (region)
    {
    case North:
    case South:
        setCursor(Qt::SizeVerCursor);
        break;
    case East:
    case West:
        setCursor(Qt::SizeHorCursor);
        break;
    case NorthWest:
    case SouthEast:
        setCursor(Qt::SizeFDiagCursor);
        break;
    default:
        setCursor(Qt::SizeBDiagCursor);
        break;
    }
}
CBaseDlg::ResizeRegion CBaseDlg::getResizeRegion(QPoint clientPos)
{
    if (clientPos.y() <= m_resizeBorderWidth) {
        if (clientPos.x() <= m_resizeBorderWidth)
            return NorthWest;
        else if (clientPos.x() >= this->width() - m_resizeBorderWidth)
            return NorthEast;
        else
            return North;
    }
    else if (clientPos.y() >= this->height() - m_resizeBorderWidth) {
        if (clientPos.x() <= m_resizeBorderWidth)
            return SouthWest;
        else if (clientPos.x() >= this->width() - m_resizeBorderWidth)
            return SouthEast;
        else
            return South;
    }
    else {
        if (clientPos.x() <= m_resizeBorderWidth)
            return West;
        else
            return East;
    }
}
void CBaseDlg::handleMove(QPoint pt)
{
    QPoint currentPos = pt - dragPos;
//    if(currentPos.x()<desktop->x()) { // bind to left
//        currentPos.setX(desktop->x());
//    }
//    else if (currentPos.x()+this->width()>desktop->width()) { // bind to right
//        currentPos.setX(desktop->width()-this->width());
//    }
//    if(currentPos.y()<desktop->y()) { // bind to top
//        currentPos.setY(desktop->y());
//    }
    changePosOnDrag(currentPos);
}
void CBaseDlg::handleResize()
{
    int xdiff = QCursor::pos().x() - m_resizeDownPos.x();
    int ydiff = QCursor::pos().y() - m_resizeDownPos.y();
    switch (m_resizeRegion)
    {
    case East:
    {
        resize(m_mouseDownRect.width()+xdiff, this->height());
        break;
    }
    case West:
    {
        resize(m_mouseDownRect.width()-xdiff, this->height());
        move(m_resizeDownPos.x()+xdiff, this->y());
        break;
    }
    case South:
    {
        resize(this->width(),m_mouseDownRect.height()+ydiff);
        break;
    }
    case North:
    {
        resize(this->width(),m_mouseDownRect.height()-ydiff);
        move(this->x(), m_resizeDownPos.y()+ydiff);
        break;
    }
    case SouthEast:
    {
        resize(m_mouseDownRect.width() + xdiff, m_mouseDownRect.height() + ydiff);
        break;
    }
    case NorthEast:
    {
        resize(m_mouseDownRect.width()+xdiff, m_mouseDownRect.height()-ydiff);
        move(this->x(), m_resizeDownPos.y()+ydiff);
        break;
    }
    case NorthWest:
    {
        resize(m_mouseDownRect.width()-xdiff, m_mouseDownRect.height()-ydiff);
        move(m_resizeDownPos.x()+xdiff, m_resizeDownPos.y()+ydiff);
        break;
    }
    case SouthWest:
    {
        resize(m_mouseDownRect.width()-xdiff, m_mouseDownRect.height()+ydiff);
        move(m_resizeDownPos.x()+xdiff, this->y());
        break;
    }
    }
}

void CBaseDlg::updateDpi(unsigned int uDpi)
{
    qDebug() << uDpi << this;
    if (m_uDpi == uDpi)
    {
        qDebug() << "Dpi not changed";
        return;
    }

    m_uDpi = uDpi;
    double ratio = static_cast<double>(uDpi) / static_cast<double>(DPI_BASE_VALUE);
    double fStretchFactor = 1;
    if (ratio >= 2)
    {
        fStretchFactor = 2;
    }
    else if (ratio >= 1.5)
    {
        fStretchFactor = 1.5;
    }
    else
    {
        fStretchFactor = 1;
    }
    qDebug() << "fStretchFactor:" << fStretchFactor;

    m_fStretchFactor = fStretchFactor;
    onDpiChanged();
}

void CBaseDlg::onDpiChanged()
{
    qDebug();
}

void CBaseDlg::changePosOnDrag(const QPoint & newPos)
{
    QPoint curPos(this->pos());
    move(newPos);
//    qDebug() << "curPos:" << curPos << ", newPos:" << newPos << ", this:" << this;
    emit sigDragPosChanged(this, newPos.x() - curPos.x(), newPos.y() - curPos.y());
}

CDpiAdjustTool
#ifndef CDPIADJUSTTOOL_H
#define CDPIADJUSTTOOL_H

#include <QMap>
#include <QLayout>
#include <QLayoutItem>

class dataLayoutItem
{
public:
    int s_type;//0 widget, 1 layout, 2 spacerItem

    //0
    int s_baseWidth;
    int s_baseHeight;
    QSizePolicy s_sizePolicy;
    QSize s_minSize;
    QSize s_maxSize;

    //1
    int s_marginLeft;
    int s_marginTop;
    int s_marginRight;
    int s_marginBottom;
    int s_spacing;

    //2
    int s_sp_width;
    int s_sp_height;
    QSizePolicy s_sp_sizePolicy;
};

class CDpiAdjustTool
{
public:
    CDpiAdjustTool() 
        : m_fStretchFactor(0)
        , m_baseWidth(0)
        , m_baseHeight(0)
    {

    }

    int m_baseWidth;
    int m_baseHeight;
    QMap< QLayoutItem*, dataLayoutItem> controldata;
    //
    double m_fStretchFactor;

    void adjustSizeWidget(QWidget* curWidget = nullptr);
    void adjustSizeLayout(QLayout* curLayout = nullptr);
    //
    void updateSizeWidget(QWidget* curWidget = nullptr);
    void updateSizeLayout(QLayout* curLayout = nullptr);
    //
    void setAutoSizeWidget(QWidget* pWidget, QLayoutItem* pLayoutItem);
    void setAutoSizeLayout(QLayout* pLayout, QLayoutItem* pLayoutItem);
    void setAutoSizeSpacerItem(QSpacerItem* pSpacerItem, QLayoutItem* pLayoutItem);
    //
    void addDataWidget(QWidget* pWidget, QLayoutItem* pLayoutItem);
    void addDataLayout(QLayout* pLayout, QLayoutItem* pLayoutItem);
    void addDataSpacerItem(QSpacerItem* pSpacerItem, QLayoutItem* pLayoutItem);

    void clearData();
    void init(int baseWidth, int baseHeight, QWidget* pWidget);
    void update(double stretchFactor, QWidget* pWidget);
    void updateChilds(double stretchFactor, QWidget* pWidget, bool resizeflag);
};

#endif // CDPIADJUSTTOOL_H

#include "dpi-adjust-tool.h"
#include <QTabWidget>
#include <QScrollArea>
#include <QStackedWidget>
#include <QDialogButtonBox>
#include <QMessageBox>
#include <QDebug>

void CDpiAdjustTool::clearData()
{
    controldata.clear();
}

void CDpiAdjustTool::init(int baseWidth, int baseHeight, QWidget* pWidget)
{
    if (m_baseWidth == 0 && m_baseHeight == 0)
    {
        m_baseWidth = baseWidth;
        m_baseHeight = baseHeight;
        updateSizeWidget(pWidget);
    }
}

void CDpiAdjustTool::update(double stretchFactor, QWidget* pWidget)
{
    if (pWidget && m_baseWidth != 0 && m_baseHeight != 0)
    {
        m_fStretchFactor = stretchFactor;
        adjustSizeWidget(pWidget);
        pWidget->setFixedSize(m_baseWidth * m_fStretchFactor, m_baseHeight * m_fStretchFactor);
    }
}

void CDpiAdjustTool::updateChilds(double stretchFactor, QWidget* pWidget, bool resizeflag)
{
    if (pWidget && m_baseWidth != 0&& m_baseHeight != 0)
    {
        m_fStretchFactor = stretchFactor;
        adjustSizeWidget(pWidget);
        if (resizeflag)
        {
            pWidget->setFixedSize(m_baseWidth * m_fStretchFactor, m_baseHeight * m_fStretchFactor);
        }
    }
}

void CDpiAdjustTool::updateSizeWidget(QWidget* curWidget)
{
    if (curWidget)
    {
        QLayout* layout = curWidget->layout();
        addDataLayout(layout, (QLayoutItem*)layout);
        updateSizeLayout(layout);
    }
}

void CDpiAdjustTool::updateSizeLayout(QLayout* curLayout)
{
    if (curLayout)
    {
        int iCount = curLayout->count();
        for (int i = 0; i < iCount; i++)
        {
            QLayoutItem* pLayoutItem = curLayout->itemAt(i);

            QWidget* x1 = pLayoutItem->widget();
            QLayout* x2 = pLayoutItem->layout();
            QSpacerItem* x3 = pLayoutItem->spacerItem();
            if (x1 != nullptr)
            {
                addDataWidget(x1, pLayoutItem);

                updateSizeWidget(x1);

                const QMetaObject *metaObj = x1->metaObject();
                QString className = metaObj->className();
                if (className == "QTabWidget")
                {
                    QTabWidget* pTabWidget = (QTabWidget*)x1;
                    int iTab = pTabWidget->count();
                    for (int j = 0; j < iTab; j++)
                    {
                        QWidget* pTab = pTabWidget->widget(j);
                        if (pTab)
                        {
                            addDataWidget(pTab, (QLayoutItem*)pTab);
                            updateSizeWidget(pTab);
                        }
                    }

                }
                else if (className == "QScrollArea")
                {
                    QScrollArea* pScrollArea = (QScrollArea*)x1;
                    QWidget* pScroll = pScrollArea->widget();
                    if (pScroll)
                    {
                        controldata.remove(pLayoutItem);
                        addDataWidget(pScroll, (QLayoutItem*)pScroll);
                        updateSizeWidget(pScroll);
                    }
                }
                else if (className == "QStackedWidget")
                {
                    QStackedWidget* pStackedWidget = (QStackedWidget*)x1;
                    int iTab = pStackedWidget->count();
                    for (int k = 0; k < iTab; k++)
                    {
                        QWidget* pTab = pStackedWidget->widget(i);
                        if (pTab)
                        {
                            addDataWidget(pTab, (QLayoutItem*)pTab);
                            updateSizeWidget(pTab);
                        }
                    }
                }
                else if (className == "QDialogButtonBox")
                {
                    QDialogButtonBox* pDialogButtonBox = (QDialogButtonBox*)x1;
                    QPushButton* ibutton = pDialogButtonBox->button(QDialogButtonBox::Ok);
                    if (ibutton)
                    {
                        addDataWidget((QWidget*)ibutton, (QLayoutItem*)ibutton);
                        ibutton = nullptr;
                    }
                    ibutton = pDialogButtonBox->button(QDialogButtonBox::Yes);
                    if (ibutton)
                    {
                        addDataWidget((QWidget*)ibutton, (QLayoutItem*)ibutton);
                        ibutton = nullptr;
                    }
                    ibutton = pDialogButtonBox->button(QDialogButtonBox::Cancel);
                    if (ibutton)
                    {
                        addDataWidget((QWidget*)ibutton, (QLayoutItem*)ibutton);
                        ibutton = nullptr;
                    }
                    ibutton = pDialogButtonBox->button(QDialogButtonBox::No);
                    if (ibutton)
                    {
                        addDataWidget((QWidget*)ibutton, (QLayoutItem*)ibutton);
                        ibutton = nullptr;
                    }
                }
            }
            if (x2 != nullptr)
            {
                addDataLayout(x2, pLayoutItem);

                updateSizeLayout(x2);
            }
            if (x3 != nullptr)
            {
                addDataSpacerItem(x3, pLayoutItem);
            }
        }
    }
}

void CDpiAdjustTool::adjustSizeWidget(QWidget* curWidget)
{
    if (curWidget)
    {
        QLayout* layout = curWidget->layout();
        setAutoSizeLayout(layout, (QLayoutItem*)layout);
        adjustSizeLayout(layout);
    }
}

void CDpiAdjustTool::adjustSizeLayout(QLayout* curLayout)
{
    if (curLayout)
    {
        int iCount = curLayout->count();
        for (int i = 0; i < iCount; i++)
        {
            QLayoutItem* pLayoutItem = curLayout->itemAt(i);

            QWidget* x1 = pLayoutItem->widget();
            QLayout* x2 = pLayoutItem->layout();
            QSpacerItem* x3 = pLayoutItem->spacerItem();
            if (x1 != nullptr)
            {
                if (controldata.contains(pLayoutItem))
                {
                    setAutoSizeWidget(x1, pLayoutItem);
                }
                else
                {
                    addDataWidget(x1, pLayoutItem);
                }
                adjustSizeWidget(x1);

                const QMetaObject *metaObj = x1->metaObject();
                QString className = metaObj->className();
                if (className == "QTabWidget")
                {
                    QTabWidget* pTabWidget = (QTabWidget*)x1;
                    int iTab = pTabWidget->count();
                    for (int j = 0; j < iTab; j++)
                    {
                        QWidget* pTab = pTabWidget->widget(j);
                        if (pTab)
                        {
                            setAutoSizeWidget(pTab, (QLayoutItem*)pTab);
                            adjustSizeWidget(pTab);
                        }
                    }

                }
                else if (className == "QScrollArea")
                {
                    QScrollArea* pScrollArea = (QScrollArea*)x1;
                    QWidget* pScroll = pScrollArea->widget();
                    if (pScroll)
                    {
                        controldata.remove(pLayoutItem);
                        setAutoSizeWidget(pScroll, (QLayoutItem*)pScroll);
                        adjustSizeWidget(pScroll);
                    }
                }
                else if (className == "QStackedWidget")
                {
                    QStackedWidget* pStackedWidget = (QStackedWidget*)x1;
                    int iTab = pStackedWidget->count();
                    for (int k = 0; k < iTab; k++)
                    {
                        QWidget* pTab = pStackedWidget->widget(i);
                        if (pTab)
                        {
                            setAutoSizeWidget(pTab, (QLayoutItem*)pTab);
                            adjustSizeWidget(pTab);
                        }
                    }
                }
                else if (className == "QDialogButtonBox")
                {
                    QDialogButtonBox* pDialogButtonBox = (QDialogButtonBox*)x1;
                    QPushButton* ibutton = pDialogButtonBox->button(QDialogButtonBox::Ok);
                    if (ibutton)
                    {
                        setAutoSizeWidget((QWidget*)ibutton, (QLayoutItem*)ibutton);
                        ibutton = nullptr;
                    }
                    ibutton = pDialogButtonBox->button(QDialogButtonBox::Yes);
                    if (ibutton)
                    {
                        setAutoSizeWidget((QWidget*)ibutton, (QLayoutItem*)ibutton);
                        ibutton = nullptr;
                    }
                    ibutton = pDialogButtonBox->button(QDialogButtonBox::Cancel);
                    if (ibutton)
                    {
                        setAutoSizeWidget((QWidget*)ibutton, (QLayoutItem*)ibutton);
                        ibutton = nullptr;
                    }
                    ibutton = pDialogButtonBox->button(QDialogButtonBox::No);
                    if (ibutton)
                    {
                        setAutoSizeWidget((QWidget*)ibutton, (QLayoutItem*)ibutton);
                        ibutton = nullptr;
                    }
                }
            }
            if (x2 != nullptr)
            {
                if (controldata.contains(pLayoutItem))
                {
                    setAutoSizeLayout(x2, pLayoutItem);
                }
                else
                {
                    addDataLayout(x2, pLayoutItem);
                }
                adjustSizeLayout(x2);
            }
            if (x3 != nullptr)
            {
                if (controldata.contains(pLayoutItem))
                {
                    setAutoSizeSpacerItem(x3, pLayoutItem);
                }
                else
                {
                    addDataSpacerItem(x3, pLayoutItem);
                }
            }
        }
    }
}

void CDpiAdjustTool::setAutoSizeWidget(QWidget* pWidget, QLayoutItem* pLayoutItem)
{
    if (pWidget && pLayoutItem)
    {
        dataLayoutItem data = controldata[pLayoutItem];
        if (data.s_type == 0)
        {
            pWidget->resize(data.s_baseWidth * m_fStretchFactor, data.s_baseHeight * m_fStretchFactor);
            bool bsetSize = data.s_sizePolicy.horizontalPolicy() == QSizePolicy::Fixed || data.s_minSize.width() == data.s_maxSize.width();
            if (bsetSize)
            {
                pWidget->setFixedWidth(data.s_baseWidth * m_fStretchFactor);
            }
            else
            {
                pWidget->setMinimumWidth(data.s_minSize.width() * m_fStretchFactor);
                if (data.s_maxSize.width() < 8000)
                {
                    pWidget->setMaximumWidth(data.s_maxSize.width() * m_fStretchFactor);
                }
            }

            bsetSize = data.s_sizePolicy.verticalPolicy() == QSizePolicy::Fixed || data.s_minSize.height() == data.s_maxSize.height();
            if (bsetSize)
            {
                pWidget->setFixedHeight(data.s_baseHeight * m_fStretchFactor);
            }
            else
            {
                pWidget->setMinimumHeight(data.s_minSize.height() * m_fStretchFactor);
                if (data.s_maxSize.height() < 8000)
                {
                    pWidget->setMaximumHeight(data.s_maxSize.height() * m_fStretchFactor);
                }
            }
        }

        /*qInfo() << "ObjectName:" << pWidget->objectName() << "====================================";
        qInfo() << "size:" << pWidget->size();
        qInfo() << "Policy:" << pWidget->sizePolicy();
        qInfo() << "minSize" << pWidget->minimumSize();
        qInfo() << "maxSize" << pWidget->maximumSize();
        qInfo() << "end========================================";*/
    }
}

void CDpiAdjustTool::setAutoSizeLayout(QLayout* pLayout, QLayoutItem* pLayoutItem)
{
    if (pLayout && pLayoutItem)
    {
        dataLayoutItem data = controldata[pLayoutItem];
        if (data.s_type == 1)
        {
            pLayout->setSpacing(data.s_spacing * m_fStretchFactor);
            pLayout->setContentsMargins(data.s_marginLeft * m_fStretchFactor, data.s_marginTop * m_fStretchFactor, data.s_marginRight * m_fStretchFactor, data.s_marginBottom * m_fStretchFactor);
        }
    }
}

void CDpiAdjustTool::setAutoSizeSpacerItem(QSpacerItem* pSpacerItem, QLayoutItem* pLayoutItem)
{
    if (pSpacerItem && pLayoutItem)
    {
        dataLayoutItem data = controldata[pLayoutItem];
        if (data.s_type == 2)
        {
            bool nflag = pSpacerItem->sizePolicy().expandingDirections() == data.s_sizePolicy.expandingDirections() && 
                    (data.s_sp_sizePolicy.horizontalPolicy() == QSizePolicy::Fixed ||
                    data.s_sp_sizePolicy.verticalPolicy() == QSizePolicy::Fixed);
            if (nflag)
            {
                pLayoutItem->invalidate();
                pSpacerItem->changeSize(data.s_sp_width * m_fStretchFactor, data.s_sp_height * m_fStretchFactor, data.s_sp_sizePolicy.horizontalPolicy(), data.s_sp_sizePolicy.verticalPolicy());
            }
        }
    }
}

void CDpiAdjustTool::addDataWidget(QWidget* pWidget, QLayoutItem* pLayoutItem)
{
    if (pWidget && pLayoutItem)
    {
        dataLayoutItem data;
        data.s_type = 0;
        data.s_baseWidth = pWidget->width();
        data.s_baseHeight = pWidget->height();
        data.s_sizePolicy = pWidget->sizePolicy();
        data.s_minSize = pWidget->minimumSize();
        data.s_maxSize = pWidget->maximumSize();
        controldata[pLayoutItem] = data;

        /*qInfo() << "ObjectName:" << pWidget->objectName() << "====================================";
        qInfo() << "basesize:" << data.s_baseWidth << data.s_baseHeight;
        qInfo() << "Policy:" << data.s_sizePolicy;
        qInfo() << "minSize" << data.s_minSize;
        qInfo() << "maxSize" << data.s_maxSize;
        qInfo() << "end========================================";*/
    }
}

void CDpiAdjustTool::addDataLayout(QLayout* pLayout, QLayoutItem* pLayoutItem)
{
    if (pLayout && pLayoutItem)
    {
        dataLayoutItem data;
        data.s_type = 1;
        pLayout->getContentsMargins(&data.s_marginLeft, &data.s_marginTop, &data.s_marginRight, &data.s_marginBottom);
        data.s_spacing = pLayout->spacing();
        controldata[pLayoutItem] = data;
    }
}

void CDpiAdjustTool::addDataSpacerItem(QSpacerItem* pSpacerItem, QLayoutItem* pLayoutItem)
{
    if (pSpacerItem && pLayoutItem)
    {
        QSize nsize = pSpacerItem->sizeHint();
        
        dataLayoutItem data;
        data.s_type = 2;
        data.s_sp_width = nsize.width();
        data.s_sp_height = nsize.height();
        data.s_sp_sizePolicy = pSpacerItem->sizePolicy();
        controldata[pLayoutItem] = data;
    }
}

Demo地址

黄权浩
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
如何解决Qt高DPI缩放问题
weixin_73186358的博客
12-13 342
例如这里的缩放是200%，那么如果你按照原来的ui界面设计，显示出来的窗口和部件都会是你在ui界面所看见的1/2，这就与预期的结果不一致，时只需要在程序的。所谓的高DPI缩放问题，就是自身电脑屏幕缩放和Qt自身内部的缩放不一致导致的。
Qt之高DPI显示器(一) - 解决方案整理
szembed的博客
07-07 1289
目录最近一直在处理高DPI问题，也花费了不少功夫，前前后后使用了多种解决方案，各种方案也都有利弊，笔者最终采用了自适配方案，虽然复杂一些，但是结果可控。这里把处理的过程记录下来，留给有同样需求的同学。
Qt程序适配屏幕DPI
最新发布
赚钱娶老婆
04-27 231
解决在不同缩放的显示器中显示异常的情况，因为不同分辨率或屏幕大小的不同，屏幕的缩放大小也不同，所以需要在main首行加入。
Qt之高DPI显示器 - 自适配解决方案分析
hw5230的博客
12-30 861
这里笔者贴一个适配完成以后的TWidget类，大家可以先分析分析，也可以猜猜看，每一处代码的具体含义。所有代码细节笔者后边会具体分析每一处细节。
Qt获取屏幕DPI缩放比
龚建波
12-21 2726
​网上很多代码是用logicalDotsPerInch 除以 96 来获取屏幕缩放比，当使能了缩放适配后，logicalDotsPerInch 值就不随系统缩放变了，我们需要更通用的方式。 ​
Windows程序DPI模式学习
qq_37954088的博客
05-26 1731
一、DPI简介 DPI的概念 （1）DPI全称为dots per inch，也就是每英寸的点数。在显示器上表示每英寸的像素个数； （2）Windows上一般默认96dpi作为100%的缩放比例，该值是Windows给我们的参考标准； （3）Windows上DPI常见取值一般为100%，150%，200%。 视觉上的伸缩 （1）在系统设置高DPI后，我们看到的程序字体会变大。因为当DPI设置高之后，程序在显示器上是每英寸的像素个数，DPI值变大，即每英寸的像素个数会变多，而字体单位是不变的（英寸），DPI的计
QT5解决win10高分辨率dpi应用程序缩放问题解决方案
09-28
系统根据当前dpi缩放设置，使用QT_SCALE_FACTOR环境变量，自动自适应屏幕demo，适用win10高分辨率下的不同设置
Qt模仿VS2015界面框架
01-28
解决这些问题通常需要查阅Qt官方文档，或者在社区论坛中寻求帮助。一旦成功编译，就可以运行程序，体验模仿VS2015的界面和交互。 对于想要深入学习Qt5和界面设计的开发者来说，这个项目提供了一个很好的实践平台。...
Qt实现窗口自动适配win10、win11屏幕缩放比例
10-13
Qt提供了一套API来解决这个问题，使得开发者可以创建出对高DPI和不同屏幕缩放比例友好的应用。 首先，要启用Qt的高DPI支持，需要在应用程序的初始化阶段设置Qt的 DPI awareness。在`main.cpp`文件中，添加以下代码...
qt窗口自适应v2.0
06-24
"qt窗口自适应v2.0"项目显然是一个利用Qt库实现的窗口自适应解决方案，旨在提供一个在不同屏幕尺寸下都能良好显示的用户体验。 首先，我们要理解窗口自适应的概念。窗口自适应是指应用程序能够根据运行设备的屏幕...
QtInputMethod_GooglePinyin：Qt5拼音输入法
02-05
QtInputMethod_GooglePinyin是Qt5环境下实现拼音输入法的一种解决方案，它结合了Google Pinyin的高效输入功能和QtIMF的灵活性。开发者可以通过这个项目轻松地在Qt应用中集成拼音输入法，提供给用户流畅的中文输入...
qt 字体不随dpi_qt 5.5文档翻译系列-High DPI Displays
weixin_35706991的博客
01-14 226
高DPI显示高DPI的显示器用来显示高质量的图像和清晰的字体越来受欢迎。例如，4K显示器包含3840x2160像素，逻辑分辨率为192DPI，然而比较老的显示器中大约有1920x1080像素达到96DPI。高DPI带来的问题高DPI显示会引起现有的应用程序许多问题：应用程序使用UI设计和固定坐标会看起来比较小。用点和用像素表示的尺寸去指定字体大小是不确定的因为点是和显示器分辨率无关的。例如，一个4...
qt 获取dpi_更改显示的DPI缩放大小使Qt应用程序的字体大小变得更大
weixin_33535402的博客
12-23 1595
我有一个固定大小的窗口，当Windows应用程序设置用于扩展所有文本大小时，窗口不够大，无法容纳它所包含的所有文本 . Windows通过dpi增加来实现这一点 . 我通过检索os缩放因子然后调整了我的窗口的大小和它的一些布局(由于某种原因我无法自动缩放)来解决这个问题 .以下是我获得dpi比例的方法(在名为“WindowsDpiScale.h”的文件中)：#ifndef WINDOWSDPIS...
Qt解决在windows平台下高DPI屏幕异常显示的问题，及全屏截图问题
joyopirate的博客
03-08 1129
Windows dpi 截图
QT 如何获知屏幕分辨修改事件
HelloKandy's Blog
09-14 1357
如何获知显示器的屏幕分辨率发生了修改，在QT环境，可 头文件： #pragma once #include <QtWidgets/QWidget> #include "ui_QtScreenResolutionTest.h" class QtScreenResolutionTest : public QWidget { Q_OBJECT public: QtScreenResolutionTest(QWidget *parent = Q_NULLPTR); protect
Qt 分辨率改变事件
sz76211822的专栏
10-09 2123
//这里是监听分辨率改变事件 QDesktopWidget* desktopWidget = QApplication::desktop(); connect(desktopWidget, &QDesktopWidget::resized, this, &MainWindow::resized); ...
让Qt程序适配高分辨率屏幕，解决软件界面错乱异常
热门推荐
cihron的博客
10-09 1万+
前期使用Qt开发一个登录模块一直使用很好。最近在一台新电脑上使用时发现排版混乱。这个问题很普遍，主要原因是旧软件对高清显示器的适配不当造成的。新电脑使用的是4K屏，win10系统自动进行了175%的缩放。
QPrinter设置DPI
风声的专栏
04-06 1189
使用QPrinter打印文件时，有时不同的DPI打印出来效果不一样，这个问题是由于DPI不同导致的； 可以使用QPrinter的setResolution();来设置DPI，需要注意的是这个函数调用必须放在begin调用之前才能生效。 参考： Qt之高DPI显示器(一) - 解决方案整理 - 朝十晚八 - 博客园 https://www.cnblogs.com/swarmbees/p/12004594.html ...
Qt程序在缩放为225%电脑下显示不完全
06-10
如果你的Qt应用程序在高缩放级别（如225%）下显示不完全，可能是因为你的应用程序没有正确处理高DPI缩放。你可以使用以下方法来解决这个问题： 1. 设置Qt应用程序的高DPI缩放因子：在应用程序的main()函数中，使用QApplication::setAttribute()方法来启用高DPI支持，并使用QApplication::setHighDpiScaleFactor()方法来设置高DPI缩放因子。例如，下面的代码将应用程序的高DPI缩放因子设置为2.25： ``` int main(int argc, char *argv[]) { QApplication::setAttribute(Qt::AA_EnableHighDpiScaling); QApplication app(argc, argv); app.setHighDpiScaleFactor(2.25); ... } ``` 2. 使用Qt的布局管理器：使用Qt的布局管理器可以确保你的应用程序在不同的窗口大小和分辨率下正确地缩放和显示。如果你的应用程序没有使用布局管理器，请尝试将其添加到你的界面中。 3. 使用像素密度独立的字体：Qt的字体类支持像素密度独立的字体，这些字体可以在不同的分辨率和缩放下正确显示。你可以使用QFont类的setPixelSize()方法来设置像素密度独立的字体大小。 4. 使用矢量图形：矢量图形可以无损地缩放，因此它们是在高分辨率屏幕上正确显示的理想选择。Qt支持许多矢量图形格式，如SVG和PDF。 如果你的应用程序已经使用了上述方法，但仍然在高缩放级别下显示不完全，请确保你的应用程序没有使用绝对像素值来定位和调整界面元素的大小和位置。相反，你应该使用相对像素值（例如百分比）或像素密度独立的值来调整界面元素的大小和位置。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

黄权浩

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值