ribbonbar.cpp

浏览该文件的文档.

 
#include "ribbonbar.h"
#include "ribbonbar_p.h"
#include "ribbonapplicationbutton.h"
#include "ribbonbuttongroup.h"
#include "ribboncontrols.h"
#include "ribbonmanager.h"
#include "ribbontabbar.h"
#include "ribbonquickaccessbar.h"
 
#include <QAction>
#include <QApplication>
#include <QDebug>
#include <QHoverEvent>
#include <QLinearGradient>
#include <QPainter>
#include <QResizeEvent>
#include <QSet>
#include <QStyleOptionMenuItem>
#include <QTimer>
#include <QVariant>
#include <QEventLoop>
#include <QMouseEvent>
#include "qtcompat/qtcompat.h"
#include <QEvent>
#include <QLayout>
 
QX_RIBBON_BEGIN_NAMESPACE
 
const int tabBarBaseLineHeight = 1;
const int tabBarMinimumWidth = 100;
const int dragAreaMinimumWidth = 20;
 
#define HELP_DRAW_RECT(p, rect)                                                                                        \
    do {                                                                                                               \
        p.save();                                                                                                      \
        QPen _pen(Qt::DashDotDotLine);                                                                                 \
        _pen.setColor(QColor(219, 26, 59));                                                                            \
        p.setPen(_pen);                                                                                                \
        p.setBrush(QBrush());                                                                                          \
        p.drawRect(rect);                                                                                              \
        p.restore();                                                                                                   \
    } while (0)
 
/* RibbonStackedWidget */
RibbonStackedWidget::RibbonStackedWidget(QWidget *parent)
    : QStackedWidget(parent)
    , m_isPopup(false)
{
}
 
RibbonStackedWidget::~RibbonStackedWidget()
{
}
 
bool RibbonStackedWidget::isPopup() const
{
    return m_isPopup;
}
 
void RibbonStackedWidget::setPopup(bool popup)
{
    if (m_isPopup == popup) {
        return;
    }
    m_isPopup = popup;
    if (popup) {
        setWindowFlags(Qt::Popup);
    } else {
        setWindowFlags(Qt::Widget);
    }
}
 
bool RibbonStackedWidget::event(QEvent *event)
{
    if (m_isPopup) {
        switch (event->type()) {
        case QEvent::Show:
            Q_EMIT aboutToShow();
            break;
        case QEvent::Hide:
            Q_EMIT aboutToHide();
            break;
        default:
            break;
        }
    }
    return QStackedWidget::event(event);
}
 
void RibbonStackedWidget::moveWidget(int from, int to)
{
    QWidget *w = widget(from);
 
    removeWidget(w);
    insertWidget(to, w);
}
 
/* RibbonQuickAccessBarContainer */
RibbonQuickAccessBarContainer::RibbonQuickAccessBarContainer(QWidget *parent)
    : RibbonCtrlContainer(parent)
{
    m_quickAccessBar = new RibbonQuickAccessBar(this);
    // use QLayout::SetDefaultConstraint instread of QLayout::SetFixedSize.
    // Otherwise, the size cannot be set using setGeometry
    m_quickAccessBar->layout()->setSizeConstraint(QLayout::SetDefaultConstraint);
    m_quickAccessBar->setObjectName(QStringLiteral("qx_QuickAccessBar"));
    setWidget(m_quickAccessBar);
    setTitleVisible(false);
}
 
RibbonQuickAccessBarContainer::~RibbonQuickAccessBarContainer()
{
}
 
RibbonQuickAccessBar *RibbonQuickAccessBarContainer::quickAccessBar() const
{
    return m_quickAccessBar;
}
 
RibbonBarPrivate::RibbonBarPrivate()
    : m_applicationButton(Q_NULLPTR)
    , m_tabBar(Q_NULLPTR)
    , m_stack(Q_NULLPTR)
    , m_iconRightBorderPosition(1)
    , m_minimumPageButton(Q_NULLPTR)
    , m_topLeftButtonGroup(Q_NULLPTR)
    , m_topRightButtonGroup(Q_NULLPTR)
    , m_bottomLeftButtonGroup(Q_NULLPTR)
    , m_bottomRightButtonGroup(Q_NULLPTR)
    , m_windowButtonGroup(Q_NULLPTR)
    , m_quickAccessBarPosition(RibbonBar::QABRightPosition)
    , m_tabBarPosition(RibbonBar::TBLeftPosition)
    , m_ribbonStyle(RibbonBar::OfficeStyle)
    , m_lastShowStyle(RibbonBar::OfficeStyle)
    , m_pageContextColorListIndex(-1)
    , m_titleAligment(Qt::AlignCenter)
    , m_minimized(true)
    , m_titleVisible(true)
    , m_pageContextCoverTab(false)
    , m_layoutRequest(false)
    , m_blockResize(false)
{
    m_pageContextColorList << QColor(201, 89, 156)   // 玫红
                           << QColor(242, 203, 29)   // 黄
                           << QColor(255, 157, 0)    // 橙
                           << QColor(14, 81, 167)    // 蓝
                           << QColor(228, 0, 69)     // 红
                           << QColor(67, 148, 0)     // 绿
        ;
}
 
void RibbonBarPrivate::init()
{
    Q_Q(RibbonBar);
    m_applicationButton = new RibbonApplicationButton(tr("app"), q);
    m_applicationButton->setObjectName(QStringLiteral("qx_RibbonApplicationButton"));
    connect(m_applicationButton, &QAbstractButton::clicked, q, &RibbonBar::applicationButtonClicked);
    m_tabBar = new RibbonTabBar(q);
    m_tabBar->setObjectName(QStringLiteral("qx_RibbonTabBar"));
    m_tabBar->setDrawBase(false);
    connect(m_tabBar, &QTabBar::currentChanged, this, &RibbonBarPrivate::onCurrentRibbonTabChanged);
    connect(m_tabBar, &QTabBar::tabBarClicked, this, &RibbonBarPrivate::onCurrentRibbonTabClicked);
    connect(m_tabBar, &QTabBar::tabBarDoubleClicked, this, &RibbonBarPrivate::onCurrentRibbonTabDoubleClicked);
    connect(m_tabBar, &QTabBar::tabMoved, this, &RibbonBarPrivate::onTabMoved);
 
    m_tabBarBaseLine = new QWidget(q);
    m_tabBarBaseLine->setObjectName(QStringLiteral("qx_RibbonTabBarBaseLine"));
    m_tabBarBaseLine->setFixedHeight(tabBarBaseLineHeight);
    m_tabBarBaseLine->setVisible(false);
 
    m_stack = new RibbonStackedWidget(q);
    m_tabBar->setObjectName(QStringLiteral("qx_RibbonStackedWidget"));
    connect(m_stack, &RibbonStackedWidget::aboutToHide, this, &RibbonBarPrivate::onStackWidgetHided);
    m_stack->installEventFilter(q);
    setMinimizedFlag(false);
 
    m_quickAccessBar = new RibbonQuickAccessBarContainer(q);
    m_quickAccessBar->setObjectName(QStringLiteral("qx_RibbonQuickAccessBar"));
    m_quickAccessBar->setIcon(q->windowIcon());
}
 
void RibbonBarPrivate::setApplicationButton(QAbstractButton *btn)
{
    Q_Q(RibbonBar);
    if (m_applicationButton) {
        delete m_applicationButton;
    }
    if (btn) {
        if (btn->parent() != q) {
            btn->setParent(q);
        }
        btn->move(0, q->titleBarHeight());
        connect(btn, &QAbstractButton::clicked, q, &RibbonBar::applicationButtonClicked);
 
        if (btn->objectName().isEmpty()) {
            btn->setObjectName(QStringLiteral("qx_RibbonApplicationButton"));
        }
        btn->setVisible(true);
    }
    m_applicationButton = btn;
}
 
bool RibbonBarPrivate::isPageContextVisible(RibbonPageContext *pageContext)
{
    for (int i = 0; i < m_currentShowingPageContextList.size(); ++i) {
        if (m_currentShowingPageContextList[i] == pageContext) {   // operator is overridden
            return true;
        }
    }
    return false;
}
 
void RibbonBarPrivate::setMinimizedFlag(bool flag)
{
    Q_Q(RibbonBar);
    if (m_minimized == flag) {
        return;
    }
    m_minimized = flag;
 
    if (flag) {
        m_stack->setPopup(true);
        m_stack->setFocusPolicy(Qt::NoFocus);
        m_stack->clearFocus();
        m_tabBar->setFocus();
        m_stack->hide();
        m_blockResize = true;
        q->setFixedHeight(m_tabBar->geometry().bottom());
        m_blockResize = false;
    } else {
        m_stack->setPopup(false);
        m_stack->setFocus();
        m_stack->show();
    }
}
 
