wilderjds
/
kwin
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Drop QuickTileFlag::Maximize

Browse Source 
Maximize mode cannot be expressed using quick tiling infrastructure
because its semantics are very distinct from the quick tile modes.
For example, maximized vertically or horizontally require processing
interactive moves in a way that makes no sense for tiling.
wilder/Plasma/6.3
Vlad Zahorodnii 2 years ago
parent 22b12a4709
commit e229d28bde
6 changed files with 60 additions and 210 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 20
      autotests/integration/move_resize_window_test.cpp
  2. 154
      autotests/integration/quick_tiling_test.cpp
  3. 1
      src/effect/globals.h
  4. 4
      src/tiles/quicktile.cpp
  5. 83
      src/window.cpp
  6. 8
      src/window.h

20
autotests/integration/move_resize_window_test.cpp
Unescape View File

@ -791,7 +791,7 @@ void MoveResizeWindowTest::testCancelInteractiveMoveResize_data()
QTest::newRow("quicktile_right") << QuickTileMode(QuickTileFlag::Right) << MaximizeMode::MaximizeRestore;
QTest::newRow("maximize_vertical") << QuickTileMode(QuickTileFlag::None) << MaximizeMode::MaximizeVertical;
QTest::newRow("maximize_horizontal") << QuickTileMode(QuickTileFlag::None) << MaximizeMode::MaximizeHorizontal;
QTest::newRow("maximize_full") << QuickTileMode(QuickTileFlag::Maximize) << MaximizeMode::MaximizeFull;
QTest::newRow("maximize_full") << QuickTileMode(QuickTileFlag::None) << MaximizeMode::MaximizeFull;
}
void MoveResizeWindowTest::testCancelInteractiveMoveResize()
@ -821,22 +821,14 @@ void MoveResizeWindowTest::testCancelInteractiveMoveResize()
} else {
window->setQuickTileModeAtCurrentPosition(quickTileMode);
}
if (quickTileMode == QuickTileFlag::Maximize) {
QCOMPARE(window->requestedQuickTileMode(), QuickTileFlag::None);
} else {
QCOMPARE(window->requestedQuickTileMode(), quickTileMode);
}
QCOMPARE(window->requestedQuickTileMode(), quickTileMode);
QCOMPARE(window->requestedMaximizeMode(), maximizeMode);
QVERIFY(surfaceConfigureRequestedSpy.wait());
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().at(0).value<quint32>());
Test::render(surface.get(), toplevelConfigureRequestedSpy.last().first().toSize(), Qt::blue);
QVERIFY(frameGeomtryChangedSpy.wait());
if (quickTileMode == QuickTileFlag::Maximize) {
QCOMPARE(window->quickTileMode(), QuickTileFlag::None);
} else {
QCOMPARE(window->quickTileMode(), quickTileMode);
}
QCOMPARE(window->quickTileMode(), quickTileMode);
const QRectF geometry = window->moveResizeGeometry();
const QRectF geometryRestore = window->geometryRestore();
@ -869,11 +861,7 @@ void MoveResizeWindowTest::testCancelInteractiveMoveResize()
Test::render(surface.get(), toplevelConfigureRequestedSpy.last().first().toSize(), Qt::blue);
QVERIFY(frameGeomtryChangedSpy.wait());
QCOMPARE(window->moveResizeGeometry(), geometry);
if (quickTileMode == QuickTileFlag::Maximize) {
QCOMPARE(window->quickTileMode(), QuickTileFlag::None);
} else {
QCOMPARE(window->quickTileMode(), quickTileMode);
}
QCOMPARE(window->quickTileMode(), quickTileMode);
QCOMPARE(window->requestedMaximizeMode(), maximizeMode);
QCOMPARE(window->geometryRestore(), geometryRestore);
}

154
autotests/integration/quick_tiling_test.cpp
Unescape View File

