ribbongroup.cpp

浏览该文件的文档.

 
#include "ribbongroup.h"
#include "ribbongroup_p.h"
#include "ribbongallery.h"
#include "ribbongrouplayout.h"
#include "ribboncontrols.h"
#include "ribbonbutton.h"
#include "ribbonmanager.h"
 
#include <QAction>
#include <QApplication>
#include <QDebug>
#include <QFontMetrics>
#include <QGridLayout>
#include <QIcon>
#include <QMenu>
#include <QPainter>
#include <QResizeEvent>
#include <QWidgetAction>
 
QX_RIBBON_BEGIN_NAMESPACE
 
#ifndef QX_RIBBON_PROP_ROW_PROPORTION
#define QX_RIBBON_PROP_ROW_PROPORTION "_qx_RibbonGroupRowProportion"
#endif
 
#define HELP_DRAW_RECT(p, rect)                                                                                        \
    do {                                                                                                               \
        p.save();                                                                                                      \
        QPen _pen(Qt::DashLine);                                                                                       \
        _pen.setColor(Qt::blue);                                                                                       \
        p.setPen(_pen);                                                                                                \
        p.setBrush(QBrush());                                                                                          \
        p.drawRect(rect);                                                                                              \
        p.restore();                                                                                                   \
    } while (0)
 
RibbonGroupOptionButton::RibbonGroupOptionButton(QWidget *parent)
    : QToolButton(parent)
{
    setAutoRaise(true);
    setCheckable(false);
    setToolButtonStyle(Qt::ToolButtonIconOnly);
    setFixedSize(16, 16);
    setIconSize(QSize(10, 10));
    setIcon(QIcon(":/image/res/group_option.png"));
}
 
void RibbonGroupOptionButton::connectAction(QAction *action)
{
    connect(this, &RibbonGroupOptionButton::clicked, action, &QAction::trigger);
}
 
int RibbonGroupPrivate::s_groupTitleHeight = 21;
bool RibbonGroupPrivate::s_titleVisible = true;
 
RibbonGroupPrivate::RibbonGroupPrivate()
    : m_optionActionButton(Q_NULLPTR)
    , m_groupLayoutMode(RibbonGroup::ThreeRowMode)
    , m_isCanCustomize(true)
{
}
 
void RibbonGroupPrivate::init()
{
    Q_Q(RibbonGroup);
    m_layout = new RibbonGroupLayout(q);
    m_layout->setSpacing(2);
    m_layout->setContentsMargins(2, 2, 2, 2);
}
 
RibbonButton *RibbonGroupPrivate::lastAddedButton()
{
    QWidget *w = m_layout->lastWidget();
 
    return qobject_cast<RibbonButton *>(w);
}
 
void RibbonGroupPrivate::resetLargeToolButtonStyle()
{
    Q_Q(RibbonGroup);
    QList<RibbonButton *> btns = q->ribbonButtons();
 
    for (RibbonButton *b : std::as_const(btns)) {
        if ((Q_NULLPTR == b) || (RibbonButton::LargeButton != b->buttonType())) {
            continue;
        }
        if (RibbonGroup::ThreeRowMode == m_groupLayoutMode) {
            if (RibbonButton::Normal != b->largeButtonType()) {
                b->setLargeButtonType(RibbonButton::Normal);
            }
        } else {
            if (RibbonButton::Lite != b->largeButtonType()) {
                b->setLargeButtonType(RibbonButton::Lite);
            }
        }
    }
}
 
const QList<RibbonGroupItem *> &RibbonGroupPrivate::ribbonGroupItems() const
{
    return m_layout->ribbonGroupItems();
}
 
/* RibbonGroup */
RibbonGroup::RibbonGroup(QWidget *parent)
    : QWidget(parent)
{
    QX_INIT_PRIVATE(RibbonGroup);
    Q_D(RibbonGroup);
    d->init();
    setGroupLayoutMode(ThreeRowMode);
}
 
RibbonGroup::RibbonGroup(const QString &name, QWidget *parent)
    : RibbonGroup(parent)
{
    setGroupName(name);
}
 