void RibbonBarPrivate::updateMinimumButtonIcon()
{
    Q_Q(RibbonBar);
    if (m_minimumPageButton) {
        QAction *action = m_minimumPageButton->defaultAction();
        if (action) {
            action->setIcon(q->style()->standardIcon(m_minimized ? QStyle::SP_TitleBarUnshadeButton
                                                                 : QStyle::SP_TitleBarShadeButton,
                                                     0, m_minimumPageButton));
        }
    }
}
 
QColor RibbonBarPrivate::getPageContextColor()
{
    if (m_pageContextColorList.isEmpty()) {
        m_pageContextColorListIndex = -1;
        return QColor();
    }
    ++m_pageContextColorListIndex;
    if ((m_pageContextColorListIndex >= m_pageContextColorList.size()) || (m_pageContextColorListIndex < 0)) {
        m_pageContextColorListIndex = 0;
    }
    return m_pageContextColorList.at(m_pageContextColorListIndex);
}
 
void RibbonBarPrivate::updateTabData()
{
    int tabcount = m_tabBar->count();
 
    for (int i = 0; i < tabcount; ++i) {
        QVariant var = m_tabBar->tabData(i);
        if (var.isValid()) {
            RibbonTabData data = var.value<RibbonTabData>();
            data.index = i;
            m_tabBar->setTabData(i, QVariant::fromValue(data));
        }
    }
    // 刷新完tabdata信息也要接着刷新ContextPage信息
    updatePageContextManagerData();
}
 
void RibbonBarPrivate::updatePageContextManagerData()
{
    const int c = m_tabBar->count();
 
    for (PageContextManagerData &cd : m_currentShowingPageContextList) {
        cd.tabPageIndex.clear();
        for (int i = 0; i < cd.pageContext->pageCount(); ++i) {
            RibbonPage *page = cd.pageContext->page(i);
            for (int t = 0; t < c; ++t) {
                QVariant v = m_tabBar->tabData(t);
                if (v.isValid()) {
                    RibbonTabData data = v.value<RibbonTabData>();
                    if (data.page == page) {
                        cd.tabPageIndex.append(t);
                    }
                } else {
                    cd.tabPageIndex.append(-1);
                }
            }
        }
    }
}
 
void RibbonBarPrivate::updateRibbonElementGeometry()
{
    Q_Q(RibbonBar);
    // 根据样式调整 RibbonPage 的布局形式
    QList<RibbonPage *> pages = q->pages();
    for (RibbonPage *page : std::as_const(pages)) {
        page->setGroupLayoutMode(isTwoRowStyle() ? RibbonGroup::TwoRowMode : RibbonGroup::ThreeRowMode);
    }
    // 阻止因高度变化而会触发resizeEvent，进而执行resizeXX
    m_blockResize = true;
    updateRibbonBarHeight();
    m_blockResize = false;
}
 
void RibbonBarPrivate::updateRibbonBarHeight()
{
    Q_Q(RibbonBar);
    // 根据样式调整bar的高度
    if (m_minimized) {
        // 处于最小模式下时，bar 的高度为 tabbar 的 bottom
        // 最小模式时，bar 的高度在 setMinimizedFlag 中已调整
        // q->setFixedHeight(m_tabBar->geometry().bottom());
    } else {
        q->setFixedHeight(mainBarHeight());
    }
}
 
void RibbonBarPrivate::paintInOfficeStyle(QPainter &p)
{
    Q_Q(RibbonBar);
    paintBackground(p);
 
    p.save();
    QList<PageContextManagerData> pageContextDataList = m_currentShowingPageContextList;
 
    QPoint pageContextPos(q->width(), -1);   // x表示左边界，y表示右边界
    QMargins border = q->contentsMargins();
    for (int i = 0; i < pageContextDataList.size(); ++i) {
        QRect contextTitleRect;
        QList<int> indexs = pageContextDataList[i].tabPageIndex;
        QColor clr = pageContextDataList[i].pageContext->contextColor();
        if (!indexs.isEmpty()) {
            contextTitleRect = m_tabBar->tabRect(indexs.first());
            QRect endRect = m_tabBar->tabRect(indexs.last());
            contextTitleRect.setRight(endRect.right());
            // contextTitleRect是相对于m_tabBar返回的矩形框，不是RibbonBar中的真实位置，所以需要移动到m_tabBar的起点坐标处
            contextTitleRect.translate(m_tabBar->x(), m_tabBar->y());
            contextTitleRect.setHeight(m_tabBar->height() - 1);   // 减1像素，避免tabbar基线覆盖
            contextTitleRect -= m_tabBar->tabMargin() / 2;
            contextTitleRect.setTop(border.top());   // 把区域顶部扩展到窗口顶部
            QRect tabBarRect(m_tabBar->pos(), m_tabBar->size());
            if (tabBarRect.intersects(contextTitleRect)) {
                QRect visibleRect = tabBarRect.intersected(contextTitleRect);
                visibleRect.setTop(contextTitleRect.top());
                paintPageContextTab(p, pageContextDataList[i].pageContext->contextTitle(), visibleRect, clr);
            }
            // 更新上下文标签的范围，用于控制标题栏的显示。如果pageContextPos.y()小于0，说明没有显示上下文标签
            if (contextTitleRect.left() < pageContextPos.x()) {
                pageContextPos.setX(contextTitleRect.left());
            }
            if (contextTitleRect.right() > pageContextPos.y()) {
                pageContextPos.setY(contextTitleRect.right());
            }
        }
#ifdef QX_DRAW_CONTEXT_PAGE_BORDER
        if (indexs.contains(m_tabBar->currentIndex())) {
            QPen pen;
            pen.setColor(clr);
            pen.setWidth(1);
            p.setPen(pen);
            p.setBrush(Qt::NoBrush);
            p.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
            p.drawRect(m_stack->geometry());
        }
#endif
    }
    p.restore();
 
    QWidget *parWindow = q->parentWidget();
    if (parWindow && m_titleVisible) {
        QRect titleRegion;
        int x = border.right();
        // |border|m_quickAccessBar|m_topLeftButtonGroup|~~~
        if (m_topLeftButtonGroup && m_topLeftButtonGroup->isVisible()) {
            x = m_topLeftButtonGroup->geometry().right() + 1;
        } else if (m_quickAccessBar && m_quickAccessBar->isVisible()) {
            x = m_quickAccessBar->geometry().right() + 1;
        }
        if (pageContextPos.y() < 0) {
            // ~~~~|m_topRightButtonGroup|m_windowButtonGroup|m_iconRightBorderPosition|border|
            int w = q->width() - m_iconRightBorderPosition - border.right() - x;
            if (m_windowButtonGroup && m_windowButtonGroup->isVisible()) {
                w -= m_windowButtonGroup->width();
            }
            if (m_topRightButtonGroup && m_topRightButtonGroup->isVisible()) {
                w -= m_topRightButtonGroup->width();
            }
            titleRegion.setRect(x, border.top(), w, q->titleBarHeight());
        } else {
            // ~~~|~~~~~   ~~~~~~|PageContext|~~~~~    ~~~~|
            int leftwidth = pageContextPos.x() - m_iconRightBorderPosition - x;
            int rightwidth = q->width() - pageContextPos.y();
            if (m_windowButtonGroup && m_windowButtonGroup->isVisible()) {
                rightwidth -= m_windowButtonGroup->width();
            }
            if (m_topRightButtonGroup && m_topRightButtonGroup->isVisible()) {
                rightwidth -= m_topRightButtonGroup->width();
            }
            if (rightwidth > leftwidth) {
                titleRegion.setRect(pageContextPos.y(), border.top(), rightwidth, q->titleBarHeight());
            } else {
                titleRegion.setRect(m_iconRightBorderPosition + x, border.top(), leftwidth, q->titleBarHeight());
            }
        }
#ifdef QX_RIBBON_DEBUG_HELP_DRAW
        p.save();
        p.setBrush(QColor(255, 0, 0, 120));
        p.drawRect(titleRegion);
        p.restore();
#endif
        paintWindowTitle(p, parWindow->windowTitle(), titleRegion);
    }
}
 
