TitleBar.cpp

// Copyright Copyright (c) Kang Lin studio, All Rights Reserved
// Author Kang Lin <kl222@126.com>
 
#include "TitleBar.h"
#include <QHBoxLayout>
#include <QDockWidget>
#include <QMargins>
 
namespace RabbitCommon {
 
QPushButton* CTitleBar::CreateSmallPushButton(QIcon icon, QWidget *parent) {
    QPushButton *button = new QPushButton(icon, "", parent);
    if(!button) return button;
    
    button->setObjectName("TitleBarButton");
    button->setFlat(true);
 
    // avoid keyboard focus, this looks bad
    button->setFocusPolicy(Qt::NoFocus);
    
    return button;
}
 
CTitleBar::CTitleBar(QWidget *parent)
    : QWidget{parent},
    m_pTitle(nullptr),
    m_pIcon(nullptr),
    m_pCloseButton(nullptr),
    m_pFloatButton(nullptr),
    m_pMaxButton(nullptr),
    m_pMinButton(nullptr)
{
    bool check = false;
 
    // Muse set parent
    Q_ASSERT(parent);
 
    // Title bar horizontal layout
    QHBoxLayout *layout = new QHBoxLayout(this);
    setLayout(layout);
    // ugly platform dependent layout fix:
    // this should be solved by the style sheet
    layout->setContentsMargins(10, 3, 10, 3);  // left, top, right, bottom
    #ifdef __APPLE__
        layout->setSpacing(10);
    #else
        layout->setSpacing(0);
    #endif
 
    m_pIcon = new QLabel(this);
    Q_ASSERT(m_pIcon);
    m_pIcon->setWindowIcon(parent->windowIcon());
    check = connect(parent, &QWidget::windowIconChanged,
                    this, [&](const QIcon &icon){
                        do {
                            if(icon.isNull())
                                break;
                            auto sizeList = icon.availableSizes();
                            if(sizeList.isEmpty())
                                break;
                            QPixmap p = icon.pixmap(*sizeList.begin());
                            if(p.isNull())
                                break;
                            QMargins cm = m_pIcon->contentsMargins();
                            int w = m_pIcon->height() - cm.top() - cm.bottom();
                            p = p.scaled(w, w, Qt::KeepAspectRatio, Qt::SmoothTransformation);
                            m_pIcon->setPixmap(p);
                            //m_pIcon->setScaledContents(true);
                            return;
                        }while(0);
                        m_pIcon->setPixmap(QPixmap());
                    });
    Q_ASSERT(check);
    layout->addWidget(m_pIcon);
    m_pIcon->show();
 
    m_pTitle = new QLabel(this);
    Q_ASSERT(m_pTitle);
    m_pTitle->setText(parent->windowTitle());
    check = connect(parent, SIGNAL(windowTitleChanged(const QString&)),
                           m_pTitle, SLOT(setText(const QString&)));
    Q_ASSERT(check);
    m_pTitle->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Preferred);
    layout->addWidget(m_pTitle);
 
    m_pMinButton = CreateSmallPushButton(QIcon::fromTheme("window-minimize"), this);
    Q_ASSERT(m_pMinButton);
    m_pMinButton->setToolTip(tr("Minimize"));
    layout->addWidget(m_pMinButton);
    check = connect(m_pMinButton, SIGNAL(clicked()),
                    this, SLOT(slotMinimize()));
    Q_ASSERT(check);
    
    m_pMaxButton = CreateSmallPushButton(QIcon::fromTheme("window-maximize"), this);
    Q_ASSERT(m_pMaxButton);
    m_pMaxButton->setToolTip(tr("Maximize"));
    layout->addWidget(m_pMaxButton);
    check = connect(m_pMaxButton, SIGNAL(clicked()),
                    this, SLOT(slotMaximize()));
    Q_ASSERT(check);
    
    m_pFloatButton = CreateSmallPushButton(QIcon::fromTheme("floating"), this);
    Q_ASSERT(m_pFloatButton);
    m_pFloatButton->setToolTip(tr("Floating"));
    layout->addWidget(m_pFloatButton);
    check = connect(m_pFloatButton, SIGNAL(clicked()),
                    this, SLOT(slotFloat()));
    Q_ASSERT(check);
    
