Remove appbase as an external dependency.

lib/appbase/widgets/BaseWidget.cpp

@@ -0,0 +1,164 @@
+#include "widgets/BaseWidget.hpp"
+
+#include "BaseSettings.hpp"
+#include "BaseTheme.hpp"
+#include "debug/Log.hpp"
+#include "widgets/BaseWindow.hpp"
+
+#include <QChildEvent>
+#include <QDebug>
+#include <QIcon>
+#include <QLayout>
+#include <QtGlobal>
+
+namespace AB_NAMESPACE {
+
+BaseWidget::BaseWidget(QWidget *parent, Qt::WindowFlags f)
+    : QWidget(parent, f)
+{
+    // REMOVED
+    this->theme = getTheme();
+
+    this->signalHolder_.managedConnect(this->theme->updated, [this]() {
+        this->themeChangedEvent();
+
+        this->update();
+    });
+}
+
+float BaseWidget::scale() const
+{
+    if (this->overrideScale_)
+    {
+        return this->overrideScale_.get();
+    }
+    else if (auto baseWidget = dynamic_cast<BaseWidget *>(this->window()))
+    {
+        return baseWidget->scale_;
+    }
+    else
+    {
+        return 1.f;
+    }
+}
+
+void BaseWidget::setScale(float value)
+{
+    // update scale value
+    this->scale_ = value;
+
+    this->scaleChangedEvent(this->scale());
+    this->scaleChanged.invoke(this->scale());
+
+    this->setScaleIndependantSize(this->scaleIndependantSize());
+}
+
+void BaseWidget::setOverrideScale(boost::optional<float> value)
+{
+    this->overrideScale_ = value;
+    this->setScale(this->scale());
+}
+
+boost::optional<float> BaseWidget::overrideScale() const
+{
+    return this->overrideScale_;
+}
+
+QSize BaseWidget::scaleIndependantSize() const
+{
+    return this->scaleIndependantSize_;
+}
+
+int BaseWidget::scaleIndependantWidth() const
+{
+    return this->scaleIndependantSize_.width();
+}
+
+int BaseWidget::scaleIndependantHeight() const
+{
+    return this->scaleIndependantSize_.height();
+}
+
+void BaseWidget::setScaleIndependantSize(int width, int height)
+{
+    this->setScaleIndependantSize(QSize(width, height));
+}
+
+void BaseWidget::setScaleIndependantSize(QSize size)
+{
+    this->scaleIndependantSize_ = size;
+
+    if (size.width() > 0)
+    {
+        this->setFixedWidth(int(size.width() * this->scale()));
+    }
+    if (size.height() > 0)
+    {
+        this->setFixedHeight(int(size.height() * this->scale()));
+    }
+}
+
+void BaseWidget::setScaleIndependantWidth(int value)
+{
+    this->setScaleIndependantSize(
+        QSize(value, this->scaleIndependantSize_.height()));
+}
+
+void BaseWidget::setScaleIndependantHeight(int value)
+{
+    this->setScaleIndependantSize(
+        QSize(this->scaleIndependantSize_.width(), value));
+}
+
+float BaseWidget::qtFontScale() const
+{
+    if (auto window = dynamic_cast<BaseWindow *>(this->window()))
+    {
+        return this->scale() / window->nativeScale_;
+    }
+    else
+    {
+        return this->scale();
+    }
+}
+
+void BaseWidget::childEvent(QChildEvent *event)
+{
+    if (event->added())
+    {
+        // add element if it's a basewidget
+        if (auto widget = dynamic_cast<BaseWidget *>(event->child()))
+        {
+            this->widgets_.push_back(widget);
+        }
+    }
+    else if (event->removed())
+    {
+        // find element to be removed
+        auto it = std::find_if(this->widgets_.begin(), this->widgets_.end(),
+                               [&](auto &&x) { return x == event->child(); });
+
+        // remove if found
+        if (it != this->widgets_.end())
+        {
+            this->widgets_.erase(it);
+        }
+    }
+}
+
+void BaseWidget::showEvent(QShowEvent *)
+{
+    this->setScale(this->scale());
+    this->themeChangedEvent();
+}
+
+void BaseWidget::scaleChangedEvent(float newDpi)
+{
+}
+
+void BaseWidget::themeChangedEvent()
+{
+    // Do any color scheme updates here
+}
+
+}  // namespace AB_NAMESPACE

lib/appbase/widgets/BaseWidget.hpp

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <QWidget>
+#include <boost/optional.hpp>
+#include <pajlada/signals/signal.hpp>
+#include <pajlada/signals/signalholder.hpp>
+
+namespace AB_NAMESPACE {
+
+class Theme;
+class BaseWindow;
+
+class BaseWidget : public QWidget
+{
+    Q_OBJECT
+
+public:
+    explicit BaseWidget(QWidget *parent, Qt::WindowFlags f = Qt::WindowFlags());
+
+    virtual float scale() const;
+    pajlada::Signals::Signal<float> scaleChanged;
+
+    boost::optional<float> overrideScale() const;
+    void setOverrideScale(boost::optional<float>);
+
+    QSize scaleIndependantSize() const;
+    int scaleIndependantWidth() const;
+    int scaleIndependantHeight() const;
+    void setScaleIndependantSize(int width, int height);
+    void setScaleIndependantSize(QSize);
+    void setScaleIndependantWidth(int value);
+    void setScaleIndependantHeight(int value);
+
+    float qtFontScale() const;
+
+protected:
+    virtual void childEvent(QChildEvent *) override;
+    virtual void showEvent(QShowEvent *) override;
+
+    virtual void scaleChangedEvent(float newScale);
+    virtual void themeChangedEvent();
+
+    void setScale(float value);
+
+    Theme *theme;
+
+private:
+    float scale_{1.f};
+    boost::optional<float> overrideScale_;
+    QSize scaleIndependantSize_;
+
+    std::vector<BaseWidget *> widgets_;
+
+    pajlada::Signals::SignalHolder signalHolder_;
+
+    friend class BaseWindow;
+};
+
+}  // namespace AB_NAMESPACE

lib/appbase/widgets/BaseWindow.cpp

