diff --git a/README.md b/README.md
index bad8506d67..136ce4fd0a 100644
--- a/README.md
+++ b/README.md
@@ -8,7 +8,7 @@ Better Blur (formerly kwin-effects-forceblur) is a fork the KWin Blur effect for
- X11 and Wayland support
- Force blur
- Rounded corners with optional anti-aliasing
-- Optional blur texture caching for much lower GPU usage, works best with tiling
+- Static blur for much lower GPU usage, works best with tiling
### Bug fixes
Fixes for blur-related Plasma bugs that haven't been patched yet.
diff --git a/docs/configuration.md b/docs/configuration.md
index 98126a8eeb..2362ef5ae1 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -1,42 +1,131 @@
-# General
-### Window opacity affects blur
-Since Plasma 6, window opacity now affects blur opacity with no option to disable it in the stock blur effect.
+# Simple
+A simple configuration system with a UI. For more complex configuration (for example blur menus but not firefox's menus), use window rules.
-Enabled (default):
-
+Obvious options are not explained here.
-Disabled:
-
+## General
-# Force blur
-### Blur window decorations
-Whether to blur window decorations, including borders. Enable this if your window decoration doesn't support blur, or you want rounded top corners.
+| Option | Description |
+|---------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Noise strength** | Noise is used to mask color banding. |
+| **Window opacity affects blur** | Whether the blur opacity should be affected by the window's opacity. Window fading animations will still affect the blur opacity.
Enabled:
Disabled:
|
-This option will override the blur region specified by the decoration.
+## Force blur
+| Option | Description |
+|-------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Window classes** | A list of classes of windows to force blur, separated by new line.
Regular expressions are supported and can be specified by using the ``$regex:`` prefix. Example: ``$regex:org\.kde\..*`` |
+| **Blur window decorations as well** | Whether to blur the window decorations (titlebar and borders) in addition to the content. This will override the decoration's blur region, possibly breaking rounded corners, in which case you need to manually specify the corner radius in the *Rounded corners* section. |
+| **Treat windows as transparent** | Whether force-blurred windows should be considered as transparent in order to fix transparency for applications that don't mark their windows as transparent. See #38 for an example. |
-### Paint windows as non-opaque
-Fixes transparency for some applications by marking their windows as transparent. This will only be done for force-blurred windows.
+## Rounded corners
+| Option | Description |
+|------------------------------|----------------------------------------------------------------------------------------|
+| **Window top corner radius** | Requires *Blur window decorations as well* to be enabled for windows with decorations. |
+| **Anti-aliasing** | Makes rounded corners appear smoother. |
-# Fake blur
-When enabled, the blur texture will be cached and reused. The blurred areas of the window will be marked as opaque, resulting in KWin not painting anything behind them.
-Only one image per screen is cached at a time.
+## Static blur
+When enabled, a cached texture will be painted behind the window instead of actually blurring the background (dynamic blur).
+The blurred areas of the window will also be marked as opaque, causing KWin to not paint anything behind the window.
+Both things result in lower resource usage.
-Fake blur is mainly intended for laptop users who want longer battery life while still having blur everywhere.
+Static blur is mainly intended for laptop users who want longer battery life while still having blur everywhere.
-### Use real blur for windows that are in front of other windows
-By default, when two windows overlap, you won't be able to see the window behind.
-
+| Option | Description |
+|-------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Use dynamic blur for windows with another window behind** | Whether to switch to dynamic blur when a window has another window behind it, allowing you to see the one behind.
Enabled:
Disabled:
|
+| **Texture source** | The image to use for static blur.
- Desktop wallpaper - A screenshot of the desktop is taken for every screen. Icons and widgets will be included. The cached texture is invalidated when the entire desktop is repainted, which can happen when the wallpaper changes, icons are interacted with or when widgets update.
- Custom - The specified image is scaled for every screen without respecting the aspect ratio. Supported formats are JPEG and PNG. |
+| **Blur texture** | Whether to blur the texture. This is only done once during texture creation. |
-If this option is enabled, the effect will automatically switch to real blur when necessary. At very high blur strengths, there may be a slight difference in the texture.
+## Window rules
-https://github.com/taj-ny/kwin-effects-forceblur/assets/79316397/7bae6a16-6c78-4889-8df1-feb24005dabc
+| Option | Description |
+|-------------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Convert simple config to window rules** | Whether to automatically convert simple configuration into window rules. Disabling this will cause most options in the simple configuration UI to not have an effect anymore. |
-### Image source
-The image to use for fake blur.
+# Window rules
+Configuration UI for window rules will be added in v2. The configuration file is located at ``~/.config/kwinbetterblurrc`` and isn't created automatically.
-- Desktop wallpaper - A screenshot of the desktop is taken for every screen. Icons and widgets will be included. The cached texture is invalidated when the entire desktop is repainted,
-which can happen when the wallpaper changes, icons are interacted with or when widgets update.
-- Custom - The specified image is scaled for every screen without respecting the aspect ratio. Supported formats are JPEG and PNG.
+Simple configuration is converted into multiple rules with priorities lower than 0. They are not added into the configuration file. This behavior can be disabled in the configuration UI in the *Window Rules* tab.
-### Blur image
-Whether to blur the image used for fake blur. This is only done once.
+An example is provided at the end.
+
+## File structure
+### Window rule
+**Group**: [WindowRules][\$RuleName], where **$RuleName (string)** is the unique name of this rule.
+
+Rules are not evaluated in order as they appear in the file.
+
+| Property | Type | Description |
+|--------------|---------------|-----------------------------------------------------------------------------------------------------------------------------------------|
+| **Priority** | ``int (>=0)`` | Properties of rules with higher priority override properties of rules with lower priority.
Priorities lower than 0 are reserved. |
+
+### Conditions
+**Group**: [WindowRules][\$RuleName][Conditions][\$ConditionName], where **$ConditionName (string)** is the unique name of this condition in the rule.
+
+At least 1 (or 0 if none specified) condition must be satisfied in order for this rule to be applied. All specified subconditions in a condition must be satisfied.
+
+| Property | Type | Description |
+|-----------------------------|--------------------------------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **Negate** | ``enum (WindowClass, WindowState, WindowType)``
Multiple values are allowed. | Which subconditions should be negated.
Separated by space. |
+| **HasWindowBehind** | ``bool`` | Whether only windows that (don't) have another window (excluding desktops) behind them should satisfy this condition. |
+| **WindowClass** | ``string`` or ``regex`` | A regular expression executed on the window class. Only a partial match is required.
For an exact match, use ``^class$``.
To specify multiple classes, separate them by ``\|``: ``class1\|class2``.
A dot matches any character, which can be prevented by escaping it: ``\.``. | - |
+| **WindowState** | ``enum (Fullscreen, Maximized)``
Multiple values are allowed. | Separated by space. |
+| **WindowType** | ``enum (Dialog, Dock, Normal, Menu, Toolbar, Tooltip, Utility)``
Multiple values are allowed. | Separated by space.
+
+### Properties
+**Group**: [WindowRules][\$RuleName][Properties]
+
+Properties don't have default values. Unset properties don't override properties of other rules.
+
+| Property | Type | Description |
+|:-----------------------------|------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| **BlurContent** | ``bool`` | Whether to force blur the window's content, excluding decorations. |
+| **BlurDecorations** | ``bool`` | See *Blur window decorations as well* in the *Simple* section. The difference is that in window rules it's possible to blur only the decorations and the corner radius is specified in the *CornerRadius* property. |
+| **CornerRadius** | ``float (>= 0)`` | Corner radius for the blur region.
A single number specifies the same radius for both top and bottom corners. Example: ``12.5``
Two numbers separated by a space specify different radii for top and bottom corners respectively. Example: ``0 12.5``
Top corner radius will only be applied to windows with force-blurred decorations or no decorations. |
+| **CornerAntialiasing** | ``float (>= 0)`` | Makes rounded corners appear smoother. Recommended value is 1. |
+| **ForceTransparency** | ``bool`` | See *Treat windows as transparent* in the *Simple* section. |
+| **StaticBlur** | ``bool`` | Whether to use static blur instead of dynamic blur for the window.
+| **WindowOpacityAffectsBlur** | ``bool`` | See *Window opacity affects blur* in the *Simple* section. |
+
+## Example
+```
+[WindowRules][AllWindows][Properties]
+CornerAntialiasing = true
+WindowOpacityAffectsBlur = false
+
+
+[WindowRules][ForceBlur][Conditions][0]
+WindowClass = clementine|kate|kwrite|org\.freedesktop\.impl\.portal\.desktop\.kde|plasmashell
+WindowType = Dialog Normal Menu Toolbar Tooltip Utility
+
+[WindowRules][ForceBlur][Conditions][1]
+WindowClass = firefox
+WindowType = Normal
+
+[WindowRules][ForceBlur][Properties]
+BlurContent = true
+BlurDecorations = true
+
+
+[WindowRules][StaticBlur][Conditions][0]
+HasWindowBehind = false
+
+[WindowRules][StaticBlur][Properties]
+StaticBlur = true
+
+
+[WindowRules][WindowCorners][Conditions][0]
+Negate = WindowState
+WindowState = Fullscreen Maximized
+WindowType = Normal
+
+[WindowRules][WindowCorners][Properties]
+CornerRadius = 15
+
+
+[WindowRules][MenuCorners][Conditions][0]
+WindowType = Menu
+
+[WindowRules][MenuCorners][Properties]
+CornerRadius = 10
+```
\ No newline at end of file
diff --git a/flake.lock b/flake.lock
index 71f15f8dba..5a7324ca64 100644
--- a/flake.lock
+++ b/flake.lock
@@ -2,11 +2,11 @@
"nodes": {
"nixpkgs": {
"locked": {
- "lastModified": 1730200266,
- "narHash": "sha256-l253w0XMT8nWHGXuXqyiIC/bMvh1VRszGXgdpQlfhvU=",
+ "lastModified": 1731139594,
+ "narHash": "sha256-IigrKK3vYRpUu+HEjPL/phrfh7Ox881er1UEsZvw9Q4=",
"owner": "NixOS",
"repo": "nixpkgs",
- "rev": "807e9154dcb16384b1b765ebe9cd2bba2ac287fd",
+ "rev": "76612b17c0ce71689921ca12d9ffdc9c23ce40b2",
"type": "github"
},
"original": {
diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
index 2ce5f865c7..641f3eb292 100644
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@@ -16,11 +16,15 @@ set(forceblur_SOURCES
blur.cpp
blur.qrc
main.cpp
- settings.cpp
+ windowrules/windowrulecondition.cpp
+ windowrules/windowrule.cpp
+ windowrules/windowrulelist.cpp
+ windowrules/windowproperties.cpp
+ blurwindow.cpp
)
kconfig_add_kcfg_files(forceblur_SOURCES
- blurconfig.kcfgc
+ config/config.kcfgc
)
add_library(forceblur MODULE ${forceblur_SOURCES})
@@ -31,5 +35,6 @@ target_link_libraries(forceblur PRIVATE
KDecoration2::KDecoration
)
+target_compile_definitions(forceblur PRIVATE CONFIG_KWIN)
install(TARGETS forceblur DESTINATION ${KDE_INSTALL_PLUGINDIR}/kwin/effects/plugins)
diff --git a/src/blur.cpp b/src/blur.cpp
index d156dc4e0f..d86c93e47e 100644
--- a/src/blur.cpp
+++ b/src/blur.cpp
@@ -8,7 +8,7 @@
#include "blur.h"
// KConfigSkeleton
-#include "blurconfig.h"
+#include "config.h"
#include "core/pixelgrid.h"
#include "core/rendertarget.h"
@@ -16,11 +16,13 @@
#include "effect/effecthandler.h"
#include "opengl/glutils.h"
#include "opengl/glplatform.h"
+#include "scene/windowitem.h"
#include "utils.h"
#include "utils/xcbutils.h"
#include "wayland/blur.h"
#include "wayland/display.h"
#include "wayland/surface.h"
+#include "kwin/window.h"
#include
#include
@@ -53,10 +55,12 @@ static const QByteArray s_blurAtomName = QByteArrayLiteral("_KDE_NET_WM_BLUR_BEH
BlurManagerInterface *BlurEffect::s_blurManager = nullptr;
QTimer *BlurEffect::s_blurManagerRemoveTimer = nullptr;
+std::vector BlurEffect::s_allWindows;
BlurEffect::BlurEffect()
{
- BlurConfig::instance(effects->config());
+ m_config = std::make_unique();
+ BetterBlur::Config::instance(effects->config());
ensureResources();
m_downsamplePass.shader = ShaderManager::instance()->generateShaderFromFile(ShaderTrait::MapTexture,
@@ -221,131 +225,42 @@ void BlurEffect::initBlurStrengthValues()
void BlurEffect::reconfigure(ReconfigureFlags flags)
{
- m_settings.read();
+ Q_UNUSED(flags)
- m_iterationCount = blurStrengthValues[m_settings.general.blurStrength].iteration;
- m_offset = blurStrengthValues[m_settings.general.blurStrength].offset;
+ BetterBlur::Config::self()->read();
+ m_config->load();
+
+ int blurStrength = BetterBlur::Config::blurStrength() - 1;
+ m_iterationCount = blurStrengthValues[blurStrength].iteration;
+ m_offset = blurStrengthValues[blurStrength].offset;
m_expandSize = blurOffsets[m_iterationCount - 1].expandSize;
- m_fakeBlurTextures.clear();
+ m_noiseStrength = BetterBlur::Config::noiseStrength();
+ m_staticBlurImage = QImage(BetterBlur::Config::fakeBlurImage());
+ m_staticBlurTextures.clear();
- for (EffectWindow *w : effects->stackingOrder()) {
- updateBlurRegion(w);
+ for (const auto &[_, w] : m_windows) {
+ w->updateProperties();
+ w->updateBlurRegion();
}
// Update all windows for the blur to take effect
effects->addRepaintFull();
}
-void BlurEffect::updateBlurRegion(EffectWindow *w, bool geometryChanged)
-{
- std::optional content;
- std::optional frame;
-
- if (net_wm_blur_region != XCB_ATOM_NONE) {
- const QByteArray value = w->readProperty(net_wm_blur_region, XCB_ATOM_CARDINAL, 32);
- QRegion region;
- if (value.size() > 0 && !(value.size() % (4 * sizeof(uint32_t)))) {
- const uint32_t *cardinals = reinterpret_cast(value.constData());
- for (unsigned int i = 0; i < value.size() / sizeof(uint32_t);) {
- int x = cardinals[i++];
- int y = cardinals[i++];
- int w = cardinals[i++];
- int h = cardinals[i++];
- region += Xcb::fromXNative(QRect(x, y, w, h)).toRect();
- }
- }
- if (!value.isNull()) {
- content = region;
- }
- }
-
- SurfaceInterface *surf = w->surface();
-
- if (surf && surf->blur()) {
- content = surf->blur()->region();
- }
-
- if (auto internal = w->internalWindow()) {
- const auto property = internal->property("kwin_blur");
- if (property.isValid()) {
- content = property.value();
- }
- }
-
- if (w->decorationHasAlpha() && decorationSupportsBlurBehind(w)) {
- frame = decorationBlurRegion(w);
- }
-
- // Don't override blur region for menus that already have one. The window geometry could include shadows.
- if (shouldForceBlur(w) && !((isMenu(w) || w->isTooltip()) && (content.has_value() || geometryChanged))) {
- content = w->expandedGeometry().translated(-w->x(), -w->y()).toRect();
- if (m_settings.forceBlur.blurDecorations && w->decoration()) {
- frame = w->frameGeometry().translated(-w->x(), -w->y()).toRect();
- }
- }
-
- if (content.has_value() || frame.has_value()) {
- BlurEffectData &data = m_windows[w];
- data.content = content;
- data.frame = frame;
- } else if (!geometryChanged) { // Blur may disappear if this method is called when window geometry changes
- if (auto it = m_windows.find(w); it != m_windows.end()) {
- effects->makeOpenGLContextCurrent();
- m_windows.erase(it);
- }
- }
-}
-
-bool BlurEffect::hasFakeBlur(EffectWindow *w)
-{
- if (!m_settings.fakeBlur.enable) {
- return false;
- }
-
- if (m_settings.fakeBlur.disableWhenWindowBehind) {
- if (auto it = m_windows.find(w); it != m_windows.end()) {
- return !it->second.hasWindowBehind;
- }
- }
-
- return true;
-}
-
void BlurEffect::slotWindowAdded(EffectWindow *w)
{
- SurfaceInterface *surf = w->surface();
-
- if (surf) {
- windowBlurChangedConnections[w] = connect(surf, &SurfaceInterface::blurChanged, this, [this, w]() {
- if (w) {
- updateBlurRegion(w);
- }
- });
- }
+ s_allWindows.push_back(w);
+ m_windows[w] = std::make_unique(m_config.get(), w, net_wm_blur_region);
windowExpandedGeometryChangedConnections[w] = connect(w, &EffectWindow::windowExpandedGeometryChanged, this, [this,w]() {
- if (!w) {
- return;
- }
-
- if (w->isDesktop() && !effects->waylandDisplay()) {
- m_fakeBlurTextures.erase(nullptr);
- return;
+ if (w && w->isDesktop() && !effects->waylandDisplay()) {
+ m_staticBlurTextures.erase(nullptr);
}
-
- updateBlurRegion(w, true);
});
if (auto internal = w->internalWindow()) {
internal->installEventFilter(this);
}
-
- connect(w, &EffectWindow::windowDecorationChanged, this, &BlurEffect::setupDecorationConnections);
- setupDecorationConnections(w);
-
- updateBlurRegion(w);
-
- m_allWindows.push_back(w);
}
void BlurEffect::slotWindowDeleted(EffectWindow *w)
@@ -354,41 +269,35 @@ void BlurEffect::slotWindowDeleted(EffectWindow *w)
effects->makeOpenGLContextCurrent();
m_windows.erase(it);
}
- if (auto it = windowBlurChangedConnections.find(w); it != windowBlurChangedConnections.end()) {
- disconnect(*it);
- windowBlurChangedConnections.erase(it);
- }
if (auto it = windowExpandedGeometryChangedConnections.find(w); it != windowExpandedGeometryChangedConnections.end()) {
disconnect(*it);
windowExpandedGeometryChangedConnections.erase(it);
}
- if (auto it = std::find(m_allWindows.begin(), m_allWindows.end(), w); it != m_allWindows.end()) {
- m_allWindows.erase(it);
+ if (auto it = std::find(s_allWindows.begin(), s_allWindows.end(), w); it != s_allWindows.end()) {
+ s_allWindows.erase(it);
}
- if (m_blurWhenTransformed.contains(w)) {
- m_blurWhenTransformed.removeOne(w);
- }
+ m_windows.erase(w);
}
void BlurEffect::slotScreenAdded(KWin::Output *screen)
{
screenChangedConnections[screen] = connect(screen, &Output::changed, this, [this, screen]() {
- if (!m_settings.fakeBlur.enable) {
+ if (m_staticBlurTextures.empty()) {
return;
}
- m_fakeBlurTextures.erase(screen);
+ m_staticBlurTextures.erase(screen);
effects->addRepaintFull();
});
}
void BlurEffect::slotScreenRemoved(KWin::Output *screen)
{
- for (auto &[window, data] : m_windows) {
- if (auto it = data.render.find(screen); it != data.render.end()) {
+ for (auto &[_, w] : m_windows) {
+ if (auto it = w->render.find(screen); it != w->render.end()) {
effects->makeOpenGLContextCurrent();
- data.render.erase(it);
+ w->render.erase(it);
}
}
@@ -401,21 +310,10 @@ void BlurEffect::slotScreenRemoved(KWin::Output *screen)
void BlurEffect::slotPropertyNotify(EffectWindow *w, long atom)
{
if (w && atom == net_wm_blur_region && net_wm_blur_region != XCB_ATOM_NONE) {
- updateBlurRegion(w);
+ m_windows[w]->updateBlurRegion();
}
}
-void BlurEffect::setupDecorationConnections(EffectWindow *w)
-{
- if (!w->decoration()) {
- return;
- }
-
- connect(w->decoration(), &KDecoration2::Decoration::blurRegionChanged, this, [this, w]() {
- updateBlurRegion(w);
- });
-}
-
bool BlurEffect::eventFilter(QObject *watched, QEvent *event)
{
auto internal = qobject_cast(watched);
@@ -423,7 +321,7 @@ bool BlurEffect::eventFilter(QObject *watched, QEvent *event)
QDynamicPropertyChangeEvent *pe = static_cast(event);
if (pe->propertyName() == "kwin_blur") {
if (auto w = effects->findWindow(internal)) {
- updateBlurRegion(w);
+ m_windows[w]->updateBlurRegion();
}
}
}
@@ -444,52 +342,11 @@ bool BlurEffect::supported()
#endif
}
-bool BlurEffect::decorationSupportsBlurBehind(const EffectWindow *w) const
-{
- return w->decoration() && !w->decoration()->blurRegion().isNull();
-}
-
-QRegion BlurEffect::decorationBlurRegion(const EffectWindow *w) const
-{
- if (!decorationSupportsBlurBehind(w)) {
- return QRegion();
- }
-
- QRegion decorationRegion = QRegion(w->decoration()->rect()) - w->contentsRect().toRect();
- //! we return only blurred regions that belong to decoration region
- return decorationRegion.intersected(w->decoration()->blurRegion());
-}
-
-QRegion BlurEffect::blurRegion(EffectWindow *w) const
-{
- QRegion region;
-
- if (auto it = m_windows.find(w); it != m_windows.end()) {
- const std::optional &content = it->second.content;
- const std::optional &frame = it->second.frame;
- if (content.has_value()) {
- if (content->isEmpty()) {
- // An empty region means that the blur effect should be enabled
- // for the whole window.
- region = w->rect().toRect();
- } else {
- if (frame.has_value()) {
- region = frame.value();
- }
- region += content->translated(w->contentsRect().topLeft().toPoint()) & w->contentsRect().toRect();
- }
- } else if (frame.has_value()) {
- region = frame.value();
- }
- }
-
- return region;
-}
-
void BlurEffect::prePaintScreen(ScreenPrePaintData &data, std::chrono::milliseconds presentTime)
{
- m_paintedArea = QRegion();
- m_currentBlur = QRegion();
+ m_paintedArea = {};
+ m_currentBlur = {};
+ m_windowGeometriesSum = {};
m_currentScreen = effects->waylandDisplay() ? data.screen : nullptr;
effects->prePaintScreen(data, presentTime);
@@ -499,24 +356,26 @@ void BlurEffect::prePaintWindow(EffectWindow *w, WindowPrePaintData &data, std::
{
// this effect relies on prePaintWindow being called in the bottom to top order
- // in case this window has regions to be blurred
- const QRegion blurArea = blurRegion(w).translated(w->pos().toPoint());
-
- bool fakeBlur = hasFakeBlur(w) && m_fakeBlurTextures.contains(m_currentScreen) && !blurArea.isEmpty();
- if (fakeBlur) {
- data.opaque += blurArea;
-
- int topCornerRadius;
- int bottomCornerRadius;
- if (isMenu(w)) {
- topCornerRadius = bottomCornerRadius = std::ceil(m_settings.roundedCorners.menuRadius);
- } else if (w->isDock()) {
- topCornerRadius = bottomCornerRadius = std::ceil(m_settings.roundedCorners.dockRadius);
- } else {
- topCornerRadius = std::ceil(m_settings.roundedCorners.windowTopRadius);
- bottomCornerRadius = std::ceil(m_settings.roundedCorners.windowBottomRadius);
+ const auto &blurWindow = m_windows[w];
+
+ if (!w->isDesktop()) {
+ const auto hadWindowBehind = blurWindow->hasWindowBehind();
+ blurWindow->setHasWindowBehind(m_windowGeometriesSum.intersects(w->frameGeometry().toRect()));
+ if (hadWindowBehind != blurWindow->hasWindowBehind()) {
+ data.paint += w->windowItem()->boundingRect().toRect();
+ }
+ }
+
+ const QRegion blurArea = blurWindow->blurRegion().translated(w->pos().toPoint());
+
+ bool staticBlur = blurWindow->properties()->staticBlur() && m_staticBlurTextures.contains(m_currentScreen) && !blurArea.isEmpty();
+ if (staticBlur) {
+ if (!blurWindow->properties()->windowOpacityAffectsBlur()) {
+ data.opaque += blurArea;
}
+ const int topCornerRadius = std::ceil(blurWindow->properties()->topCornerRadius());
+ const int bottomCornerRadius = std::ceil(blurWindow->properties()->bottomCornerRadius());
if (!w->isDock() || (w->isDock() && isDockFloating(w, blurArea))) {
const QRect blurRect = blurArea.boundingRect();
data.opaque -= QRect(blurRect.x(), blurRect.y(), topCornerRadius, topCornerRadius);
@@ -526,46 +385,17 @@ void BlurEffect::prePaintWindow(EffectWindow *w, WindowPrePaintData &data, std::
}
}
- if (m_settings.fakeBlur.enable) {
- if (m_settings.fakeBlur.disableWhenWindowBehind) {
- if (auto it = m_windows.find(w); it != m_windows.end()) {
- const bool hadWindowBehind = it->second.hasWindowBehind;
- it->second.hasWindowBehind = false;
- for (EffectWindow *other : m_allWindows) {
- if (w->window()->stackingOrder() <= other->window()->stackingOrder()
- || other->isDesktop()
- || !other->isOnCurrentDesktop()
- || !other->isOnCurrentActivity()
- || other->window()->resourceClass() == "xwaylandvideobridge"
- || other->isMinimized()) {
- continue;
- }
-
- if (w->frameGeometry().intersects(other->frameGeometry())) {
- it->second.hasWindowBehind = true;
- break;
- }
- }
-
- if (hadWindowBehind != it->second.hasWindowBehind) {
- data.paint += blurArea;
- data.opaque -= blurArea;
- }
- }
- }
-
- if (m_settings.fakeBlur.imageSource == FakeBlurImageSource::DesktopWallpaper && w->isDesktop() && w->frameGeometry() == data.paint.boundingRect()) {
- m_fakeBlurTextures.erase(m_currentScreen);
- }
+ if (!m_staticBlurTextures.empty() && w->isDesktop() && w->frameGeometry() == data.paint.boundingRect()) {
+ m_staticBlurTextures.erase(m_currentScreen);
}
- if (m_settings.forceBlur.markWindowAsTranslucent && !fakeBlur && shouldForceBlur(w)) {
+ if (!staticBlur && blurWindow->properties()->forceTransparency()) {
data.setTranslucent();
}
effects->prePaintWindow(w, data, presentTime);
- if (!fakeBlur) {
+ if (!staticBlur) {
const QRegion oldOpaque = data.opaque;
if (data.opaque.intersects(m_currentBlur)) {
// to blur an area partially we have to shrink the opaque area of a window
@@ -601,67 +431,26 @@ void BlurEffect::prePaintWindow(EffectWindow *w, WindowPrePaintData &data, std::
m_paintedArea -= data.opaque;
m_paintedArea += data.paint;
-}
-
-bool BlurEffect::shouldBlur(const EffectWindow *w, int mask, const WindowPaintData &data)
-{
- const bool hasForceBlurRole = w->data(WindowForceBlurRole).toBool();
- if ((effects->activeFullScreenEffect() && !hasForceBlurRole) || w->isDesktop()) {
- return false;
- }
-
- bool scaled = !qFuzzyCompare(data.xScale(), 1.0) && !qFuzzyCompare(data.yScale(), 1.0);
- bool translated = data.xTranslation() || data.yTranslation();
- if (!(scaled || (translated || (mask & PAINT_WINDOW_TRANSFORMED)))) {
- if (m_blurWhenTransformed.contains(w)) {
- m_blurWhenTransformed.removeOne(w);
- }
-
- return true;
- }
-
- // The force blur role may be removed while the window is still transformed, causing the blur to disappear for
- // a short time. To avoid that, we allow the window to be blurred until it's not transformed anymore.
- if (m_blurWhenTransformed.contains(w)) {
- return true;
- } else if (hasForceBlurRole) {
- m_blurWhenTransformed.append(w);
+ if (!w->isDesktop() && w->window()->resourceClass() != "xwaylandvideobridge") {
+ m_windowGeometriesSum += w->frameGeometry().toRect();
}
-
- return hasForceBlurRole;
-}
-
-bool BlurEffect::shouldForceBlur(const EffectWindow *w) const
-{
- if (w->isDesktop() || (!m_settings.forceBlur.blurDocks && w->isDock()) || (!m_settings.forceBlur.blurMenus && isMenu(w))) {
- return false;
- }
-
- bool matches = m_settings.forceBlur.windowClasses.contains(w->window()->resourceName())
- || m_settings.forceBlur.windowClasses.contains(w->window()->resourceClass());
- return (matches && m_settings.forceBlur.windowClassMatchingMode == WindowClassMatchingMode::Whitelist)
- || (!matches && m_settings.forceBlur.windowClassMatchingMode == WindowClassMatchingMode::Blacklist);
}
void BlurEffect::drawWindow(const RenderTarget &renderTarget, const RenderViewport &viewport, EffectWindow *w, int mask, const QRegion ®ion, WindowPaintData &data)
{
- auto it = m_windows.find(w);
- if (it != m_windows.end()) {
- BlurEffectData &blurInfo = it->second;
- BlurRenderData &renderInfo = blurInfo.render[m_currentScreen];
- if (shouldBlur(w, mask, data)) {
- blur(renderInfo, renderTarget, viewport, w, mask, region, data);
- }
+ auto blurWindow = m_windows[w].get();
+ if (blurWindow->shouldBlur(mask, data)) {
+ blur(blurWindow, blurWindow->render[m_currentScreen], renderTarget, viewport, mask, region, data);
}
// Draw the window over the blurred area
effects->drawWindow(renderTarget, viewport, w, mask, region, data);
}
-GLTexture *BlurEffect::ensureFakeBlurTexture(const Output *output, const RenderTarget &renderTarget)
+GLTexture *BlurEffect::ensureStaticBlurTexture(const Output *output, const RenderTarget &renderTarget)
{
- if (m_fakeBlurTextures.contains(output)) {
- return m_fakeBlurTextures[output].get();
+ if (m_staticBlurTextures.contains(output)) {
+ return m_staticBlurTextures[output].get();
}
if (effects->waylandDisplay() && !output) {
@@ -673,23 +462,23 @@ GLTexture *BlurEffect::ensureFakeBlurTexture(const Output *output, const RenderT
textureFormat = renderTarget.texture()->internalFormat();
}
GLTexture *texture = effects->waylandDisplay()
- ? createFakeBlurTextureWayland(output, renderTarget, textureFormat)
- : createFakeBlurTextureX11(textureFormat);
+ ? createStaticBlurTextureWayland(output, renderTarget, textureFormat)
+ : createStaticBlurTextureX11(textureFormat);
if (!texture) {
return nullptr;
}
- return (m_fakeBlurTextures[output] = std::unique_ptr(texture)).get();
+ return (m_staticBlurTextures[output] = std::unique_ptr(texture)).get();
}
GLTexture *BlurEffect::ensureNoiseTexture()
{
- if (m_settings.general.noiseStrength == 0) {
+ if (m_noiseStrength == 0) {
return nullptr;
}
const qreal scale = std::max(1.0, QGuiApplication::primaryScreen()->logicalDotsPerInch() / 96.0);
- if (!noiseTexture || noiseTextureScale != scale || noiseTextureStength != m_settings.general.noiseStrength) {
+ if (!noiseTexture || noiseTextureScale != scale || noiseTextureStength != m_noiseStrength) {
// Init randomness based on time
std::srand((uint)QTime::currentTime().msec());
@@ -699,7 +488,7 @@ GLTexture *BlurEffect::ensureNoiseTexture()
uint8_t *noiseImageLine = (uint8_t *)noiseImage.scanLine(y);
for (int x = 0; x < noiseImage.width(); x++) {
- noiseImageLine[x] = std::rand() % m_settings.general.noiseStrength;
+ noiseImageLine[x] = std::rand() % m_noiseStrength;
}
}
@@ -712,16 +501,18 @@ GLTexture *BlurEffect::ensureNoiseTexture()
noiseTexture->setFilter(GL_NEAREST);
noiseTexture->setWrapMode(GL_REPEAT);
noiseTextureScale = scale;
- noiseTextureStength = m_settings.general.noiseStrength;
+ noiseTextureStength = m_noiseStrength;
}
return noiseTexture.get();
}
-void BlurEffect::blur(BlurRenderData &renderInfo, const RenderTarget &renderTarget, const RenderViewport &viewport, EffectWindow *w, int mask, const QRegion ®ion, WindowPaintData &data)
+void BlurEffect::blur(BetterBlur::Window *w, BetterBlur::BlurRenderData &renderInfo, const RenderTarget &renderTarget, const RenderViewport &viewport, int mask, const QRegion ®ion, WindowPaintData &data)
{
+ Q_UNUSED(mask)
+
// Compute the effective blur shape. Note that if the window is transformed, so will be the blur shape.
- QRegion blurShape = w ? blurRegion(w).translated(w->pos().toPoint()) : region;
+ QRegion blurShape = w ? w->blurRegion().translated(w->window()->pos().toPoint()) : region;
if (data.xScale() != 1 || data.yScale() != 1) {
QPoint pt = blurShape.boundingRect().topLeft();
QRegion scaledShape;
@@ -739,8 +530,8 @@ void BlurEffect::blur(BlurRenderData &renderInfo, const RenderTarget &renderTarg
const QRect backgroundRect = blurShape.boundingRect();
const QRect deviceBackgroundRect = snapToPixelGrid(scaledRect(backgroundRect, viewport.scale()));
- const auto opacity = w && m_settings.general.windowOpacityAffectsBlur
- ? w->opacity() * data.opacity()
+ const auto opacity = w && w->properties()->windowOpacityAffectsBlur()
+ ? w->window()->opacity() * data.opacity()
: data.opacity();
QList effectiveShape;
@@ -767,20 +558,11 @@ void BlurEffect::blur(BlurRenderData &renderInfo, const RenderTarget &renderTarg
float topCornerRadius = 0;
float bottomCornerRadius = 0;
- if (w && !(w->isDock() && !isDockFloating(w, blurShape))) {
- const bool isMaximized = effects->clientArea(MaximizeArea, effects->activeScreen(), effects->currentDesktop()) == w->frameGeometry();
- if (isMenu(w)) {
- topCornerRadius = bottomCornerRadius = m_settings.roundedCorners.menuRadius;
- } else if (w->isDock()) {
- topCornerRadius = bottomCornerRadius = m_settings.roundedCorners.dockRadius;
- } else if ((!w->isFullScreen() && !isMaximized) || m_settings.roundedCorners.roundMaximized) {
- if (!w->decoration() || (w->decoration() && m_settings.forceBlur.blurDecorations)) {
- topCornerRadius = m_settings.roundedCorners.windowTopRadius;
- }
- bottomCornerRadius = m_settings.roundedCorners.windowBottomRadius;
+ if (w && !(w->window()->isDock() && !isDockFloating(w->window(), blurShape))) {
+ if (!w->window()->decoration() || (w->window()->decoration() && w->properties()->blurDecorations())) {
+ topCornerRadius = w->properties()->topCornerRadius() * viewport.scale();
}
- topCornerRadius = topCornerRadius * viewport.scale();
- bottomCornerRadius = bottomCornerRadius * viewport.scale();
+ bottomCornerRadius = w->properties()->bottomCornerRadius() * viewport.scale();
}
// Maybe reallocate offscreen render targets. Keep in mind that the first one contains
@@ -792,12 +574,12 @@ void BlurEffect::blur(BlurRenderData &renderInfo, const RenderTarget &renderTarg
// Since the VBO is shared, the texture needs to be blurred before the geometry is uploaded, otherwise it will be
// reset.
- GLTexture *fakeBlurTexture = nullptr;
- if (w && hasFakeBlur(w)) {
- fakeBlurTexture = ensureFakeBlurTexture(m_currentScreen, renderTarget);
+ GLTexture *staticBlurTexture = nullptr;
+ if (w && w->properties()->staticBlur()) {
+ staticBlurTexture = ensureStaticBlurTexture(m_currentScreen, renderTarget);
}
- if (!fakeBlurTexture
+ if (!staticBlurTexture
&& (renderInfo.framebuffers.size() != (m_iterationCount + 1)
|| renderInfo.textures[0]->size() != backgroundRect.size()
|| renderInfo.textures[0]->internalFormat() != textureFormat)) {
@@ -824,7 +606,7 @@ void BlurEffect::blur(BlurRenderData &renderInfo, const RenderTarget &renderTarg
}
// Fetch the pixels behind the shape that is going to be blurred.
- if (!fakeBlurTexture) {
+ if (!staticBlurTexture) {
const QRegion dirtyRegion = region & backgroundRect;
for (const QRect &dirtyRect: dirtyRegion) {
renderInfo.framebuffers[0]->blitFromRenderTarget(renderTarget, viewport, dirtyRect, dirtyRect.translated(-backgroundRect.topLeft()));
@@ -935,7 +717,7 @@ void BlurEffect::blur(BlurRenderData &renderInfo, const RenderTarget &renderTarg
vbo->bindArrays();
- if (fakeBlurTexture) {
+ if (staticBlurTexture) {
ShaderManager::instance()->pushShader(m_texture.shader.get());
QMatrix4x4 projectionMatrix;
@@ -948,16 +730,16 @@ void BlurEffect::blur(BlurRenderData &renderInfo, const RenderTarget &renderTarg
}
m_texture.shader->setUniform(m_texture.mvpMatrixLocation, projectionMatrix);
- m_texture.shader->setUniform(m_texture.textureSizeLocation, QVector2D(fakeBlurTexture->size().width(), fakeBlurTexture->size().height()));
+ m_texture.shader->setUniform(m_texture.textureSizeLocation, QVector2D(staticBlurTexture->size().width(), staticBlurTexture->size().height()));
m_texture.shader->setUniform(m_texture.texStartPosLocation, QVector2D(backgroundRect.x() - screenGeometry.x(), backgroundRect.y() - screenGeometry.y()));
m_texture.shader->setUniform(m_texture.blurSizeLocation, QVector2D(backgroundRect.width(), backgroundRect.height()));
m_texture.shader->setUniform(m_texture.scaleLocation, (float)viewport.scale());
m_texture.shader->setUniform(m_texture.topCornerRadiusLocation, topCornerRadius);
m_texture.shader->setUniform(m_texture.bottomCornerRadiusLocation, bottomCornerRadius);
- m_texture.shader->setUniform(m_texture.antialiasingLocation, m_settings.roundedCorners.antialiasing);
+ m_texture.shader->setUniform(m_texture.antialiasingLocation, w->properties()->cornerAntialiasing());
m_texture.shader->setUniform(m_texture.opacityLocation, static_cast(opacity));
- fakeBlurTexture->bind();
+ staticBlurTexture->bind();
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
@@ -1023,7 +805,7 @@ void BlurEffect::blur(BlurRenderData &renderInfo, const RenderTarget &renderTarg
GLFramebuffer::popFramebuffer();
const auto &read = renderInfo.framebuffers[1];
- if (m_settings.general.noiseStrength > 0) {
+ if (m_noiseStrength > 0) {
if (const auto *noiseTexture = ensureNoiseTexture()) {
m_upsamplePass.shader->setUniform(m_upsamplePass.noiseLocation, true);
m_upsamplePass.shader->setUniform(m_upsamplePass.noiseTextureSizeLocation, QVector2D(noiseTexture->width(), noiseTexture->height()));
@@ -1039,7 +821,7 @@ void BlurEffect::blur(BlurRenderData &renderInfo, const RenderTarget &renderTarg
m_upsamplePass.shader->setUniform(m_upsamplePass.topCornerRadiusLocation, topCornerRadius);
m_upsamplePass.shader->setUniform(m_upsamplePass.bottomCornerRadiusLocation, bottomCornerRadius);
- m_upsamplePass.shader->setUniform(m_upsamplePass.antialiasingLocation, m_settings.roundedCorners.antialiasing);
+ m_upsamplePass.shader->setUniform(m_upsamplePass.antialiasingLocation, w ? w->properties()->cornerAntialiasing() : 0.0);
m_upsamplePass.shader->setUniform(m_upsamplePass.blurSizeLocation, QVector2D(backgroundRect.width(), backgroundRect.height()));
m_upsamplePass.shader->setUniform(m_upsamplePass.opacityLocation, static_cast(opacity));
@@ -1068,13 +850,13 @@ void BlurEffect::blur(GLTexture *texture)
const QRect textureRect = QRect(0, 0, texture->width(), texture->height());
auto blurredFramebuffer = std::make_unique(texture);
- BlurRenderData renderData;
+ BetterBlur::BlurRenderData renderInfo;
const RenderTarget renderTarget(blurredFramebuffer.get());
const RenderViewport renderViewport(textureRect, 1.0, renderTarget);
WindowPaintData data;
GLFramebuffer::pushFramebuffer(blurredFramebuffer.get());
- blur(renderData, renderTarget, renderViewport, nullptr, 0, textureRect, data);
+ blur(nullptr, renderInfo, renderTarget, renderViewport, 0, textureRect, data);
GLFramebuffer::popFramebuffer();
}
@@ -1110,7 +892,7 @@ GLTexture *BlurEffect::wallpaper(EffectWindow *desktop, const qreal &scale, cons
return texture.release();
}
-GLTexture *BlurEffect::createFakeBlurTextureWayland(const Output *output, const RenderTarget &renderTarget, const GLenum &textureFormat)
+GLTexture *BlurEffect::createStaticBlurTextureWayland(const Output *output, const RenderTarget &renderTarget, const GLenum &textureFormat)
{
EffectWindow *desktop = nullptr;
for (EffectWindow *w : effects->stackingOrder()) {
@@ -1124,10 +906,10 @@ GLTexture *BlurEffect::createFakeBlurTextureWayland(const Output *output, const
}
std::unique_ptr texture;
- if (m_settings.fakeBlur.imageSource == FakeBlurImageSource::DesktopWallpaper) {
+ if (BetterBlur::Config::fakeBlurImageSourceDesktopWallpaper()) {
texture.reset(wallpaper(desktop, output->scale(), textureFormat));
- } else if (m_settings.fakeBlur.imageSource == FakeBlurImageSource::Custom) {
- texture = GLTexture::upload(m_settings.fakeBlur.customImage.scaled(output->pixelSize(), Qt::AspectRatioMode::IgnoreAspectRatio, Qt::TransformationMode::SmoothTransformation));
+ } else if (BetterBlur::Config::fakeBlurImageSourceCustom()) {
+ texture = GLTexture::upload(m_staticBlurImage.scaled(output->pixelSize(), Qt::AspectRatioMode::IgnoreAspectRatio, Qt::TransformationMode::SmoothTransformation));
}
if (!texture) {
return nullptr;
@@ -1162,14 +944,14 @@ GLTexture *BlurEffect::createFakeBlurTextureWayland(const Output *output, const
GLFramebuffer::popFramebuffer();
ShaderManager::instance()->popShader();
- if (m_settings.fakeBlur.blurCustomImage) {
+ if (BetterBlur::Config::fakeBlurCustomImageBlur()) {
blur(texture.get());
}
return texture.release();
}
-GLTexture *BlurEffect::createFakeBlurTextureX11(const GLenum &textureFormat)
+GLTexture *BlurEffect::createStaticBlurTextureX11(const GLenum &textureFormat)
{
std::vector desktops;
QRegion desktopGeometries;
@@ -1196,16 +978,16 @@ GLTexture *BlurEffect::createFakeBlurTextureX11(const GLenum &textureFormat)
const auto geometry = desktop->frameGeometry();
std::unique_ptr texture;
- if (m_settings.fakeBlur.imageSource == FakeBlurImageSource::DesktopWallpaper) {
+ if (BetterBlur::Config::fakeBlurImageSourceDesktopWallpaper()) {
texture.reset(wallpaper(desktop, 1, textureFormat));
- } else if (m_settings.fakeBlur.imageSource == FakeBlurImageSource::Custom) {
- texture = GLTexture::upload(m_settings.fakeBlur.customImage.scaled(geometry.width(), geometry.height(), Qt::AspectRatioMode::IgnoreAspectRatio, Qt::TransformationMode::SmoothTransformation));
+ } else if (BetterBlur::Config::fakeBlurImageSourceCustom()) {
+ texture = GLTexture::upload(m_staticBlurImage.scaled(geometry.width(), geometry.height(), Qt::AspectRatioMode::IgnoreAspectRatio, Qt::TransformationMode::SmoothTransformation));
}
if (!texture) {
return nullptr;
}
- if (m_settings.fakeBlur.blurCustomImage) {
+ if (BetterBlur::Config::fakeBlurCustomImageBlur()) {
blur(texture.get());
}
@@ -1222,6 +1004,11 @@ GLTexture *BlurEffect::createFakeBlurTextureX11(const GLenum &textureFormat)
return compositeTexture.release();
}
+const std::vector BlurEffect::allWindows()
+{
+ return BlurEffect::s_allWindows;
+}
+
bool BlurEffect::isActive() const
{
return m_valid && !effects->isScreenLocked();
diff --git a/src/blur.h b/src/blur.h
index bb06547f25..961d5b367a 100644
--- a/src/blur.h
+++ b/src/blur.h
@@ -7,10 +7,11 @@
#pragma once
+#include "windowrules/windowrulelist.h"
+
#include "effect/effect.h"
#include "opengl/glutils.h"
-#include "settings.h"
-#include "window.h"
+#include "blurwindow.h"
#include
@@ -21,28 +22,6 @@ namespace KWin
class BlurManagerInterface;
-struct BlurRenderData
-{
- /// Temporary render targets needed for the Dual Kawase algorithm, the first texture
- /// contains not blurred background behind the window, it's cached.
- std::vector> textures;
- std::vector> framebuffers;
-};
-
-struct BlurEffectData
-{
- /// The region that should be blurred behind the window
- std::optional content;
-
- /// The region that should be blurred behind the frame
- std::optional frame;
-
- /// The render data per screen. Screens can have different color spaces.
- std::unordered_map