    m_pCloseButton = CreateSmallPushButton(
                QIcon::fromTheme("window-close"), this);
    Q_ASSERT(m_pCloseButton);
    m_pCloseButton->setToolTip(tr("Close"));
    layout->addWidget(m_pCloseButton);
    check = connect(m_pCloseButton, SIGNAL(clicked()),
                    parent, SLOT(close()));
    Q_ASSERT(check);
    
    QDockWidget* pParent = qobject_cast<QDockWidget*>(parent);
    if(pParent) {    
        QDockWidget::DockWidgetFeatures features = pParent->features();
        VisibleCloseButton(QDockWidget::DockWidgetClosable & features);
        VisibleFloatButton(QDockWidget::DockWidgetFloatable & features);
        bool bFloating = pParent->isFloating();
        if(m_pFloatButton) {
            if(bFloating)
                m_pFloatButton->setIcon(QIcon::fromTheme("unfloating"));
            else
                m_pFloatButton->setIcon(QIcon::fromTheme("floating"));
        }
        bool check = connect(parent, SIGNAL(topLevelChanged(bool)),
                             this, SLOT(slotTopLevelChanged(bool)));
        Q_ASSERT(check);
        if(!pParent->isFloating())
        {
            VisibleMaximizeButton(false);
            VisibleMinimizeButton(false);
        }
    } else {
        VisibleFloatButton(false);
    }
}
 
int CTitleBar::AddWidgets(QList<QWidget*> pLstWidget)
{
    QHBoxLayout *layout = qobject_cast<QHBoxLayout*>(this->layout());
    foreach (auto w, pLstWidget) {
        if(layout)
            layout->insertWidget(2, w);
    }
    return 0;
}
 
int CTitleBar::VisibleIconButton(bool bVisible)
{
    if(m_pIcon)
        m_pIcon->setVisible(bVisible);
    return 0;
}
 
int CTitleBar::VisibleTitleButton(bool bVisible)
{
    if(m_pTitle)
        m_pTitle->setVisible(bVisible);
    return 0;
}
 
int CTitleBar::VisibleMaximizeButton(bool bVisible)
{
    if(m_pMaxButton)
        m_pMaxButton->setVisible(bVisible);
    return 0;
}
 
int CTitleBar::VisibleMinimizeButton(bool bVisible)
{
    if(m_pMaxButton)
        m_pMinButton->setVisible(bVisible);
    return 0;
}
 
int CTitleBar::VisibleFloatButton(bool bVisible)
{
    if(m_pFloatButton)
        m_pFloatButton->setVisible(bVisible);
    return 0;
}
 
int CTitleBar::VisibleCloseButton(bool bVisible)
{
    if(m_pCloseButton)
        m_pCloseButton->setVisible(bVisible);
    return 0;
}
 
void CTitleBar::slotMinimize()
{
    QWidget* pParent = qobject_cast<QWidget*>(parent());
    if(!pParent) return;
    if(pParent->isMinimized())
        pParent->showNormal();
    else
        pParent->showMinimized();
}
 
void CTitleBar::slotMaximize()
{
    QWidget* pParent = qobject_cast<QWidget*>(parent());
    if(!pParent) return;
    if(pParent->isMaximized())
        pParent->showNormal();
    else
        pParent->showMaximized();
}
 
void CTitleBar::slotFloat()
{
    QDockWidget* pParent = qobject_cast<QDockWidget*>(parent());
    if(pParent) {
        pParent->setFloating(!pParent->isFloating());
    }
}
 
void CTitleBar::slotTopLevelChanged(bool topLevel)
{
    if(m_pFloatButton) {
        if(topLevel) {
#if !defined(Q_OS_UNIX)
            VisibleMaximizeButton(true);
            //VisibleMinimizeButton(true);
#endif
            m_pFloatButton->setIcon(QIcon::fromTheme("unfloating"));
        } else {
            m_pFloatButton->setIcon(QIcon::fromTheme("floating"));
            VisibleMaximizeButton(false);
            VisibleMinimizeButton(false);
        }
    }
}
 
} // namespace RabbitCommon