RibbonGroup::~RibbonGroup()
{
    QX_FINI_PRIVATE();
}
 
QString RibbonGroup::groupName() const
{
    return windowTitle();
}
 
void RibbonGroup::setGroupName(const QString &title)
{
    setWindowTitle(title);
    update();
}
 
QString RibbonGroup::title() const
{
    return groupName();
}
 
void RibbonGroup::setTitle(const QString &title)
{
    setGroupName(title);
}
 
RibbonGroup::RowProportion RibbonGroup::getActionRowProportionProperty(QAction *action)
{
    bool isok = false;
    int r = action->property(QX_RIBBON_PROP_ROW_PROPORTION).toInt(&isok);
 
    if (isok) {
        return static_cast<RibbonGroup::RowProportion>(r);
    }
    return RibbonGroup::Large;
}
 
void RibbonGroup::setActionRowProportionProperty(QAction *action, RibbonGroup::RowProportion rp)
{
    if (action == Q_NULLPTR) {
        return;
    }
    action->setProperty(QX_RIBBON_PROP_ROW_PROPORTION, int(rp));
}
 
void RibbonGroup::setActionRowProportion(QAction *action, RibbonGroup::RowProportion rp)
{
    Q_D(RibbonGroup);
    if (action == Q_NULLPTR) {
        return;
    }
    setActionRowProportionProperty(action, rp);
 
    RibbonGroupLayout *lay = d->m_layout;
    if (lay) {
        RibbonGroupItem *it = lay->groupItem(action);
        if (it) {
            it->rowProportion = rp;
            lay->invalidate();
        }
    }
}
 
RibbonButton *RibbonGroup::addAction(QAction *action, RibbonGroup::RowProportion rp)
{
    Q_D(RibbonGroup);
    if (action == Q_NULLPTR) {
        return Q_NULLPTR;
    }
    setActionRowProportionProperty(action, rp);
    QWidget::addAction(action);
 
    return d->lastAddedButton();
}
 
RibbonButton *RibbonGroup::addLargeAction(QAction *action)
{
    return addAction(action, RibbonGroup::Large);
}
 
RibbonButton *RibbonGroup::addMediumAction(QAction *action)
{
    return addAction(action, RibbonGroup::Medium);
}
 
RibbonButton *RibbonGroup::addSmallAction(QAction *action)
{
    return addAction(action, RibbonGroup::Small);
}
 
void RibbonGroup::addAction(QAction *act, QToolButton::ToolButtonPopupMode popMode, RibbonGroup::RowProportion rp)
{
    Q_D(RibbonGroup);
    if (act == Q_NULLPTR) {
        return;
    }
    setActionRowProportionProperty(act, rp);
    QWidget::addAction(act);
    RibbonButton *btn = d->lastAddedButton();
    if (btn) {
        btn->setPopupMode(popMode);
    }
}
 
QAction *RibbonGroup::addAction(const QString &text, const QIcon &icon, QToolButton::ToolButtonPopupMode popMode,
                                RibbonGroup::RowProportion rp)
{
    QAction *action = new QAction(icon, text, this);
    addAction(action, popMode, rp);
    return action;
}
 
RibbonButton *RibbonGroup::addMenu(QMenu *menu, RibbonGroup::RowProportion rp, QToolButton::ToolButtonPopupMode popMode)
{
    Q_D(RibbonGroup);
    if (menu == Q_NULLPTR) {
        return Q_NULLPTR;
    }
    QAction *action = menu->menuAction();
 
    addAction(action, rp);
    RibbonButton *btn = d->lastAddedButton();
    if (btn) {
        btn->setPopupMode(popMode);
    }
    return btn;
}
 
RibbonButton *RibbonGroup::addLargeMenu(QMenu *menu, QToolButton::ToolButtonPopupMode popMode)
{
    return addMenu(menu, RibbonGroup::Large, popMode);
}
 
RibbonButton *RibbonGroup::addSmallMenu(QMenu *menu, QToolButton::ToolButtonPopupMode popMode)
{
    return addMenu(menu, RibbonGroup::Small, popMode);
}
 