void RibbonBarPrivate::paintInWpsLiteStyle(QPainter &p)
{
    Q_Q(RibbonBar);
    paintBackground(p);
 
    p.save();
    QList<PageContextManagerData> pageContextDataList = m_currentShowingPageContextList;
 
    QMargins border = q->contentsMargins();
    for (int i = 0; i < pageContextDataList.size(); ++i) {
        QRect contextTitleRect;
        QList<int> indexs = pageContextDataList[i].tabPageIndex;
        QColor clr = pageContextDataList[i].pageContext->contextColor();
        if (!indexs.isEmpty()) {
            contextTitleRect = m_tabBar->tabRect(indexs.first());
            QRect endRect = m_tabBar->tabRect(indexs.last());
            contextTitleRect.setRight(endRect.right());
            contextTitleRect.translate(m_tabBar->x(), m_tabBar->y());
            contextTitleRect.setHeight(m_tabBar->height() - 1);
            contextTitleRect -= m_tabBar->tabMargin() / 2;
            contextTitleRect.setTop(border.top());   // 把区域顶部扩展到窗口顶部
            QRect tabBarRect(m_tabBar->pos(), m_tabBar->size());
            if (tabBarRect.intersects(contextTitleRect)) {
                QRect visibleRect = tabBarRect.intersected(contextTitleRect);
                paintPageContextTab(p, QString(), visibleRect, clr);
            }
        }
#ifdef QX_DRAW_CONTEXT_PAGE_BORDER
        if (indexs.contains(m_tabBar->currentIndex())) {
            QPen pen;
            pen.setColor(clr);
            pen.setWidth(1);
            p.setPen(pen);
            p.setBrush(Qt::NoBrush);
            p.setRenderHints(QPainter::Antialiasing | QPainter::SmoothPixmapTransform);
            p.drawRect(m_stack->geometry());
        }
#endif
    }
    p.restore();
 
    QWidget *parWindow = q->parentWidget();
    if (parWindow && m_titleVisible) {
        // |m_tabBar|~~~        ~~~|m_windowButtonGroup|
        int start = m_tabBar->x() + m_tabBar->width();
        int width = q->width() - start;
        if (m_windowButtonGroup && m_windowButtonGroup->isVisible()) {
            width -= m_windowButtonGroup->width();
        }
        // ~~~|m_quickAccessBar|bottomLeftBG|topRightBG|bottomRightBG|m_windowButtonGroup|
        if (m_quickAccessBarPosition == RibbonBar::QABRightPosition && m_quickAccessBar &&
            m_quickAccessBar->isVisible()) {
            width = m_quickAccessBar->x() - start;
        } else if (m_bottomLeftButtonGroup && m_bottomLeftButtonGroup->isVisible()) {
            width = m_bottomLeftButtonGroup->x() - start;
        } else if (m_topRightButtonGroup && m_topRightButtonGroup->isVisible()) {
            width = m_topRightButtonGroup->x() - start;
        } else if (m_bottomRightButtonGroup && m_bottomRightButtonGroup->isVisible()) {
            width = m_bottomRightButtonGroup->x() - start;
        }
        if (width > 20) {
            QRect titleRegion(start, border.top(), width, q->titleBarHeight());
#ifdef QX_RIBBON_DEBUG_HELP_DRAW
            p.save();
            p.setBrush(QColor(255, 0, 0, 120));
            p.drawRect(titleRegion);
            p.restore();
#endif
            paintWindowTitle(p, parWindow->windowTitle(), titleRegion);
        }
    }
}
 
void RibbonBarPrivate::paintBackground(QPainter &painter)
{
    Q_Q(RibbonBar);
    // 在tabbar下绘制一条线
    painter.save();
    QPen pen(m_tabBarBaseLine->palette().window().color());
    pen.setWidth(tabBarBaseLineHeight);
    pen.setStyle(Qt::SolidLine);
    painter.setPen(pen);
    QMargins border = q->contentsMargins();
    const int lineY = m_tabBar->geometry().bottom();
    painter.drawLine(QPoint(border.left(), lineY), QPoint(q->width() - border.right() - 1, lineY));
    painter.restore();
}
 
void RibbonBarPrivate::paintWindowTitle(QPainter &painter, const QString &title, const QRect &titleRegion)
{
    Q_Q(RibbonBar);
    painter.save();
    painter.setPen(q->palette().color(QPalette::WindowText));
    painter.drawText(titleRegion, m_titleAligment, title);
    painter.restore();
}
 
void RibbonBarPrivate::paintPageContextTab(QPainter &painter, const QString &title, QRect contextRect,
                                           const QColor &color)
{
    Q_Q(RibbonBar);
    // 首先有5像素的实体粗线位于顶部
    QMargins border = q->contentsMargins();
    painter.save();
    painter.setPen(Qt::NoPen);
    painter.setBrush(color);
    painter.drawRect(QRect(contextRect.x(), border.top(), contextRect.width(), 5));
 
    // 剩下把颜色变亮90%
    QColor gColor = color.lighter(190);
 
    // 减去之前的5像素
    contextRect -= QMargins(0, 5, 0, 0);
    if (!m_pageContextCoverTab) {
        // 设置底部位置，不覆盖 tab
        contextRect.setBottom(m_tabBar->geometry().top());
    }
    painter.fillRect(contextRect, gColor);
 
    // 只有在office模式下才需要绘制标题
    if (q->isOfficeStyle()) {
        if (!title.isEmpty()) {
            contextRect.setBottom(m_tabBar->geometry().top());
            painter.setPen(color);
            painter.drawText(contextRect, Qt::AlignCenter, title);
        }
    }
    painter.restore();
 
    if (!m_pageContextCoverTab) {
        painter.save();
        // 绘制 tab 边框
        painter.setPen(gColor);
        painter.setBrush(Qt::NoBrush);
        QRect tabRect(contextRect.bottomLeft(), QPoint(contextRect.bottomRight().x(), m_tabBar->geometry().bottom()));
        painter.drawLine(tabRect.topLeft(), tabRect.bottomLeft());
        painter.drawLine(tabRect.topRight(), tabRect.bottomRight());
        painter.restore();
    }
}
 
void RibbonBarPrivate::resizeInOfficeStyle()
{
    Q_Q(RibbonBar);
    updateRibbonElementGeometry();
 
    QMargins border = q->contentsMargins();
    int x = border.left();
    int y = border.top();
 
    const int validTitleBarHeight = q->titleBarHeight();
    const int tabH = q->tabBarHeight();
    const int otherH = tabH - tabBarBaseLineHeight;
 
    // row-1
    x += m_iconRightBorderPosition + 1;
    // |cornerL|m_quickAccessBar|m_topLeftButtonGroup|~~~~~
    QWidget *cornerL = q->cornerWidget(Qt::TopLeftCorner);
    if (cornerL && cornerL->isVisible()) {
        QSize cornerSize = cornerL->sizeHint();
        if (cornerSize.height() < validTitleBarHeight) {
            int detal = (validTitleBarHeight - cornerSize.height()) / 2;
            cornerL->setGeometry(x, y + detal, cornerSize.width(), cornerSize.height());
        } else {
            cornerL->setGeometry(x, y, cornerSize.width(), validTitleBarHeight);
        }
        x = cornerL->geometry().right() + 5;
    }
    if (m_quickAccessBar && m_quickAccessBar->isVisible()) {
        QSize quickAccessBarSize = m_quickAccessBar->sizeHint();
        m_quickAccessBar->setGeometry(x, y, quickAccessBarSize.width(), validTitleBarHeight);
        x += quickAccessBarSize.width() + 5;
    }
    if (m_topLeftButtonGroup && m_topLeftButtonGroup->isVisible()) {
        QSize wSize = m_topLeftButtonGroup->sizeHint();
        m_topLeftButtonGroup->setGeometry(x, y, wSize.width(), validTitleBarHeight);
    }
    // ~~~~~~~~|m_topRightButtonGroup|m_windowButtonGroup|
    int endX = q->width() - border.right();
    if (m_windowButtonGroup && m_windowButtonGroup->isVisible()) {
        QSize wSize = m_windowButtonGroup->sizeHint();
        endX -= wSize.width();
        m_windowButtonGroup->setGeometry(endX, y, wSize.width(), validTitleBarHeight);
    }
    if (m_topRightButtonGroup && m_topRightButtonGroup->isVisible()) {
        QSize wSize = m_topRightButtonGroup->sizeHint();
        endX -= wSize.width();
        m_topRightButtonGroup->setGeometry(endX, y, wSize.width(), validTitleBarHeight);
    }
 
    // row-2
    x = border.left();
    y += validTitleBarHeight;
    // |m_applicationButton|~~~~~ m_tabBar ~~~~~|m_bottomLeftButtonGroup|m_bottomRightButtonGroup|cornerW|
    if (m_applicationButton && m_applicationButton->isVisible()) {
        m_applicationButton->setGeometry(x, y, m_applicationButton->size().width(), otherH);
        x = m_applicationButton->geometry().right();
    }
    endX = q->width() - border.right();
    QWidget *cornerW = q->cornerWidget(Qt::TopRightCorner);
    if (cornerW && cornerW->isVisible()) {
        QSize cornerSize = cornerW->sizeHint();
        endX -= cornerSize.width();
        if (cornerSize.height() < tabH) {
            int detal = (tabH - cornerSize.height()) / 2;
            cornerW->setGeometry(endX, y + detal, cornerSize.width(), cornerSize.height());
        } else {
            cornerW->setGeometry(endX, y, cornerSize.width(), otherH);
        }
    }
    if (m_bottomRightButtonGroup && m_bottomRightButtonGroup->isVisible()) {
        QSize wSize = m_bottomRightButtonGroup->sizeHint();
        endX -= wSize.width();
        m_bottomRightButtonGroup->setGeometry(endX, y, wSize.width(), otherH);
    }
    if (m_bottomLeftButtonGroup && m_bottomLeftButtonGroup->isVisible()) {
        QSize wSize = m_bottomLeftButtonGroup->sizeHint();
        endX -= wSize.width();
        m_bottomLeftButtonGroup->setGeometry(endX, y, wSize.width(), otherH);
    }
    int allowedTabBarWidth = endX - x;
    int minTabBarWidth = calcMinTabBarWidth();
    if (m_tabBarPosition == RibbonBar::TBLeftPosition) {
        m_tabBar->setGeometry(x, y, qMin(minTabBarWidth, allowedTabBarWidth), tabH);
    } else {   // RibbonBar::TBCenterPosition
        if (minTabBarWidth < allowedTabBarWidth) {
            // |~~~~~~~~~~~~~~~~~~ allowedTabBarWidth ~~~~~~~~~~~~~~|
            // |~~ xOffset ~~|~~~~ mintabBarWidth ~~~~|~~ xOffset ~~|
            int xOffset = (allowedTabBarWidth - minTabBarWidth) / 2;
            m_tabBar->setGeometry(x + xOffset, y, minTabBarWidth, tabH);
        } else {
            m_tabBar->setGeometry(x, y, allowedTabBarWidth, tabH);
        }
    }
 
    resizeStackedWidget();
}
 