@ -57,8 +57,6 @@ private Q_SLOTS:
void cleanup();
void testQuickTiling_data();
void testQuickTiling();
void testQuickMaximizing_data();
void testQuickMaximizing();
void testQuickTilingKeyboardMove_data();
void testQuickTilingKeyboardMove();
void testQuickTilingPointerMove_data();
@ -142,9 +140,6 @@ void QuickTilingTest::testQuickTiling_data()
QTest::newRow("top right") << (FLAG(Right) | FLAG(Top)) << QRectF(640, 0, 640, 512) << QRectF(1920, 0, 640, 512) << QuickTileMode();
QTest::newRow("bottom left") << (FLAG(Left) | FLAG(Bottom)) << QRectF(0, 512, 640, 512) << QRectF(1280, 512, 640, 512) << (FLAG(Right) | FLAG(Bottom));
QTest::newRow("bottom right") << (FLAG(Right) | FLAG(Bottom)) << QRectF(640, 512, 640, 512) << QRectF(1920, 512, 640, 512) << QuickTileMode();
QTest::newRow("maximize") << FLAG(Maximize) << QRectF(0, 0, 1280, 1024) << QRectF(1280, 0, 1280, 1024) << QuickTileMode();
#undef FLAG
}
@ -179,11 +174,7 @@ void QuickTilingTest::testQuickTiling()
// at this point the geometry did not yet change
QCOMPARE(window->frameGeometry(), QRect(0, 0, 100, 50));
// Manually maximized window is always without a tile
if (mode == QuickTileFlag::Maximize) {
QCOMPARE(window->requestedQuickTileMode(), QuickTileFlag::None);
} else {
QCOMPARE(window->requestedQuickTileMode(), mode);
}
QCOMPARE(window->requestedQuickTileMode(), mode);
// Actual quickTileMOde didn't change yet
QCOMPARE(window->quickTileMode(), oldQuickTileMode);
@ -199,28 +190,19 @@ void QuickTilingTest::testQuickTiling()
QVERIFY(frameGeometryChangedSpy.wait());
QCOMPARE(frameGeometryChangedSpy.count(), 1);
QCOMPARE(window->frameGeometry(), expectedGeometry);
if (mode == QuickTileFlag::Maximize) {
QCOMPARE(quickTileChangedSpy.count(), 0);
QCOMPARE(window->quickTileMode(), QuickTileFlag::None);
} else {
QCOMPARE(quickTileChangedSpy.count(), 1);
QCOMPARE(window->quickTileMode(), mode);
}
QCOMPARE(quickTileChangedSpy.count(), 1);
QCOMPARE(window->quickTileMode(), mode);
// send window to other screen
QList<Output *> outputs = workspace()->outputs();
QCOMPARE(window->output(), outputs[0]);
window->sendToOutput(outputs[1]);
QCOMPARE(window->output(), outputs[1]);
if (mode == QuickTileFlag::Maximize) {
QCOMPARE(window->quickTileMode(), QuickTileFlag::None);
} else {
// quick tile should not be changed
QCOMPARE(window->quickTileMode(), mode);
}
// quick tile should not be changed
QCOMPARE(window->quickTileMode(), mode);
QTEST(window->frameGeometry(), "secondScreen");
Tile *tile = workspace()->tileManager(outputs[1])->quickTile(mode);
QCOMPARE(window->tile(), mode == QuickTileFlag::Maximize ? nullptr : tile);
QCOMPARE(window->tile(), tile);
// now try to toggle again
window->handleQuickTileShortcut(mode);
@ -230,109 +212,11 @@ void QuickTilingTest::testQuickTiling()
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().at(0).value<quint32>());
Test::render(surface.get(), toplevelConfigureRequestedSpy.last().at(0).toSize(), Qt::red);
if (mode == QuickTileFlag::Maximize) {
QVERIFY(!quickTileChangedSpy.wait());
QCOMPARE(quickTileChangedSpy.count(), 0);
} else {
QVERIFY(quickTileChangedSpy.wait());
QCOMPARE(quickTileChangedSpy.count(), 2);
}
QVERIFY(quickTileChangedSpy.wait());
QCOMPARE(quickTileChangedSpy.count(), 2);
QTEST(window->quickTileMode(), "expectedModeAfterToggle");
}
void QuickTilingTest::testQuickMaximizing_data()
{
QTest::addColumn<QuickTileMode>("mode");
#define FLAG(name) QuickTileMode(QuickTileFlag::name)
QTest::newRow("maximize") << FLAG(Maximize);
QTest::newRow("none") << FLAG(None);
#undef FLAG
}
void QuickTilingTest::testQuickMaximizing()
{
std::unique_ptr<KWayland::Client::Surface> surface(Test::createSurface());
QVERIFY(surface != nullptr);
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
QVERIFY(shellSurface != nullptr);
// Map the window.
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
QVERIFY(window);
QCOMPARE(workspace()->activeWindow(), window);
QCOMPARE(window->frameGeometry(), QRect(0, 0, 100, 50));
QCOMPARE(window->quickTileMode(), QuickTileMode(QuickTileFlag::None));
QCOMPARE(window->maximizeMode(), MaximizeRestore);
// We have to receive a configure event upon becoming active.
QSignalSpy toplevelConfigureRequestedSpy(shellSurface.get(), &Test::XdgToplevel::configureRequested);
QSignalSpy surfaceConfigureRequestedSpy(shellSurface->xdgSurface(), &Test::XdgSurface::configureRequested);
QVERIFY(surfaceConfigureRequestedSpy.wait());
QCOMPARE(surfaceConfigureRequestedSpy.count(), 1);
QSignalSpy quickTileChangedSpy(window, &Window::quickTileModeChanged);
QSignalSpy frameGeometryChangedSpy(window, &Window::frameGeometryChanged);
QSignalSpy maximizeChangedSpy(window, &Window::maximizedChanged);
const QuickTileMode oldQuickTileMode = window->quickTileMode();
window->setQuickTileModeAtCurrentPosition(QuickTileFlag::Maximize);
// at this point the geometry did not yet change
QCOMPARE(window->frameGeometry(), QRect(0, 0, 100, 50));
// Manually maximized window is always without a tile
QCOMPARE(window->requestedQuickTileMode(), QuickTileFlag::None);
QCOMPARE(window->quickTileMode(), oldQuickTileMode);
QCOMPARE(window->geometryRestore(), QRect(0, 0, 100, 50));
// but we got requested a new geometry
QVERIFY(surfaceConfigureRequestedSpy.wait());
QCOMPARE(surfaceConfigureRequestedSpy.count(), 2);
QCOMPARE(toplevelConfigureRequestedSpy.last().at(0).toSize(), QSize(1280, 1024));
// attach a new image
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().at(0).value<quint32>());
Test::render(surface.get(), QSize(1280, 1024), Qt::red);
QVERIFY(frameGeometryChangedSpy.wait());
QCOMPARE(frameGeometryChangedSpy.count(), 1);
QCOMPARE(quickTileChangedSpy.count(), 0);
QCOMPARE(window->quickTileMode(), QuickTileFlag::None);
QCOMPARE(window->frameGeometry(), QRect(0, 0, 1280, 1024));
QCOMPARE(window->geometryRestore(), QRect(0, 0, 100, 50));
// window is now set to maximised
QCOMPARE(maximizeChangedSpy.count(), 1);
QCOMPARE(window->maximizeMode(), MaximizeFull);
QCOMPARE(window->tile(), nullptr);
// go back to quick tile none
QFETCH(QuickTileMode, mode);
window->setQuickTileModeAtCurrentPosition(mode);
QCOMPARE(window->requestedQuickTileMode(), QuickTileMode(QuickTileFlag::None));
// geometry not yet changed
QCOMPARE(window->frameGeometry(), QRect(0, 0, 1280, 1024));
QCOMPARE(window->geometryRestore(), QRect(0, 0, 100, 50));
// we got requested a new geometry
QVERIFY(surfaceConfigureRequestedSpy.wait());
QCOMPARE(surfaceConfigureRequestedSpy.count(), 3);
QCOMPARE(toplevelConfigureRequestedSpy.last().at(0).toSize(), QSize(100, 50));
// render again
shellSurface->xdgSurface()->ack_configure(surfaceConfigureRequestedSpy.last().at(0).value<quint32>());
Test::render(surface.get(), toplevelConfigureRequestedSpy.last().at(0).toSize(), Qt::yellow);
QVERIFY(frameGeometryChangedSpy.wait());
QCOMPARE(frameGeometryChangedSpy.count(), 2);
QCOMPARE(quickTileChangedSpy.count(), 0);
QCOMPARE(window->quickTileMode(), QuickTileMode(QuickTileFlag::None));
QCOMPARE(window->frameGeometry(), QRect(0, 0, 100, 50));
QCOMPARE(window->geometryRestore(), QRect(0, 0, 100, 50));
QCOMPARE(maximizeChangedSpy.count(), 2);
}
void QuickTilingTest::testQuickTilingKeyboardMove_data()
{
QTest::addColumn<QPoint>("targetPos");
@ -602,8 +486,6 @@ void QuickTilingTest::testX11QuickTiling_data()
QTest::newRow("bottom left") << (FLAG(Left) | FLAG(Bottom)) << QRectF(0, 512, 640, 512) << 0 << QuickTileMode();
QTest::newRow("bottom right") << (FLAG(Right) | FLAG(Bottom)) << QRectF(640, 512, 640, 512) << 1 << (FLAG(Left) | FLAG(Bottom));
QTest::newRow("maximize") << FLAG(Maximize) << QRectF(0, 0, 1280, 1024) << 0 << QuickTileMode();
#undef FLAG
}
void QuickTilingTest::testX11QuickTiling()
@ -638,13 +520,8 @@ void QuickTilingTest::testX11QuickTiling()
const QRectF origGeo = window->frameGeometry();
QFETCH(QuickTileMode, mode);
window->handleQuickTileShortcut(mode);
if (mode == QuickTileFlag::Maximize) {
QCOMPARE(quickTileChangedSpy.count(), 0);
QCOMPARE(window->quickTileMode(), QuickTileFlag::None);
} else {
QCOMPARE(quickTileChangedSpy.count(), 1);
QCOMPARE(window->quickTileMode(), mode);
}
QCOMPARE(quickTileChangedSpy.count(), 1);
QCOMPARE(window->quickTileMode(), mode);
QTEST(window->frameGeometry(), "expectedGeometry");
QCOMPARE(window->geometryRestore(), origGeo);
@ -685,8 +562,6 @@ void QuickTilingTest::testX11QuickTilingAfterVertMaximize_data()
QTest::newRow("bottom left") << (FLAG(Left) | FLAG(Bottom)) << QRectF(0, 512, 640, 512);
QTest::newRow("bottom right") << (FLAG(Right) | FLAG(Bottom)) << QRectF(640, 512, 640, 512);
QTest::newRow("maximize") << FLAG(Maximize) << QRectF(0, 0, 1280, 1024);
#undef FLAG
}
@ -729,13 +604,8 @@ void QuickTilingTest::testX11QuickTilingAfterVertMaximize()
QSignalSpy quickTileChangedSpy(window, &Window::quickTileModeChanged);
QFETCH(QuickTileMode, mode);
window->setQuickTileModeAtCurrentPosition(mode);
if (mode == QuickTileFlag::Maximize) {
QCOMPARE(window->quickTileMode(), QuickTileFlag::None);
QCOMPARE(quickTileChangedSpy.count(), 0);
} else {
QCOMPARE(window->quickTileMode(), mode);
QCOMPARE(quickTileChangedSpy.count(), 1);
}
QCOMPARE(window->quickTileMode(), mode);
QCOMPARE(quickTileChangedSpy.count(), 1);
QTEST(window->frameGeometry(), "expectedGeometry");
// and destroy the window again