RibbonButton *RibbonGroup::addActionMenu(QAction *action, QMenu *menu, RibbonGroup::RowProportion rp)
{
    RibbonButton *btn = addAction(action, rp);
    if (Q_NULLPTR == btn) {
        return Q_NULLPTR;
    }
    btn->setMenu(menu);
    btn->setPopupMode(QToolButton::MenuButtonPopup);
    return btn;
}
 
RibbonButton *RibbonGroup::addLargeActionMenu(QAction *action, QMenu *menu)
{
    return addActionMenu(action, menu, RibbonGroup::Large);
}
 
QAction *RibbonGroup::addWidget(QWidget *w, RibbonGroup::RowProportion rp)
{
    QWidgetAction *action = new QWidgetAction(this);
 
    // The lifecycle of w is taken over by action
    action->setDefaultWidget(w);
    w->setAttribute(Qt::WA_Hover);
    setActionRowProportionProperty(action, rp);
    QWidget::addAction(action);
    return action;
}
 
QAction *RibbonGroup::addLargeWidget(QWidget *w)
{
    return addWidget(w, RibbonGroup::Large);
}
 
QAction *RibbonGroup::addMediumWidget(QWidget *w)
{
    return addWidget(w, RibbonGroup::Medium);
}
 
QAction *RibbonGroup::addSmallWidget(QWidget *w)
{
    return addWidget(w, RibbonGroup::Small);
}
 
RibbonGallery *RibbonGroup::addGallery()
{
    RibbonGallery *gallery = new RibbonGallery(this);
 
    addWidget(gallery, RibbonGroup::Large);
 
    setExpanding();
    return gallery;
}
 
QAction *RibbonGroup::addSeparator(int top, int bottom)
{
    Q_D(RibbonGroup);
    QAction *action = new QAction(this);
 
    action->setSeparator(true);
    setActionRowProportionProperty(action, RibbonGroup::Large);
    QWidget::addAction(action);
    QWidget *w = d->m_layout->lastWidget();
    RibbonSeparator *sep = qobject_cast<RibbonSeparator *>(w);
    if (sep) {
        sep->setTopBottomMargins(top, bottom);
    }
    return action;
}
 
int RibbonGroup::ribbonButtonCount() const
{
    return ribbonButtons().count();
}
 
RibbonButton *RibbonGroup::ribbonButtonByIndex(int index) const
{
    int cnt = ribbonButtonCount();
    if (index < 0 || index >= cnt) {
        return nullptr;
    }
    return ribbonButtons().at(index);
}
 
RibbonButton *RibbonGroup::ribbonButtonForAction(QAction *action) const
{
    RibbonGroupLayout *lay = qobject_cast<RibbonGroupLayout *>(layout());
 
    if (lay) {
        int index = lay->indexOf(action);
        if (index == -1) {
            return Q_NULLPTR;
        }
        QLayoutItem *item = lay->itemAt(index);
        if (item) {
            return qobject_cast<RibbonButton *>(item->widget());
        }
    }
    return Q_NULLPTR;
}
 
QList<RibbonButton *> RibbonGroup::ribbonButtons() const
{
    const QObjectList &objs = children();
    QList<RibbonButton *> res;
 
    for (QObject *o : objs) {
        RibbonButton *b = qobject_cast<RibbonButton *>(o);
        if (b) {
            res.append(b);
        }
    }
    return res;
}
 
bool RibbonGroup::hasOptionAction() const
{
    Q_D(const RibbonGroup);
    return (d->m_optionActionButton != Q_NULLPTR);
}
 
void RibbonGroup::addOptionAction(QAction *action)
{
    Q_D(RibbonGroup);
    if (Q_NULLPTR == action) {
        if (d->m_optionActionButton) {
            delete d->m_optionActionButton;
            d->m_optionActionButton = Q_NULLPTR;
        }
        return;
    }
    if (Q_NULLPTR == d->m_optionActionButton) {
        d->m_optionActionButton = new RibbonGroupOptionButton(this);
    }
    d->m_optionActionButton->setFixedSize(optionActionButtonSize());
    d->m_optionActionButton->setIconSize(optionActionButtonSize() - QSize(-2, -2));
    d->m_optionActionButton->connectAction(action);
    updateGeometry();   // 通知layout进行重新布局
    repaint();
}
 