void RibbonBarPrivate::resizeInWpsLiteStyle()
{
    Q_Q(RibbonBar);
    updateRibbonElementGeometry();
 
    QMargins border = q->contentsMargins();
    int x = border.left();
    int y = border.top();
 
    const int validTitleBarHeight = q->titleBarHeight();
 
    // ~~~~|m_bottomLeftButtonGroup|m_topRightButtonGroup|m_bottomRightButtonGroup|cornerR|m_windowButtonGroup|
    int endX = q->width() - border.right();
    if (m_windowButtonGroup && m_windowButtonGroup->isVisible()) {
        QSize wSize = m_windowButtonGroup->sizeHint();
        endX -= wSize.width();
        m_windowButtonGroup->setGeometry(endX, y, wSize.width(), validTitleBarHeight);
    }
    QWidget *cornerR = q->cornerWidget(Qt::TopRightCorner);
    if (cornerR && cornerR->isVisible()) {
        QSize cornerSize = cornerR->sizeHint();
        endX -= cornerSize.width();
        if (cornerSize.height() < validTitleBarHeight) {
            int detal = (validTitleBarHeight - cornerSize.height()) / 2;
            cornerR->setGeometry(endX, y + detal, cornerSize.width(), cornerSize.height());
        } else {
            cornerR->setGeometry(endX, y, cornerSize.width(), validTitleBarHeight);
        }
    }
    if (m_bottomRightButtonGroup && m_bottomRightButtonGroup->isVisible()) {
        QSize wSize = m_bottomRightButtonGroup->sizeHint();
        endX -= wSize.width();
        m_bottomRightButtonGroup->setGeometry(endX, y, wSize.width(), validTitleBarHeight);
    }
    if (m_topRightButtonGroup && m_topRightButtonGroup->isVisible()) {
        QSize wSize = m_topRightButtonGroup->sizeHint();
        endX -= wSize.width();
        m_topRightButtonGroup->setGeometry(endX, y, wSize.width(), validTitleBarHeight);
    }
    if (m_bottomLeftButtonGroup && m_bottomLeftButtonGroup->isVisible()) {
        QSize wSize = m_bottomLeftButtonGroup->sizeHint();
        endX -= wSize.width();
        m_bottomLeftButtonGroup->setGeometry(endX, y, wSize.width(), validTitleBarHeight);
    }
    // ~~~~|m_quickAccessBar|m_bottomLeftButtonGroup|~~~~~
    if (m_quickAccessBarPosition == RibbonBar::QABRightPosition && m_quickAccessBar && m_quickAccessBar->isVisible()) {
        QSize quickAccessBarSize = m_quickAccessBar->sizeHint();
        endX -= quickAccessBarSize.width();
        m_quickAccessBar->setGeometry(endX, y, quickAccessBarSize.width(), validTitleBarHeight);
    }
    // ~~~~|cornerL|<m_quickAccessBar>|m_bottomLeftButtonGroup|~~~~~
    QWidget *cornerL = q->cornerWidget(Qt::TopLeftCorner);
    if (cornerL && cornerL->isVisible()) {
        QSize cornerSize = cornerL->sizeHint();
        endX -= cornerSize.width();
        if (cornerSize.height() < validTitleBarHeight) {
            int detal = (validTitleBarHeight - cornerSize.height()) / 2;
            cornerL->setGeometry(endX, y + detal, cornerSize.width(), cornerSize.height());
        } else {
            cornerL->setGeometry(endX, y, cornerSize.width(), validTitleBarHeight);
        }
    }
 
    // tab 的y值需要重新计算
    int tabH = q->tabBarHeight();
    if (tabH > validTitleBarHeight) {
        // 这种直接把tabH设置为validTitleBarHeight
        tabH = validTitleBarHeight;
    }
    // 如果tabH较小，则下移，让tab底部和title的底部对齐
    y += validTitleBarHeight - tabH;
 
    // |m_applicationButton|<m_quickAccessBar>|m_topLeftButtonGroup|m_tabBar|~~~~~~
    if (m_applicationButton && m_applicationButton->isVisible()) {
        m_applicationButton->setGeometry(x, y, m_applicationButton->size().width(), tabH);
        x = m_applicationButton->geometry().right() + 2;
    }
    if (m_quickAccessBarPosition == RibbonBar::QABLeftPosition && m_quickAccessBar && m_quickAccessBar->isVisible()) {
        QSize quickAccessBarSize = m_quickAccessBar->sizeHint();
        m_quickAccessBar->setGeometry(x, border.top(), quickAccessBarSize.width(), validTitleBarHeight);
        x = m_quickAccessBar->geometry().right() + 2;
    }
    if (m_topLeftButtonGroup && m_topLeftButtonGroup->isVisible()) {
        QSize wSize = m_topLeftButtonGroup->sizeHint();
        m_topLeftButtonGroup->setGeometry(x, y, wSize.width(), tabH);
        x = m_topLeftButtonGroup->geometry().right() + 2;
    }
    int allowedTabBarWidth = endX - x - dragAreaMinimumWidth;
    // 20200831
    // tabBarWidth的宽度原来为endX - x;，现需要根据实际进行调整
    // 为了把tabbar没有tab的部分不占用，这里的宽度需要根据tab的size来进行设置，让tabbar的长度刚刚好，这样能让出
    // mainwindow的空间，接受鼠标事件，从而实现拖动等操作，否则tabbar占用整个顶栏，鼠标无法点击到mainwindow
    int minTabBarWidth = calcMinTabBarWidth();
    if (m_tabBarPosition == RibbonBar::TBLeftPosition) {
        m_tabBar->setGeometry(x, y, qMin(minTabBarWidth, allowedTabBarWidth), tabH);
    } else {   // RibbonBar::TBCenterPosition
        if (minTabBarWidth < allowedTabBarWidth) {
            // |~~~~~~~~~~~~~~~~~~ allowedTabBarWidth ~~~~~~~~~~~~~~|
            // |~~ xOffset ~~|~~~~ mintabBarWidth ~~~~|~~ xOffset ~~|
            int xOffset = (allowedTabBarWidth - minTabBarWidth) / 2;
            m_tabBar->setGeometry(x + xOffset, y, minTabBarWidth, tabH);
        } else {
            m_tabBar->setGeometry(x, y, allowedTabBarWidth, tabH);
        }
    }
 
    resizeStackedWidget();
}
 
void RibbonBarPrivate::resizeStackedWidget()
{
    Q_Q(RibbonBar);
    QMargins border = q->contentsMargins();
    if (m_stack->isPopup()) {
        QPoint absPosition = q->mapToGlobal(QPoint(border.left(), m_tabBar->geometry().bottom() + 1));
        m_stack->setGeometry(absPosition.x(), absPosition.y(), q->width() - border.left() - border.right(),
                             mainBarHeight() - m_tabBar->geometry().bottom() - border.bottom() - 1);
    } else {
        m_stack->setGeometry(border.left(), m_tabBar->geometry().bottom() + 1,
                             q->width() - border.left() - border.right(),
                             mainBarHeight() - m_tabBar->geometry().bottom() - border.bottom() - 1);
    }
}
 
void RibbonBarPrivate::resizeRibbon()
{
    if (isOfficeStyle()) {
        resizeInOfficeStyle();
    } else {
        resizeInWpsLiteStyle();
    }
}
 
