Remove appbase as an external dependency.

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