int RibbonGroup::actionIndex(QAction *act) const
{
    Q_D(const RibbonGroup);
    return d->m_layout->indexOf(act);
}
 
void RibbonGroup::moveAction(int from, int to)
{
    Q_D(RibbonGroup);
    d->m_layout->move(from, to);
    updateGeometry();   // 通知layout进行重新布局
}
 
RibbonGroup::GroupLayoutMode RibbonGroup::groupLayoutMode() const
{
    Q_D(const RibbonGroup);
    return d->m_groupLayoutMode;
}
 
void RibbonGroup::setGroupLayoutMode(RibbonGroup::GroupLayoutMode mode)
{
    Q_D(RibbonGroup);
    if (d->m_groupLayoutMode == mode) {
        return;
    }
    d->m_groupLayoutMode = mode;
    updateItemGeometry();
}
 
void RibbonGroup::updateItemGeometry()
{
    Q_D(RibbonGroup);
    // reset layout
    layout()->setSpacing(isTwoRow() ? 4 : 2);
    updateGeometry();
 
    d->resetLargeToolButtonStyle();
}
 
bool RibbonGroup::isTwoRow() const
{
    Q_D(const RibbonGroup);
    return (TwoRowMode == d->m_groupLayoutMode);
}
 
QSize RibbonGroup::optionActionButtonSize() const
{
    return (isTwoRow() ? QSize(12, 12) : QSize(16, 16));
}
 
QSize RibbonGroup::sizeHint() const
{
    Q_D(const RibbonGroup);
    QSize laySize = layout()->sizeHint();
    int maxWidth = laySize.width() + 2;
 
    if (titleVisible()) {
        QFontMetrics fm = fontMetrics();
        QSize titleSize = fm.size(Qt::TextShowMnemonic, groupName());
        if (d->m_optionActionButton) {
            // optionActionButton的宽度需要预留
            titleSize.setWidth(titleSize.width() + d->m_optionActionButton->width() + 4);
        }
        maxWidth = qMax(maxWidth, titleSize.width());
    }
    return QSize(maxWidth, laySize.height());
}
 
QSize RibbonGroup::minimumSizeHint() const
{
    return layout()->minimumSize();
}
 
bool RibbonGroup::isExpanding() const
{
    QSizePolicy sp = sizePolicy();
 
    return (sp.horizontalPolicy() == QSizePolicy::Expanding);
}
 
void RibbonGroup::setExpanding(bool expanding)
{
    setSizePolicy(expanding ? QSizePolicy::Expanding : QSizePolicy::Preferred, QSizePolicy::Fixed);
}
 
bool RibbonGroup::isCanCustomize() const
{
    Q_D(const RibbonGroup);
    return d->m_isCanCustomize;
}
 
void RibbonGroup::setCanCustomize(bool b)
{
    Q_D(RibbonGroup);
    d->m_isCanCustomize = b;
}
 
int RibbonGroup::largeHeight() const
{
    return RibbonGroupLayout::calcLargeHeight(rect(), this);
}
 
int RibbonGroup::titleHeight() const
{
    return (titleVisible() ? groupTitleHeight() : 0);
}
 
bool RibbonGroup::titleVisible()
{
    return RibbonGroupPrivate::s_titleVisible;
}
 
void RibbonGroup::setTitleVisible(bool visible)
{
    if (RibbonGroupPrivate::s_titleVisible != visible) {
        RibbonGroupPrivate::s_titleVisible = visible;
        RibbonElementStyleOpt.recalc();
    }
}
 
int RibbonGroup::groupTitleHeight()
{
    return RibbonGroupPrivate::s_groupTitleHeight;
}
 
void RibbonGroup::setGroupTitleHeight(int h)
{
    if (RibbonGroupPrivate::s_groupTitleHeight != h) {
        RibbonGroupPrivate::s_groupTitleHeight = h;
        RibbonElementStyleOpt.recalc();
    }
}
 