int RibbonBarPrivate::minimumWidthInOfficeStyle() const
{
    Q_Q(const RibbonBar);
    QMargins border = q->contentsMargins();
 
    int w1 = 0;
    int w2 = 0;
 
    // row-1
    w1 += m_iconRightBorderPosition + 1;
    // |cornerL|m_quickAccessBar|m_topLeftButtonGroup|~~~~~~~~~|m_topRightButtonGroup|m_windowButtonGroup|
    QWidget *cornerL = q->cornerWidget(Qt::TopLeftCorner);
    if (cornerL && cornerL->isVisible()) {
        w1 += cornerL->sizeHint().width() + 5;
    }
    if (m_quickAccessBar && m_quickAccessBar->isVisible()) {
        w1 += m_quickAccessBar->sizeHint().width() + 5;
    }
    if (m_topLeftButtonGroup && m_topLeftButtonGroup->isVisible()) {
        w1 += m_topLeftButtonGroup->sizeHint().width();
    }
    if (m_windowButtonGroup && m_windowButtonGroup->isVisible()) {
        w1 += m_windowButtonGroup->sizeHint().width();
    }
    if (m_topRightButtonGroup && m_topRightButtonGroup->isVisible()) {
        w1 += m_topRightButtonGroup->sizeHint().width();
    }
    w1 += dragAreaMinimumWidth;
 
    // row-2
    // |m_applicationButton|~~~~~ m_tabBar ~~~~~|m_bottomLeftButtonGroup|m_bottomRightButtonGroup|cornerW|
    if (m_applicationButton && m_applicationButton->isVisible()) {
        w2 += m_applicationButton->size().width();
    }
    QWidget *cornerW = q->cornerWidget(Qt::TopRightCorner);
    if (cornerW && cornerW->isVisible()) {
        w2 += cornerW->sizeHint().width();
    }
    if (m_bottomRightButtonGroup && m_bottomRightButtonGroup->isVisible()) {
        w2 += m_bottomRightButtonGroup->sizeHint().width();
    }
    if (m_bottomLeftButtonGroup && m_bottomLeftButtonGroup->isVisible()) {
        w2 += m_bottomLeftButtonGroup->sizeHint().width();
    }
    w2 += tabBarMinimumWidth;
 
    return qMax(w1, w2) + border.left() + border.right();
}
 
int RibbonBarPrivate::minimumWidthInWpsLiteStyle() const
{
    Q_Q(const RibbonBar);
    QMargins border = q->contentsMargins();
 
    int w = 0;
 
    // ~~~~|m_bottomLeftButtonGroup|m_topRightButtonGroup|m_bottomRightButtonGroup|cornerR|m_windowButtonGroup|
    if (m_windowButtonGroup && m_windowButtonGroup->isVisible()) {
        w += m_windowButtonGroup->sizeHint().width();
    }
    QWidget *cornerR = q->cornerWidget(Qt::TopRightCorner);
    if (cornerR && cornerR->isVisible()) {
        w += cornerR->sizeHint().width();
    }
    if (m_bottomRightButtonGroup && m_bottomRightButtonGroup->isVisible()) {
        w += m_bottomRightButtonGroup->sizeHint().width();
    }
    if (m_topRightButtonGroup && m_topRightButtonGroup->isVisible()) {
        w += m_topRightButtonGroup->sizeHint().width();
    }
    if (m_bottomLeftButtonGroup && m_bottomLeftButtonGroup->isVisible()) {
        w += m_bottomLeftButtonGroup->sizeHint().width();
    }
    // ~~~~|m_quickAccessBar|m_bottomLeftButtonGroup|~~~~~
    if (m_quickAccessBar && m_quickAccessBar->isVisible()) {
        w += m_quickAccessBar->sizeHint().width();
    }
    // ~~~~|cornerL|<m_quickAccessBar>|m_bottomLeftButtonGroup|~~~~~
    QWidget *cornerL = q->cornerWidget(Qt::TopLeftCorner);
    if (cornerL && cornerL->isVisible()) {
        w += cornerL->sizeHint().width();
    }
    // |m_applicationButton|<m_quickAccessBar>|m_topLeftButtonGroup|m_tabBar|~~~~~~
    if (m_applicationButton && m_applicationButton->isVisible()) {
        w += m_applicationButton->size().width();
    }
    if (m_topLeftButtonGroup && m_topLeftButtonGroup->isVisible()) {
        w += m_topLeftButtonGroup->sizeHint().width();
    }
    w += dragAreaMinimumWidth;
 
    return w + tabBarMinimumWidth + border.left() + border.right();
}
 
int RibbonBarPrivate::calcMinTabBarWidth() const
{
    const QMargins &mg = m_tabBar->tabMargin();
    int mintabBarWidth = 0;
 
    int cnt = m_tabBar->count();
    ++cnt;   // add sentry tab
 
    for (int i = 0; i < cnt; ++i) {
        mintabBarWidth += m_tabBar->tabRect(i).width();
    }
    mintabBarWidth += (mg.left() + mg.right());
    return mintabBarWidth;
}
 
int RibbonBarPrivate::mainBarHeight() const
{
    return RibbonElementStyleOpt.ribbonBarHeight(m_ribbonStyle);
}
 
int RibbonBarPrivate::tabIndex(RibbonPage *page) const
{
    if (page == Q_NULLPTR) {
        return -1;
    }
    const int size = m_tabBar->count();
 
    for (int i = 0; i < size; ++i) {
        QVariant v = m_tabBar->tabData(i);
        if (v.isValid()) {
            RibbonTabData innerValue = v.value<RibbonTabData>();
            if (innerValue.page == page) {
                return i;
            }
        }
    }
    return -1;
}
 
RibbonButtonGroup *RibbonBarPrivate::createButtonGroup()
{
    Q_Q(RibbonBar);
    RibbonButtonGroup *buttonGroup = new RibbonButtonGroup(q);
    buttonGroup->setObjectName(QStringLiteral("qx_RibbonButtonGroup"));
    buttonGroup->setFrameShape(QFrame::NoFrame);
    return buttonGroup;
}
 
void RibbonBarPrivate::onWindowTitleChanged(const QString &title)
{
    Q_Q(RibbonBar);
    Q_UNUSED(title);
    q->update();
}
 
void RibbonBarPrivate::onWindowIconChanged(const QIcon &icon)
{
    if (m_quickAccessBar) {
        m_quickAccessBar->setIcon(icon);
    }
}
 
void RibbonBarPrivate::onPageWindowTitleChanged(const QString &title)
{
    RibbonPage *w = qobject_cast<RibbonPage *>(sender());
 
    if (Q_NULLPTR == w) {
        return;
    }
    for (int i = 0; i < m_tabBar->count(); ++i) {
        // 鉴于tab不会很多，不考虑效率问题
        QVariant var = m_tabBar->tabData(i);
        if (var.isValid()) {
            RibbonTabData data = var.value<RibbonTabData>();
            if (w == data.page) {
                m_tabBar->setTabText(i, title);
            }
        }
    }
}
 
void RibbonBarPrivate::onPageContextAdded(RibbonPage *page)
{
    Q_ASSERT_X(page != Q_NULLPTR, "onPageContextAdded", "add Q_NULLPTR page");
    m_stack->addWidget(page);   // 这里stackedWidget用append，其他地方都应该使用insert
}
 
void RibbonBarPrivate::onCurrentRibbonTabChanged(int index)
{
    Q_Q(RibbonBar);
    QVariant var = m_tabBar->tabData(index);
    RibbonPage *page = Q_NULLPTR;
 
    if (var.isValid()) {
        RibbonTabData data = var.value<RibbonTabData>();
        page = data.page;
    }
    if (page) {
        if (m_stack->currentWidget() != page) {
            m_stack->setCurrentWidget(page);
        }
        if (m_minimized) {
            m_tabBar->clearFocus();
            if (!m_stack->isVisible() && m_stack->isPopup()) {
                // 在StackedWindget弹出前，先给tabbar一个QHoverEvent,让tabbar知道鼠标已经移开
#if QT_VERSION < QT_VERSION_CHECK(6, 3, 0)
                QHoverEvent ehl(QEvent::HoverLeave, m_tabBar->mapToGlobal(QCursor::pos()),
                                m_tabBar->mapToGlobal(QCursor::pos()));
#else
                QHoverEvent ehl(QEvent::HoverLeave, m_tabBar->mapToParent(QCursor::pos()),
                                m_tabBar->mapToGlobal(QCursor::pos()), m_tabBar->mapToGlobal(QCursor::pos()));
#endif
                QApplication::sendEvent(m_tabBar, &ehl);
                resizeStackedWidget();
                m_stack->setFocus();
                m_stack->show();
                // 在最小模式下，每次显示完StackedWindget后把tab的
                // 的index设置为-1，这样每次点击都会触发onCurrentRibbonTabChanged
            }
        }
    }
    Q_EMIT q->currentRibbonTabChanged(index);
}
 