@@ -0,0 +1,917 @@
+#include "BaseWindow.hpp"
+
+#include "BaseSettings.hpp"
+#include "BaseTheme.hpp"
+#include "boost/algorithm/algorithm.hpp"
+#include "debug/Log.hpp"
+#include "util/PostToThread.hpp"
+#include "util/Shortcut.hpp"
+#include "util/WindowsHelper.hpp"
+#include "widgets/Label.hpp"
+#include "widgets/TooltipWidget.hpp"
+#include "widgets/helper/EffectLabel.hpp"
+
+#include <QApplication>
+#include <QDebug>
+#include <QDesktopWidget>
+#include <QFont>
+#include <QIcon>
+#include <functional>
+
+#ifdef CHATTERINO
+#    include "Application.hpp"
+#    include "singletons/WindowManager.hpp"
+#endif
+
+#ifdef USEWINSDK
+#    include <ObjIdl.h>
+#    include <VersionHelpers.h>
+#    include <Windows.h>
+#    include <dwmapi.h>
+#    include <gdiplus.h>
+#    include <windowsx.h>
+
+//#include <ShellScalingApi.h>
+#    pragma comment(lib, "Dwmapi.lib")
+
+#    include <QHBoxLayout>
+#    include <QVBoxLayout>
+
+#    define WM_DPICHANGED 0x02E0
+#endif
+
+#include "widgets/helper/TitlebarButton.hpp"
+
+namespace AB_NAMESPACE {
+
+BaseWindow::BaseWindow(QWidget *parent, Flags _flags)
+    : BaseWidget(parent,
+                 Qt::Window | ((_flags & TopMost) ? Qt::WindowStaysOnTopHint
+                                                  : Qt::WindowFlags()))
+    , enableCustomFrame_(_flags & EnableCustomFrame)
+    , frameless_(_flags & Frameless)
+    , flags_(_flags)
+{
+    if (this->frameless_)
+    {
+        this->enableCustomFrame_ = false;
+        this->setWindowFlag(Qt::FramelessWindowHint);
+    }
+
+    this->init();
+
+    getSettings()->uiScale.connect(
+        [this]() { postToThread([this] { this->updateScale(); }); },
+        this->connections_);
+
+    this->updateScale();
+
+    createWindowShortcut(this, "CTRL+0",
+                         [] { getSettings()->uiScale.setValue(1); });
+
+    //    QTimer::this->scaleChangedEvent(this->getScale());
+
+    this->resize(300, 300);
+}
+
+float BaseWindow::scale() const
+{
+    return this->overrideScale().value_or(this->scale_);
+}
+
+float BaseWindow::qtFontScale() const
+{
+    return this->scale() / this->nativeScale_;
+}
+
+BaseWindow::Flags BaseWindow::getFlags()
+{
+    return this->flags_;
+}
+
+void BaseWindow::init()
+{
+    this->setWindowIcon(QIcon(":/images/icon.png"));
+
+#ifdef USEWINSDK
+    if (this->hasCustomWindowFrame())
+    {
+        // CUSTOM WINDOW FRAME
+        QVBoxLayout *layout = new QVBoxLayout();
+        this->ui_.windowLayout = layout;
+        layout->setContentsMargins(0, 1, 0, 0);
+        layout->setSpacing(0);
+        this->setLayout(layout);
+        {
+            if (!this->frameless_)
+            {
+                QHBoxLayout *buttonLayout = this->ui_.titlebarBox =
+                    new QHBoxLayout();
+                buttonLayout->setMargin(0);
+                layout->addLayout(buttonLayout);
+
+                // title
+                Label *title = new Label;
+                QObject::connect(
+                    this, &QWidget::windowTitleChanged,
+                    [title](const QString &text) { title->setText(text); });
+
+                QSizePolicy policy(QSizePolicy::Ignored,
+                                   QSizePolicy::Preferred);
+                policy.setHorizontalStretch(1);
+                title->setSizePolicy(policy);
+                buttonLayout->addWidget(title);
+                this->ui_.titleLabel = title;
+
+                // buttons
+                TitleBarButton *_minButton = new TitleBarButton;
+                _minButton->setButtonStyle(TitleBarButtonStyle::Minimize);
+                TitleBarButton *_maxButton = new TitleBarButton;
+                _maxButton->setButtonStyle(TitleBarButtonStyle::Maximize);
+                TitleBarButton *_exitButton = new TitleBarButton;
+                _exitButton->setButtonStyle(TitleBarButtonStyle::Close);
+
+                QObject::connect(_minButton, &TitleBarButton::leftClicked, this,
+                                 [this] {
+                                     this->setWindowState(Qt::WindowMinimized |
+                                                          this->windowState());
+                                 });
+                QObject::connect(_maxButton, &TitleBarButton::leftClicked, this,
+                                 [this, _maxButton] {
+                                     this->setWindowState(
+                                         _maxButton->getButtonStyle() !=
+                                                 TitleBarButtonStyle::Maximize
+                                             ? Qt::WindowActive
+                                             : Qt::WindowMaximized);
+                                 });
+                QObject::connect(_exitButton, &TitleBarButton::leftClicked,
+                                 this, [this] { this->close(); });
+
+                this->ui_.minButton = _minButton;
+                this->ui_.maxButton = _maxButton;
+                this->ui_.exitButton = _exitButton;
+
+                this->ui_.buttons.push_back(_minButton);
+                this->ui_.buttons.push_back(_maxButton);
+                this->ui_.buttons.push_back(_exitButton);
+
+                //            buttonLayout->addStretch(1);
+                buttonLayout->addWidget(_minButton);
+                buttonLayout->addWidget(_maxButton);
+                buttonLayout->addWidget(_exitButton);
+                buttonLayout->setSpacing(0);
+            }
+        }
+        this->ui_.layoutBase = new BaseWidget(this);
+        layout->addWidget(this->ui_.layoutBase);
+    }
+
+// DPI
+//    auto dpi = getWindowDpi(this->winId());
+
+//    if (dpi) {
+//        this->scale = dpi.value() / 96.f;
+//    }
+#endif
+
+#ifdef USEWINSDK
+    // fourtf: don't ask me why we need to delay this
+    if (!(this->flags_ & Flags::TopMost))
+    {
+        QTimer::singleShot(1, this, [this] {
+            getSettings()->windowTopMost.connect(
+                [this](bool topMost, auto) {
+                    ::SetWindowPos(HWND(this->winId()),
+                                   topMost ? HWND_TOPMOST : HWND_NOTOPMOST, 0,
+                                   0, 0, 0,
+                                   SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
+                },
+                this->managedConnections_);
+        });
+    }
+#else
+//    if (getSettings()->windowTopMost.getValue()) {
+//        this->setWindowFlag(Qt::WindowStaysOnTopHint);
+//    }
+#endif
+}
+
+void BaseWindow::setStayInScreenRect(bool value)
+{
+    this->stayInScreenRect_ = value;
+
+    this->moveIntoDesktopRect(this);
+}
+
+bool BaseWindow::getStayInScreenRect() const
+{
+    return this->stayInScreenRect_;
+}
+
+void BaseWindow::setActionOnFocusLoss(ActionOnFocusLoss value)
+{
+    this->actionOnFocusLoss_ = value;
+}
+
+BaseWindow::ActionOnFocusLoss BaseWindow::getActionOnFocusLoss() const
+{
+    return this->actionOnFocusLoss_;
+}
+
+QWidget *BaseWindow::getLayoutContainer()
+{
+    if (this->hasCustomWindowFrame())
+    {
+        return this->ui_.layoutBase;
+    }
+    else
+    {
+        return this;
+    }
+}
+
+bool BaseWindow::hasCustomWindowFrame()
+{
+#ifdef USEWINSDK
+    static bool isWin8 = IsWindows8OrGreater();
+
+    return isWin8 && this->enableCustomFrame_;
+#else
+    return false;
+#endif
+}
+
+void BaseWindow::themeChangedEvent()
+{
+    if (this->hasCustomWindowFrame())
+    {
+        QPalette palette;
+        palette.setColor(QPalette::Background, QColor(0, 0, 0, 0));
+        palette.setColor(QPalette::Foreground, this->theme->window.text);
+        this->setPalette(palette);
+
+        if (this->ui_.titleLabel)
+        {
+            QPalette palette_title;
+            palette_title.setColor(
+                QPalette::Foreground,
+                this->theme->isLightTheme() ? "#333" : "#ccc");
+            this->ui_.titleLabel->setPalette(palette_title);
+        }
+
+        for (Button *button : this->ui_.buttons)
+        {
+            button->setMouseEffectColor(this->theme->window.text);
+        }
+    }
+    else
+    {
+        QPalette palette;
+        palette.setColor(QPalette::Background, this->theme->window.background);
+        palette.setColor(QPalette::Foreground, this->theme->window.text);
+        this->setPalette(palette);
+    }
+}
+
+bool BaseWindow::event(QEvent *event)
+{
+    if (event->type() ==
+        QEvent::WindowDeactivate /*|| event->type() == QEvent::FocusOut*/)
+    {
+        this->onFocusLost();
+    }
+
+    return QWidget::event(event);
+}
+
+void BaseWindow::wheelEvent(QWheelEvent *event)
+{
+    if (event->orientation() != Qt::Vertical)
+    {
+        return;
+    }
+
+    if (event->modifiers() & Qt::ControlModifier)
+    {
+        if (event->delta() > 0)
+        {
+            getSettings()->setClampedUiScale(
+                getSettings()->getClampedUiScale() + 0.1);
+        }
+        else
+        {
+            getSettings()->setClampedUiScale(
+                getSettings()->getClampedUiScale() - 0.1);
+        }
+    }
+}
+
+void BaseWindow::onFocusLost()
+{
+    switch (this->getActionOnFocusLoss())
+    {
+        case Delete:
+        {
+            this->deleteLater();
+        }
+        break;
+
+        case Close:
+        {
+            this->close();
+        }
+        break;
+
+        case Hide:
+        {
+            this->hide();
+        }
+        break;
+
+        default:;
+    }
+}
+
+void BaseWindow::mousePressEvent(QMouseEvent *event)
+{
+#ifndef Q_OS_WIN
+    if (this->flags_ & FramelessDraggable)
+    {
+        this->movingRelativePos = event->localPos();
+        if (auto widget =
+                this->childAt(event->localPos().x(), event->localPos().y()))
+        {
+            std::function<bool(QWidget *)> recursiveCheckMouseTracking;
+            recursiveCheckMouseTracking = [&](QWidget *widget) {
+                if (widget == nullptr)
+                {
+                    return false;
+                }
+
+                if (widget->hasMouseTracking())
+                {
+                    return true;
+                }
+
+                return recursiveCheckMouseTracking(widget->parentWidget());
+            };
+
+            if (!recursiveCheckMouseTracking(widget))
+            {
+                log("Start moving");
+                this->moving = true;
+            }
+        }
+    }
+#endif
+
+    BaseWidget::mousePressEvent(event);
+}
+
+void BaseWindow::mouseReleaseEvent(QMouseEvent *event)
+{
+#ifndef Q_OS_WIN
+    if (this->flags_ & FramelessDraggable)
+    {
+        if (this->moving)
+        {
+            log("Stop moving");
+            this->moving = false;
+        }
+    }
+#endif
+
+    BaseWidget::mouseReleaseEvent(event);
+}
+
+void BaseWindow::mouseMoveEvent(QMouseEvent *event)
+{
+#ifndef Q_OS_WIN
+    if (this->flags_ & FramelessDraggable)
+    {
+        if (this->moving)
+        {
+            const auto &newPos = event->screenPos() - this->movingRelativePos;
+            this->move(newPos.x(), newPos.y());
+        }
+    }
+#endif
+
+    BaseWidget::mouseMoveEvent(event);
+}
+
+TitleBarButton *BaseWindow::addTitleBarButton(const TitleBarButtonStyle &style,
+                                              std::function<void()> onClicked)
+{
+    TitleBarButton *button = new TitleBarButton;
+    button->setScaleIndependantSize(30, 30);
+
+    this->ui_.buttons.push_back(button);
+    this->ui_.titlebarBox->insertWidget(1, button);
+    button->setButtonStyle(style);
+
+    QObject::connect(button, &TitleBarButton::leftClicked, this,
+                     [onClicked] { onClicked(); });
+
+    return button;
+}
+
+EffectLabel *BaseWindow::addTitleBarLabel(std::function<void()> onClicked)
+{
+    EffectLabel *button = new EffectLabel;
+    button->setScaleIndependantHeight(30);
+
+    this->ui_.buttons.push_back(button);
+    this->ui_.titlebarBox->insertWidget(1, button);
+
+    QObject::connect(button, &EffectLabel::leftClicked, this,
+                     [onClicked] { onClicked(); });
+
+    return button;
+}
+
+void BaseWindow::changeEvent(QEvent *)
+{
+    if (this->isVisible())
+    {
+        TooltipWidget::getInstance()->hide();
+    }
+
+#ifdef USEWINSDK
+    if (this->ui_.maxButton)
+    {
+        this->ui_.maxButton->setButtonStyle(
+            this->windowState() & Qt::WindowMaximized
+                ? TitleBarButtonStyle::Unmaximize
+                : TitleBarButtonStyle::Maximize);
+    }
+#endif
+
+#ifndef Q_OS_WIN
+    this->update();
+#endif
+}
+
+void BaseWindow::leaveEvent(QEvent *)
+{
+    TooltipWidget::getInstance()->hide();
+}
+
+void BaseWindow::moveTo(QWidget *parent, QPoint point, bool offset)
+{
+    if (offset)
+    {
+        point.rx() += 16;
+        point.ry() += 16;
+    }
+
+    this->move(point);
+    this->moveIntoDesktopRect(parent);
+}
+
+void BaseWindow::resizeEvent(QResizeEvent *)
+{
+    // Queue up save because: Window resized
+#ifdef CHATTERINO
+    getApp()->windows->queueSave();
+#endif
+
+    this->moveIntoDesktopRect(this);
+
+    this->calcButtonsSizes();
+}
+
+void BaseWindow::moveEvent(QMoveEvent *event)
+{
+    // Queue up save because: Window position changed
+#ifdef CHATTERINO
+    getApp()->windows->queueSave();
+#endif
+
+    BaseWidget::moveEvent(event);
+}
+
+void BaseWindow::closeEvent(QCloseEvent *)
+{
+    this->closing.invoke();
+}
+
+void BaseWindow::moveIntoDesktopRect(QWidget *parent)
+{
+    if (!this->stayInScreenRect_)
+        return;
+
+    // move the widget into the screen geometry if it's not already in there
+    QDesktopWidget *desktop = QApplication::desktop();
+
+    QRect s = desktop->availableGeometry(parent);
+    QPoint p = this->pos();
+
+    if (p.x() < s.left())
+    {
+        p.setX(s.left());
+    }
+    if (p.y() < s.top())
+    {
+        p.setY(s.top());
+    }
+    if (p.x() + this->width() > s.right())
+    {
+        p.setX(s.right() - this->width());
+    }
+    if (p.y() + this->height() > s.bottom())
+    {
+        p.setY(s.bottom() - this->height());
+    }
+
+    if (p != this->pos())
+        this->move(p);
+}
+
+bool BaseWindow::nativeEvent(const QByteArray &eventType, void *message,
+                             long *result)
+{
+#ifdef USEWINSDK
+#    if (QT_VERSION == QT_VERSION_CHECK(5, 11, 1))
+    MSG *msg = *reinterpret_cast<MSG **>(message);
+#    else
+    MSG *msg = reinterpret_cast<MSG *>(message);
+#    endif
+
+    bool returnValue = false;
+
+    switch (msg->message)
+    {
+        case WM_DPICHANGED:
+            returnValue = handleDPICHANGED(msg);
+            break;
+
+        case WM_SHOWWINDOW:
+            returnValue = this->handleSHOWWINDOW(msg);
+            break;
+
+        case WM_NCCALCSIZE:
+            returnValue = this->handleNCCALCSIZE(msg, result);
+            break;
+
+        case WM_SIZE:
+            returnValue = this->handleSIZE(msg);
+            break;
+
+        case WM_NCHITTEST:
+            returnValue = this->handleNCHITTEST(msg, result);
+            break;
+
+        default:
+            return QWidget::nativeEvent(eventType, message, result);
+    }
+
+    QWidget::nativeEvent(eventType, message, result);
+
+    return returnValue;
+#else
+    return QWidget::nativeEvent(eventType, message, result);
+#endif
+}
+
+void BaseWindow::scaleChangedEvent(float scale)
+{
+#ifdef USEWINSDK
+    this->calcButtonsSizes();
+#endif
+
+    this->setFont(getFonts()->getFont(FontStyle::UiTabs, this->qtFontScale()));
+}
+
+void BaseWindow::paintEvent(QPaintEvent *)
+{
+    QPainter painter(this);
+
+    if (this->frameless_)
+    {
+        painter.setPen(QColor("#999"));
+        painter.drawRect(0, 0, this->width() - 1, this->height() - 1);
+    }
+
+    this->drawCustomWindowFrame(painter);
+}
+
+void BaseWindow::updateScale()
+{
+    auto scale =
+        this->nativeScale_ * (this->flags_ & DisableCustomScaling
+                                  ? 1
+                                  : getABSettings()->getClampedUiScale());
+
+    this->setScale(scale);
+
+    for (auto child : this->findChildren<BaseWidget *>())
+    {
+        child->setScale(scale);
+    }
+}
+
+void BaseWindow::calcButtonsSizes()
+{
+    if (!this->shown_)
+    {
+        return;
+    }
+
+    if ((this->width() / this->scale()) < 300)
+    {
+        if (this->ui_.minButton)
+            this->ui_.minButton->setScaleIndependantSize(30, 30);
+        if (this->ui_.maxButton)
+            this->ui_.maxButton->setScaleIndependantSize(30, 30);
+        if (this->ui_.exitButton)
+            this->ui_.exitButton->setScaleIndependantSize(30, 30);
+    }
+    else
+    {
+        if (this->ui_.minButton)
+            this->ui_.minButton->setScaleIndependantSize(46, 30);
+        if (this->ui_.maxButton)
+            this->ui_.maxButton->setScaleIndependantSize(46, 30);
+        if (this->ui_.exitButton)
+            this->ui_.exitButton->setScaleIndependantSize(46, 30);
+    }
+}
+
+void BaseWindow::drawCustomWindowFrame(QPainter &painter)
+{
+#ifdef USEWINSDK
+    if (this->hasCustomWindowFrame())
+    {
+        QPainter painter(this);
+
+        QColor bg = this->overrideBackgroundColor_.value_or(
+            this->theme->window.background);
+
+        painter.fillRect(QRect(0, 1, this->width() - 0, this->height() - 0),
+                         bg);
+    }
+#endif
+}
+
+bool BaseWindow::handleDPICHANGED(MSG *msg)
+{
+#ifdef USEWINSDK
+    int dpi = HIWORD(msg->wParam);
+
+    float _scale = dpi / 96.f;
+
+    static bool firstResize = true;
+
+    if (!firstResize)
+    {
+        auto *prcNewWindow = reinterpret_cast<RECT *>(msg->lParam);
+        SetWindowPos(msg->hwnd, nullptr, prcNewWindow->left, prcNewWindow->top,
+                     prcNewWindow->right - prcNewWindow->left,
+                     prcNewWindow->bottom - prcNewWindow->top,
+                     SWP_NOZORDER | SWP_NOACTIVATE);
+    }
+    firstResize = false;
+
+    this->nativeScale_ = _scale;
+    this->updateScale();
+
+    return true;
+#else
+    return false;
+#endif
+}
+
+bool BaseWindow::handleSHOWWINDOW(MSG *msg)
+{
+#ifdef USEWINSDK
+    if (auto dpi = getWindowDpi(msg->hwnd))
+    {
+        this->nativeScale_ = dpi.get() / 96.f;
+        this->updateScale();
+    }
+
+    if (!this->shown_ && this->isVisible() && this->hasCustomWindowFrame())
+    {
+        this->shown_ = true;
+
+        const MARGINS shadow = {8, 8, 8, 8};
+        DwmExtendFrameIntoClientArea(HWND(this->winId()), &shadow);
+    }
+
+    this->calcButtonsSizes();
+
+    return true;
+#else
+    return false;
+#endif
+}
+
+bool BaseWindow::handleNCCALCSIZE(MSG *msg, long *result)
+{
+#ifdef USEWINSDK
+    if (this->hasCustomWindowFrame())
+    {
+        // int cx = GetSystemMetrics(SM_CXSIZEFRAME);
+        // int cy = GetSystemMetrics(SM_CYSIZEFRAME);
+
+        if (msg->wParam == TRUE)
+        {
+            NCCALCSIZE_PARAMS *ncp =
+                (reinterpret_cast<NCCALCSIZE_PARAMS *>(msg->lParam));
+            ncp->lppos->flags |= SWP_NOREDRAW;
+            RECT *clientRect = &ncp->rgrc[0];
+
+            clientRect->left += 1;
+            clientRect->top += 0;
+            clientRect->right -= 1;
+            clientRect->bottom -= 1;
+        }
+
+        *result = 0;
+        return true;
+    }
+    return false;
+#else
+    return false;
+#endif
+}
+
+bool BaseWindow::handleSIZE(MSG *msg)
+{
+#ifdef USEWINSDK
+    if (this->ui_.windowLayout)
+    {
+        if (this->frameless_)
+        {
+            //
+        }
+        else if (this->hasCustomWindowFrame())
+        {
+            if (msg->wParam == SIZE_MAXIMIZED)
+            {
+                auto offset = int(this->scale() * 8);
+
+                this->ui_.windowLayout->setContentsMargins(offset, offset,
+                                                           offset, offset);
+            }
+            else
+            {
+                this->ui_.windowLayout->setContentsMargins(0, 1, 0, 0);
+            }
+        }
+    }
+    return false;
+#else
+    return false;
+#endif
+}
+
+bool BaseWindow::handleNCHITTEST(MSG *msg, long *result)
+{
+#ifdef USEWINSDK
+    const LONG border_width = 8;  // in pixels
+    RECT winrect;
+    GetWindowRect(HWND(winId()), &winrect);
+
+    long x = GET_X_LPARAM(msg->lParam);
+    long y = GET_Y_LPARAM(msg->lParam);
+
+    QPoint point(x - winrect.left, y - winrect.top);
+
+    if (this->hasCustomWindowFrame())
+    {
+        *result = 0;
+
+        bool resizeWidth = minimumWidth() != maximumWidth();
+        bool resizeHeight = minimumHeight() != maximumHeight();
+
+        if (resizeWidth)
+        {
+            // left border
+            if (x < winrect.left + border_width)
+            {
+                *result = HTLEFT;
+            }
+            // right border
+            if (x >= winrect.right - border_width)
+            {
+                *result = HTRIGHT;
+            }
+        }
+        if (resizeHeight)
+        {
+            // bottom border
+            if (y >= winrect.bottom - border_width)
+            {
+                *result = HTBOTTOM;
+            }
+            // top border
+            if (y < winrect.top + border_width)
+            {
+                *result = HTTOP;
+            }
+        }
+        if (resizeWidth && resizeHeight)
+        {
+            // bottom left corner
+            if (x >= winrect.left && x < winrect.left + border_width &&
+                y < winrect.bottom && y >= winrect.bottom - border_width)
+            {
+                *result = HTBOTTOMLEFT;
+            }
+            // bottom right corner
+            if (x < winrect.right && x >= winrect.right - border_width &&
+                y < winrect.bottom && y >= winrect.bottom - border_width)
+            {
+                *result = HTBOTTOMRIGHT;
+            }
+            // top left corner
+            if (x >= winrect.left && x < winrect.left + border_width &&
+                y >= winrect.top && y < winrect.top + border_width)
+            {
+                *result = HTTOPLEFT;
+            }
+            // top right corner
+            if (x < winrect.right && x >= winrect.right - border_width &&
+                y >= winrect.top && y < winrect.top + border_width)
+            {
+                *result = HTTOPRIGHT;
+            }
+        }
+
+        if (*result == 0)
+        {
+            bool client = false;
+
+            for (QWidget *widget : this->ui_.buttons)
+            {
+                if (widget->geometry().contains(point))
+                {
+                    client = true;
+                }
+            }
+
+            if (this->ui_.layoutBase->geometry().contains(point))
+            {
+                client = true;
+            }
+
+            if (client)
+            {
+                *result = HTCLIENT;
+            }
+            else
+            {
+                *result = HTCAPTION;
+            }
+        }
+
+        return true;
+    }
+    else if (this->flags_ & FramelessDraggable)
+    {
+        *result = 0;
+        bool client = false;
+
+        if (auto widget = this->childAt(point))
+        {
+            std::function<bool(QWidget *)> recursiveCheckMouseTracking;
+            recursiveCheckMouseTracking = [&](QWidget *widget) {
+                if (widget == nullptr)
+                {
+                    return false;
+                }
+
+                if (widget->hasMouseTracking())
+                {
+                    return true;
+                }
+
+                return recursiveCheckMouseTracking(widget->parentWidget());
+            };
+
+            if (recursiveCheckMouseTracking(widget))
+            {
+                client = true;
+            }
+        }
+
+        if (client)
+        {
+            *result = HTCLIENT;
+        }
+        else
+        {
+            *result = HTCAPTION;
+        }
+
+        return true;
+    }
+    return false;
+#else
+    return false;
+#endif
+}
+
+}  // namespace AB_NAMESPACE

lib/appbase/widgets/BaseWindow.hpp

@@ -0,0 +1,123 @@
+#pragma once
+
+#include "widgets/BaseWidget.hpp"
+
+#include <functional>
+#include <pajlada/signals/signalholder.hpp>
+
+class QHBoxLayout;
+struct tagMSG;
+typedef struct tagMSG MSG;
+
+namespace AB_NAMESPACE {
+
+class Button;
+class EffectLabel;
+class TitleBarButton;
+enum class TitleBarButtonStyle;
+
+class BaseWindow : public BaseWidget
+{
+    Q_OBJECT
+
+public:
+    enum Flags {
+        None = 0,
+        EnableCustomFrame = 1,
+        Frameless = 2,
+        TopMost = 4,
+        DisableCustomScaling = 8,
+        FramelessDraggable = 16,
+    };
+
+    enum ActionOnFocusLoss { Nothing, Delete, Close, Hide };
+
+    explicit BaseWindow(QWidget *parent = nullptr, Flags flags_ = None);
+
+    QWidget *getLayoutContainer();
+    bool hasCustomWindowFrame();
+    TitleBarButton *addTitleBarButton(const TitleBarButtonStyle &style,
+                                      std::function<void()> onClicked);
+    EffectLabel *addTitleBarLabel(std::function<void()> onClicked);
+
+    void setStayInScreenRect(bool value);
+    bool getStayInScreenRect() const;
+
+    void setActionOnFocusLoss(ActionOnFocusLoss value);
+    ActionOnFocusLoss getActionOnFocusLoss() const;
+
+    void moveTo(QWidget *widget, QPoint point, bool offset = true);
+
+    virtual float scale() const override;
+    float qtFontScale() const;
+
+    Flags getFlags();
+
+    pajlada::Signals::NoArgSignal closing;
+
+protected:
+    virtual bool nativeEvent(const QByteArray &eventType, void *message,
+                             long *result) override;
+    virtual void scaleChangedEvent(float) override;
+
+    virtual void paintEvent(QPaintEvent *) override;
+
+    virtual void changeEvent(QEvent *) override;
+    virtual void leaveEvent(QEvent *) override;
+    virtual void resizeEvent(QResizeEvent *) override;
+    virtual void moveEvent(QMoveEvent *) override;
+    virtual void closeEvent(QCloseEvent *) override;
+
+    virtual void themeChangedEvent() override;
+    virtual bool event(QEvent *event) override;
+    virtual void wheelEvent(QWheelEvent *event) override;
+
+    void mousePressEvent(QMouseEvent *event) override;
+    void mouseReleaseEvent(QMouseEvent *event) override;
+    void mouseMoveEvent(QMouseEvent *event) override;
+    QPointF movingRelativePos;
+    bool moving{};
+
+    void updateScale();
+
+    boost::optional<QColor> overrideBackgroundColor_;
+
+private:
+    void init();
+    void moveIntoDesktopRect(QWidget *parent);
+    void calcButtonsSizes();
+    void drawCustomWindowFrame(QPainter &painter);
+    void onFocusLost();
+
+    bool handleDPICHANGED(MSG *msg);
+    bool handleSHOWWINDOW(MSG *msg);
+    bool handleNCCALCSIZE(MSG *msg, long *result);
+    bool handleSIZE(MSG *msg);
+    bool handleNCHITTEST(MSG *msg, long *result);
+
+    bool enableCustomFrame_;
+    ActionOnFocusLoss actionOnFocusLoss_ = Nothing;
+    bool frameless_;
+    bool stayInScreenRect_ = false;
+    bool shown_ = false;
+    Flags flags_;
+    float nativeScale_ = 1;
+
+    struct {
+        QLayout *windowLayout = nullptr;
+        QHBoxLayout *titlebarBox = nullptr;
+        QWidget *titleLabel = nullptr;
+        TitleBarButton *minButton = nullptr;
+        TitleBarButton *maxButton = nullptr;
+        TitleBarButton *exitButton = nullptr;
+        QWidget *layoutBase = nullptr;
+        std::vector<Button *> buttons;
+    } ui_;
+
+    pajlada::Signals::SignalHolder connections_;
+    std::vector<pajlada::Signals::ScopedConnection> managedConnections_;
+
+    friend class BaseWidget;
+};
+
+}  // namespace AB_NAMESPACE

lib/appbase/widgets/Label.cpp

@@ -0,0 +1,130 @@
+#include "Label.hpp"
+
+#include <QPainter>
+
+namespace AB_NAMESPACE {
+
+Label::Label(QString text, FontStyle style)
+    : Label(nullptr, text, style)
+{
+}
+
+Label::Label(BaseWidget *parent, QString text, FontStyle style)
+    : BaseWidget(parent)
+    , text_(text)
+    , fontStyle_(style)
+{
+    this->connections_.managedConnect(getFonts()->fontChanged,
+                                      [this] { this->updateSize(); });
+}
+
+const QString &Label::getText() const
+{
+    return this->text_;
+}
+
+void Label::setText(const QString &text)
+{
+    if (this->text_ != text)
+    {
+        this->text_ = text;
+        this->updateSize();
+        this->update();
+    }
+}
+
+FontStyle Label::getFontStyle() const
+{
+    return this->fontStyle_;
+}
+
+bool Label::getCentered() const
+{
+    return this->centered_;
+}
+
+void Label::setCentered(bool centered)
+{
+    this->centered_ = centered;
+    this->updateSize();
+}
+
+bool Label::getHasOffset() const
+{
+    return this->hasOffset_;
+}
+
+void Label::setHasOffset(bool hasOffset)
+{
+    this->hasOffset_ = hasOffset;
+    this->updateSize();
+}
+void Label::setFontStyle(FontStyle style)
+{
+    this->fontStyle_ = style;
+    this->updateSize();
+}
+
+void Label::scaleChangedEvent(float scale)
+{
+    this->updateSize();
+}
+
+QSize Label::sizeHint() const
+{
+    return this->preferedSize_;
+}
+
+QSize Label::minimumSizeHint() const
+{
+    return this->preferedSize_;
+}
+
+void Label::paintEvent(QPaintEvent *)
+{
+    QPainter painter(this);
+    QFontMetrics metrics = getFonts()->getFontMetrics(
+        this->getFontStyle(),
+        this->scale() * 96.f / this->logicalDpiX() * this->devicePixelRatioF());
+    painter.setFont(getFonts()->getFont(
+        this->getFontStyle(), this->scale() * 96.f / this->logicalDpiX() *
+                                  this->devicePixelRatioF()));
+
+    int offset = this->getOffset();
+
+    // draw text
+    QRect textRect(offset, 0, this->width() - offset - offset, this->height());
+
+    int width = metrics.width(this->text_);
+    Qt::Alignment alignment = !this->centered_ || width > textRect.width()
+                                  ? Qt::AlignLeft | Qt::AlignVCenter
+                                  : Qt::AlignCenter;
+
+    QTextOption option(alignment);
+    option.setWrapMode(QTextOption::NoWrap);
+    painter.drawText(textRect, this->text_, option);
+
+#if 0
+    painter.setPen(QColor(255, 0, 0));
+    painter.drawRect(0, 0, this->width() - 1, this->height() - 1);
+#endif
+}
+
+void Label::updateSize()
+{
+    QFontMetrics metrics =
+        getFonts()->getFontMetrics(this->fontStyle_, this->scale());
+
+    int width = metrics.width(this->text_) + (2 * this->getOffset());
+    int height = metrics.height();
+    this->preferedSize_ = QSize(width, height);
+
+    this->updateGeometry();
+}
+
+int Label::getOffset()
+{
+    return this->hasOffset_ ? int(8 * this->scale()) : 0;
+}
+
+}  // namespace AB_NAMESPACE

lib/appbase/widgets/Label.hpp

@@ -0,0 +1,50 @@
+#pragma once
+
+#include "singletons/Fonts.hpp"
+#include "widgets/BaseWidget.hpp"
+
+#include <pajlada/signals/signalholder.hpp>
+
+namespace AB_NAMESPACE {
+
+class Label : public BaseWidget
+{
+public:
+    explicit Label(QString text = QString(),
+                   FontStyle style = FontStyle::UiMedium);
+    explicit Label(BaseWidget *parent, QString text = QString(),
+                   FontStyle style = FontStyle::UiMedium);
+
+    const QString &getText() const;
+    void setText(const QString &text);
+
+    FontStyle getFontStyle() const;
+    void setFontStyle(FontStyle style);
+
+    bool getCentered() const;
+    void setCentered(bool centered);
+
+    bool getHasOffset() const;
+    void setHasOffset(bool hasOffset);
+
+protected:
+    virtual void scaleChangedEvent(float scale_) override;
+    virtual void paintEvent(QPaintEvent *) override;
+
+    virtual QSize sizeHint() const override;
+    virtual QSize minimumSizeHint() const override;
+
+private:
+    void updateSize();
+    int getOffset();
+
+    QString text_;
+    FontStyle fontStyle_;
+    QSize preferedSize_;
+    bool centered_ = false;
+    bool hasOffset_ = true;
+
+    pajlada::Signals::SignalHolder connections_;
+};
+
+}  // namespace AB_NAMESPACE

lib/appbase/widgets/TooltipWidget.cpp

@@ -0,0 +1,112 @@
+#include "TooltipWidget.hpp"
+
+#include "BaseTheme.hpp"
+#include "singletons/Fonts.hpp"
+
+#include <QDebug>
+#include <QDesktopWidget>
+#include <QStyle>
+#include <QVBoxLayout>
+
+#ifdef USEWINSDK
+#    include <Windows.h>
+#endif
+
+namespace AB_NAMESPACE {
+
+TooltipWidget *TooltipWidget::getInstance()
+{
+    static TooltipWidget *tooltipWidget = new TooltipWidget();
+    return tooltipWidget;
+}
+
+TooltipWidget::TooltipWidget(BaseWidget *parent)
+    : BaseWindow(parent, BaseWindow::TopMost)
+    , displayImage_(new QLabel())
+    , displayText_(new QLabel())
+{
+    this->setStyleSheet("color: #fff; background: #000");
+    this->setWindowOpacity(0.8);
+    this->updateFont();
+    this->setStayInScreenRect(true);
+
+    this->setAttribute(Qt::WA_ShowWithoutActivating);
+    this->setWindowFlags(Qt::Tool | Qt::FramelessWindowHint |
+                         Qt::X11BypassWindowManagerHint |
+                         Qt::BypassWindowManagerHint);
+
+    displayImage_->hide();
+    displayImage_->setAlignment(Qt::AlignHCenter);
+    displayText_->setAlignment(Qt::AlignHCenter);
+    displayText_->setText("tooltip text");
+    auto layout = new QVBoxLayout();
+    layout->setContentsMargins(10, 5, 10, 5);
+    layout->addWidget(displayImage_);
+    layout->addWidget(displayText_);
+    this->setLayout(layout);
+
+    this->fontChangedConnection_ =
+        getFonts()->fontChanged.connect([this] { this->updateFont(); });
+}
+
+TooltipWidget::~TooltipWidget()
+{
+    this->fontChangedConnection_.disconnect();
+}
+
+#ifdef USEWINSDK
+void TooltipWidget::raise()
+{
+    ::SetWindowPos(HWND(this->winId()), HWND_TOPMOST, 0, 0, 0, 0,
+                   SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
+}
+#endif
+
+void TooltipWidget::themeChangedEvent()
+{
+    this->setStyleSheet("color: #fff; background: #000");
+}
+
+void TooltipWidget::scaleChangedEvent(float)
+{
+    this->updateFont();
+}
+
+void TooltipWidget::updateFont()
+{
+    this->setFont(
+        getFonts()->getFont(FontStyle::ChatMediumSmall, this->scale()));
+}
+
+void TooltipWidget::setText(QString text)
+{
+    this->displayText_->setText(text);
+}
+
+void TooltipWidget::setWordWrap(bool wrap)
+{
+    this->displayText_->setWordWrap(wrap);
+}
+
+void TooltipWidget::clearImage()
+{
+    this->displayImage_->hide();
+}
+
+void TooltipWidget::setImage(QPixmap image)
+{
+    this->displayImage_->show();
+    this->displayImage_->setPixmap(image);
+}
+
+void TooltipWidget::changeEvent(QEvent *)
+{
+    // clear parents event
+}
+
+void TooltipWidget::leaveEvent(QEvent *)
+{
+    // clear parents event
+}
+
+}  // namespace AB_NAMESPACE

lib/appbase/widgets/TooltipWidget.hpp

@@ -0,0 +1,44 @@
+#pragma once
+
+#include "widgets/BaseWindow.hpp"
+
+#include <QLabel>
+#include <QWidget>
+#include <pajlada/signals/signal.hpp>
+
+namespace AB_NAMESPACE {
+
+class TooltipWidget : public BaseWindow
+{
+    Q_OBJECT
+
+public:
+    static TooltipWidget *getInstance();
+
+    TooltipWidget(BaseWidget *parent = nullptr);
+    ~TooltipWidget() override;
+
+    void setText(QString text);
+    void setWordWrap(bool wrap);
+    void clearImage();
+    void setImage(QPixmap image);
+
+#ifdef USEWINSDK
+    void raise();
+#endif
+
+protected:
+    void changeEvent(QEvent *) override;
+    void leaveEvent(QEvent *) override;
+    void themeChangedEvent() override;
+    void scaleChangedEvent(float) override;
+
+private:
+    void updateFont();
+
+    QLabel *displayImage_;
+    QLabel *displayText_;
+    pajlada::Signals::Connection fontChangedConnection_;
+};
+
+}  // namespace AB_NAMESPACE

lib/appbase/widgets/helper/Button.cpp

@@ -0,0 +1,338 @@
+#include "Button.hpp"
+
+#include <QApplication>
+#include <QDebug>
+#include <QDesktopWidget>
+#include <QPainter>
+
+#include "BaseTheme.hpp"
+#include "util/FunctionEventFilter.hpp"
+
+namespace AB_NAMESPACE {
+
+Button::Button(BaseWidget *parent)
+    : BaseWidget(parent)
+{
+    connect(&effectTimer_, &QTimer::timeout, this,
+            &Button::onMouseEffectTimeout);
+
+    this->effectTimer_.setInterval(20);
+    this->effectTimer_.start();
+
+    this->setMouseTracking(true);
+}
+
+void Button::setMouseEffectColor(boost::optional<QColor> color)
+{
+    this->mouseEffectColor_ = color;
+}
+
+void Button::setPixmap(const QPixmap &_pixmap)
+{
+    this->pixmap_ = _pixmap;
+    this->update();
+}
+
+const QPixmap &Button::getPixmap() const
+{
+    return this->pixmap_;
+}
+
+void Button::setDim(bool value)
+{
+    this->dimPixmap_ = value;
+
+    this->update();
+}
+
+bool Button::getDim() const
+{
+    return this->dimPixmap_;
+}
+
+void Button::setEnable(bool value)
+{
+    this->enabled_ = value;
+
+    this->update();
+}
+
+bool Button::getEnable() const
+{
+    return this->enabled_;
+}
+
+void Button::setEnableMargin(bool value)
+{
+    this->enableMargin_ = value;
+
+    this->update();
+}
+
+bool Button::getEnableMargin() const
+{
+    return this->enableMargin_;
+}
+
+qreal Button::getCurrentDimAmount() const
+{
+    return this->dimPixmap_ && !this->mouseOver_ ? 0.7 : 1;
+}
+
+void Button::setBorderColor(const QColor &color)
+{
+    this->borderColor_ = color;
+
+    this->update();
+}
+
+const QColor &Button::getBorderColor() const
+{
+    return this->borderColor_;
+}
+
+void Button::setMenu(std::unique_ptr<QMenu> menu)
+{
+    this->menu_ = std::move(menu);
+
+    this->menu_->installEventFilter(
+        new FunctionEventFilter(this, [this](QObject *, QEvent *event) {
+            if (event->type() == QEvent::Hide)
+            {
+                QTimer::singleShot(20, this,
+                                   [this] { this->menuVisible_ = false; });
+            }
+            return false;
+        }));
+}
+
+void Button::paintEvent(QPaintEvent *)
+{
+    QPainter painter(this);
+
+    painter.setRenderHint(QPainter::SmoothPixmapTransform);
+
+    if (!this->pixmap_.isNull())
+    {
+        if (!this->mouseOver_ && this->dimPixmap_ && this->enabled_)
+        {
+            painter.setOpacity(this->getCurrentDimAmount());
+        }
+
+        QRect rect = this->rect();
+        int s = this->enableMargin_ ? int(6 * this->scale()) : 0;
+
+        rect.moveLeft(s);
+        rect.setRight(rect.right() - s - s);
+        rect.moveTop(s);
+        rect.setBottom(rect.bottom() - s - s);
+
+        painter.drawPixmap(rect, this->pixmap_);
+
+        painter.setOpacity(1);
+    }
+
+    this->fancyPaint(painter);
+
+    if (this->borderColor_.isValid())
+    {
+        painter.setRenderHint(QPainter::Antialiasing, false);
+        painter.setPen(this->borderColor_);
+        painter.drawRect(0, 0, this->width() - 1, this->height() - 1);
+    }
+}
+
+void Button::fancyPaint(QPainter &painter)
+{
+    if (!this->enabled_)
+    {
+        return;
+    }
+
+    painter.setRenderHint(QPainter::HighQualityAntialiasing);
+    painter.setRenderHint(QPainter::Antialiasing);
+    QColor c;
+
+    if (this->mouseEffectColor_)
+    {
+        c = this->mouseEffectColor_.get();
+    }
+    else
+    {
+        c = this->theme->isLightTheme() ? QColor(0, 0, 0)
+                                        : QColor(255, 255, 255);
+    }
+
+    if (this->hoverMultiplier_ > 0)
+    {
+        QRadialGradient gradient(QPointF(mousePos_), this->width() / 2);
+
+        gradient.setColorAt(0, QColor(c.red(), c.green(), c.blue(),
+                                      int(50 * this->hoverMultiplier_)));
+        gradient.setColorAt(1, QColor(c.red(), c.green(), c.blue(),
+                                      int(40 * this->hoverMultiplier_)));
+
+        painter.fillRect(this->rect(), gradient);
+    }
+
+    for (auto effect : this->clickEffects_)
+    {
+        QRadialGradient gradient(effect.position.x(), effect.position.y(),
+                                 effect.progress * qreal(width()) * 2,
+                                 effect.position.x(), effect.position.y());
+
+        gradient.setColorAt(0, QColor(c.red(), c.green(), c.blue(),
+                                      int((1 - effect.progress) * 95)));
+        gradient.setColorAt(0.9999, QColor(c.red(), c.green(), c.blue(),
+                                           int((1 - effect.progress) * 95)));
+        gradient.setColorAt(1, QColor(c.red(), c.green(), c.blue(), int(0)));
+
+        painter.fillRect(this->rect(), gradient);
+    }
+}
+
+void Button::enterEvent(QEvent *)
+{
+    this->mouseOver_ = true;
+}
+
+void Button::leaveEvent(QEvent *)
+{
+    this->mouseOver_ = false;
+}
+
+void Button::mousePressEvent(QMouseEvent *event)
+{
+    if (!this->enabled_)
+    {
+        return;
+    }
+
+    if (event->button() != Qt::LeftButton)
+    {
+        return;
+    }
+
+    this->clickEffects_.push_back(ClickEffect(event->pos()));
+
+    this->mouseDown_ = true;
+
+    emit this->leftMousePress();
+
+    if (this->menu_ && !this->menuVisible_)
+    {
+        QTimer::singleShot(80, this, [this] { this->showMenu(); });
+        this->mouseDown_ = false;
+        this->mouseOver_ = false;
+    }
+}
+
+void Button::mouseReleaseEvent(QMouseEvent *event)
+{
+    if (!this->enabled_)
+        return;
+
+    if (event->button() == Qt::LeftButton)
+    {
+        this->mouseDown_ = false;
+
+        if (this->rect().contains(event->pos()))
+            emit leftClicked();
+    }
+
+    emit clicked(event->button());
+}
+
+void Button::mouseMoveEvent(QMouseEvent *event)
+{
+    if (this->enabled_)
+    {
+        this->mousePos_ = event->pos();
+
+        this->update();
+    }
+}
+
+void Button::onMouseEffectTimeout()
+{
+    bool performUpdate = false;
+
+    if (selected_)
+    {
+        if (this->hoverMultiplier_ != 0)
+        {
+            this->hoverMultiplier_ =
+                std::max(0.0, this->hoverMultiplier_ - 0.1);
+            performUpdate = true;
+        }
+    }
+    else if (mouseOver_)
+    {
+        if (this->hoverMultiplier_ != 1)
+        {
+            this->hoverMultiplier_ =
+                std::min(1.0, this->hoverMultiplier_ + 0.5);
+            performUpdate = true;
+        }
+    }
+    else
+    {
+        if (this->hoverMultiplier_ != 0)
+        {
+            this->hoverMultiplier_ =
+                std::max(0.0, this->hoverMultiplier_ - 0.3);
+            performUpdate = true;
+        }
+    }
+
+    if (this->clickEffects_.size() != 0)
+    {
+        performUpdate = true;
+
+        for (auto it = this->clickEffects_.begin();
+             it != this->clickEffects_.end();)
+        {
+            it->progress += mouseDown_ ? 0.02 : 0.07;
+
+            if (it->progress >= 1.0)
+            {
+                it = this->clickEffects_.erase(it);
+            }
+            else
+            {
+                it++;
+            }
+        }
+    }
+
+    if (performUpdate)
+    {
+        update();
+    }
+}
+
+void Button::showMenu()
+{
+    if (!this->menu_)
+        return;
+
+    auto point = [this] {
+        auto bounds = QApplication::desktop()->availableGeometry(this);
+
+        auto point = this->mapToGlobal(
+            QPoint(this->width() - this->menu_->width(), this->height()));
+
+        if (point.y() + this->menu_->height() > bounds.bottom())
+        {
+            point.setY(point.y() - this->menu_->height() - this->height());
+        }
+
+        return point;
+    };
+
+    this->menu_->popup(point());
+    this->menu_->move(point());
+    this->menuVisible_ = true;
+}
+
+}  // namespace AB_NAMESPACE

lib/appbase/widgets/helper/Button.hpp

@@ -0,0 +1,89 @@
+#pragma once
+
+#include <boost/optional.hpp>
+
+#include "widgets/BaseWidget.hpp"
+
+#include <QMenu>
+#include <QMouseEvent>
+#include <QPainter>
+#include <QPoint>
+#include <QTimer>
+#include <QWidget>
+
+namespace AB_NAMESPACE {
+
+class Button : public BaseWidget
+{
+    Q_OBJECT
+
+    struct ClickEffect {
+        double progress = 0.0;
+        QPoint position;
+
+        ClickEffect(QPoint _position)
+            : position(_position)
+        {
+        }
+    };
+
+public:
+    Button(BaseWidget *parent = nullptr);
+
+    void setMouseEffectColor(boost::optional<QColor> color);
+    void setPixmap(const QPixmap &pixmap_);
+    const QPixmap &getPixmap() const;
+
+    void setDim(bool value);
+    bool getDim() const;
+    qreal getCurrentDimAmount() const;
+
+    void setEnable(bool value);
+    bool getEnable() const;
+
+    void setEnableMargin(bool value);
+    bool getEnableMargin() const;
+
+    void setBorderColor(const QColor &color);
+    const QColor &getBorderColor() const;
+
+    void setMenu(std::unique_ptr<QMenu> menu);
+
+signals:
+    void leftClicked();
+    void clicked(Qt::MouseButton button);
+    void leftMousePress();
+
+protected:
+    virtual void paintEvent(QPaintEvent *) override;
+    virtual void enterEvent(QEvent *) override;
+    virtual void leaveEvent(QEvent *) override;
+    virtual void mousePressEvent(QMouseEvent *event) override;
+    virtual void mouseReleaseEvent(QMouseEvent *event) override;
+    virtual void mouseMoveEvent(QMouseEvent *event) override;
+
+    void fancyPaint(QPainter &painter);
+
+    bool enabled_{true};
+    bool selected_{false};
+    bool mouseOver_{false};
+    bool mouseDown_{false};
+    bool menuVisible_{false};
+
+private:
+    void onMouseEffectTimeout();
+    void showMenu();
+
+    QColor borderColor_{};
+    QPixmap pixmap_{};
+    bool dimPixmap_{true};
+    bool enableMargin_{true};
+    QPoint mousePos_{};
+    double hoverMultiplier_{0.0};
+    QTimer effectTimer_{};
+    std::vector<ClickEffect> clickEffects_{};
+    boost::optional<QColor> mouseEffectColor_{};
+    std::unique_ptr<QMenu> menu_{};
+};
+
+}  // namespace AB_NAMESPACE

lib/appbase/widgets/helper/EffectLabel.cpp

@@ -0,0 +1,43 @@
+#include "widgets/helper/EffectLabel.hpp"
+
+#include <QBrush>
+#include <QPainter>
+
+namespace AB_NAMESPACE {
+
+EffectLabel::EffectLabel(BaseWidget *parent, int spacing)
+    : Button(parent)
+    , label_(this)
+{
+    setLayout(&this->hbox_);
+
+    this->label_.setAlignment(Qt::AlignCenter);
+
+    this->hbox_.setMargin(0);
+    this->hbox_.addSpacing(spacing);
+    this->hbox_.addWidget(&this->label_);
+    this->hbox_.addSpacing(spacing);
+}
+
+EffectLabel2::EffectLabel2(BaseWidget *parent, int padding)
+    : Button(parent)
+    , label_(this)
+{
+    auto *hbox = new QHBoxLayout(this);
+    this->setLayout(hbox);
+
+    //    this->label_.setAlignment(Qt::AlignCenter);
+    this->label_.setCentered(true);
+
+    hbox->setMargin(0);
+    //    hbox.addSpacing(spacing);
+    hbox->addWidget(&this->label_);
+    //    hbox.addSpacing(spacing);
+}
+
+Label &EffectLabel2::getLabel()
+{
+    return this->label_;
+}
+
+}  // namespace AB_NAMESPACE

lib/appbase/widgets/helper/EffectLabel.hpp

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "widgets/BaseWidget.hpp"
+#include "widgets/Label.hpp"
+#include "widgets/helper/Button.hpp"
+#include "widgets/helper/SignalLabel.hpp"
+
+#include <QHBoxLayout>
+#include <QLabel>
+#include <QPaintEvent>
+#include <QWidget>
+
+namespace AB_NAMESPACE {
+
+class EffectLabel : public Button
+{
+public:
+    explicit EffectLabel(BaseWidget *parent = nullptr, int spacing = 6);
+
+    SignalLabel &getLabel()
+    {
+        return this->label_;
+    }
+
+private:
+    QHBoxLayout hbox_;
+    SignalLabel label_;
+};
+
+class EffectLabel2 : public Button
+{
+public:
+    explicit EffectLabel2(BaseWidget *parent = nullptr, int padding = 6);
+
+    Label &getLabel();
+
+private:
+    Label label_;
+};
+
+}  // namespace AB_NAMESPACE

lib/appbase/widgets/helper/SignalLabel.cpp

@@ -0,0 +1,41 @@
+#include "widgets/helper/SignalLabel.hpp"
+
+namespace AB_NAMESPACE {
+
+SignalLabel::SignalLabel(QWidget *parent, Qt::WindowFlags f)
+    : QLabel(parent, f)
+{
+}
+
+void SignalLabel::mouseDoubleClickEvent(QMouseEvent *ev)
+{
+    emit this->mouseDoubleClick(ev);
+}
+
+void SignalLabel::mousePressEvent(QMouseEvent *event)
+{
+    if (event->button() == Qt::LeftButton)
+    {
+        emit mouseDown();
+    }
+
+    event->ignore();
+}
+
+void SignalLabel::mouseReleaseEvent(QMouseEvent *event)
+{
+    if (event->button() == Qt::LeftButton)
+    {
+        emit mouseUp();
+    }
+
+    event->ignore();
+}
+
+void SignalLabel::mouseMoveEvent(QMouseEvent *event)
+{
+    emit this->mouseMove(event);
+    event->ignore();
+}
+
+}  // namespace AB_NAMESPACE

lib/appbase/widgets/helper/SignalLabel.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <QFlags>
+#include <QLabel>
+#include <QMouseEvent>
+#include <QWidget>
+
+namespace AB_NAMESPACE {
+
+class SignalLabel : public QLabel
+{
+    Q_OBJECT
+
+public:
+    explicit SignalLabel(QWidget *parent = nullptr, Qt::WindowFlags f = 0);
+    virtual ~SignalLabel() override = default;
+
+signals:
+    void mouseDoubleClick(QMouseEvent *ev);
+
+    void mouseDown();
+    void mouseUp();
+    void mouseMove(QMouseEvent *event);
+
+protected:
+    void mouseDoubleClickEvent(QMouseEvent *ev) override;
+    void mousePressEvent(QMouseEvent *event) override;
+    void mouseReleaseEvent(QMouseEvent *event) override;
+    void mouseMoveEvent(QMouseEvent *event) override;
+};
+
+}  // namespace AB_NAMESPACE

lib/appbase/widgets/helper/TitlebarButton.cpp

@@ -0,0 +1,134 @@
+#include "TitlebarButton.hpp"
+
+#include "BaseTheme.hpp"
+
+namespace AB_NAMESPACE {
+
+TitleBarButton::TitleBarButton()
+    : Button(nullptr)
+{
+}
+
+TitleBarButtonStyle TitleBarButton::getButtonStyle() const
+{
+    return this->style_;
+}
+
+void TitleBarButton::setButtonStyle(TitleBarButtonStyle _style)
+{
+    this->style_ = _style;
+    this->update();
+}
+
+void TitleBarButton::paintEvent(QPaintEvent *event)
+{
+    QPainter painter(this);
+
+    painter.setOpacity(this->getCurrentDimAmount());
+
+    QColor color = this->theme->window.text;
+    QColor background = this->theme->window.background;
+
+    int xD = this->height() / 3;
+    int centerX = this->width() / 2;
+
+    painter.setRenderHint(QPainter::Antialiasing, false);
+
+    switch (this->style_)
+    {
+        case TitleBarButtonStyle::Minimize:
+        {
+            painter.fillRect(centerX - xD / 2, xD * 3 / 2, xD, 1, color);
+            break;
+        }
+        case TitleBarButtonStyle::Maximize:
+        {
+            painter.setPen(color);
+            painter.drawRect(centerX - xD / 2, xD, xD - 1, xD - 1);
+            break;
+        }
+        case TitleBarButtonStyle::Unmaximize:
+        {
+            int xD2 = xD * 1 / 5;
+            int xD3 = xD * 4 / 5;
+
+            painter.drawRect(centerX - xD / 2 + xD2, xD, xD3, xD3);
+            painter.fillRect(centerX - xD / 2, xD + xD2, xD3, xD3,
+                             this->theme->window.background);
+            painter.drawRect(centerX - xD / 2, xD + xD2, xD3, xD3);
+            break;
+        }
+        case TitleBarButtonStyle::Close:
+        {
+            QRect rect(centerX - xD / 2, xD, xD - 1, xD - 1);
+            painter.setPen(QPen(color, 1));
+
+            painter.drawLine(rect.topLeft(), rect.bottomRight());
+            painter.drawLine(rect.topRight(), rect.bottomLeft());
+            break;
+        }
+        case TitleBarButtonStyle::User:
+        {
+            color = "#999";
+
+            painter.setRenderHint(QPainter::Antialiasing);
+            painter.setRenderHint(QPainter::HighQualityAntialiasing);
+
+            auto a = xD / 3;
+            QPainterPath path;
+
+            painter.save();
+            painter.translate(3, 3);
+
+            path.arcMoveTo(a, 4 * a, 6 * a, 6 * a, 0);
+            path.arcTo(a, 4 * a, 6 * a, 6 * a, 0, 180);
+
+            painter.fillPath(path, color);
+
+            painter.setBrush(background);
+            painter.drawEllipse(2 * a, 1 * a, 4 * a, 4 * a);
+
+            painter.setBrush(color);
+            painter.drawEllipse(2.5 * a, 1.5 * a, 3 * a + 1, 3 * a);
+            painter.restore();
+
+            break;
+        }
+        case TitleBarButtonStyle::Settings:
+        {
+            color = "#999";
+            painter.setRenderHint(QPainter::Antialiasing);
+            painter.setRenderHint(QPainter::HighQualityAntialiasing);
+
+            painter.save();
+            painter.translate(3, 3);
+
+            auto a = xD / 3;
+            QPainterPath path;
+
+            path.arcMoveTo(a, a, 6 * a, 6 * a, 0 - (360 / 32.0));
+
+            for (int i = 0; i < 8; i++)
+            {
+                path.arcTo(a, a, 6 * a, 6 * a, i * (360 / 8.0) - (360 / 32.0),
+                           (360 / 32.0));
+                path.arcTo(2 * a, 2 * a, 4 * a, 4 * a,
+                           i * (360 / 8.0) + (360 / 32.0), (360 / 32.0));
+            }
+
+            painter.strokePath(path, color);
+            painter.fillPath(path, color);
+
+            painter.setBrush(background);
+            painter.drawEllipse(3 * a, 3 * a, 2 * a, 2 * a);
+            painter.restore();
+            break;
+        }
+        default:;
+    }
+
+    Button::paintEvent(event);
+    //    this->fancyPaint(painter);
+}
+
+}  // namespace AB_NAMESPACE

lib/appbase/widgets/helper/TitlebarButton.hpp

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "widgets/helper/Button.hpp"
+
+namespace AB_NAMESPACE {
+
+enum class TitleBarButtonStyle {
+    None = 0,
+    Minimize = 1,
+    Maximize = 2,
+    Unmaximize = 4,
+    Close = 8,
+    User = 16,
+    Settings = 32
+};
+
+class TitleBarButton : public Button
+{
+public:
+    TitleBarButton();
+
+    TitleBarButtonStyle getButtonStyle() const;
+    void setButtonStyle(TitleBarButtonStyle style_);
+
+protected:
+    void paintEvent(QPaintEvent *) override;
+
+private:
+    TitleBarButtonStyle style_;
+};
+
+}  // namespace AB_NAMESPACE