Code cleanup

src/ShapeCornersEffect.cpp

@@ -17,9 +17,11 @@
  *   Boston, MA 02110-1301, USA.
  */
 
-#include "ShapeCornersEffect.h"
 #include <QtDBus/QDBusConnection>
 #include <QDBusError>
+#include <kwinglutils.h>
+#include "ShapeCornersEffect.h"
+#include "ShapeCornersConfig.h"
 
 #if KWIN_EFFECT_API_VERSION >= 235
 #include <KX11Extras>
@@ -36,8 +38,8 @@ ShapeCornersEffect::ShapeCornersEffect()
 {
     reconfigure(ReconfigureAll);
 
-    auto connection = QDBusConnection::sessionBus();
-    if (!connection.isConnected()) {
+    if (auto connection = QDBusConnection::sessionBus();
+        !connection.isConnected()) {
         qWarning("ShapeCorners: Cannot connect to the D-Bus session bus.\n");
     }
     else {
@@ -58,7 +60,7 @@ ShapeCornersEffect::ShapeCornersEffect()
         const auto& windowList = KWindowSystem::windows();
 #endif
         for (const auto& id: windowList)
-            if (auto win = KWin::effects->findWindow(id))
+            if (const auto win = KWin::effects->findWindow(id))
                 windowAdded(win);
         connect(KWin::effects, &KWin::EffectsHandler::windowAdded, this, &ShapeCornersEffect::windowAdded);
         connect(KWin::effects, &KWin::EffectsHandler::windowDeleted, this, &ShapeCornersEffect::windowRemoved);
@@ -71,8 +73,7 @@ void
 ShapeCornersEffect::windowAdded(KWin::EffectWindow *w)
 {
     qDebug() << w->windowRole() << w->windowType() << w->windowClass();
-    auto r = m_managed.insert(w);
-    if (r.second) {
+    if (const auto& [w2, r] = m_managed.insert(w); r) {
         redirect(w);
         setShader(w, m_shaderManager.GetShader().get());
     }
@@ -85,22 +86,22 @@ void ShapeCornersEffect::windowRemoved(KWin::EffectWindow *w)
 }
 
 void
-ShapeCornersEffect::reconfigure(ReconfigureFlags flags)
+ShapeCornersEffect::reconfigure(const ReconfigureFlags flags)
 {
     Q_UNUSED(flags)
     ShapeCornersConfig::self()->read();
 }
 
 bool ShapeCornersEffect::isMaximized(const KWin::EffectWindow *w) {
-    auto screenGeometry = KWin::effects->findScreen(w->screen()->name())->geometry();
+    const auto& screenGeometry = KWin::effects->findScreen(w->screen()->name())->geometry();
     return (w->x() == screenGeometry.x() && w->width() == screenGeometry.width()) ||
            (w->y() == screenGeometry.y() && w->height() == screenGeometry.height());
 }
 
-QRectF operator *(QRect r, qreal scale) { return {r.x() * scale, r.y() * scale, r.width() * scale, r.height() * scale}; }
-QRectF operator *(QRectF r, qreal scale) { return {r.x() * scale, r.y() * scale, r.width() * scale, r.height() * scale}; }
-QRect toRect(const QRectF& r) { return {(int)r.x(), (int)r.y(), (int)r.width(), (int)r.height()}; }
-const QRect& toRect(const QRect& r) { return r; }
+inline QRectF operator *(const QRect& r, const qreal scale) { return {r.x() * scale, r.y() * scale, r.width() * scale, r.height() * scale}; }
+inline QRectF operator *(const QRectF& r, const qreal scale) { return {r.x() * scale, r.y() * scale, r.width() * scale, r.height() * scale}; }
+inline QRect toRect(const QRectF& r) { return {static_cast<int>(r.x()), static_cast<int>(r.y()), static_cast<int>(r.width()), static_cast<int>(r.height())}; }
+inline const QRect& toRect(const QRect& r) { return r; }
 
 void ShapeCornersEffect::prePaintWindow(KWin::EffectWindow *w, KWin::WindowPrePaintData &data, std::chrono::milliseconds time)
 {
@@ -110,7 +111,7 @@ void ShapeCornersEffect::prePaintWindow(KWin::EffectWindow *w, KWin::WindowPrePa
         return;
     }
 
-    auto size = isWindowActive(w) ? ShapeCornersConfig::size(): ShapeCornersConfig::inactiveCornerRadius();
+    const auto size = isWindowActive(w) ? ShapeCornersConfig::size(): ShapeCornersConfig::inactiveCornerRadius();
 
 #if KWIN_EFFECT_API_VERSION >= 234
     const auto geo = w->frameGeometry() * KWin::effects->renderTargetScale();
@@ -167,18 +168,18 @@ void ShapeCornersEffect::drawWindow(KWin::EffectWindow *w, int mask, const QRegi
 }
 
 bool ShapeCornersEffect::hasEffect(const KWin::EffectWindow *w) const {
-    auto name = w->windowClass().split(' ').first();
+    const auto name = w->windowClass().split(' ').first();
     return m_shaderManager.IsValid()
            && m_managed.contains(w)
            && (w->hasDecoration() || (w->isNormalWindow() && ShapeCornersConfig::inclusions().contains(name)))
            && !ShapeCornersConfig::exclusions().contains(name)
            && !(ShapeCornersConfig::excludeMaximizedWindows() && isMaximized(w));
 }
 
-QString ShapeCornersEffect::get_window_titles() {
+QString ShapeCornersEffect::get_window_titles() const {
     QSet<QString> response;
     for (const auto& win: m_managed) {
-        auto name = win->windowClass().split(' ').first();
+        const auto name = win->windowClass().split(' ').first();
         if (name == "plasmashell")
             continue;
         response.insert(name);

src/ShapeCornersEffect.h

@@ -25,10 +25,10 @@
 
 #if KWIN_EFFECT_API_VERSION >= 236
 #include <kwinoffscreeneffect.h>
-class ShapeCornersEffect : public KWin::OffscreenEffect
+class ShapeCornersEffect final: public KWin::OffscreenEffect
 #else
 #include <kwindeformeffect.h>
-class ShapeCornersEffect : public KWin::DeformEffect
+class ShapeCornersEffect final: public KWin::DeformEffect
 #endif
 {
     Q_OBJECT
@@ -44,16 +44,16 @@ class ShapeCornersEffect : public KWin::DeformEffect
     void reconfigure(ReconfigureFlags flags) override;
 
     void prePaintWindow(KWin::EffectWindow *w, KWin::WindowPrePaintData &data, std::chrono::milliseconds time) override;
-    void drawWindow(KWin::EffectWindow *window, int mask, const QRegion &region, KWin::WindowPaintData &data) override;
+    void drawWindow(KWin::EffectWindow *w, int mask, const QRegion &region, KWin::WindowPaintData &data) override;
 
     [[nodiscard]] int requestedEffectChainPosition() const override { return 99; }
 
 public Q_SLOTS:
-    QString get_window_titles();
+    [[nodiscard]] QString get_window_titles() const;
 
 protected Q_SLOTS:
-    void windowAdded(KWin::EffectWindow *window);
-    void windowRemoved(KWin::EffectWindow *window);
+    void windowAdded(KWin::EffectWindow *w);
+    void windowRemoved(KWin::EffectWindow *w);
 
 private:
     std::set<const KWin::EffectWindow*> m_managed;

src/ShapeCornersShader.cpp

@@ -2,50 +2,48 @@
 // Created by matin on 20/07/22.
 //
 
-#include <kwinglplatform.h>
 #include <QFile>
+#include <QWidget>
+#include <kwinglplatform.h>
 #include <kwineffects.h>
+#include <kwinglutils.h>
 #include "ShapeCornersEffect.h"
+#include "ShapeCornersConfig.h"
 #include "ShapeCornersShader.h"
 
 ShapeCornersShader::ShapeCornersShader():
-        m_manager(KWin::ShaderManager::instance())
+        m_manager(KWin::ShaderManager::instance()),
+        m_widget(new QWidget)
 {
     const QString shadersDir = IsLegacy()? "kwin/shaders/1.10/": "kwin/shaders/1.40/";
     const QString fragmentshader = QStandardPaths::locate(QStandardPaths::GenericDataLocation, shadersDir + QStringLiteral("shapecorners.frag"));
 //    m_shader = KWin::ShaderManager::instance()->loadFragmentShader(KWin::ShaderManager::GenericShader, fragmentshader);
     QFile file(fragmentshader);
-    if (file.open(QFile::ReadOnly))
-    {
-        QByteArray frag = file.readAll();
-        auto shader = m_manager->generateCustomShader(KWin::ShaderTrait::MapTexture, QByteArray(), frag);
+    if (!file.open(QFile::ReadOnly))
+        qCritical() << "ShapeCorners: no shaders found! Exiting...";
+
+    const QByteArray frag = file.readAll();
+    auto shader = m_manager->generateCustomShader(KWin::ShaderTrait::MapTexture, QByteArray(), frag);
 #if KWIN_EFFECT_API_VERSION >= 235
-        m_shader = std::move(shader);
+    m_shader = std::move(shader);
 #else
-        m_shader.reset(shader);
+    m_shader.reset(shader);
 #endif
-        file.close();
+    file.close();
 //        qDebug() << frag;        
-        if (m_shader->isValid())
-        {
-            m_shader_windowSize = m_shader->uniformLocation("windowSize");
-            m_shader_windowExpandedSize = m_shader->uniformLocation("windowExpandedSize");
-            m_shader_windowTopLeft = m_shader->uniformLocation("windowTopLeft");
-            m_shader_shadowColor = m_shader->uniformLocation("shadowColor");
-            m_shader_shadowSize = m_shader->uniformLocation("shadowSize");
-            m_shader_radius = m_shader->uniformLocation("radius");
-            m_shader_outlineColor = m_shader->uniformLocation("outlineColor");
-            m_shader_outlineThickness = m_shader->uniformLocation("outlineThickness");
-            m_shader_front = m_shader->uniformLocation("front");
-            qInfo() << "ShapeCorners: shaders loaded.";
-        }
-        else
-            qCritical() << "ShapeCorners: no valid shaders found! ShapeCorners will not work.";
-    }
-    else
-    {
-        qCritical() << "ShapeCorners: no shaders found! Exiting...";
-    }
+    if (!m_shader->isValid())
+        qCritical() << "ShapeCorners: no valid shaders found! ShapeCorners will not work.";
+
+    m_shader_windowSize = m_shader->uniformLocation("windowSize");
+    m_shader_windowExpandedSize = m_shader->uniformLocation("windowExpandedSize");
+    m_shader_windowTopLeft = m_shader->uniformLocation("windowTopLeft");
+    m_shader_shadowColor = m_shader->uniformLocation("shadowColor");
+    m_shader_shadowSize = m_shader->uniformLocation("shadowSize");
+    m_shader_radius = m_shader->uniformLocation("radius");
+    m_shader_outlineColor = m_shader->uniformLocation("outlineColor");
+    m_shader_outlineThickness = m_shader->uniformLocation("outlineThickness");
+    m_shader_front = m_shader->uniformLocation("front");
+    qInfo() << "ShapeCorners: shaders loaded.";
 }
 
 bool ShapeCornersShader::IsValid() const {
@@ -56,17 +54,16 @@ const std::unique_ptr<KWin::GLShader>&
 ShapeCornersShader::Bind(KWin::EffectWindow *w) const {
     QColor outlineColor, shadowColor;
     float shadowSize;
-    auto& m_palette = m_widget.palette();
-    auto max_shadow_size = (w->frameGeometry().topLeft() - w->expandedGeometry().topLeft()).manhattanLength();
-    auto xy = QVector2D((w->frameGeometry().left() - w->expandedGeometry().left()),
-                        (w->frameGeometry().top() - w->expandedGeometry().top()));
+    auto& m_palette = m_widget->palette();
+    auto xy = QVector2D(w->frameGeometry().topLeft() - w->expandedGeometry().topLeft());
+    auto max_shadow_size = xy.length();
     m_manager->pushShader(m_shader.get());
-    m_shader->setUniform(m_shader_windowSize, QVector2D(w->frameGeometry().width(), w->frameGeometry().height()));
-    m_shader->setUniform(m_shader_windowExpandedSize, QVector2D(w->expandedGeometry().width(), w->expandedGeometry().height()));
+    m_shader->setUniform(m_shader_windowSize, QVector2DSize(w->frameGeometry().size()));
+    m_shader->setUniform(m_shader_windowExpandedSize, QVector2DSize(w->expandedGeometry().size()));
     m_shader->setUniform(m_shader_windowTopLeft, xy);
     m_shader->setUniform(m_shader_front, 0);
     if (ShapeCornersEffect::isWindowActive(w)) {
-        shadowSize = std::min<float>(ShapeCornersConfig::shadowSize(), max_shadow_size);
+        shadowSize = std::min(static_cast<float>(ShapeCornersConfig::shadowSize()), max_shadow_size);
         m_shader->setUniform(m_shader_radius, static_cast<float>(ShapeCornersConfig::size()));
         m_shader->setUniform(m_shader_outlineThickness, static_cast<float>(ShapeCornersConfig::outlineThickness()));
 
@@ -79,7 +76,7 @@ ShapeCornersShader::Bind(KWin::EffectWindow *w) const {
         outlineColor.setAlpha(ShapeCornersConfig::activeOutlineAlpha());
         shadowColor.setAlpha(ShapeCornersConfig::activeShadowAlpha());
     } else {
-        shadowSize = std::min<float>(ShapeCornersConfig::inactiveShadowSize(), max_shadow_size);
+        shadowSize = std::min(static_cast<float>(ShapeCornersConfig::inactiveShadowSize()), max_shadow_size);
         m_shader->setUniform(m_shader_radius, static_cast<float>(ShapeCornersConfig::inactiveCornerRadius()));
         m_shader->setUniform(m_shader_outlineThickness, static_cast<float>(ShapeCornersConfig::inactiveOutlineThickness()));
 
@@ -111,9 +108,9 @@ void ShapeCornersShader::Unbind() const {
 
 bool ShapeCornersShader::IsLegacy() {
 #ifdef KWIN_HAVE_OPENGLES
-    const qint64 coreVersionNumber = kVersionNumber(3, 0);
+    const qint64 version = KWin::kVersionNumber(3, 0);
 #else
     const qint64 version = KWin::kVersionNumber(1, 40);
 #endif
-    return (KWin::GLPlatform::instance()->glslVersion() < version);
+    return KWin::GLPlatform::instance()->glslVersion() < version;
 }

src/ShapeCornersShader.h

@@ -5,16 +5,16 @@
 #ifndef KWIN4_SHAPECORNERS_CONFIG_SHADERMANAGER_H
 #define KWIN4_SHAPECORNERS_CONFIG_SHADERMANAGER_H
 
-#include <kwinglutils.h>
-#include <memory>
-#include <QWidget>
-#include "ShapeCornersConfig.h"
-
 namespace KWin {
     class GLShader;
     class ShaderManager;
 }
 
+struct QVector2DSize final: QVector2D {
+    explicit QVector2DSize(const QSizeF s):
+      QVector2D(static_cast<float>(s.width()), static_cast<float>(s.height())) {}
+};
+
 class ShapeCornersShader {
 public:
     /**
@@ -68,7 +68,7 @@ class ShapeCornersShader {
     /**
      * \brief Used only for its `palette()` function which holds the currently active highlight colors.
      */
-    QWidget m_widget;
+    std::shared_ptr<QWidget> m_widget;
 
     /**
      * \brief Reference to `uniform vec2 windowSize;`

src/kcm/ShapeCornersKCM.cpp

@@ -1,12 +1,10 @@
 #include <QDialog>
 #include <QList>
-
 #include <kwineffects.h>
 #include "kwineffects_interface.h"
+#include "ui_ShapeCornersKCM.h"
 #include "ShapeCornersKCM.h"
 
-#include <QDBusConnection>
-
 ShapeCornersKCM::ShapeCornersKCM(QWidget* parent, const QVariantList& args)
     : KCModule(parent, args)
     , ui(new Ui::Form)
@@ -47,13 +45,13 @@ ShapeCornersKCM::ShapeCornersKCM(QWidget* parent, const QVariantList& args)
 
     connect(ui->refreshButton, &QPushButton::pressed, this, &ShapeCornersKCM::update_windows);
     connect(ui->includeButton, &QPushButton::pressed, [=, this]() {
-        const auto s = ui->currentWindowList->currentItem();
-        if (s && ui->InclusionList->findItems(s->text(), Qt::MatchExactly).empty())
+        if (const auto s = ui->currentWindowList->currentItem();
+            s && ui->InclusionList->findItems(s->text(), Qt::MatchExactly).empty())
             ui->InclusionList->addItem(s->text());
     });
     connect(ui->excludeButton, &QPushButton::pressed, [=, this]() {
-        const auto s = ui->currentWindowList->currentItem();
-        if (s && ui->ExclusionList->findItems(s->text(), Qt::MatchExactly).empty())
+        if (const auto s = ui->currentWindowList->currentItem();
+            s && ui->ExclusionList->findItems(s->text(), Qt::MatchExactly).empty())
             ui->ExclusionList->addItem(s->text());
     });
     connect(ui->deleteIncludeButton, &QPushButton::pressed, [=, this]() {
@@ -87,7 +85,7 @@ ShapeCornersKCM::~ShapeCornersKCM() {
     delete ui;
 }
 
-void ShapeCornersKCM::update_colors() {
+void ShapeCornersKCM::update_colors() const {
     QColor color;
     bool checked;
     int index;
@@ -113,23 +111,15 @@ void ShapeCornersKCM::update_colors() {
     ui->kcfg_InactiveShadowAlpha->setSecondColor(color);
 }
 
-void ShapeCornersKCM::update_windows() {
-    QList<QString> windowList;
-    ui->currentWindowList->clear();
-
-    const auto connection = QDBusConnection::sessionBus();
-    if (connection.isConnected()) {
-        QDBusInterface interface("org.kde.ShapeCorners", "/ShapeCornersEffect");
-        if (interface.isValid()) {
-            const QDBusReply<QString> reply = interface.call("get_window_titles");
-            if (reply.isValid())
+void ShapeCornersKCM::update_windows() const {
+    QStringList windowList;
+    if (const auto connection = QDBusConnection::sessionBus(); connection.isConnected())
+        if (QDBusInterface interface("org.kde.ShapeCorners", "/ShapeCornersEffect"); interface.isValid())
+            if (const QDBusReply<QString> reply = interface.call("get_window_titles"); reply.isValid())
                 windowList = reply.value().split("\n");
-        }
-    }
 
-    for (const auto& w: windowList)
-        if (!w.isEmpty())
-            ui->currentWindowList->addItem(w);
+    ui->currentWindowList->clear();
+    ui->currentWindowList->addItems(windowList);
 }
 
 void ShapeCornersKCM::load() {

src/kcm/ShapeCornersKCM.h

@@ -1,9 +1,12 @@
 #pragma once
 
 #include <kcmodule.h>
-#include "ui_ShapeCornersKCM.h"
 #include "ShapeCornersConfig.h"
 
+namespace Ui {
+    class Form;
+}
+
 class ShapeCornersKCM final: public KCModule
 {
     Q_OBJECT
@@ -15,8 +18,8 @@ public slots:
     void defaults() override;
     void load() override;
     void save() override;
-    void update_colors();
-    void update_windows();
+    void update_colors() const;
+    void update_windows() const;
 
 private:
     Ui::Form *ui;