void RibbonBarPrivate::onCurrentRibbonTabClicked(int index)
{
    if (index != m_tabBar->currentIndex()) {
        // 点击的标签不一致通过changed槽去处理
        return;
    }
    if (index == -1) {
        return;
    }
    if (index == m_tabBar->count()) {
        return;   // sentry tab
    }
    if (m_minimized) {
        if (!m_stack->isVisible() && m_stack->isPopup()) {
            // 在StackedWindget弹出前，先给tabbar一个QHoverEvent,让tabbar知道鼠标已经移开
#if QT_VERSION < QT_VERSION_CHECK(6, 3, 0)
            QHoverEvent ehl(QEvent::HoverLeave, m_tabBar->mapToGlobal(QCursor::pos()),
                            m_tabBar->mapToGlobal(QCursor::pos()));
#else
            QHoverEvent ehl(QEvent::HoverLeave, m_tabBar->mapToParent(QCursor::pos()),
                            m_tabBar->mapToGlobal(QCursor::pos()), m_tabBar->mapToGlobal(QCursor::pos()));
#endif
            QApplication::sendEvent(m_tabBar, &ehl);
            // 弹出前都调整一下位置，避免移动后位置异常
            resizeStackedWidget();
            m_stack->setFocus();
            m_stack->show();
        }
    }
}
 
void RibbonBarPrivate::onCurrentRibbonTabDoubleClicked(int index)
{
    Q_Q(RibbonBar);
    if (index == -1) {
        return;
    }
    if (index == m_tabBar->count()) {
        return;   // sentry tab
    }
    q->setMinimized(!m_minimized);
}
 
void RibbonBarPrivate::onTabMoved(int from, int to)
{
    m_stack->moveWidget(from, to);
}
 
void RibbonBarPrivate::onStackWidgetHided()
{
    m_tabBar->setCurrentIndex(-1);
}
 
void RibbonBarPrivate::onFontChanged()
{
    RibbonElementStyleOpt.recalc();
}
 
/* RibbonBar */
RibbonBar::RibbonBar(QWidget *parent)
    : QMenuBar(parent)
{
    QX_INIT_PRIVATE(RibbonBar)
    Q_D(RibbonBar);
    d->init();
    if (parent) {
        connect(parent, &QWidget::windowTitleChanged, d, &RibbonBarPrivate::onWindowTitleChanged);
        connect(parent, &QWidget::windowIconChanged, d, &RibbonBarPrivate::onWindowIconChanged);
    }
    setRibbonStyle(OfficeStyle);
}
 
RibbonBar::~RibbonBar()
{
    QX_FINI_PRIVATE();
}
 
QAbstractButton *RibbonBar::applicationButton()
{
    Q_D(RibbonBar);
    return d->m_applicationButton;
}
 
void RibbonBar::setApplicationButton(QAbstractButton *btn)
{
    Q_D(RibbonBar);
    d->setApplicationButton(btn);
    QApplication::postEvent(this, new QResizeEvent(size(), size()));
}
 
RibbonPage *RibbonBar::addPage(const QString &title)
{
    return insertPage(-1, title);
}
 
void RibbonBar::addPage(RibbonPage *page)
{
    insertPage(-1, page);
}
 
RibbonPage *RibbonBar::insertPage(int index, const QString &title)
{
    RibbonPage *page = new RibbonPage(this);
    page->setObjectName(title);
    page->setPageName(title);
    insertPage(index, page);
    return page;
}
 
void RibbonBar::insertPage(int index, RibbonPage *page)
{
    Q_D(RibbonBar);
    if (Q_NULLPTR == page) {
        return;
    }
    page->setGroupLayoutMode(isTwoRowStyle() ? RibbonGroup::TwoRowMode : RibbonGroup::ThreeRowMode);
    page->setRibbonBar(this);
 
    int i = d->m_tabBar->insertTab(index, page->windowTitle());
    RibbonTabData tabdata;
    tabdata.page = page;
    tabdata.index = i;
    d->m_tabBar->setTabData(i, QVariant::fromValue(tabdata));
    if (index != -1) {
        d->updateTabData();
    }
 
    d->m_stack->insertWidget(i, page);
 
    connect(page, &QWidget::windowTitleChanged, d, &RibbonBarPrivate::onPageWindowTitleChanged);
    QApplication::postEvent(this, new QResizeEvent(size(), size()));
}
 
RibbonPage *RibbonBar::page(int index) const
{
    Q_D(const RibbonBar);
    QVariant var = d->m_tabBar->tabData(index);
 
    if (var.isValid()) {
        RibbonTabData data = var.value<RibbonTabData>();
        return data.page;
    }
    return Q_NULLPTR;
}
 
RibbonPage *RibbonBar::pageByName(const QString &title) const
{
    Q_D(const RibbonBar);
    int c = d->m_stack->count();
 
    for (int i = 0; i < c; ++i) {
        RibbonPage *w = qobject_cast<RibbonPage *>(d->m_stack->widget(i));
        if (w && w->windowTitle() == title) {
            return w;
        }
    }
    return Q_NULLPTR;
}
 
RibbonPage *RibbonBar::pageByObjectName(const QString &objname) const
{
    Q_D(const RibbonBar);
    int c = d->m_stack->count();
 
    for (int i = 0; i < c; ++i) {
        RibbonPage *w = qobject_cast<RibbonPage *>(d->m_stack->widget(i));
        if (w && w->objectName() == objname) {
            return (w);
        }
    }
    return Q_NULLPTR;
}
 
QList<RibbonPage *> RibbonBar::pages(bool getAll) const
{
    Q_D(const RibbonBar);
    int c = d->m_stack->count();
    QList<RibbonPage *> res;
 
    for (int i = 0; i < c; ++i) {
        RibbonPage *w = qobject_cast<RibbonPage *>(d->m_stack->widget(i));
        if (w) {
            if (!getAll && w->isPageContext()) {
                // 不是getall且是上下文时跳过
                continue;
            }
            res.append(w);
        }
    }
    return res;
}
 
bool RibbonBar::isPageVisible(RibbonPage *page) const
{
    int tabindex = pageIndex(page);
 
    return (tabindex >= 0);
}
 
void RibbonBar::showPage(RibbonPage *page)
{
    Q_D(RibbonBar);
    for (auto i = d->m_hidedPage.begin(); i != d->m_hidedPage.end(); ++i) {
        if (i->page == page) {   // 说明要显示
            int index = d->m_tabBar->insertTab(i->index, i->page->windowTitle());
            i->index = index;
            d->m_tabBar->setTabData(index, QVariant::fromValue(*i));
            d->m_hidedPage.erase(i);   // 移除
            d->updateTabData();        // 更新index信息
            break;
        }
    }
    raisePage(page);
}
 
void RibbonBar::hidePage(RibbonPage *page)
{
    Q_D(RibbonBar);
    int tabcount = d->m_tabBar->count();
 
    for (int i = 0; i < tabcount; ++i) {
        QVariant var = d->m_tabBar->tabData(i);
        if (var.isValid()) {
            RibbonTabData p = var.value<RibbonTabData>();
            if (p.page == page) {
                d->m_hidedPage.append(p);
                d->m_tabBar->removeTab(i);   // 仅仅把tab移除
                // 注意Page隐藏后，contex的位置就会发生变化，需要更新
                d->updateTabData();
                return;
            }
        }
    }
}
 
void RibbonBar::raisePage(RibbonPage *page)
{
    Q_D(RibbonBar);
    int index = d->m_stack->indexOf(page);
 
    if (index >= 0) {
        setCurrentIndex(index);
    }
}
 
void RibbonBar::removePage(RibbonPage *page)
{
    Q_D(RibbonBar);
    int index = d->tabIndex(page);
    bool isupdate = false;
    if (index >= 0) {
        d->m_tabBar->removeTab(index);
        isupdate = true;
    }
    d->m_stack->removeWidget(page);
    // 同时验证这个page是否是contexpage里的
    for (RibbonPageContext *c : std::as_const(d->m_pageContextList)) {
        c->takePage(page);
    }
    // 这时要刷新所有tabdata的index信息
    if (isupdate) {
        d->updateTabData();
    }
    // 移除完后需要重绘
    repaint();
    QApplication::postEvent(this, new QResizeEvent(size(), size()));
}
 
void RibbonBar::clearPages()
{
    for (RibbonPage *page : pages(false)) {
        removePage(page);
        delete page;
    }
}
 
void RibbonBar::movePage(int from, int to)
{
    Q_D(RibbonBar);
    d->m_tabBar->moveTab(from, to);
    // 这时要刷新所有tabdata的index信息
    d->updateTabData();
    // 这里会触发tabMoved信号，在tabMoved信号中调整stacked里窗口的位置
}
 
int RibbonBar::pageIndex(RibbonPage *page) const
{
    Q_D(const RibbonBar);
    return d->tabIndex(page);
}
 
RibbonPageContext *RibbonBar::addPageContext(const QString &title, const QColor &color)
{
    Q_D(RibbonBar);
    RibbonPageContext *context = new RibbonPageContext(this);
 
    context->setObjectName(title);
    context->setContextTitle(title);
    context->setContextColor(color.isValid() ? color : d->getPageContextColor());
    addPageContext(context);
    return context;
}
 