void RibbonGroup::paintEvent(QPaintEvent *event)
{
    Q_D(RibbonGroup);
    QPainter p(this);
 
#ifdef QX_RIBBON_DEBUG_HELP_DRAW
    HELP_DRAW_RECT(p, rect());
#endif
    if (titleVisible()) {
        const int th = titleHeight();
        QFont f = font();
        p.setFont(f);
        QRect r;
        if (d->m_optionActionButton) {
            r = QRect(1, height() - th, width() - d->m_optionActionButton->width() - 4, th);
        } else {
            r = QRect(1, height() - th, width(), th);
        }
        p.drawText(r, Qt::AlignCenter, groupName());
#ifdef QX_RIBBON_DEBUG_HELP_DRAW
        HELP_DRAW_RECT(p, r);
#endif
    }
 
    QWidget::paintEvent(event);
}
 
void RibbonGroup::resizeEvent(QResizeEvent *event)
{
    Q_D(RibbonGroup);
    if (d->m_optionActionButton) {
        if (titleVisible()) {
            d->m_optionActionButton->move(width() - d->m_optionActionButton->width() - 2,
                                          height() - titleHeight() +
                                              (titleHeight() - d->m_optionActionButton->height()) / 2);
        } else {
            d->m_optionActionButton->move(width() - d->m_optionActionButton->width(),
                                          height() - d->m_optionActionButton->height());
        }
    }
    return QWidget::resizeEvent(event);
}
 
void RibbonGroup::actionEvent(QActionEvent *event)
{
    Q_D(RibbonGroup);
    QAction *action = event->action();
 
    switch (event->type()) {
    case QEvent::ActionAdded: {
        RibbonGroupLayout *lay = d->m_layout;
        int index = layout()->count();
        if (event->before()) {
            // 说明是插入
            index = lay->indexOf(action);
            if (-1 == index) {
                index = layout()->count();   // 找不到的时候就插入到最后
            }
        }
        lay->insertAction(index, action, getActionRowProportionProperty(action));
        // 由于group的尺寸发生变化，需要让page也调整
        if (parentWidget()) {
            QApplication::postEvent(parentWidget(), new QEvent(QEvent::LayoutRequest));
        }
    } break;
 
    case QEvent::ActionChanged: {
        // 让布局重新绘制
        layout()->invalidate();
        // 由于group的尺寸发生变化，需要让page也调整
        if (parentWidget()) {
            QApplication::postEvent(parentWidget(), new QEvent(QEvent::LayoutRequest));
        }
    } break;
 
    case QEvent::ActionRemoved: {
        RibbonGroupLayout *lay = d->m_layout;
        action->disconnect(this);
        int index = lay->indexOf(action);
        if (index != -1) {
            QLayoutItem *item = lay->takeAt(index);
            delete item;
        }
        // 由于group的尺寸发生变化，需要让page也调整
        if (parentWidget()) {
            QApplication::postEvent(parentWidget(), new QEvent(QEvent::LayoutRequest));
        }
    } break;
 
    default:
        break;
    }
}
 
/* RibbonSeparator */
RibbonSeparator::RibbonSeparator(int height, QWidget *parent)
    : RibbonSeparator(parent)
{
    setFixedHeight(height);
}
 
RibbonSeparator::RibbonSeparator(QWidget *parent)
    : QWidget(parent)
    , m_topMargin(4)
    , m_bottomMargin(4)
{
    setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding);
    setFixedWidth(6);
}
 
QSize RibbonSeparator::sizeHint() const
{
    return QSize(6, height());
}
 
void RibbonSeparator::setTopBottomMargins(int top, int bottom)
{
    m_topMargin = top;
    m_bottomMargin = bottom;
}
 
void RibbonSeparator::paintEvent(QPaintEvent *event)
{
    Q_UNUSED(event);
    QPainter painter(this);
 
    painter.setPen(palette().window().color().darker(114));
    int x1 = rect().center().x();
 
    painter.drawLine(QPoint(x1, rect().top() + m_topMargin), QPoint(x1, rect().bottom() - m_bottomMargin));
}
 
QX_RIBBON_END_NAMESPACE