1
src/effect/globals.h
Unescape View File

@ -186,7 +186,6 @@ enum class QuickTileFlag {
Custom = 1 << 4,
Horizontal = Left | Right,
Vertical = Top | Bottom,
Maximize = Left | Right | Top | Bottom,
};
Q_ENUM_NS(QuickTileFlag)
Q_DECLARE_FLAGS(QuickTileMode, QuickTileFlag)

4
src/tiles/quicktile.cpp
Unescape View File

@ -17,7 +17,7 @@ QuickRootTile::QuickRootTile(TileManager *tiling, Tile *parentItem)
{
setPadding(0.0);
setRelativeGeometry(QRectF(0, 0, 1, 1));
setQuickTileMode(QuickTileFlag::Maximize);
setQuickTileMode(QuickTileFlag::None);
auto createTile = [this, &tiling](const QRectF &geometry, QuickTileMode tileMode) {
Tile *tile = new Tile(tiling, this);
@ -102,8 +102,6 @@ Tile *QuickRootTile::tileForMode(QuickTileMode mode)
return m_bottomLeftTile.get();
case QuickTileMode(QuickTileFlag::Right | QuickTileFlag::Bottom):
return m_bottomRightTile.get();
case QuickTileMode(QuickTileFlag::Maximize):
return this;
default:
return nullptr;
}

83
src/window.cpp
Unescape View File

@ -8,6 +8,8 @@
SPDX-License-Identifier: GPL-2.0-or-later
*/
#include "window.h"
#include "effect/globals.h"
#include "utils/common.h"
#if KWIN_BUILD_ACTIVITIES
#include "activities.h"
@ -1251,12 +1253,16 @@ void Window::finishInteractiveMoveResize(bool cancel)
}
if (isElectricBorderMaximizing()) {
setQuickTileMode(electricBorderMode(), m_interactiveMoveResize.anchor);
if (auto quickTileMode = std::get_if<QuickTileMode>(&m_electricMode.value())) {
setQuickTileMode(*quickTileMode, m_interactiveMoveResize.anchor);
} else if (auto maximizeMode = std::get_if<MaximizeMode>(&m_electricMode.value())) {
maximize(*maximizeMode, m_electricGeometryRestore);
}
setElectricBorderMaximizing(false);
} else if (wasMove && (m_interactiveMoveResize.modifiers & Qt::ShiftModifier)) {
setQuickTileMode(QuickTileFlag::Custom, m_interactiveMoveResize.anchor);
}
setElectricBorderMode(QuickTileMode(QuickTileFlag::None));
setElectricBorderMode(std::nullopt);
workspace()->outline()->hide();
m_interactiveMoveResize.counter++;
@ -2438,7 +2444,7 @@ void Window::doInteractiveResizeSync(const QRectF &)
void Window::checkQuickTilingMaximizationZones(int xroot, int yroot)
{
QuickTileMode mode = QuickTileFlag::None;
std::optional<ElectricBorderMode> mode = std::nullopt;
bool innerBorder = false;
const auto outputs = workspace()->outputs();
@ -2460,24 +2466,26 @@ void Window::checkQuickTilingMaximizationZones(int xroot, int yroot)
};
QRectF area = workspace()->clientArea(MaximizeArea, this, QPointF(xroot, yroot));
QuickTileMode tile = QuickTileFlag::None;
if (options->electricBorderTiling()) {
if (xroot <= area.x() + 20) {
mode |= QuickTileFlag::Left;
tile |= QuickTileFlag::Left;
innerBorder = isInScreen(QPoint(area.x() - 1, yroot));
} else if (xroot >= area.x() + area.width() - 20) {
mode |= QuickTileFlag::Right;
tile |= QuickTileFlag::Right;
innerBorder = isInScreen(QPoint(area.right() + 1, yroot));
}
}
if (mode != QuickTileMode(QuickTileFlag::None)) {
if (tile != QuickTileMode(QuickTileFlag::None)) {
if (yroot <= area.y() + area.height() * options->electricBorderCornerRatio()) {
mode |= QuickTileFlag::Top;
tile |= QuickTileFlag::Top;
} else if (yroot >= area.y() + area.height() - area.height() * options->electricBorderCornerRatio()) {
mode |= QuickTileFlag::Bottom;
tile |= QuickTileFlag::Bottom;
}
mode = tile;
} else if (options->electricBorderMaximize() && yroot <= area.y() + 5 && isMaximizable()) {
mode = QuickTileFlag::Maximize;
mode = MaximizeFull;
innerBorder = isInScreen(QPoint(xroot, area.y() - 1));
}
break; // no point in checking other screens to contain this... "point"...
@ -2491,25 +2499,25 @@ void Window::checkQuickTilingMaximizationZones(int xroot, int yroot)
m_electricMaximizingDelay->setSingleShot(true);
connect(m_electricMaximizingDelay, &QTimer::timeout, this, [this]() {
if (isInteractiveMove()) {
setElectricBorderMaximizing(electricBorderMode() != QuickTileMode(QuickTileFlag::None));
setElectricBorderMaximizing(electricBorderMode().has_value());
}
});
}
m_electricMaximizingDelay->start();
} else {
setElectricBorderMaximizing(mode != QuickTileMode(QuickTileFlag::None));
setElectricBorderMaximizing(mode.has_value());
}
}
}
void Window::resetQuickTilingMaximizationZones()
{
if (electricBorderMode() != QuickTileMode(QuickTileFlag::None)) {
if (electricBorderMode().has_value()) {
if (m_electricMaximizingDelay) {
m_electricMaximizingDelay->stop();
}
setElectricBorderMaximizing(false);
setElectricBorderMode(QuickTileFlag::None);
setElectricBorderMode(std::nullopt);
}
}
@ -3360,17 +3368,20 @@ void Window::moveResize(const QRectF &rect)
moveResizeInternal(rect, MoveResizeMode::MoveResize);
}
void Window::setElectricBorderMode(QuickTileMode mode)
void Window::setElectricBorderMode(std::optional<ElectricBorderMode> mode)
{
if (mode != QuickTileMode(QuickTileFlag::Maximize)) {
// sanitize the mode, ie. simplify "invalid" combinations
if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Horizontal)) {
mode &= ~QuickTileMode(QuickTileFlag::Horizontal);
}
if ((mode & QuickTileFlag::Vertical) == QuickTileMode(QuickTileFlag::Vertical)) {
mode &= ~QuickTileMode(QuickTileFlag::Vertical);
if (mode.has_value()) {
if (auto quickTileMode = std::get_if<QuickTileMode>(&mode.value())) {
// sanitize the mode, ie. simplify "invalid" combinations
if ((*quickTileMode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Horizontal)) {
*quickTileMode &= ~QuickTileMode(QuickTileFlag::Horizontal);
}
if ((*quickTileMode & QuickTileFlag::Vertical) == QuickTileMode(QuickTileFlag::Vertical)) {
*quickTileMode &= ~QuickTileMode(QuickTileFlag::Vertical);
}
}
}
m_electricMode = mode;
}
@ -3378,7 +3389,11 @@ void Window::setElectricBorderMaximizing(bool maximizing)
{
m_electricMaximizing = maximizing;
if (maximizing) {
workspace()->outline()->show(quickTileGeometry(electricBorderMode(), interactiveMoveResizeAnchor()).toRect(), moveResizeGeometry().toRect());
if (auto quickTileMode = std::get_if<QuickTileMode>(&m_electricMode.value())) {
workspace()->outline()->show(quickTileGeometry(*quickTileMode, interactiveMoveResizeAnchor()).toRect(), moveResizeGeometry().toRect());
} else if (auto maximizeMode = std::get_if<MaximizeMode>(&m_electricMode.value())) {
workspace()->outline()->show(workspace()->clientArea(MaximizeArea, this, interactiveMoveResizeAnchor()).toRect(), moveResizeGeometry().toRect());
}
} else {
workspace()->outline()->hide();
}
@ -3386,14 +3401,6 @@ void Window::setElectricBorderMaximizing(bool maximizing)
QRectF Window::quickTileGeometry(QuickTileMode mode, const QPointF &pos) const
{
if (mode == QuickTileMode(QuickTileFlag::Maximize)) {
if (requestedMaximizeMode() == MaximizeFull) {
return geometryRestore();
} else {
return workspace()->clientArea(MaximizeArea, this, pos);
}
}
Output *output = workspace()->outputAt(pos);
if (mode & QuickTileFlag::Custom) {
@ -3515,22 +3522,8 @@ void Window::setQuickTileMode(QuickTileMode mode, const QPointF &tileAtPoint)
workspace()->updateFocusMousePosition(Cursors::self()->mouse()->pos()); // may cause leave event
const QuickTileMode oldMode = requestedQuickTileMode();
if (mode == QuickTileMode(QuickTileFlag::Maximize)) {
if (requestedMaximizeMode() == MaximizeFull) {
m_requestedQuickTileMode = QuickTileFlag::None;
setMaximize(false, false);
} else {
const QRectF effectiveGeometryRestore = quickTileGeometryRestore();
m_requestedQuickTileMode = QuickTileFlag::Maximize;
setMaximize(true, true, effectiveGeometryRestore);
}
doSetQuickTileMode();
return;
}
// sanitize the mode, ie. simplify "invalid" combinations
const QuickTileMode oldMode = requestedQuickTileMode();
if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Horizontal)) {
mode &= ~QuickTileMode(QuickTileFlag::Horizontal);
}

8
src/window.h
Unescape View File

@ -56,6 +56,8 @@ class DecoratedClientImpl;
class DecorationPalette;
}
using ElectricBorderMode = std::variant<QuickTileMode, MaximizeMode>;
class KWIN_EXPORT Window : public QObject
{
Q_OBJECT
@ -1557,8 +1559,8 @@ protected:
bool isActiveFullScreen() const;
// electric border / quick tiling
void setElectricBorderMode(QuickTileMode mode);
QuickTileMode electricBorderMode() const
void setElectricBorderMode(std::optional<ElectricBorderMode> mode);
std::optional<ElectricBorderMode> electricBorderMode() const
{
return m_electricMode;
}
@ -1814,7 +1816,7 @@ protected:
QPointer<Tile> m_tile;
// electric border/quick tiling
QuickTileMode m_electricMode = QuickTileFlag::None;
std::optional<ElectricBorderMode> m_electricMode = std::nullopt;
QRectF m_electricGeometryRestore;
bool m_electricMaximizing = false;
// The requested quick tile mode of this window.

Write Preview
Loading…
Cancel
Save