void RibbonBar::addPageContext(RibbonPageContext *context)
{
    Q_D(RibbonBar);
    if (Q_NULLPTR == context) {
        return;
    }
    connect(context, &RibbonPageContext::pageAdded, d, &RibbonBarPrivate::onPageContextAdded);
    // remove并没有绑定，主要是remove后在stacked里也不会显示，remove且delete的话，stacked里也会删除
    if (currentRibbonStyle() == WpsLiteStyle) {
        d->resizeInWpsLiteStyle();
    }
    d->m_pageContextList.append(context);
}
 
void RibbonBar::showPageContext(RibbonPageContext *context)
{
    Q_D(RibbonBar);
    if (isPageContextVisible(context)) {
        return;
    }
    PageContextManagerData pageContextData;
 
    pageContextData.pageContext = context;
    int cnt = context->pageCount();
    for (int i = 0; i < context->pageCount(); ++i) {
        RibbonPage *page = context->page(i);
        // 此句如果模式重复设置不会进行多余操作
        page->setGroupLayoutMode(isTwoRowStyle() ? RibbonGroup::TwoRowMode : RibbonGroup::ThreeRowMode);
        // 切换模式后会改变高度，上下文标签显示时要保证显示出来
        // page->setFixedHeight(pageHeight());
        int index = d->m_tabBar->addTab(page->windowTitle());
        pageContextData.tabPageIndex.append(index);
 
        RibbonTabData tabdata;
        tabdata.page = page;
        tabdata.index = index;
        d->m_tabBar->setTabData(index, QVariant::fromValue(tabdata));
        if (cnt > 1) {
            // 如果连续添加多页，每添加一页就立即更新一下尺寸，如果依赖最后的postEvent会短暂出现导航箭头
            QRect r = d->m_tabBar->geometry();
            r.setWidth(d->calcMinTabBarWidth());
            d->m_tabBar->setGeometry(r);
        }
    }
    d->m_currentShowingPageContextList.append(pageContextData);
    // 由于上下文都是在最后追加，不需要调用updateTabData();
    QApplication::postEvent(this, new QResizeEvent(size(), size()));
}
 
void RibbonBar::hidePageContext(RibbonPageContext *context)
{
    Q_D(RibbonBar);
    bool needResize = false;
 
    for (int i = 0; i < d->m_currentShowingPageContextList.size(); ++i) {
        if (d->m_currentShowingPageContextList[i].pageContext == context) {
            const QList<int> &indexs = d->m_currentShowingPageContextList[i].tabPageIndex;
            for (int j = indexs.size() - 1; j >= 0; --j) {
                d->m_tabBar->removeTab(indexs[j]);
            }
            // 注意，删除ContextPage后，tab的序号就会改变，这时，这个tab后面的都要调整它的序号
            needResize = true;
            d->m_currentShowingPageContextList.removeAt(i);
            break;
        }
    }
    if (needResize) {
        d->updateTabData();
        QApplication::postEvent(this, new QResizeEvent(size(), size()));
    }
}
 
bool RibbonBar::isPageContextVisible(RibbonPageContext *context)
{
    Q_D(RibbonBar);
    return d->isPageContextVisible(context);
}
 
void RibbonBar::setPageContextVisible(RibbonPageContext *context, bool visible)
{
    if (Q_NULLPTR == context) {
        return;
    }
    if (visible) {
        showPageContext(context);
    } else {
        hidePageContext(context);
    }
}
 
bool RibbonBar::isPageContextCoverTab()
{
    Q_D(RibbonBar);
    return d->m_pageContextCoverTab;
}
 
void RibbonBar::setPageContextCoverTab(bool cover)
{
    Q_D(RibbonBar);
    d->m_pageContextCoverTab = cover;
}
 
QList<RibbonPageContext *> RibbonBar::pageContextList() const
{
    Q_D(const RibbonBar);
    return d->m_pageContextList;
}
 
void RibbonBar::destroyPageContext(RibbonPageContext *context)
{
    Q_D(RibbonBar);
    if (Q_NULLPTR == context) {
        return;
    }
    if (isPageContextVisible(context)) {
        hidePageContext(context);
    }
    d->m_pageContextList.removeAll(context);
 
    QList<RibbonPage *> res = context->pageList();
    for (RibbonPage *page : std::as_const(res)) {
        page->hide();
        page->deleteLater();
    }
    context->deleteLater();
    QApplication::postEvent(this, new QResizeEvent(size(), size()));
}
 
void RibbonBar::minimize()
{
    setMinimized(true);
}
 
bool RibbonBar::isMinimized() const
{
    Q_D(const RibbonBar);
    return d->m_minimized;
}
 
void RibbonBar::setMinimized(bool flag)
{
    Q_D(RibbonBar);
    d->setMinimizedFlag(flag);
    d->updateMinimumButtonIcon();
    QResizeEvent resizeEvent(size(), size());
    QApplication::sendEvent(this, &resizeEvent);
    Q_EMIT minimizationChanged(flag);
}
 
bool RibbonBar::haveShowMinimumButton() const
{
    Q_D(const RibbonBar);
    return (Q_NULLPTR != d->m_minimumPageButton);
}
 
void RibbonBar::showMinimumButton(bool isShow)
{
    Q_D(RibbonBar);
    if (isShow) {
        cornerButtonGroup(Qt::BottomRightCorner);   // create m_bottomRightButtonGroup
        if (Q_NULLPTR == d->m_minimumPageButton) {
            d->m_minimumPageButton = RibbonElementFactory->createHideGroupButton(this);
            d->m_minimumPageButton->ensurePolished();   // 载入样式图标
            QAction *action = new QAction(d->m_minimumPageButton);
            connect(action, &QAction::triggered, this, [=]() {
                this->setMinimized(!isMinimized());
            });
            d->m_minimumPageButton->setDefaultAction(action);
            d->m_bottomRightButtonGroup->addWidget(d->m_minimumPageButton);
            update();
        }
        d->updateMinimumButtonIcon();
    } else {
        if (Q_NULLPTR != d->m_minimumPageButton) {
            d->m_minimumPageButton->hide();
            d->m_minimumPageButton->deleteLater();
            d->m_minimumPageButton = Q_NULLPTR;
        }
    }
    QResizeEvent resizeEvent(size(), size());
    QApplication::sendEvent(this, &resizeEvent);
}
 
int RibbonBar::tabBarHeight() const
{
    return RibbonElementStyleOpt.tabBarHeight();
}
 
int RibbonBar::titleBarHeight() const
{
    return RibbonElementStyleOpt.titleBarHeight();
}
 
RibbonButtonGroup *RibbonBar::cornerButtonGroup(Qt::Corner corner)
{
    Q_D(RibbonBar);
    RibbonButtonGroup *buttonGroup = Q_NULLPTR;
 
    switch (corner) {
    case Qt::TopLeftCorner:
        if (Q_NULLPTR == d->m_topLeftButtonGroup) {
            d->m_topLeftButtonGroup = d->createButtonGroup();
        }
        buttonGroup = d->m_topLeftButtonGroup;
        break;
    case Qt::TopRightCorner:
        if (Q_NULLPTR == d->m_topRightButtonGroup) {
            d->m_topRightButtonGroup = d->createButtonGroup();
        }
        buttonGroup = d->m_topRightButtonGroup;
        break;
    case Qt::BottomLeftCorner:
        if (Q_NULLPTR == d->m_bottomLeftButtonGroup) {
            d->m_bottomLeftButtonGroup = d->createButtonGroup();
        }
        buttonGroup = d->m_bottomLeftButtonGroup;
        break;
    case Qt::BottomRightCorner:
        if (Q_NULLPTR == d->m_bottomRightButtonGroup) {
            d->m_bottomRightButtonGroup = d->createButtonGroup();
        }
        buttonGroup = d->m_bottomRightButtonGroup;
        break;
    default:
        break;
    }
    if (buttonGroup) {
        buttonGroup->show();
    }
    return buttonGroup;
}
 
RibbonQuickAccessBar *RibbonBar::quickAccessBar() const
{
    Q_D(const RibbonBar);
    return d->m_quickAccessBar->quickAccessBar();
}
 
void RibbonBar::setQuickAccessBarPosition(QuickAccessBarPosition position)
{
    Q_D(RibbonBar);
    if (d->m_quickAccessBarPosition == position) {
        return;
    }
    d->m_quickAccessBarPosition = position;
    if (!d->isOfficeStyle()) {
        resizeRibbon();
    }
}
 
RibbonBar::QuickAccessBarPosition RibbonBar::quickAccessBarPosition() const
{
    Q_D(const RibbonBar);
    return d->m_quickAccessBarPosition;
}
 
