diff --git a/abstract_client.h b/abstract_client.h --- a/abstract_client.h +++ b/abstract_client.h @@ -498,17 +498,6 @@ // a helper for the workspace window packing. tests for screen validity and updates since in maximization case as with normal moving void packTo(int left, int top); - enum QuickTileFlag { - QuickTileNone = 0, - QuickTileLeft = 1, - QuickTileRight = 1<<1, - QuickTileTop = 1<<2, - QuickTileBottom = 1<<3, - QuickTileHorizontal = QuickTileLeft|QuickTileRight, - QuickTileVertical = QuickTileTop|QuickTileBottom, - QuickTileMaximize = QuickTileLeft|QuickTileRight|QuickTileTop|QuickTileBottom - }; - Q_DECLARE_FLAGS(QuickTileMode, QuickTileFlag) /** Set the quick tile mode ("snap") of this window. * This will also handle preserving and restoring of window geometry as necessary. * @param mode The tile mode (left/right) to give this window. @@ -1028,11 +1017,11 @@ Layer m_layer = UnknownLayer; // electric border/quick tiling - QuickTileMode m_electricMode = QuickTileNone; + QuickTileMode m_electricMode = QuickTileFlag::None; bool m_electricMaximizing = false; /** The quick tile mode of this window. */ - int m_quickTileMode = QuickTileNone; + int m_quickTileMode = int(QuickTileFlag::None); QTimer *m_electricMaximizingDelay = nullptr; // geometry @@ -1141,6 +1130,5 @@ Q_DECLARE_METATYPE(KWin::AbstractClient*) Q_DECLARE_METATYPE(QList) -Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::AbstractClient::QuickTileMode) #endif diff --git a/abstract_client.cpp b/abstract_client.cpp --- a/abstract_client.cpp +++ b/abstract_client.cpp @@ -1281,7 +1281,7 @@ void AbstractClient::checkQuickTilingMaximizationZones(int xroot, int yroot) { - QuickTileMode mode = QuickTileNone; + QuickTileMode mode = QuickTileFlag::None; bool innerBorder = false; for (int i=0; i < screens()->count(); ++i) { @@ -1302,21 +1302,21 @@ QRect area = workspace()->clientArea(MaximizeArea, QPoint(xroot, yroot), desktop()); if (options->electricBorderTiling()) { if (xroot <= area.x() + 20) { - mode |= QuickTileLeft; + mode |= QuickTileFlag::Left; innerBorder = isInScreen(QPoint(area.x() - 1, yroot)); } else if (xroot >= area.x() + area.width() - 20) { - mode |= QuickTileRight; + mode |= QuickTileFlag::Right; innerBorder = isInScreen(QPoint(area.right() + 1, yroot)); } } - if (mode != QuickTileNone) { + if (mode != QuickTileMode(QuickTileFlag::None)) { if (yroot <= area.y() + area.height() * options->electricBorderCornerRatio()) - mode |= QuickTileTop; + mode |= QuickTileFlag::Top; else if (yroot >= area.y() + area.height() - area.height() * options->electricBorderCornerRatio()) - mode |= QuickTileBottom; + mode |= QuickTileFlag::Bottom; } else if (options->electricBorderMaximize() && yroot <= area.y() + 5 && isMaximizable()) { - mode = QuickTileMaximize; + mode = QuickTileFlag::Maximize; innerBorder = isInScreen(QPoint(xroot, area.y() - 1)); } break; // no point in checking other screens to contain this... "point"... @@ -1330,12 +1330,12 @@ m_electricMaximizingDelay->setSingleShot(true); connect(m_electricMaximizingDelay, &QTimer::timeout, [this]() { if (isMove()) - setElectricBorderMaximizing(electricBorderMode() != QuickTileNone); + setElectricBorderMaximizing(electricBorderMode() != QuickTileMode(QuickTileFlag::None)); }); } m_electricMaximizingDelay->start(); } else { - setElectricBorderMaximizing(mode != QuickTileNone); + setElectricBorderMaximizing(mode != QuickTileMode(QuickTileFlag::None)); } } } diff --git a/autotests/integration/move_resize_window_test.cpp b/autotests/integration/move_resize_window_test.cpp --- a/autotests/integration/move_resize_window_test.cpp +++ b/autotests/integration/move_resize_window_test.cpp @@ -41,7 +41,7 @@ #include #include -Q_DECLARE_METATYPE(KWin::AbstractClient::QuickTileMode) +Q_DECLARE_METATYPE(KWin::QuickTileMode) Q_DECLARE_METATYPE(KWin::MaximizeMode) namespace KWin diff --git a/autotests/integration/quick_tiling_test.cpp b/autotests/integration/quick_tiling_test.cpp --- a/autotests/integration/quick_tiling_test.cpp +++ b/autotests/integration/quick_tiling_test.cpp @@ -44,7 +44,7 @@ #include -Q_DECLARE_METATYPE(KWin::AbstractClient::QuickTileMode) +Q_DECLARE_METATYPE(KWin::QuickTileMode) Q_DECLARE_METATYPE(KWin::MaximizeMode) namespace KWin @@ -125,24 +125,24 @@ void QuickTilingTest::testQuickTiling_data() { - QTest::addColumn("mode"); + QTest::addColumn("mode"); QTest::addColumn("expectedGeometry"); QTest::addColumn("secondScreen"); - QTest::addColumn("expectedModeAfterToggle"); + QTest::addColumn("expectedModeAfterToggle"); -#define FLAG(name) AbstractClient::QuickTileMode(AbstractClient::QuickTile##name) +#define FLAG(name) QuickTileMode(QuickTileFlag::name) QTest::newRow("left") << FLAG(Left) << QRect(0, 0, 640, 1024) << QRect(1280, 0, 640, 1024) << FLAG(Right); QTest::newRow("top") << FLAG(Top) << QRect(0, 0, 1280, 512) << QRect(1280, 0, 1280, 512) << FLAG(Top); - QTest::newRow("right") << FLAG(Right) << QRect(640, 0, 640, 1024) << QRect(1920, 0, 640, 1024) << AbstractClient::QuickTileMode(); + QTest::newRow("right") << FLAG(Right) << QRect(640, 0, 640, 1024) << QRect(1920, 0, 640, 1024) << QuickTileMode(); QTest::newRow("bottom") << FLAG(Bottom) << QRect(0, 512, 1280, 512) << QRect(1280, 512, 1280, 512) << FLAG(Bottom); QTest::newRow("top left") << (FLAG(Left) | FLAG(Top)) << QRect(0, 0, 640, 512) << QRect(1280, 0, 640, 512) << (FLAG(Right) | FLAG(Top)); - QTest::newRow("top right") << (FLAG(Right) | FLAG(Top)) << QRect(640, 0, 640, 512) << QRect(1920, 0, 640, 512) << AbstractClient::QuickTileMode(); + QTest::newRow("top right") << (FLAG(Right) | FLAG(Top)) << QRect(640, 0, 640, 512) << QRect(1920, 0, 640, 512) << QuickTileMode(); QTest::newRow("bottom left") << (FLAG(Left) | FLAG(Bottom)) << QRect(0, 512, 640, 512) << QRect(1280, 512, 640, 512) << (FLAG(Right) | FLAG(Bottom)); - QTest::newRow("bottom right") << (FLAG(Right) | FLAG(Bottom)) << QRect(640, 512, 640, 512) << QRect(1920, 512, 640, 512) << AbstractClient::QuickTileMode(); + QTest::newRow("bottom right") << (FLAG(Right) | FLAG(Bottom)) << QRect(640, 512, 640, 512) << QRect(1920, 512, 640, 512) << QuickTileMode(); - QTest::newRow("maximize") << FLAG(Maximize) << QRect(0, 0, 1280, 1024) << QRect(1280, 0, 1280, 1024) << AbstractClient::QuickTileMode(); + QTest::newRow("maximize") << FLAG(Maximize) << QRect(0, 0, 1280, 1024) << QRect(1280, 0, 1280, 1024) << QuickTileMode(); #undef FLAG } @@ -164,13 +164,13 @@ QVERIFY(c); QCOMPARE(workspace()->activeClient(), c); QCOMPARE(c->geometry(), QRect(0, 0, 100, 50)); - QCOMPARE(c->quickTileMode(), AbstractClient::QuickTileNone); + QCOMPARE(c->quickTileMode(), QuickTileMode(QuickTileFlag::None)); QSignalSpy quickTileChangedSpy(c, &AbstractClient::quickTileModeChanged); QVERIFY(quickTileChangedSpy.isValid()); QSignalSpy geometryChangedSpy(c, &AbstractClient::geometryChanged); QVERIFY(geometryChangedSpy.isValid()); - QFETCH(AbstractClient::QuickTileMode, mode); + QFETCH(QuickTileMode, mode); QFETCH(QRect, expectedGeometry); c->setQuickTileMode(mode, true); QCOMPARE(quickTileChangedSpy.count(), 1); @@ -208,9 +208,9 @@ void QuickTilingTest::testQuickMaximizing_data() { - QTest::addColumn("mode"); + QTest::addColumn("mode"); -#define FLAG(name) AbstractClient::QuickTileMode(AbstractClient::QuickTile##name) +#define FLAG(name) QuickTileMode(QuickTileFlag::name) QTest::newRow("maximize") << FLAG(Maximize); QTest::newRow("none") << FLAG(None); @@ -235,7 +235,7 @@ QVERIFY(c); QCOMPARE(workspace()->activeClient(), c); QCOMPARE(c->geometry(), QRect(0, 0, 100, 50)); - QCOMPARE(c->quickTileMode(), AbstractClient::QuickTileNone); + QCOMPARE(c->quickTileMode(), QuickTileMode(QuickTileFlag::None)); QCOMPARE(c->maximizeMode(), MaximizeRestore); QSignalSpy quickTileChangedSpy(c, &AbstractClient::quickTileModeChanged); QVERIFY(quickTileChangedSpy.isValid()); @@ -246,7 +246,7 @@ QSignalSpy maximizeChangedSpy2(c, SIGNAL(clientMaximizedStateChanged(KWin::AbstractClient*,bool,bool))); QVERIFY(maximizeChangedSpy2.isValid()); - c->setQuickTileMode(AbstractClient::QuickTileMaximize, true); + c->setQuickTileMode(QuickTileFlag::Maximize, true); QCOMPARE(quickTileChangedSpy.count(), 1); QCOMPARE(maximizeChangedSpy1.count(), 1); QCOMPARE(maximizeChangedSpy1.first().first().value(), c); @@ -258,7 +258,7 @@ // at this point the geometry did not yet change QCOMPARE(c->geometry(), QRect(0, 0, 100, 50)); // but quick tile mode already changed - QCOMPARE(c->quickTileMode(), AbstractClient::QuickTileMaximize); + QCOMPARE(c->quickTileMode(), QuickTileFlag::Maximize); QCOMPARE(c->maximizeMode(), MaximizeFull); QCOMPARE(c->geometryRestore(), QRect(0, 0, 100, 50)); @@ -277,7 +277,7 @@ QCOMPARE(c->geometryRestore(), QRect(0, 0, 100, 50)); // go back to quick tile none - QFETCH(AbstractClient::QuickTileMode, mode); + QFETCH(QuickTileMode, mode); c->setQuickTileMode(mode, true); QCOMPARE(quickTileChangedSpy.count(), 2); QCOMPARE(maximizeChangedSpy1.count(), 2); @@ -287,7 +287,7 @@ QCOMPARE(maximizeChangedSpy2.last().first().value(), c); QCOMPARE(maximizeChangedSpy2.last().at(1).toBool(), false); QCOMPARE(maximizeChangedSpy2.last().at(2).toBool(), false); - QCOMPARE(c->quickTileMode(), AbstractClient::QuickTileNone); + QCOMPARE(c->quickTileMode(), QuickTileMode(QuickTileFlag::None)); QCOMPARE(c->maximizeMode(), MaximizeRestore); // geometry not yet changed QCOMPARE(c->geometry(), QRect(0, 0, 1280, 1024)); @@ -310,14 +310,14 @@ void QuickTilingTest::testQuickTilingKeyboardMove_data() { QTest::addColumn("targetPos"); - QTest::addColumn("expectedMode"); - - QTest::newRow("topRight") << QPoint(2559, 24) << AbstractClient::QuickTileMode(AbstractClient::QuickTileTop | AbstractClient::QuickTileRight); - QTest::newRow("right") << QPoint(2559, 512) << AbstractClient::QuickTileMode(AbstractClient::QuickTileRight); - QTest::newRow("bottomRight") << QPoint(2559, 1023) << AbstractClient::QuickTileMode(AbstractClient::QuickTileBottom | AbstractClient::QuickTileRight); - QTest::newRow("bottomLeft") << QPoint(0, 1023) << AbstractClient::QuickTileMode(AbstractClient::QuickTileBottom | AbstractClient::QuickTileLeft); - QTest::newRow("Left") << QPoint(0, 512) << AbstractClient::QuickTileMode(AbstractClient::QuickTileLeft); - QTest::newRow("topLeft") << QPoint(0, 24) << AbstractClient::QuickTileMode(AbstractClient::QuickTileTop | AbstractClient::QuickTileLeft); + QTest::addColumn("expectedMode"); + + QTest::newRow("topRight") << QPoint(2559, 24) << QuickTileMode(QuickTileFlag::Top | QuickTileFlag::Right); + QTest::newRow("right") << QPoint(2559, 512) << QuickTileMode(QuickTileFlag::Right); + QTest::newRow("bottomRight") << QPoint(2559, 1023) << QuickTileMode(QuickTileFlag::Bottom | QuickTileFlag::Right); + QTest::newRow("bottomLeft") << QPoint(0, 1023) << QuickTileMode(QuickTileFlag::Bottom | QuickTileFlag::Left); + QTest::newRow("Left") << QPoint(0, 512) << QuickTileMode(QuickTileFlag::Left); + QTest::newRow("topLeft") << QPoint(0, 24) << QuickTileMode(QuickTileFlag::Top | QuickTileFlag::Left); } void QuickTilingTest::testQuickTilingKeyboardMove() @@ -337,7 +337,7 @@ QVERIFY(c); QCOMPARE(workspace()->activeClient(), c); QCOMPARE(c->geometry(), QRect(0, 0, 100, 50)); - QCOMPARE(c->quickTileMode(), AbstractClient::QuickTileNone); + QCOMPARE(c->quickTileMode(), QuickTileMode(QuickTileFlag::None)); QCOMPARE(c->maximizeMode(), MaximizeRestore); QSignalSpy quickTileChangedSpy(c, &AbstractClient::quickTileModeChanged); @@ -381,14 +381,14 @@ void QuickTilingTest::testQuickTilingPointerMove_data() { QTest::addColumn("targetPos"); - QTest::addColumn("expectedMode"); - - QTest::newRow("topRight") << QPoint(2559, 24) << AbstractClient::QuickTileMode(AbstractClient::QuickTileTop | AbstractClient::QuickTileRight); - QTest::newRow("right") << QPoint(2559, 512) << AbstractClient::QuickTileMode(AbstractClient::QuickTileRight); - QTest::newRow("bottomRight") << QPoint(2559, 1023) << AbstractClient::QuickTileMode(AbstractClient::QuickTileBottom | AbstractClient::QuickTileRight); - QTest::newRow("bottomLeft") << QPoint(0, 1023) << AbstractClient::QuickTileMode(AbstractClient::QuickTileBottom | AbstractClient::QuickTileLeft); - QTest::newRow("Left") << QPoint(0, 512) << AbstractClient::QuickTileMode(AbstractClient::QuickTileLeft); - QTest::newRow("topLeft") << QPoint(0, 24) << AbstractClient::QuickTileMode(AbstractClient::QuickTileTop | AbstractClient::QuickTileLeft); + QTest::addColumn("expectedMode"); + + QTest::newRow("topRight") << QPoint(2559, 24) << QuickTileMode(QuickTileFlag::Top | QuickTileFlag::Right); + QTest::newRow("right") << QPoint(2559, 512) << QuickTileMode(QuickTileFlag::Right); + QTest::newRow("bottomRight") << QPoint(2559, 1023) << QuickTileMode(QuickTileFlag::Bottom | QuickTileFlag::Right); + QTest::newRow("bottomLeft") << QPoint(0, 1023) << QuickTileMode(QuickTileFlag::Bottom | QuickTileFlag::Left); + QTest::newRow("Left") << QPoint(0, 512) << QuickTileMode(QuickTileFlag::Left); + QTest::newRow("topLeft") << QPoint(0, 24) << QuickTileMode(QuickTileFlag::Top | QuickTileFlag::Left); } void QuickTilingTest::testQuickTilingPointerMove() @@ -408,7 +408,7 @@ QVERIFY(c); QCOMPARE(workspace()->activeClient(), c); QCOMPARE(c->geometry(), QRect(0, 0, 100, 50)); - QCOMPARE(c->quickTileMode(), AbstractClient::QuickTileNone); + QCOMPARE(c->quickTileMode(), QuickTileMode(QuickTileFlag::None)); QCOMPARE(c->maximizeMode(), MaximizeRestore); QSignalSpy quickTileChangedSpy(c, &AbstractClient::quickTileModeChanged); @@ -440,24 +440,24 @@ void QuickTilingTest::testX11QuickTiling_data() { - QTest::addColumn("mode"); + QTest::addColumn("mode"); QTest::addColumn("expectedGeometry"); QTest::addColumn("screen"); - QTest::addColumn("modeAfterToggle"); + QTest::addColumn("modeAfterToggle"); -#define FLAG(name) AbstractClient::QuickTileMode(AbstractClient::QuickTile##name) +#define FLAG(name) QuickTileMode(QuickTileFlag::name) - QTest::newRow("left") << FLAG(Left) << QRect(0, 0, 640, 1024) << 0 << AbstractClient::QuickTileMode(); + QTest::newRow("left") << FLAG(Left) << QRect(0, 0, 640, 1024) << 0 << QuickTileMode(); QTest::newRow("top") << FLAG(Top) << QRect(0, 0, 1280, 512) << 1 << FLAG(Top); QTest::newRow("right") << FLAG(Right) << QRect(640, 0, 640, 1024) << 1 << FLAG(Left); QTest::newRow("bottom") << FLAG(Bottom) << QRect(0, 512, 1280, 512) << 1 << FLAG(Bottom); - QTest::newRow("top left") << (FLAG(Left) | FLAG(Top)) << QRect(0, 0, 640, 512) << 0 << AbstractClient::QuickTileMode(); + QTest::newRow("top left") << (FLAG(Left) | FLAG(Top)) << QRect(0, 0, 640, 512) << 0 << QuickTileMode(); QTest::newRow("top right") << (FLAG(Right) | FLAG(Top)) << QRect(640, 0, 640, 512) << 1 << (FLAG(Left) | FLAG(Top)); - QTest::newRow("bottom left") << (FLAG(Left) | FLAG(Bottom)) << QRect(0, 512, 640, 512) << 0 << AbstractClient::QuickTileMode(); + QTest::newRow("bottom left") << (FLAG(Left) | FLAG(Bottom)) << QRect(0, 512, 640, 512) << 0 << QuickTileMode(); QTest::newRow("bottom right") << (FLAG(Right) | FLAG(Bottom)) << QRect(640, 512, 640, 512) << 1 << (FLAG(Left) | FLAG(Bottom)); - QTest::newRow("maximize") << FLAG(Maximize) << QRect(0, 0, 1280, 1024) << 0 << AbstractClient::QuickTileMode(); + QTest::newRow("maximize") << FLAG(Maximize) << QRect(0, 0, 1280, 1024) << 0 << QuickTileMode(); #undef FLAG } @@ -493,7 +493,7 @@ QSignalSpy quickTileChangedSpy(client, &AbstractClient::quickTileModeChanged); QVERIFY(quickTileChangedSpy.isValid()); const QRect origGeo = client->geometry(); - QFETCH(AbstractClient::QuickTileMode, mode); + QFETCH(QuickTileMode, mode); client->setQuickTileMode(mode, true); QCOMPARE(client->quickTileMode(), mode); QTEST(client->geometry(), "expectedGeometry"); @@ -521,10 +521,10 @@ void QuickTilingTest::testX11QuickTilingAfterVertMaximize_data() { - QTest::addColumn("mode"); + QTest::addColumn("mode"); QTest::addColumn("expectedGeometry"); -#define FLAG(name) AbstractClient::QuickTileMode(AbstractClient::QuickTile##name) +#define FLAG(name) QuickTileMode(QuickTileFlag::name) QTest::newRow("left") << FLAG(Left) << QRect(0, 0, 640, 1024); QTest::newRow("top") << FLAG(Top) << QRect(0, 0, 1280, 512); @@ -580,7 +580,7 @@ // now quick tile QSignalSpy quickTileChangedSpy(client, &AbstractClient::quickTileModeChanged); QVERIFY(quickTileChangedSpy.isValid()); - QFETCH(AbstractClient::QuickTileMode, mode); + QFETCH(QuickTileMode, mode); client->setQuickTileMode(mode, true); QEXPECT_FAIL("left", "Quick tiling not working", Continue); QEXPECT_FAIL("right", "Quick tiling not working", Continue); @@ -617,10 +617,10 @@ void QuickTilingTest::testShortcut_data() { QTest::addColumn("shortcut"); - QTest::addColumn("expectedMode"); + QTest::addColumn("expectedMode"); QTest::addColumn("expectedGeometry"); -#define FLAG(name) AbstractClient::QuickTileMode(AbstractClient::QuickTile##name) +#define FLAG(name) QuickTileMode(QuickTileFlag::name) QTest::newRow("top") << QStringLiteral("Window Quick Tile Top") << FLAG(Top) << QRect(0, 0, 1280, 512); QTest::newRow("left") << QStringLiteral("Window Quick Tile Left") << FLAG(Left) << QRect(0, 0, 640, 1024); QTest::newRow("bottom") << QStringLiteral("Window Quick Tile Bottom") << FLAG(Bottom) << QRect(0, 512, 1280, 512); @@ -651,14 +651,14 @@ QVERIFY(c); QCOMPARE(workspace()->activeClient(), c); QCOMPARE(c->geometry(), QRect(0, 0, 100, 50)); - QCOMPARE(c->quickTileMode(), AbstractClient::QuickTileNone); + QCOMPARE(c->quickTileMode(), QuickTileMode(QuickTileFlag::None)); QSignalSpy quickTileChangedSpy(c, &AbstractClient::quickTileModeChanged); QVERIFY(quickTileChangedSpy.isValid()); QSignalSpy geometryChangedSpy(c, &AbstractClient::geometryChanged); QVERIFY(geometryChangedSpy.isValid()); QFETCH(QString, shortcut); - QFETCH(AbstractClient::QuickTileMode, expectedMode); + QFETCH(QuickTileMode, expectedMode); QFETCH(QRect, expectedGeometry); // invoke global shortcut through dbus @@ -695,10 +695,10 @@ void QuickTilingTest::testScript_data() { QTest::addColumn("action"); - QTest::addColumn("expectedMode"); + QTest::addColumn("expectedMode"); QTest::addColumn("expectedGeometry"); -#define FLAG(name) AbstractClient::QuickTileMode(AbstractClient::QuickTile##name) +#define FLAG(name) QuickTileMode(QuickTileFlag::name) QTest::newRow("top") << QStringLiteral("Top") << FLAG(Top) << QRect(0, 0, 1280, 512); QTest::newRow("left") << QStringLiteral("Left") << FLAG(Left) << QRect(0, 0, 640, 1024); QTest::newRow("bottom") << QStringLiteral("Bottom") << FLAG(Bottom) << QRect(0, 512, 1280, 512); @@ -729,7 +729,7 @@ QVERIFY(c); QCOMPARE(workspace()->activeClient(), c); QCOMPARE(c->geometry(), QRect(0, 0, 100, 50)); - QCOMPARE(c->quickTileMode(), AbstractClient::QuickTileNone); + QCOMPARE(c->quickTileMode(), QuickTileMode(QuickTileFlag::None)); QSignalSpy quickTileChangedSpy(c, &AbstractClient::quickTileModeChanged); QVERIFY(quickTileChangedSpy.isValid()); QSignalSpy geometryChangedSpy(c, &AbstractClient::geometryChanged); @@ -744,7 +744,7 @@ out << "workspace.slotWindowQuickTile" << action << "()"; out.flush(); - QFETCH(AbstractClient::QuickTileMode, expectedMode); + QFETCH(QuickTileMode, expectedMode); QFETCH(QRect, expectedGeometry); const int id = Scripting::self()->loadScript(tmpFile.fileName()); diff --git a/client.cpp b/client.cpp --- a/client.cpp +++ b/client.cpp @@ -1585,9 +1585,9 @@ setClientShown(!(isMinimized() || isShade())); bool keepSize = toGeometry.size() == size(); bool changedSize = false; - if (quickTileMode() != QuickTileNone) { + if (quickTileMode() != QuickTileMode(QuickTileFlag::None)) { changedSize = true; - setQuickTileMode(QuickTileNone); // if we leave a quicktiled group, assume that the user wants to untile + setQuickTileMode(QuickTileFlag::None); // if we leave a quicktiled group, assume that the user wants to untile } if (toGeometry.isValid()) { if (maximizeMode() != MaximizeRestore) { diff --git a/decorations/decoratedclient.cpp b/decorations/decoratedclient.cpp --- a/decorations/decoratedclient.cpp +++ b/decorations/decoratedclient.cpp @@ -254,25 +254,25 @@ Qt::Edges DecoratedClientImpl::adjacentScreenEdges() const { Qt::Edges edges; - const AbstractClient::QuickTileMode mode = m_client->quickTileMode(); - if (mode.testFlag(AbstractClient::QuickTileLeft)) { + const QuickTileMode mode = m_client->quickTileMode(); + if (mode.testFlag(QuickTileFlag::Left)) { edges |= Qt::LeftEdge; - if (!mode.testFlag(AbstractClient::QuickTileTop) && !mode.testFlag(AbstractClient::QuickTileBottom)) { + if (!mode.testFlag(QuickTileFlag::Top) && !mode.testFlag(QuickTileFlag::Bottom)) { // using complete side edges |= Qt::TopEdge | Qt::BottomEdge; } } - if (mode.testFlag(AbstractClient::QuickTileTop)) { + if (mode.testFlag(QuickTileFlag::Top)) { edges |= Qt::TopEdge; } - if (mode.testFlag(AbstractClient::QuickTileRight)) { + if (mode.testFlag(QuickTileFlag::Right)) { edges |= Qt::RightEdge; - if (!mode.testFlag(AbstractClient::QuickTileTop) && !mode.testFlag(AbstractClient::QuickTileBottom)) { + if (!mode.testFlag(QuickTileFlag::Top) && !mode.testFlag(QuickTileFlag::Bottom)) { // using complete side edges |= Qt::TopEdge | Qt::BottomEdge; } } - if (mode.testFlag(AbstractClient::QuickTileBottom)) { + if (mode.testFlag(QuickTileFlag::Bottom)) { edges |= Qt::BottomEdge; } return edges; diff --git a/geometry.cpp b/geometry.cpp --- a/geometry.cpp +++ b/geometry.cpp @@ -1125,7 +1125,7 @@ return; } - if (quickTileMode() != QuickTileNone) { + if (quickTileMode() != QuickTileMode(QuickTileFlag::None)) { setGeometry(electricBorderMaximizeGeometry(geometry().center(), desktop())); return; } @@ -1677,14 +1677,14 @@ bool(maximizeMode() & MaximizeHorizontal); // we want to (partially) ignore the request when the window is somehow maximized or quicktiled - bool ignore = !app_noborder && (quickTileMode() != QuickTileNone || maximizeMode() != MaximizeRestore); + bool ignore = !app_noborder && (quickTileMode() != QuickTileMode(QuickTileFlag::None) || maximizeMode() != MaximizeRestore); // however, the user shall be able to force obedience despite and also disobedience in general ignore = rules()->checkIgnoreGeometry(ignore); if (!ignore) { // either we're not max'd / q'tiled or the user allowed the client to break that - so break it. - updateQuickTileMode(QuickTileNone); + updateQuickTileMode(QuickTileFlag::None); max_mode = MaximizeRestore; emit quickTileModeChanged(); - } else if (!app_noborder && quickTileMode() == QuickTileNone && + } else if (!app_noborder && quickTileMode() == QuickTileMode(QuickTileFlag::None) && (maximizeMode() == MaximizeVertical || maximizeMode() == MaximizeHorizontal)) { // ignoring can be, because either we do, or the user does explicitly not want it. // for partially maximized windows we want to allow configures in the other dimension. @@ -2281,7 +2281,7 @@ else sz = size(); - if (quickTileMode() == QuickTileNone) { + if (quickTileMode() == QuickTileMode(QuickTileFlag::None)) { if (!adjust && !(old_mode & MaximizeVertical)) { geom_restore.setTop(y()); geom_restore.setHeight(sz.height()); @@ -2319,16 +2319,16 @@ const ForceGeometry_t geom_mode = isDecorated() ? ForceGeometrySet : NormalGeometrySet; // Conditional quick tiling exit points - if (quickTileMode() != QuickTileNone) { + if (quickTileMode() != QuickTileMode(QuickTileFlag::None)) { if (old_mode == MaximizeFull && !clientArea.contains(geom_restore.center())) { // Not restoring on the same screen // TODO: The following doesn't work for some reason - //quick_tile_mode = QuickTileNone; // And exit quick tile mode manually + //quick_tile_mode = QuickTileFlag::None; // And exit quick tile mode manually } else if ((old_mode == MaximizeVertical && max_mode == MaximizeRestore) || (old_mode == MaximizeFull && max_mode == MaximizeHorizontal)) { // Modifying geometry of a tiled window - updateQuickTileMode(QuickTileNone); // Exit quick tile mode without restoring geometry + updateQuickTileMode(QuickTileFlag::None); // Exit quick tile mode without restoring geometry } } @@ -2407,7 +2407,7 @@ if (!clientArea.contains(geom_restore.center())) // Not restoring to the same screen Placement::self()->place(this, clientArea); info->setState(0, NET::Max); - updateQuickTileMode(QuickTileNone); + updateQuickTileMode(QuickTileFlag::None); break; } @@ -2455,9 +2455,9 @@ } setGeometry(r, geom_mode); if (options->electricBorderMaximize() && r.top() == clientArea.top()) - updateQuickTileMode(QuickTileMaximize); + updateQuickTileMode(QuickTileFlag::Maximize); else - updateQuickTileMode(QuickTileNone); + updateQuickTileMode(QuickTileFlag::None); info->setState(NET::Max, NET::Max); break; } @@ -2688,9 +2688,9 @@ } } - if (quickTileMode() != QuickTileNone && mode != PositionCenter) { // Cannot use isResize() yet + if (quickTileMode() != QuickTileMode(QuickTileFlag::None) && mode != PositionCenter) { // Cannot use isResize() yet // Exit quick tile mode when the user attempts to resize a tiled window - updateQuickTileMode(QuickTileNone); // Do so without restoring original geometry + updateQuickTileMode(QuickTileFlag::None); // Do so without restoring original geometry setGeometryRestore(geometry()); emit quickTileModeChanged(); } @@ -2881,16 +2881,16 @@ const QRect oldGeo = geometry(); handleMoveResize(local.x(), local.y(), global.x(), global.y()); if (!isFullScreen() && isMove()) { - if (quickTileMode() != QuickTileNone && oldGeo != geometry()) { + if (quickTileMode() != QuickTileMode(QuickTileFlag::None) && oldGeo != geometry()) { GeometryUpdatesBlocker blocker(this); - setQuickTileMode(QuickTileNone); + setQuickTileMode(QuickTileFlag::None); const QRect &geom_restore = geometryRestore(); setMoveOffset(QPoint(double(moveOffset().x()) / double(oldGeo.width()) * double(geom_restore.width()), double(moveOffset().y()) / double(oldGeo.height()) * double(geom_restore.height()))); if (rules()->checkMaximize(MaximizeRestore) == MaximizeRestore) setMoveResizeGeometry(geom_restore); handleMoveResize(local.x(), local.y(), global.x(), global.y()); // fix position - } else if (quickTileMode() == QuickTileNone && isResizable()) { + } else if (quickTileMode() == QuickTileMode(QuickTileFlag::None) && isResizable()) { checkQuickTilingMaximizationZones(global.x(), global.y()); } } @@ -3262,12 +3262,12 @@ void AbstractClient::setElectricBorderMode(QuickTileMode mode) { - if (mode != QuickTileMaximize) { + if (mode != QuickTileMode(QuickTileFlag::Maximize)) { // sanitize the mode, ie. simplify "invalid" combinations - if ((mode & QuickTileHorizontal) == QuickTileHorizontal) - mode &= ~QuickTileHorizontal; - if ((mode & QuickTileVertical) == QuickTileVertical) - mode &= ~QuickTileVertical; + if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Horizontal)) + mode &= ~QuickTileMode(QuickTileFlag::Horizontal); + if ((mode & QuickTileFlag::Vertical) == QuickTileMode(QuickTileFlag::Vertical)) + mode &= ~QuickTileMode(QuickTileFlag::Vertical); } m_electricMode = mode; } @@ -3284,21 +3284,21 @@ QRect AbstractClient::electricBorderMaximizeGeometry(QPoint pos, int desktop) { - if (electricBorderMode() == QuickTileMaximize) { + if (electricBorderMode() == QuickTileMode(QuickTileFlag::Maximize)) { if (maximizeMode() == MaximizeFull) return geometryRestore(); else return workspace()->clientArea(MaximizeArea, pos, desktop); } QRect ret = workspace()->clientArea(MaximizeArea, pos, desktop); - if (electricBorderMode() & QuickTileLeft) + if (electricBorderMode() & QuickTileFlag::Left) ret.setRight(ret.left()+ret.width()/2 - 1); - else if (electricBorderMode() & QuickTileRight) + else if (electricBorderMode() & QuickTileFlag::Right) ret.setLeft(ret.right()-(ret.width()-ret.width()/2) + 1); - if (electricBorderMode() & QuickTileTop) + if (electricBorderMode() & QuickTileFlag::Top) ret.setBottom(ret.top()+ret.height()/2 - 1); - else if (electricBorderMode() & QuickTileBottom) + else if (electricBorderMode() & QuickTileFlag::Bottom) ret.setTop(ret.bottom()-(ret.height()-ret.height()/2) + 1); return ret; @@ -3314,14 +3314,14 @@ GeometryUpdatesBlocker blocker(this); - if (mode == QuickTileMaximize) { + if (mode == QuickTileMode(QuickTileFlag::Maximize)) { TabSynchronizer syncer(this, TabGroup::QuickTile|TabGroup::Geometry|TabGroup::Maximized); - m_quickTileMode = QuickTileNone; + m_quickTileMode = int(QuickTileFlag::None); if (maximizeMode() == MaximizeFull) { setMaximize(false, false); } else { QRect prev_geom_restore = geometryRestore(); // setMaximize() would set moveResizeGeom as geom_restore - m_quickTileMode = QuickTileMaximize; + m_quickTileMode = int(QuickTileFlag::Maximize); setMaximize(true, true); QRect clientArea = workspace()->clientArea(MaximizeArea, this); if (geometry().top() != clientArea.top()) { @@ -3336,23 +3336,23 @@ } // sanitize the mode, ie. simplify "invalid" combinations - if ((mode & QuickTileHorizontal) == QuickTileHorizontal) - mode &= ~QuickTileHorizontal; - if ((mode & QuickTileVertical) == QuickTileVertical) - mode &= ~QuickTileVertical; + if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Horizontal)) + mode &= ~QuickTileMode(QuickTileFlag::Horizontal); + if ((mode & QuickTileFlag::Vertical) == QuickTileMode(QuickTileFlag::Vertical)) + mode &= ~QuickTileMode(QuickTileFlag::Vertical); setElectricBorderMode(mode); // used by ::electricBorderMaximizeGeometry(.) // restore from maximized so that it is possible to tile maximized windows with one hit or by dragging if (maximizeMode() != MaximizeRestore) { TabSynchronizer syncer(this, TabGroup::QuickTile|TabGroup::Geometry|TabGroup::Maximized); - if (mode != QuickTileNone) { + if (mode != QuickTileMode(QuickTileFlag::None)) { m_quickTileMode = mode; // decorations may turn off some borders when tiled const ForceGeometry_t geom_mode = isDecorated() ? ForceGeometrySet : NormalGeometrySet; - m_quickTileMode = QuickTileNone; // Temporary, so the maximize code doesn't get all confused + m_quickTileMode = int(QuickTileFlag::None); // Temporary, so the maximize code doesn't get all confused setGeometry(electricBorderMaximizeGeometry(keyboard ? geometry().center() : Cursor::pos(), desktop()), geom_mode); } // Store the mode change @@ -3365,13 +3365,13 @@ return; } - if (mode != QuickTileNone) { + if (mode != QuickTileMode(QuickTileFlag::None)) { TabSynchronizer syncer(this, TabGroup::QuickTile|TabGroup::Geometry); QPoint whichScreen = keyboard ? geometry().center() : Cursor::pos(); // If trying to tile to the side that the window is already tiled to move the window to the next - // screen if it exists, otherwise toggle the mode (set QuickTileNone) + // screen if it exists, otherwise toggle the mode (set QuickTileFlag::None) if (quickTileMode() == mode) { const int numScreens = screens()->count(); const int curScreen = screen(); @@ -3388,53 +3388,53 @@ continue; // not in horizontal line const int x = screens[i].center().x(); - if ((mode & QuickTileHorizontal) == QuickTileLeft) { + if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Left)) { if (x >= screens[curScreen].center().x() || (curScreen != nextScreen && x <= screens[nextScreen].center().x())) continue; // not left of current or more left then found next - } else if ((mode & QuickTileHorizontal) == QuickTileRight) { + } else if ((mode & QuickTileFlag::Horizontal) == QuickTileMode(QuickTileFlag::Right)) { if (x <= screens[curScreen].center().x() || (curScreen != nextScreen && x >= screens[nextScreen].center().x())) continue; // not right of current or more right then found next } nextScreen = i; } if (nextScreen == curScreen) { - mode = QuickTileNone; // No other screens, toggle tiling + mode = QuickTileFlag::None; // No other screens, toggle tiling } else { // Move to other screen setGeometry(geometryRestore().translated(screens[nextScreen].topLeft() - screens[curScreen].topLeft())); whichScreen = screens[nextScreen].center(); // Swap sides - if (mode & QuickTileHorizontal) { - mode = (~mode & QuickTileHorizontal) | (mode & QuickTileVertical); + if (mode & QuickTileFlag::Horizontal) { + mode = (~mode & QuickTileFlag::Horizontal) | (mode & QuickTileFlag::Vertical); } } setElectricBorderMode(mode); // used by ::electricBorderMaximizeGeometry(.) - } else if (quickTileMode() == QuickTileNone) { + } else if (quickTileMode() == QuickTileMode(QuickTileFlag::None)) { // Not coming out of an existing tile, not shifting monitors, we're setting a brand new tile. // Store geometry first, so we can go out of this tile later. setGeometryRestore(geometry()); } - if (mode != QuickTileNone) { + if (mode != QuickTileMode(QuickTileFlag::None)) { m_quickTileMode = mode; // decorations may turn off some borders when tiled const ForceGeometry_t geom_mode = isDecorated() ? ForceGeometrySet : NormalGeometrySet; // Temporary, so the maximize code doesn't get all confused - m_quickTileMode = QuickTileNone; + m_quickTileMode = int(QuickTileFlag::None); setGeometry(electricBorderMaximizeGeometry(whichScreen, desktop()), geom_mode); } // Store the mode change m_quickTileMode = mode; } - if (mode == QuickTileNone) { + if (mode == QuickTileMode(QuickTileFlag::None)) { TabSynchronizer syncer(this, TabGroup::QuickTile|TabGroup::Geometry); - m_quickTileMode = QuickTileNone; + m_quickTileMode = int(QuickTileFlag::None); // Untiling, so just restore geometry, and we're done. if (!geometryRestore().isValid()) // invalid if we started maximized and wait for placement setGeometryRestore(geometry()); @@ -3469,16 +3469,16 @@ QuickTileMode qtMode = quickTileMode(); if (maxMode != MaximizeRestore) maximize(MaximizeRestore); - if (qtMode != QuickTileNone) - setQuickTileMode(QuickTileNone, true); + if (qtMode != QuickTileMode(QuickTileFlag::None)) + setQuickTileMode(QuickTileFlag::None, true); QRect oldScreenArea = workspace()->clientArea(MaximizeArea, this); QRect screenArea = workspace()->clientArea(MaximizeArea, newScreen, desktop()); // the window can have its center so that the position correction moves the new center onto // the old screen, what will tile it where it is. Ie. the screen is not changed // this happens esp. with electric border quicktiling - if (qtMode != QuickTileNone) + if (qtMode != QuickTileMode(QuickTileFlag::None)) keepInArea(oldScreenArea); QRect oldGeom = geometry(); @@ -3509,11 +3509,11 @@ setGeometryRestore(geometry()); // finally reset special states - // NOTICE that MaximizeRestore/QuickTileNone checks are required. - // eg. setting QuickTileNone would break maximization + // NOTICE that MaximizeRestore/QuickTileFlag::None checks are required. + // eg. setting QuickTileFlag::None would break maximization if (maxMode != MaximizeRestore) maximize(maxMode); - if (qtMode != QuickTileNone && qtMode != quickTileMode()) + if (qtMode != QuickTileMode(QuickTileFlag::None) && qtMode != quickTileMode()) setQuickTileMode(qtMode, true); auto tso = workspace()->ensureStackingOrder(transients()); diff --git a/input.h b/input.h --- a/input.h +++ b/input.h @@ -104,8 +104,8 @@ * to the @p slot being invoked. If not using this overload it's required to ensure that * registerShortcut is called before connecting to QAction's triggered signal. **/ - template - void registerShortcut(const QKeySequence &shortcut, QAction *action, T *receiver, void (T::*slot)()); + template + void registerShortcut(const QKeySequence &shortcut, QAction *action, T *receiver, Slot slot); void registerPointerShortcut(Qt::KeyboardModifiers modifiers, Qt::MouseButton pointerButtons, QAction *action); void registerAxisShortcut(Qt::KeyboardModifiers modifiers, PointerAxisDirection axis, QAction *action); void registerTouchpadSwipeShortcut(SwipeDirection direction, QAction *action); @@ -406,9 +406,9 @@ return InputRedirection::s_self; } -template +template inline -void InputRedirection::registerShortcut(const QKeySequence &shortcut, QAction *action, T *receiver, void (T::*slot)()) { +void InputRedirection::registerShortcut(const QKeySequence &shortcut, QAction *action, T *receiver, Slot slot) { registerShortcut(shortcut, action); connect(action, &QAction::triggered, receiver, slot); } diff --git a/kwinbindings.cpp b/kwinbindings.cpp --- a/kwinbindings.cpp +++ b/kwinbindings.cpp @@ -36,6 +36,9 @@ #define DEF3( name, key, fnSlot, value ) \ initShortcut(QStringLiteral(name).arg(value), i18n(name, value), key, &Workspace::fnSlot, value); +#define DEF4( name, descr, key, functor ) \ + initShortcut(QStringLiteral(name), i18n(descr), key, functor); + DEF(I18N_NOOP("Walk Through Window Tabs"), 0, slotActivateNextTab); DEF(I18N_NOOP("Walk Through Window Tabs (Reverse)"), 0, slotActivatePrevTab); @@ -93,22 +96,22 @@ 0, slotWindowShrinkHorizontal); DEF2("Window Shrink Vertical", I18N_NOOP("Pack Shrink Window Vertically"), 0, slotWindowShrinkVertical); -DEF2("Window Quick Tile Left", I18N_NOOP("Quick Tile Window to the Left"), - 0, slotWindowQuickTileLeft); -DEF2("Window Quick Tile Right", I18N_NOOP("Quick Tile Window to the Right"), - 0, slotWindowQuickTileRight); -DEF2("Window Quick Tile Top", I18N_NOOP("Quick Tile Window to the Top"), - 0, slotWindowQuickTileTop); -DEF2("Window Quick Tile Bottom", I18N_NOOP("Quick Tile Window to the Bottom"), - 0, slotWindowQuickTileBottom); -DEF2("Window Quick Tile Top Left", I18N_NOOP("Quick Tile Window to the Top Left"), - 0, slotWindowQuickTileTopLeft); -DEF2("Window Quick Tile Bottom Left", I18N_NOOP("Quick Tile Window to the Bottom Left"), - 0, slotWindowQuickTileBottomLeft); -DEF2("Window Quick Tile Top Right", I18N_NOOP("Quick Tile Window to the Top Right"), - 0, slotWindowQuickTileTopRight); -DEF2("Window Quick Tile Bottom Right", I18N_NOOP("Quick Tile Window to the Bottom Right"), - 0, slotWindowQuickTileBottomRight); +DEF4("Window Quick Tile Left", I18N_NOOP("Quick Tile Window to the Left"), + 0, std::bind(&Workspace::quickTileWindow, this, QuickTileFlag::Left)); +DEF4("Window Quick Tile Right", I18N_NOOP("Quick Tile Window to the Right"), + 0, std::bind(&Workspace::quickTileWindow, this, QuickTileFlag::Right)); +DEF4("Window Quick Tile Top", I18N_NOOP("Quick Tile Window to the Top"), + 0, std::bind(&Workspace::quickTileWindow, this, QuickTileFlag::Top)); +DEF4("Window Quick Tile Bottom", I18N_NOOP("Quick Tile Window to the Bottom"), + 0, std::bind(&Workspace::quickTileWindow, this, QuickTileFlag::Bottom)); +DEF4("Window Quick Tile Top Left", I18N_NOOP("Quick Tile Window to the Top Left"), + 0, std::bind(&Workspace::quickTileWindow, this, QuickTileFlag::Top | QuickTileFlag::Left)); +DEF4("Window Quick Tile Bottom Left", I18N_NOOP("Quick Tile Window to the Bottom Left"), + 0, std::bind(&Workspace::quickTileWindow, this, QuickTileFlag::Bottom | QuickTileFlag::Left)); +DEF4("Window Quick Tile Top Right", I18N_NOOP("Quick Tile Window to the Top Right"), + 0, std::bind(&Workspace::quickTileWindow, this, QuickTileFlag::Top | QuickTileFlag::Right)); +DEF4("Window Quick Tile Bottom Right", I18N_NOOP("Quick Tile Window to the Bottom Right"), + 0, std::bind(&Workspace::quickTileWindow, this, QuickTileFlag::Bottom | QuickTileFlag::Right)); DEF2("Switch Window Up", I18N_NOOP("Switch to Window Above"), Qt::META + Qt::ALT + Qt::Key_Up, slotSwitchWindowUp); DEF2("Switch Window Down", I18N_NOOP("Switch to Window Below"), diff --git a/placement.cpp b/placement.cpp --- a/placement.cpp +++ b/placement.cpp @@ -839,69 +839,13 @@ } } - -void Workspace::slotWindowQuickTileLeft() -{ - if (!active_client) - return; - - active_client->setQuickTileMode(Client::QuickTileLeft, true); -} - -void Workspace::slotWindowQuickTileRight() -{ - if (!active_client) - return; - - active_client->setQuickTileMode(Client::QuickTileRight, true); -} - -void Workspace::slotWindowQuickTileTop() -{ - if (!active_client) - return; - - active_client->setQuickTileMode(Client::QuickTileTop, true); -} - -void Workspace::slotWindowQuickTileBottom() -{ - if (!active_client) - return; - - active_client->setQuickTileMode(Client::QuickTileBottom, true); -} - -void Workspace::slotWindowQuickTileTopLeft() -{ - if (!active_client) { - return; - } - active_client->setQuickTileMode(Client::QuickTileTop|Client::QuickTileLeft, true); -} - -void Workspace::slotWindowQuickTileTopRight() +void Workspace::quickTileWindow(QuickTileMode mode) { if (!active_client) { return; } - active_client->setQuickTileMode(Client::QuickTileTop|Client::QuickTileRight, true); -} -void Workspace::slotWindowQuickTileBottomLeft() -{ - if (!active_client) { - return; - } - active_client->setQuickTileMode(Client::QuickTileBottom|Client::QuickTileLeft, true); -} - -void Workspace::slotWindowQuickTileBottomRight() -{ - if (!active_client) { - return; - } - active_client->setQuickTileMode(Client::QuickTileBottom|Client::QuickTileRight, true); + active_client->setQuickTileMode(mode, true); } int Workspace::packPositionLeft(const AbstractClient* cl, int oldx, bool left_edge) const diff --git a/scripting/workspace_wrapper.cpp b/scripting/workspace_wrapper.cpp --- a/scripting/workspace_wrapper.cpp +++ b/scripting/workspace_wrapper.cpp @@ -149,14 +149,6 @@ SLOTWRAPPER(slotWindowGrowVertical) SLOTWRAPPER(slotWindowShrinkHorizontal) SLOTWRAPPER(slotWindowShrinkVertical) -SLOTWRAPPER(slotWindowQuickTileLeft) -SLOTWRAPPER(slotWindowQuickTileRight) -SLOTWRAPPER(slotWindowQuickTileTop) -SLOTWRAPPER(slotWindowQuickTileBottom) -SLOTWRAPPER(slotWindowQuickTileTopLeft) -SLOTWRAPPER(slotWindowQuickTileTopRight) -SLOTWRAPPER(slotWindowQuickTileBottomLeft) -SLOTWRAPPER(slotWindowQuickTileBottomRight) SLOTWRAPPER(slotSwitchWindowUp) SLOTWRAPPER(slotSwitchWindowDown) @@ -185,6 +177,22 @@ #undef SLOTWRAPPER +#define SLOTWRAPPER(name,modes) \ +void WorkspaceWrapper::name() { \ + Workspace::self()->quickTileWindow(modes); \ +} + +SLOTWRAPPER(slotWindowQuickTileLeft, QuickTileFlag::Left) +SLOTWRAPPER(slotWindowQuickTileRight, QuickTileFlag::Right) +SLOTWRAPPER(slotWindowQuickTileTop, QuickTileFlag::Top) +SLOTWRAPPER(slotWindowQuickTileBottom, QuickTileFlag::Bottom) +SLOTWRAPPER(slotWindowQuickTileTopLeft, QuickTileFlag::Top | QuickTileFlag::Left) +SLOTWRAPPER(slotWindowQuickTileTopRight, QuickTileFlag::Top | QuickTileFlag::Right) +SLOTWRAPPER(slotWindowQuickTileBottomLeft, QuickTileFlag::Bottom | QuickTileFlag::Left) +SLOTWRAPPER(slotWindowQuickTileBottomRight, QuickTileFlag::Bottom | QuickTileFlag::Right) + +#undef SLOTWRAPPER + #define SLOTWRAPPER(name,direction) \ void WorkspaceWrapper::name( ) { \ VirtualDesktopManager::self()->moveTo(options->isRollOverDesktops()); \ diff --git a/shell_client.cpp b/shell_client.cpp --- a/shell_client.cpp +++ b/shell_client.cpp @@ -728,36 +728,36 @@ // Conditional quick tiling exit points const auto oldQuickTileMode = quickTileMode(); - if (quickTileMode() != QuickTileNone) { + if (quickTileMode() != QuickTileMode(QuickTileFlag::None)) { if (oldMode == MaximizeFull && !clientArea.contains(m_geomMaximizeRestore.center())) { // Not restoring on the same screen // TODO: The following doesn't work for some reason //quick_tile_mode = QuickTileNone; // And exit quick tile mode manually } else if ((oldMode == MaximizeVertical && m_maximizeMode == MaximizeRestore) || (oldMode == MaximizeFull && m_maximizeMode == MaximizeHorizontal)) { // Modifying geometry of a tiled window - updateQuickTileMode(QuickTileNone); // Exit quick tile mode without restoring geometry + updateQuickTileMode(QuickTileFlag::None); // Exit quick tile mode without restoring geometry } } // TODO: check rules if (m_maximizeMode == MaximizeFull) { m_geomMaximizeRestore = geometry(); // TODO: Client has more checks if (options->electricBorderMaximize()) { - updateQuickTileMode(QuickTileMaximize); + updateQuickTileMode(QuickTileFlag::Maximize); } else { - updateQuickTileMode(QuickTileNone); + updateQuickTileMode(QuickTileFlag::None); } if (quickTileMode() != oldQuickTileMode) { emit quickTileModeChanged(); } requestGeometry(workspace()->clientArea(MaximizeArea, this)); workspace()->raiseClient(this); } else { if (m_maximizeMode == MaximizeRestore) { - updateQuickTileMode(QuickTileNone); + updateQuickTileMode(QuickTileFlag::None); } if (quickTileMode() != oldQuickTileMode) { emit quickTileModeChanged(); diff --git a/utils.h b/utils.h --- a/utils.h +++ b/utils.h @@ -141,6 +141,18 @@ return MaximizeMode(int(m1) ^ int(m2)); } +enum class QuickTileFlag { + None = 0, + Left = 1, + Right = 1<<1, + Top = 1<<2, + Bottom = 1<<3, + Horizontal = Left|Right, + Vertical = Top|Bottom, + Maximize = Left|Right|Top|Bottom +}; +Q_DECLARE_FLAGS(QuickTileMode, QuickTileFlag) + template using ScopedCPointer = QScopedPointer; void KWIN_EXPORT updateXTime(); @@ -246,5 +258,6 @@ // Must be outside namespace Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::StrutAreas) +Q_DECLARE_OPERATORS_FOR_FLAGS(KWin::QuickTileMode) #endif diff --git a/workspace.h b/workspace.h --- a/workspace.h +++ b/workspace.h @@ -369,6 +369,8 @@ void markXStackingOrderAsDirty(); + void quickTileWindow(QuickTileMode mode); + public Q_SLOTS: void performWindowOperation(KWin::AbstractClient* c, Options::WindowOperation op); // Keybindings @@ -401,14 +403,6 @@ void slotWindowGrowVertical(); void slotWindowShrinkHorizontal(); void slotWindowShrinkVertical(); - void slotWindowQuickTileLeft(); - void slotWindowQuickTileRight(); - void slotWindowQuickTileTop(); - void slotWindowQuickTileBottom(); - void slotWindowQuickTileTopLeft(); - void slotWindowQuickTileTopRight(); - void slotWindowQuickTileBottomLeft(); - void slotWindowQuickTileBottomRight(); void slotSwitchWindowUp(); void slotSwitchWindowDown();