void RibbonBar::setTabBarPosition(RibbonBar::TabBarPosition position)
{
    Q_D(RibbonBar);
    if (d->m_tabBarPosition == position) {
        return;
    }
    d->m_tabBarPosition = position;
    resizeRibbon();
}
 
RibbonBar::TabBarPosition RibbonBar::tabBarPosition() const
{
    Q_D(const RibbonBar);
    return d->m_tabBarPosition;
}
 
RibbonBar::RibbonStyle RibbonBar::currentRibbonStyle() const
{
    Q_D(const RibbonBar);
    return d->m_ribbonStyle;
}
 
void RibbonBar::setRibbonStyle(RibbonBar::RibbonStyle v)
{
    Q_D(RibbonBar);
    d->m_ribbonStyle = v;
    d->m_lastShowStyle = v;
    d->m_quickAccessBar->setIconVisible(isOfficeStyle() && d->m_titleVisible);
    d->updateRibbonElementGeometry();
 
    /*
    QSize oldSize = size();
    QSize newSize(oldSize.width(), d->mainBarHeight());
    QResizeEvent es(newSize, oldSize);
    QApplication::sendEvent(this, &es);
    */
    // sendEvent会导致RibbonQuickAccessBar在样式切换后无法更新尺寸，改为用postEvent
    // resizeRibbon();
 
    // FIXME: 使用 resizeRibbon 中的 postEvent，会存在延迟。当采用 WPS 样式且处于最小模式时，从 WPS 样式切换到
    // OFFICE 样式，会出现 m_tabBar 的尺寸未及时更新就设置了 setFixedHeight(d->m_tabBar->geometry().bottom())
    // 从而导致高度仍为 WPS 样式时的高度，切换到 OFFICE 样式后，m_tabBar 所在的水平区域内容无法正常显示
    // WORKAROUND: 此处直接调用 d->resizeRibbon，保证立即更新 m_tabBar 尺寸
    d->resizeRibbon();
    update();
 
    if (isMinimized()) {
        // 处于最小模式下时，bar的高度为tabbar的bottom,这个调整必须在resize event之后
        d->m_blockResize = true;
        setFixedHeight(d->m_tabBar->geometry().bottom());
        d->m_blockResize = false;
    }
    Q_EMIT ribbonStyleChanged(d->m_ribbonStyle);
}
 
int RibbonBar::currentIndex()
{
    Q_D(RibbonBar);
    return d->m_tabBar->currentIndex();
}
 
void RibbonBar::setCurrentIndex(int index)
{
    Q_D(RibbonBar);
    d->m_tabBar->setCurrentIndex(index);
}
 
bool RibbonBar::isOfficeStyle() const
{
    Q_D(const RibbonBar);
    return d->isOfficeStyle();
}
 
bool RibbonBar::isTwoRowStyle() const
{
    Q_D(const RibbonBar);
    return d->isTwoRowStyle();
}
 
void RibbonBar::setWindowButtonGroup(QWidget *widget)
{
    Q_D(RibbonBar);
    d->m_windowButtonGroup = widget;
}
 
void RibbonBar::updateRibbonGeometry()
{
    Q_D(RibbonBar);
    d->updateRibbonBarHeight();
    QList<RibbonPage *> pages = this->pages();
    for (RibbonPage *page : std::as_const(pages)) {
        page->updateItemGeometry();
    }
}
 
void RibbonBar::updateRibbonTheme()
{
    Q_D(RibbonBar);
    d->updateMinimumButtonIcon();
}
 
void RibbonBar::resizeRibbon()
{
    // FIXME: 此处使用resizeEvent中的d->resizeRibbon()和update()来代替postEvent会出现如下问题：
    // WPS模式下，无边框和有边框之间切换后,
    // m_applicationButton.isVisible()突然返回false，导致d->resizeRibbon()中计算尺寸异常
    QApplication::postEvent(this, new QResizeEvent(size(), size()));
}
 
Qt::Alignment RibbonBar::windowTitleAligment() const
{
    Q_D(const RibbonBar);
    return d->m_titleAligment;
}
 
void RibbonBar::setWindowTitleAligment(Qt::Alignment al)
{
    Q_D(RibbonBar);
    d->m_titleAligment = al;
}
 
void RibbonBar::setWindowTitleVisible(bool visible)
{
    Q_D(RibbonBar);
    d->m_titleVisible = visible;
    d->m_quickAccessBar->setIconVisible(isOfficeStyle() && visible);
}
 
QSize RibbonBar::sizeHint() const
{
    Q_D(const RibbonBar);
    QSize sz = QMenuBar::sizeHint();
    int w = 0;
    if (isOfficeStyle()) {
        w = d->minimumWidthInOfficeStyle();
    } else {
        w = d->minimumWidthInWpsLiteStyle();
    }
    sz.setWidth(w);
    return sz;
}
 
QSize RibbonBar::minimumSizeHint() const
{
    return sizeHint();
}
 
bool RibbonBar::event(QEvent *event)
{
    Q_D(RibbonBar);
    bool res = QMenuBar::event(event);
 
    switch (event->type()) {
    // QGuiApplication::fontChanged() is deprecated since Qt 6; the same
    // notification arrives as an event on every widget instead.
    case QEvent::ApplicationFontChange: {
        d->onFontChanged();
    } break;
    case QEvent::LayoutRequest: {
        // FIXME: 引入LayoutRequest后，如果处理不当，会增加resize次数，需要梳理触发LayoutRequest的条件，
        // 同时，需要梳理哪些postEvent或sendEvent可以由LayoutRequest代替。
        // 目前，当cornerWidget为QMdiArea时，根据有效事件来设置m_layoutRequest
        if (d->m_layoutRequest) {
            d->resizeRibbon();
            d->m_layoutRequest = false;
        }
    } break;
    default:
        break;
    }
 
    return res;
}
 
bool RibbonBar::eventFilter(QObject *obj, QEvent *e)
{
    Q_D(RibbonBar);
    if (obj) {
        // 调整多文档时在窗口模式下的按钮更新
        if ((obj == cornerWidget(Qt::TopLeftCorner)) || (obj == cornerWidget(Qt::TopRightCorner))) {
            // 对于QMdiArea，最大化时会存在ShowToParent事件，之后有效点击按钮（logo、最大/小、关闭按钮）会存在MouseButtonRelease事件
            if ((QEvent::ShowToParent == e->type()) || (QEvent::MouseButtonRelease == e->type())) {
                d->m_layoutRequest = true;
            }
        } else if (obj == d->m_stack && d->m_stack->isPopup()) {
            // 在 stack 是 popup 模式时，点击 stack 区域外的时候，如果是在 ribbonTabBar 上点击, 那么忽略掉这次点击
            // 把点击下发到 ribbonTabBar, 这样可以避免在点击 ribbonTabBar 后 stack 隐藏又显示，出现闪烁
            if ((QEvent::MouseButtonPress == e->type()) || (QEvent::MouseButtonDblClick == e->type())) {
                QMouseEvent *mouseEvent = static_cast<QMouseEvent *>(e);
#if QT_VERSION < QT_VERSION_CHECK(6, 0, 0)
                QPoint pos = mouseEvent->pos();
                QPoint globalPos = QtCanpoolCompat::globalMousePos(mouseEvent);
#else
                QPoint pos = mouseEvent->position().toPoint();
                QPoint globalPos = mouseEvent->globalPosition().toPoint();
#endif
                if (!d->m_stack->rect().contains(pos)) {
                    QWidget *clickedWidget = QApplication::widgetAt(globalPos);
                    if (clickedWidget == d->m_tabBar) {
                        const QPoint targetPoint = clickedWidget->mapFromGlobal(globalPos);
                        QMouseEvent *evPress =
                            new QMouseEvent(mouseEvent->type(), targetPoint, globalPos, mouseEvent->button(),
                                            mouseEvent->buttons(), mouseEvent->modifiers());
                        QApplication::postEvent(clickedWidget, evPress);
                        return true;
                    }
                }
            }
        }
    }
    return QMenuBar::eventFilter(obj, e);
}
 
void RibbonBar::paintEvent(QPaintEvent *e)
{
    Q_D(RibbonBar);
    Q_UNUSED(e);
    QPainter p(this);
    if (isOfficeStyle()) {
        d->paintInOfficeStyle(p);
    } else {
        d->paintInWpsLiteStyle(p);
    }
#ifdef QX_RIBBON_DEBUG_HELP_DRAW
    HELP_DRAW_RECT(p, d->m_quickAccessBar->geometry());
    HELP_DRAW_RECT(p, d->m_tabBar->geometry());
    HELP_DRAW_RECT(p, d->m_stack->geometry());
#endif
}
 
void RibbonBar::resizeEvent(QResizeEvent *e)
{
    Q_D(RibbonBar);
    Q_UNUSED(e);
    if (d->m_blockResize) {
        return;
    }
    d->resizeRibbon();
    update();
}
 
QX_RIBBON_END_NAMESPACE