yukijoou/kwin
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

There's no QVector anymore, QList is the QVector in Qt6

Browse source
This commit is contained in:
Laurent Montel 2023-10-19 08:50:15 +02:00
parent f9163bf6a5
commit bc6116c5a7
276 changed files with 1080 additions and 1083 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
autotests/drm/drmTest.cpp
View file

@ -38,7 +38,7 @@ static std::unique_ptr<MockGpu> findPrimaryDevice(int crtcCount)
return nullptr;
}
QVector<drmDevice *> devices(deviceCount);
QList<drmDevice *> devices(deviceCount);
if (drmGetDevices2(0, devices.data(), devices.size()) < 0) {
return nullptr;
}
@ -203,9 +203,9 @@ void DrmTest::testZeroModesHandling()
void DrmTest::testModeGeneration_data()
{
QTest::addColumn<QSize>("nativeMode");
QTest::addColumn<QVector<QSize>>("expectedModes");
QTest::addColumn<QList<QSize>>("expectedModes");
QTest::newRow("2160p") << QSize(3840, 2160) << QVector<QSize>{
QTest::newRow("2160p") << QSize(3840, 2160) << QList<QSize>{
QSize(1600, 1200),
QSize(1280, 1024),
QSize(1024, 768),
@ -221,7 +221,7 @@ void DrmTest::testModeGeneration_data()
QSize(1368, 768),
QSize(1280, 720),
};
QTest::newRow("1440p") << QSize(2560, 1440) << QVector<QSize>{
QTest::newRow("1440p") << QSize(2560, 1440) << QList<QSize>{
QSize(1600, 1200),
QSize(1280, 1024),
QSize(1024, 768),
@ -233,7 +233,7 @@ void DrmTest::testModeGeneration_data()
QSize(1368, 768),
QSize(1280, 720),
};
QTest::newRow("1080p") << QSize(1920, 1080) << QVector<QSize>{
QTest::newRow("1080p") << QSize(1920, 1080) << QList<QSize>{
QSize(1280, 1024),
QSize(1024, 768),
QSize(1280, 800),
@ -243,7 +243,7 @@ void DrmTest::testModeGeneration_data()
QSize(1280, 720),
};
QTest::newRow("2160p 21:9") << QSize(5120, 2160) << QVector<QSize>{
QTest::newRow("2160p 21:9") << QSize(5120, 2160) << QList<QSize>{
QSize(5120, 2160),
QSize(1600, 1200),
QSize(1280, 1024),
@ -260,7 +260,7 @@ void DrmTest::testModeGeneration_data()
QSize(1368, 768),
QSize(1280, 720),
};
QTest::newRow("1440p 21:9") << QSize(3440, 1440) << QVector<QSize>{
QTest::newRow("1440p 21:9") << QSize(3440, 1440) << QList<QSize>{
QSize(3440, 1440),
QSize(1600, 1200),
QSize(1280, 1024),
@ -273,7 +273,7 @@ void DrmTest::testModeGeneration_data()
QSize(1368, 768),
QSize(1280, 720),
};
QTest::newRow("1080p 21:9") << QSize(2560, 1080) << QVector<QSize>{
QTest::newRow("1080p 21:9") << QSize(2560, 1080) << QList<QSize>{
QSize(2560, 1080),
QSize(1280, 1024),
QSize(1024, 768),
@ -298,7 +298,7 @@ void DrmTest::testModeGeneration()
auto gpu = std::make_unique<DrmGpu>(backend.get(), mockGpu->devNode, mockGpu->fd, 0);
QFETCH(QSize, nativeMode);
QFETCH(QVector<QSize>, expectedModes);
QFETCH(QList<QSize>, expectedModes);
conn->modes.clear();
conn->addMode(nativeMode.width(), nativeMode.height(), 60);
@ -310,7 +310,7 @@ void DrmTest::testModeGeneration()
mockGpu->connectors.removeAll(conn);
QVERIFY(gpu->updateOutputs());
conn->props.emplace_back(conn.get(), QStringLiteral("scaling mode"), 0, DRM_MODE_PROP_ENUM, QVector<QByteArray>{"None", "Full", "Center", "Full aspect"});
conn->props.emplace_back(conn.get(), QStringLiteral("scaling mode"), 0, DRM_MODE_PROP_ENUM, QList<QByteArray>{"None", "Full", "Center", "Full aspect"});
mockGpu->connectors.push_back(conn);
QVERIFY(gpu->updateOutputs());

20
autotests/drm/mock_drm.cpp
View file

@ -133,7 +133,7 @@ uint32_t MockObject::getPropId(const QString &propName) const
//
MockProperty::MockProperty(MockObject *obj, QString name, uint64_t initialValue, uint32_t flags, QVector<QByteArray> enums)
MockProperty::MockProperty(MockObject *obj, QString name, uint64_t initialValue, uint32_t flags, QList<QByteArray> enums)
: obj(obj)
, id(obj->gpu->idCounter++)
, flags(flags)
@ -522,7 +522,7 @@ int drmModeSetCrtc(int fd, uint32_t crtcId, uint32_t bufferId,
req->legacyEmulation = true;
drmModeAtomicAddProperty(req, crtcId, crtc->getPropId(QStringLiteral("MODE_ID")), modeBlob);
drmModeAtomicAddProperty(req, crtcId, crtc->getPropId(QStringLiteral("ACTIVE")), modeBlob && count);
QVector<uint32_t> conns;
QList<uint32_t> conns;
for (int i = 0; i < count; i++) {
conns << connectors[i];
}
@ -843,7 +843,7 @@ drmModeObjectPropertiesPtr drmModeObjectGetProperties(int fd, uint32_t object_id
errno = EINVAL;
return nullptr;
}
QVector<MockProperty> props;
QList<MockProperty> props;
bool deviceAtomic = gpu->clientCaps.contains(DRM_CLIENT_CAP_ATOMIC) && gpu->clientCaps[DRM_CLIENT_CAP_ATOMIC];
for (const auto &prop : std::as_const(obj->props)) {
if (deviceAtomic || !(prop.flags & DRM_MODE_PROP_ATOMIC)) {
@ -899,7 +899,7 @@ int drmModeObjectSetProperty(int fd, uint32_t object_id, uint32_t object_type, u
}
}
static QVector<drmModeAtomicReqPtr> s_atomicReqs;
static QList<drmModeAtomicReqPtr> s_atomicReqs;
drmModeAtomicReqPtr drmModeAtomicAlloc(void)
{
@ -963,20 +963,20 @@ int drmModeAtomicCommit(int fd, drmModeAtomicReqPtr req, uint32_t flags, void *u
return -(errno = EINVAL);
}
QVector<MockConnector> connCopies;
QList<MockConnector> connCopies;
for (const auto &conn : std::as_const(gpu->connectors)) {
connCopies << *conn;
}
QVector<MockCrtc> crtcCopies;
QList<MockCrtc> crtcCopies;
for (const auto &crtc : std::as_const(gpu->crtcs)) {
crtcCopies << *crtc;
}
QVector<MockPlane> planeCopies;
QList<MockPlane> planeCopies;
for (const auto &plane : std::as_const(gpu->planes)) {
planeCopies << *plane;
}
QVector<MockObject*> objects;
QList<MockObject *> objects;
for (int i = 0; i < connCopies.count(); i++) {
objects << &connCopies[i];
}
@ -1022,10 +1022,10 @@ int drmModeAtomicCommit(int fd, drmModeAtomicReqPtr req, uint32_t flags, void *u
// check if the desired changes are allowed
struct Pipeline {
MockCrtc *crtc;
QVector<MockConnector*> conns;
QList<MockConnector *> conns;
MockPlane *primaryPlane = nullptr;
};
QVector<Pipeline> pipelines;
QList<Pipeline> pipelines;
for (int i = 0; i < crtcCopies.count(); i++) {
if (crtcCopies[i].getProp(QStringLiteral("ACTIVE"))) {
auto blob = gpu->getBlob(crtcCopies[i].getProp(QStringLiteral("MODE_ID")));

42
autotests/drm/mock_drm.h
View file

@ -11,9 +11,9 @@
#include <xf86drm.h>
#include <xf86drmMode.h>
#include <QList>
#include <QMap>
#include <QRect>
#include <QVector>
#include <memory>
#include <mutex>
#include <vector>
@ -27,7 +27,7 @@ class MockPlane;
class MockProperty {
public:
MockProperty(MockObject *obj, QString name, uint64_t initialValue, uint32_t flags, QVector<QByteArray> enums = {});
MockProperty(MockObject *obj, QString name, uint64_t initialValue, uint32_t flags, QList<QByteArray> enums = {});
~MockProperty() = default;
MockObject *obj;
@ -35,7 +35,7 @@ public:
uint32_t flags;
QString name;
uint64_t value;
QVector<QByteArray> enums;
QList<QByteArray> enums;
};
class MockPropertyBlob {
@ -60,7 +60,7 @@ public:
uint32_t getPropId(const QString &propName) const;
uint32_t id;
QVector<MockProperty> props;
QList<MockProperty> props;
MockGpu *gpu;
};
@ -75,7 +75,7 @@ public:
drmModeConnection connection;
uint32_t type;
std::shared_ptr<MockEncoder> encoder;
QVector<drmModeModeInfo> modes;
QList<drmModeModeInfo> modes;
};
class MockEncoder : public MockObject {
@ -141,7 +141,7 @@ struct Prop {
struct _drmModeAtomicReq {
bool legacyEmulation = false;
QVector<Prop> props;
QList<Prop> props;
};
#define MOCKDRM_DEVICE_CAP_ATOMIC 0xFF
@ -165,28 +165,28 @@ public:
QMap<uint32_t, uint64_t> deviceCaps;
uint32_t idCounter = 1;
QVector<MockObject*> objects;
QList<MockObject *> objects;
QVector<std::shared_ptr<MockConnector>> connectors;
QVector<drmModeConnectorPtr> drmConnectors;
QList<std::shared_ptr<MockConnector>> connectors;
QList<drmModeConnectorPtr> drmConnectors;
QVector<std::shared_ptr<MockEncoder>> encoders;
QVector<drmModeEncoderPtr> drmEncoders;
QList<std::shared_ptr<MockEncoder>> encoders;
QList<drmModeEncoderPtr> drmEncoders;
QVector<std::shared_ptr<MockCrtc>> crtcs;
QVector<drmModeCrtcPtr> drmCrtcs;
QList<std::shared_ptr<MockCrtc>> crtcs;
QList<drmModeCrtcPtr> drmCrtcs;
QVector<std::shared_ptr<MockPlane>> planes;
QVector<drmModePlanePtr> drmPlanes;
QList<std::shared_ptr<MockPlane>> planes;
QList<drmModePlanePtr> drmPlanes;
QVector<MockFb *> fbs;
QList<MockFb *> fbs;
std::vector<std::unique_ptr<MockPropertyBlob>> propertyBlobs;
QVector<drmModeResPtr> resPtrs;
QVector<drmModePropertyPtr> drmProps;
QVector<drmModePropertyBlobPtr> drmPropertyBlobs;
QVector<drmModeObjectPropertiesPtr> drmObjectProperties;
QVector<drmModePlaneResPtr> drmPlaneRes;
QList<drmModeResPtr> resPtrs;
QList<drmModePropertyPtr> drmProps;
QList<drmModePropertyBlobPtr> drmPropertyBlobs;
QList<drmModeObjectPropertiesPtr> drmObjectProperties;
QList<drmModePlaneResPtr> drmPlaneRes;
std::mutex m_mutex;
};

4
autotests/integration/activation_test.cpp
View file

@ -511,7 +511,7 @@ void ActivationTest::stackScreensHorizontally()
// Process pending wl_output bind requests before destroying all outputs.
QTest::qWait(1);
const QVector<QRect> screenGeometries{
const QList<QRect> screenGeometries{
QRect(0, 0, 1280, 1024),
QRect(1280, 0, 1280, 1024),
};
@ -523,7 +523,7 @@ void ActivationTest::stackScreensVertically()
// Process pending wl_output bind requests before destroying all outputs.
QTest::qWait(1);
const QVector<QRect> screenGeometries{
const QList<QRect> screenGeometries{
QRect(0, 0, 1280, 1024),
QRect(0, 1024, 1280, 1024),
};

6
autotests/integration/dbus_interface_test.cpp
View file

@ -190,10 +190,10 @@ void TestDbusInterface::testGetWindowInfoXdgShellClient()
// not testing shaded as that's X11
// not testing fullscreen, maximizeHorizontal, maximizeVertical and noBorder as those require window geometry changes
const QVector<VirtualDesktop *> desktops = VirtualDesktopManager::self()->desktops();
QCOMPARE(window->desktops(), QVector<VirtualDesktop *>{desktops[0]});
const QList<VirtualDesktop *> desktops = VirtualDesktopManager::self()->desktops();
QCOMPARE(window->desktops(), QList<VirtualDesktop *>{desktops[0]});
workspace()->sendWindowToDesktops(window, {desktops[1]}, false);
QCOMPARE(window->desktops(), QVector<VirtualDesktop *>{desktops[1]});
QCOMPARE(window->desktops(), QList<VirtualDesktop *>{desktops[1]});
reply = getWindowInfo(window->internalId());
reply.waitForFinished();
QCOMPARE(reply.value().value(QStringLiteral("desktops")).toStringList(), window->desktopIds());

2
autotests/integration/effects/translucency_test.cpp
View file

@ -138,7 +138,7 @@ void TranslucencyTest::testMoveAfterDesktopChange()
// let's send the window to desktop 2
VirtualDesktopManager *vds = VirtualDesktopManager::self();
vds->setCount(2);
const QVector<VirtualDesktop *> desktops = vds->desktops();
const QList<VirtualDesktop *> desktops = vds->desktops();
workspace()->sendWindowToDesktops(window, {desktops[1]}, false);
vds->setCurrent(desktops[1]);
QVERIFY(!m_translucencyEffect->isActive());

4
autotests/integration/inputmethod_test.cpp
View file

@ -357,9 +357,9 @@ void InputMethodTest::testSwitchFocusedSurfaces()
QSignalSpy activateSpy(kwinApp()->inputMethod(), &InputMethod::activeChanged);
std::unique_ptr<KWayland::Client::TextInput> textInput(Test::waylandTextInputManager()->createTextInput(Test::waylandSeat()));
QVector<Window *> windows;
QList<Window *> windows;
std::vector<std::unique_ptr<KWayland::Client::Surface>> surfaces;
QVector<Test::XdgToplevel *> toplevels;
QList<Test::XdgToplevel *> toplevels;
// We create 3 surfaces
for (int i = 0; i < 3; ++i) {
std::unique_ptr<KWayland::Client::Surface> surface = Test::createSurface();

8
autotests/integration/kwin_wayland_test.cpp
View file

@ -212,9 +212,9 @@ void Test::FractionalScaleV1::wp_fractional_scale_v1_preferred_scale(uint32_t sc
m_preferredScale = scale;
}
void Test::setOutputConfig(const QVector<QRect> &geometries)
void Test::setOutputConfig(const QList<QRect> &geometries)
{
QVector<VirtualBackend::OutputInfo> converted;
QList<VirtualBackend::OutputInfo> converted;
std::transform(geometries.begin(), geometries.end(), std::back_inserter(converted), [](const auto &geometry) {
return VirtualBackend::OutputInfo{
.geometry = geometry,
@ -223,9 +223,9 @@ void Test::setOutputConfig(const QVector<QRect> &geometries)
static_cast<VirtualBackend *>(kwinApp()->outputBackend())->setVirtualOutputs(converted);
}
void Test::setOutputConfig(const QVector<OutputInfo> &infos)
void Test::setOutputConfig(const QList<OutputInfo> &infos)
{
QVector<VirtualBackend::OutputInfo> converted;
QList<VirtualBackend::OutputInfo> converted;
std::transform(infos.begin(), infos.end(), std::back_inserter(converted), [](const auto &info) {
return VirtualBackend::OutputInfo{
.geometry = info.geometry,

8
autotests/integration/kwin_wayland_test.h
View file

@ -637,10 +637,10 @@ KWayland::Client::PointerConstraints *waylandPointerConstraints();
KWayland::Client::AppMenuManager *waylandAppMenuManager();
WaylandOutputManagementV2 *waylandOutputManagementV2();
KWayland::Client::TextInputManager *waylandTextInputManager();
QVector<KWayland::Client::Output *> waylandOutputs();
QList<KWayland::Client::Output *> waylandOutputs();
KWayland::Client::Output *waylandOutput(const QString &name);
ScreencastingV1 *screencasting();
QVector<WaylandOutputDeviceV2 *> waylandOutputDevicesV2();
QList<WaylandOutputDeviceV2 *> waylandOutputDevicesV2();
FakeInput *waylandFakeInput();
bool waitForWaylandSurface(Window *window);
@ -839,8 +839,8 @@ struct OutputInfo
double scale = 1;
bool internal = false;
};
void setOutputConfig(const QVector<QRect> &geometries);
void setOutputConfig(const QVector<OutputInfo> &infos);
void setOutputConfig(const QList<QRect> &geometries);
void setOutputConfig(const QList<OutputInfo> &infos);
}
}

4
autotests/integration/kwinbindings_test.cpp
View file

@ -237,11 +237,11 @@ void KWinBindingsTest::testWindowToDesktop()
};
invokeShortcut(desktop);
QVERIFY(desktopsChangedSpy.wait());
QCOMPARE(window->desktops(), QVector<VirtualDesktop *>{desktops.at(desktop - 1)});
QCOMPARE(window->desktops(), QList<VirtualDesktop *>{desktops.at(desktop - 1)});
// back to desktop 1
invokeShortcut(1);
QVERIFY(desktopsChangedSpy.wait());
QCOMPARE(window->desktops(), QVector<VirtualDesktop *>{desktops.at(0)});
QCOMPARE(window->desktops(), QList<VirtualDesktop *>{desktops.at(0)});
// invoke with one desktop too many
invokeShortcut(desktop + 1);
// that should fail

2
autotests/integration/plasma_surface_test.cpp
View file

@ -190,7 +190,7 @@ void PlasmaSurfaceTest::testOSDPlacement()
QCOMPARE(window->frameGeometry(), QRect(1280 / 2 - 100 / 2, 2 * 1024 / 3 - 50 / 2, 100, 50));
// change the screen size
const QVector<QRect> geometries{QRect(0, 0, 1280, 1024), QRect(1280, 0, 1280, 1024)};
const QList<QRect> geometries{QRect(0, 0, 1280, 1024), QRect(1280, 0, 1280, 1024)};
Test::setOutputConfig(geometries);
const auto outputs = workspace()->outputs();
QCOMPARE(outputs.count(), 2);

6
autotests/integration/pointer_input.cpp
View file

@ -41,7 +41,7 @@ namespace KWin
static PlatformCursorImage loadReferenceThemeCursor_helper(const KXcursorTheme &theme,
const QByteArray &name)
{
const QVector<KXcursorSprite> sprites = theme.shape(name);
const QList<KXcursorSprite> sprites = theme.shape(name);
if (sprites.isEmpty()) {
return PlatformCursorImage();
}
@ -63,7 +63,7 @@ static PlatformCursorImage loadReferenceThemeCursor(const QByteArray &name)
return platformCursorImage;
}
const QVector<QByteArray> alternativeNames = Cursor::cursorAlternativeNames(name);
const QList<QByteArray> alternativeNames = Cursor::cursorAlternativeNames(name);
for (const QByteArray &alternativeName : alternativeNames) {
platformCursorImage = loadReferenceThemeCursor_helper(theme, alternativeName);
if (!platformCursorImage.isNull()) {
@ -1535,7 +1535,7 @@ void PointerInputTest::testConfineToScreenGeometry()
// after moving it to off-screen area
// setup screen layout
const QVector<QRect> geometries{
const QList<QRect> geometries{
QRect(0, 0, 1280, 1024),
QRect(1280, 0, 1280, 1024),
QRect(2560, 0, 1280, 1024),

4
autotests/integration/screen_changes_test.cpp
View file

@ -81,7 +81,7 @@ void ScreenChangesTest::testScreenAddRemove()
outputAnnouncedSpy.clear();
// let's announce a new output
const QVector<QRect> geometries{QRect(0, 0, 1280, 1024), QRect(1280, 0, 1280, 1024)};
const QList<QRect> geometries{QRect(0, 0, 1280, 1024), QRect(1280, 0, 1280, 1024)};
Test::setOutputConfig(geometries);
auto outputs = workspace()->outputs();
QCOMPARE(outputs.count(), 2);
@ -145,7 +145,7 @@ void ScreenChangesTest::testScreenAddRemove()
QSignalSpy o1RemovedSpy(o1.get(), &KWayland::Client::Output::removed);
QSignalSpy o2RemovedSpy(o2.get(), &KWayland::Client::Output::removed);
const QVector<QRect> geometries2{QRect(0, 0, 1280, 1024)};
const QList<QRect> geometries2{QRect(0, 0, 1280, 1024)};
Test::setOutputConfig(geometries2);
outputs = workspace()->outputs();
QCOMPARE(outputs.count(), 1);

24
autotests/integration/screens_test.cpp
View file

@ -117,14 +117,14 @@ void ScreensTest::testCurrent()
void ScreensTest::testCurrentWithFollowsMouse_data()
{
QTest::addColumn<QVector<QRect>>("geometries");
QTest::addColumn<QList<QRect>>("geometries");
QTest::addColumn<QPoint>("cursorPos");
QTest::addColumn<int>("expectedId");
QTest::newRow("cloned") << QVector<QRect>{{QRect{0, 0, 200, 100}, QRect{0, 0, 200, 100}}} << QPoint(50, 50) << 0;
QTest::newRow("adjacent-0") << QVector<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(199, 99) << 0;
QTest::newRow("adjacent-1") << QVector<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(200, 100) << 1;
QTest::newRow("gap") << QVector<QRect>{{QRect{0, 0, 10, 20}, QRect{20, 40, 10, 20}}} << QPoint(15, 30) << 1;
QTest::newRow("cloned") << QList<QRect>{{QRect{0, 0, 200, 100}, QRect{0, 0, 200, 100}}} << QPoint(50, 50) << 0;
QTest::newRow("adjacent-0") << QList<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(199, 99) << 0;
QTest::newRow("adjacent-1") << QList<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(200, 100) << 1;
QTest::newRow("gap") << QList<QRect>{{QRect{0, 0, 10, 20}, QRect{20, 40, 10, 20}}} << QPoint(15, 30) << 1;
}
void ScreensTest::testCurrentWithFollowsMouse()
@ -135,7 +135,7 @@ void ScreensTest::testCurrentWithFollowsMouse()
group.sync();
workspace()->slotReconfigure();
QFETCH(QVector<QRect>, geometries);
QFETCH(QList<QRect>, geometries);
Test::setOutputConfig(geometries);
QFETCH(QPoint, cursorPos);
@ -148,19 +148,19 @@ void ScreensTest::testCurrentWithFollowsMouse()
void ScreensTest::testCurrentPoint_data()
{
QTest::addColumn<QVector<QRect>>("geometries");
QTest::addColumn<QList<QRect>>("geometries");
QTest::addColumn<QPoint>("cursorPos");
QTest::addColumn<int>("expectedId");
QTest::newRow("cloned") << QVector<QRect>{{QRect{0, 0, 200, 100}, QRect{0, 0, 200, 100}}} << QPoint(50, 50) << 0;
QTest::newRow("adjacent-0") << QVector<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(199, 99) << 0;
QTest::newRow("adjacent-1") << QVector<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(200, 100) << 1;
QTest::newRow("gap") << QVector<QRect>{{QRect{0, 0, 10, 20}, QRect{20, 40, 10, 20}}} << QPoint(15, 30) << 1;
QTest::newRow("cloned") << QList<QRect>{{QRect{0, 0, 200, 100}, QRect{0, 0, 200, 100}}} << QPoint(50, 50) << 0;
QTest::newRow("adjacent-0") << QList<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(199, 99) << 0;
QTest::newRow("adjacent-1") << QList<QRect>{{QRect{0, 0, 200, 100}, QRect{200, 100, 400, 300}}} << QPoint(200, 100) << 1;
QTest::newRow("gap") << QList<QRect>{{QRect{0, 0, 10, 20}, QRect{20, 40, 10, 20}}} << QPoint(15, 30) << 1;
}
void ScreensTest::testCurrentPoint()
{
QFETCH(QVector<QRect>, geometries);
QFETCH(QList<QRect>, geometries);
Test::setOutputConfig(geometries);
// Disable "active screen follows mouse"

6
autotests/integration/struts_test.cpp
View file

@ -427,7 +427,7 @@ void StrutsTest::test363804()
{
// this test verifies the condition described in BUG 363804
// two screens in a vertical setup, aligned to right border with panel on the bottom screen
const QVector<QRect> geometries{QRect(0, 0, 1920, 1080), QRect(554, 1080, 1366, 768)};
const QList<QRect> geometries{QRect(0, 0, 1920, 1080), QRect(554, 1080, 1366, 768)};
Test::setOutputConfig(geometries);
QCOMPARE(workspace()->geometry(), QRect(0, 0, 1920, 1848));
@ -504,7 +504,7 @@ void StrutsTest::testLeftScreenSmallerBottomAligned()
{
// this test verifies a two screen setup with the left screen smaller than the right and bottom aligned
// the panel is on the top of the left screen, thus not at 0/0
const QVector<QRect> geometries{QRect(0, 282, 1366, 768), QRect(1366, 0, 1680, 1050)};
const QList<QRect> geometries{QRect(0, 282, 1366, 768), QRect(1366, 0, 1680, 1050)};
Test::setOutputConfig(geometries);
QCOMPARE(workspace()->geometry(), QRect(0, 0, 3046, 1050));
@ -585,7 +585,7 @@ void StrutsTest::testWindowMoveWithPanelBetweenScreens()
// to the other even if there is a panel in between.
// left screen must be smaller than right screen
const QVector<QRect> geometries{QRect(0, 282, 1366, 768), QRect(1366, 0, 1680, 1050)};
const QList<QRect> geometries{QRect(0, 282, 1366, 768), QRect(1366, 0, 1680, 1050)};
Test::setOutputConfig(geometries);
QCOMPARE(workspace()->geometry(), QRect(0, 0, 3046, 1050));

10
autotests/integration/test_helpers.cpp
View file

@ -280,8 +280,8 @@ static struct
KWayland::Client::Registry *registry = nullptr;
WaylandOutputManagementV2 *outputManagementV2 = nullptr;
QThread *thread = nullptr;
QVector<KWayland::Client::Output *> outputs;
QVector<WaylandOutputDeviceV2 *> outputDevicesV2;
QList<KWayland::Client::Output *> outputs;
QList<WaylandOutputDeviceV2 *> outputDevicesV2;
IdleInhibitManagerV1 *idleInhibitManagerV1 = nullptr;
KWayland::Client::AppMenuManager *appMenu = nullptr;
XdgDecorationManagerV1 *xdgDecorationManagerV1 = nullptr;
@ -697,7 +697,7 @@ TextInputManagerV3 *waylandTextInputManagerV3()
return s_waylandConnection.textInputManagerV3;
}
QVector<KWayland::Client::Output *> waylandOutputs()
QList<KWayland::Client::Output *> waylandOutputs()
{
return s_waylandConnection.outputs;
}
@ -717,7 +717,7 @@ ScreencastingV1 *screencasting()
return s_waylandConnection.screencastingV1;
}
QVector<KWin::Test::WaylandOutputDeviceV2 *> waylandOutputDevicesV2()
QList<KWin::Test::WaylandOutputDeviceV2 *> waylandOutputDevicesV2()
{
return s_waylandConnection.outputDevicesV2;
}
@ -1131,7 +1131,7 @@ bool renderNodeAvailable()
return false;
}
QVector<drmDevice *> devices(deviceCount);
QList<drmDevice *> devices(deviceCount);
if (drmGetDevices2(0, devices.data(), devices.size()) < 0) {
return false;
}

6
autotests/integration/virtual_desktop_test.cpp
View file

@ -160,7 +160,7 @@ void VirtualDesktopTest::testWindowOnMultipleDesktops()
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
auto window = Test::renderAndWaitForShown(surface.get(), QSize(100, 50), Qt::blue);
QVERIFY(window);
QCOMPARE(window->desktops(), (QVector<VirtualDesktop *>{desktops.at(2)}));
QCOMPARE(window->desktops(), (QList<VirtualDesktop *>{desktops.at(2)}));
// Set the window on desktop 2 as well
window->enterDesktop(VirtualDesktopManager::self()->desktopForX11Id(2));
@ -170,10 +170,10 @@ void VirtualDesktopTest::testWindowOnMultipleDesktops()
// leave desktop 3
window->leaveDesktop(desktops.at(2));
QCOMPARE(window->desktops(), (QVector<VirtualDesktop *>{desktops.at(1)}));
QCOMPARE(window->desktops(), (QList<VirtualDesktop *>{desktops.at(1)}));
// leave desktop 2
window->leaveDesktop(desktops.at(1));
QCOMPARE(window->desktops(), QVector<VirtualDesktop *>{});
QCOMPARE(window->desktops(), QList<VirtualDesktop *>{});
// we should be on all desktops now
QVERIFY(window->isOnAllDesktops());
// put on desktop 1

18
autotests/integration/xdgshellwindow_test.cpp
View file

@ -863,7 +863,7 @@ void TestXdgShellWindow::testSendClientWithTransientToDesktop()
VirtualDesktopManager *vds = VirtualDesktopManager::self();
vds->setCount(2);
const QVector<VirtualDesktop *> desktops = vds->desktops();
const QList<VirtualDesktop *> desktops = vds->desktops();
std::unique_ptr<KWayland::Client::Surface> surface{Test::createSurface()};
std::unique_ptr<Test::XdgToplevel> shellSurface(Test::createXdgToplevelSurface(surface.get()));
@ -883,15 +883,15 @@ void TestXdgShellWindow::testSendClientWithTransientToDesktop()
QVERIFY(window->transients().contains(transient));
// initially, the parent and the transient are on the first virtual desktop
QCOMPARE(window->desktops(), QVector<VirtualDesktop *>{desktops[0]});
QCOMPARE(window->desktops(), QList<VirtualDesktop *>{desktops[0]});
QVERIFY(!window->isOnAllDesktops());
QCOMPARE(transient->desktops(), QVector<VirtualDesktop *>{desktops[0]});
QCOMPARE(transient->desktops(), QList<VirtualDesktop *>{desktops[0]});
QVERIFY(!transient->isOnAllDesktops());
// send the transient to the second virtual desktop
workspace()->slotWindowToDesktop(desktops[1]);
QCOMPARE(window->desktops(), QVector<VirtualDesktop *>{desktops[0]});
QCOMPARE(transient->desktops(), QVector<VirtualDesktop *>{desktops[1]});
QCOMPARE(window->desktops(), QList<VirtualDesktop *>{desktops[0]});
QCOMPARE(transient->desktops(), QList<VirtualDesktop *>{desktops[1]});
// activate c
workspace()->activateWindow(window);
@ -899,13 +899,13 @@ void TestXdgShellWindow::testSendClientWithTransientToDesktop()
QVERIFY(window->isActive());
// and send it to the desktop it's already on
QCOMPARE(window->desktops(), QVector<VirtualDesktop *>{desktops[0]});
QCOMPARE(transient->desktops(), QVector<VirtualDesktop *>{desktops[1]});
QCOMPARE(window->desktops(), QList<VirtualDesktop *>{desktops[0]});
QCOMPARE(transient->desktops(), QList<VirtualDesktop *>{desktops[1]});
workspace()->slotWindowToDesktop(desktops[0]);
// which should move the transient back to the desktop
QCOMPARE(window->desktops(), QVector<VirtualDesktop *>{desktops[0]});
QCOMPARE(transient->desktops(), QVector<VirtualDesktop *>{desktops[0]});
QCOMPARE(window->desktops(), QList<VirtualDesktop *>{desktops[0]});
QCOMPARE(transient->desktops(), QList<VirtualDesktop *>{desktops[0]});
}
void TestXdgShellWindow::testMinimizeWindowWithTransients()

6
autotests/libinput/device_test.cpp
View file

@ -966,10 +966,10 @@ void TestLibinputDevice::testSupportedButtons()
void TestLibinputDevice::testAlphaNumericKeyboard_data()
{
QTest::addColumn<QVector<quint32>>("supportedKeys");
QTest::addColumn<QList<quint32>>("supportedKeys");
QTest::addColumn<bool>("isAlpha");
QVector<quint32> keys;
QList<quint32> keys;
for (int i = KEY_1; i <= KEY_0; i++) {
keys << i;
@ -1006,7 +1006,7 @@ void TestLibinputDevice::testAlphaNumericKeyboard_data()
void TestLibinputDevice::testAlphaNumericKeyboard()
{
QFETCH(QVector<quint32>, supportedKeys);
QFETCH(QList<quint32>, supportedKeys);
libinput_device device;
device.keyboard = true;
device.keys = supportedKeys;

4
autotests/libinput/mock_libinput.h
View file

@ -11,9 +11,9 @@
#include <libinput.h>
#include <QByteArray>
#include <QList>
#include <QPointF>
#include <QSizeF>
#include <QVector>
#include <array>
#include <chrono>
@ -74,7 +74,7 @@ struct libinput_device
quint32 scrollButton = 0;
int setScrollButtonReturnValue = 0;
Qt::MouseButtons supportedButtons;
QVector<quint32> keys;
QList<quint32> keys;
bool enabled = true;
int setEnableModeReturnValue = 0;
int setTapToClickReturnValue = 0;

4
autotests/libkwineffects/kwinglplatformtest.cpp
View file

@ -201,7 +201,7 @@ static Version readVersion(const KConfigGroup &group, const char *entry)
if (parts.count() < 2) {
return Version();
}
QVector<qint64> versionParts;
QList<qint64> versionParts;
for (int i = 0; i < parts.count(); ++i) {
bool ok = false;
const auto value = parts.at(i).toLongLong(&ok);
@ -227,7 +227,7 @@ void GLPlatformTest::testDetect()
s_gl->getString.renderer = driverGroup.readEntry("Renderer").toUtf8();
s_gl->getString.version = driverGroup.readEntry("Version").toUtf8();
s_gl->getString.shadingLanguageVersion = driverGroup.readEntry("ShadingLanguageVersion").toUtf8();
s_gl->getString.extensions = QVector<QByteArray>{QByteArrayLiteral("GL_ARB_shader_objects"),
s_gl->getString.extensions = QList<QByteArray>{QByteArrayLiteral("GL_ARB_shader_objects"),
QByteArrayLiteral("GL_ARB_fragment_shader"),
QByteArrayLiteral("GL_ARB_vertex_shader"),
QByteArrayLiteral("GL_ARB_texture_non_power_of_two")};

4
autotests/libkwineffects/mock_gl.h
View file

@ -10,7 +10,7 @@
#define MOCK_GL_H
#include <QByteArray>
#include <QVector>
#include <QList>
struct MockGL
{
@ -19,7 +19,7 @@ struct MockGL
QByteArray vendor;
QByteArray renderer;
QByteArray version;
QVector<QByteArray> extensions;
QList<QByteArray> extensions;
QByteArray extensionsString;
QByteArray shadingLanguageVersion;
} getString;

24
autotests/wayland/client/test_wayland_surface.cpp
View file

@ -843,7 +843,7 @@ void TestWaylandSurface::testOutput()
QVERIFY(surfaceCreatedSpy.wait());
auto serverSurface = surfaceCreatedSpy.first().first().value<SurfaceInterface *>();
QVERIFY(serverSurface);
QCOMPARE(serverSurface->outputs(), QVector<OutputInterface *>());
QCOMPARE(serverSurface->outputs(), QList<OutputInterface *>());
// create another registry to get notified about added outputs
KWayland::Client::Registry registry;
@ -865,31 +865,31 @@ void TestWaylandSurface::testOutput()
m_display->dispatchEvents();
// now enter it
serverSurface->setOutputs(QVector<OutputInterface *>{serverOutput.get()});
QCOMPARE(serverSurface->outputs(), QVector<OutputInterface *>{serverOutput.get()});
serverSurface->setOutputs(QList<OutputInterface *>{serverOutput.get()});
QCOMPARE(serverSurface->outputs(), QList<OutputInterface *>{serverOutput.get()});
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 1);
QCOMPARE(enteredSpy.first().first().value<KWayland::Client::Output *>(), clientOutput.get());
QCOMPARE(s->outputs(), QVector<KWayland::Client::Output *>{clientOutput.get()});
QCOMPARE(s->outputs(), QList<KWayland::Client::Output *>{clientOutput.get()});
// adding to same should not trigger
serverSurface->setOutputs(QVector<OutputInterface *>{serverOutput.get()});
serverSurface->setOutputs(QList<OutputInterface *>{serverOutput.get()});
// leave again
serverSurface->setOutputs(QVector<OutputInterface *>());
QCOMPARE(serverSurface->outputs(), QVector<OutputInterface *>());
serverSurface->setOutputs(QList<OutputInterface *>());
QCOMPARE(serverSurface->outputs(), QList<OutputInterface *>());
QVERIFY(leftSpy.wait());
QCOMPARE(enteredSpy.count(), 1);
QCOMPARE(leftSpy.count(), 1);
QCOMPARE(leftSpy.first().first().value<KWayland::Client::Output *>(), clientOutput.get());
QCOMPARE(s->outputs(), QVector<KWayland::Client::Output *>());
QCOMPARE(s->outputs(), QList<KWayland::Client::Output *>());
// leave again should not trigger
serverSurface->setOutputs(QVector<OutputInterface *>());
serverSurface->setOutputs(QList<OutputInterface *>());
// and enter again, just to verify
serverSurface->setOutputs(QVector<OutputInterface *>{serverOutput.get()});
QCOMPARE(serverSurface->outputs(), QVector<OutputInterface *>{serverOutput.get()});
serverSurface->setOutputs(QList<OutputInterface *>{serverOutput.get()});
QCOMPARE(serverSurface->outputs(), QList<OutputInterface *>{serverOutput.get()});
QVERIFY(enteredSpy.wait());
QCOMPARE(enteredSpy.count(), 2);
QCOMPARE(leftSpy.count(), 1);
@ -899,7 +899,7 @@ void TestWaylandSurface::testOutput()
serverOutput.reset();
outputHandle.reset();
QVERIFY(leftSpy.wait());
QCOMPARE(serverSurface->outputs(), QVector<OutputInterface *>());
QCOMPARE(serverSurface->outputs(), QList<OutputInterface *>());
}
void TestWaylandSurface::testInhibit()

2
autotests/wayland/server/test_datacontrol_interface.cpp
View file

@ -158,7 +158,7 @@ private:
DataControlDeviceManager *m_dataControlDeviceManager;
QVector<SurfaceInterface *> m_surfaces;
QList<SurfaceInterface *> m_surfaces;
};
static const QString s_socketName = QStringLiteral("kwin-wayland-datacontrol-test-0");

2
autotests/wayland/server/test_inputmethod_interface.cpp
View file

@ -184,7 +184,7 @@ private:
KWin::InputMethodV1Interface *m_inputMethodIface;
KWin::InputPanelV1Interface *m_inputPanelIface;
QVector<SurfaceInterface *> m_surfaces;
QList<SurfaceInterface *> m_surfaces;
};
static const QString s_socketName = QStringLiteral("kwin-wayland-server-inputmethod-test-0");

4
autotests/wayland/server/test_keyboard_shortcuts_inhibitor_interface.cpp
View file

@ -85,8 +85,8 @@ private:
CompositorInterface *m_serverCompositor;
KeyboardShortcutsInhibitManagerV1Interface *m_manager;
QVector<SurfaceInterface *> m_surfaces;
QVector<wl_surface *> m_clientSurfaces;
QList<SurfaceInterface *> m_surfaces;
QList<wl_surface *> m_clientSurfaces;
KeyboardShortcutsInhibitManager *m_inhibitManagerClient = nullptr;
};

10
autotests/wayland/server/test_tablet_interface.cpp
View file

@ -125,9 +125,9 @@ public:
Q_EMIT padAdded();
}
QVector<Tablet *> m_tablets;
QVector<TabletPad *> m_pads;
QVector<Tool *> m_tools;
QList<Tablet *> m_tablets;
QList<TabletPad *> m_pads;
QList<Tool *> m_tools;
Q_SIGNALS:
void padAdded();
@ -164,13 +164,13 @@ private:
TabletSeat *m_tabletSeatClient = nullptr;
TabletManagerV2Interface *m_tabletManager;
QVector<KWayland::Client::Surface *> m_surfacesClient;
QList<KWayland::Client::Surface *> m_surfacesClient;
TabletV2Interface *m_tablet;
TabletPadV2Interface *m_tabletPad = nullptr;
TabletToolV2Interface *m_tool;
QVector<SurfaceInterface *> m_surfaces;
QList<SurfaceInterface *> m_surfaces;
};
static const QString s_socketName = QStringLiteral("kwin-wayland-server-tablet-test-0");

8
src/backends/drm/drm_backend.cpp
View file

@ -297,9 +297,9 @@ void DrmBackend::sceneInitialized()
}
}
QVector<CompositingType> DrmBackend::supportedCompositors() const
QList<CompositingType> DrmBackend::supportedCompositors() const
{
return QVector<CompositingType>{OpenGLCompositing, QPainterCompositing};
return QList<CompositingType>{OpenGLCompositing, QPainterCompositing};
}
QString DrmBackend::supportInformation() const
@ -352,8 +352,8 @@ size_t DrmBackend::gpuCount() const
bool DrmBackend::applyOutputChanges(const OutputConfiguration &config)
{
QVector<DrmOutput *> toBeEnabled;
QVector<DrmOutput *> toBeDisabled;
QList<DrmOutput *> toBeEnabled;
QList<DrmOutput *> toBeDisabled;
for (const auto &gpu : std::as_const(m_gpus)) {
const auto &outputs = gpu->drmOutputs();
for (const auto &output : outputs) {

8
src/backends/drm/drm_backend.h
View file

@ -9,10 +9,10 @@
#pragma once
#include "core/outputbackend.h"
#include <QList>
#include <QPointer>
#include <QSize>
#include <QSocketNotifier>
#include <QVector>
#include <memory>
#include <sys/types.h>
@ -49,7 +49,7 @@ public:
Outputs outputs() const override;
Session *session() const override;
QVector<CompositingType> supportedCompositors() const override;
QList<CompositingType> supportedCompositors() const override;
QString supportInformation() const override;
Output *createVirtualOutput(const QString &name, const QSize &size, double scale) override;
@ -88,8 +88,8 @@ private:
std::unique_ptr<UdevMonitor> m_udevMonitor;
std::unique_ptr<QSocketNotifier> m_socketNotifier;
Session *m_session;
QVector<DrmAbstractOutput *> m_outputs;
QVector<QUuid> m_recentlyUnpluggedDpmsOffOutputs;
QList<DrmAbstractOutput *> m_outputs;
QList<QUuid> m_recentlyUnpluggedDpmsOffOutputs;
const QStringList m_explicitGpus;
std::vector<std::unique_ptr<DrmGpu>> m_gpus;

2
src/backends/drm/drm_commit.cpp
View file

@ -36,7 +36,7 @@ DrmGpu *DrmCommit::gpu() const
return m_gpu;
}
DrmAtomicCommit::DrmAtomicCommit(const QVector<DrmPipeline *> &pipelines)
DrmAtomicCommit::DrmAtomicCommit(const QList<DrmPipeline *> &pipelines)
: DrmCommit(pipelines.front()->gpu())
, m_pipelines(pipelines)
{

4
src/backends/drm/drm_commit.h
View file

@ -49,7 +49,7 @@ protected:
class DrmAtomicCommit : public DrmCommit
{
public:
DrmAtomicCommit(const QVector<DrmPipeline *> &pipelines);
DrmAtomicCommit(const QList<DrmPipeline *> &pipelines);
DrmAtomicCommit(const DrmAtomicCommit &copy) = default;
void addProperty(const DrmProperty &prop, uint64_t value);
@ -81,7 +81,7 @@ public:
private:
bool doCommit(uint32_t flags);
const QVector<DrmPipeline *> m_pipelines;
const QList<DrmPipeline *> m_pipelines;
std::unordered_map<const DrmProperty *, std::shared_ptr<DrmBlob>> m_blobs;
std::unordered_map<DrmPlane *, std::shared_ptr<DrmFramebuffer>> m_buffers;
std::unordered_set<DrmPlane *> m_planes;

2
src/backends/drm/drm_connector.cpp
View file

@ -326,7 +326,7 @@ void DrmConnector::disable(DrmAtomicCommit *commit)
commit->addProperty(crtcId, 0);
}
static const QVector<QSize> s_commonModes = {
static const QList<QSize> s_commonModes = {
/* 4:3 (1.33) */
QSize(1600, 1200),
QSize(1280, 1024), /* 5:4 (1.25) */

4
src/backends/drm/drm_dmabuf_feedback.cpp
View file

@ -43,7 +43,7 @@ void DmabufFeedback::scanoutSuccessful(SurfaceInterface *surface)
}
}
void DmabufFeedback::scanoutFailed(SurfaceInterface *surface, const QMap<uint32_t, QVector<uint64_t>> &formats)
void DmabufFeedback::scanoutFailed(SurfaceInterface *surface, const QMap<uint32_t, QList<uint64_t>> &formats)
{
m_attemptedThisFrame = true;
if (surface != m_surface) {
@ -57,7 +57,7 @@ void DmabufFeedback::scanoutFailed(SurfaceInterface *surface, const QMap<uint32_
const DmaBufAttributes *dmabufAttrs = surface->buffer()->dmabufAttributes();
if (!m_attemptedFormats[dmabufAttrs->format].contains(dmabufAttrs->modifier)) {
m_attemptedFormats[dmabufAttrs->format] << dmabufAttrs->modifier;
QVector<LinuxDmaBufV1Feedback::Tranche> scanoutTranches;
QList<LinuxDmaBufV1Feedback::Tranche> scanoutTranches;
const auto tranches = m_eglBackend->tranches();
for (const auto &tranche : tranches) {
LinuxDmaBufV1Feedback::Tranche scanoutTranche;

6
src/backends/drm/drm_dmabuf_feedback.h
View file

@ -8,9 +8,9 @@
*/
#pragma once
#include <QList>
#include <QMap>
#include <QPointer>
#include <QVector>
namespace KWin
{
@ -26,11 +26,11 @@ public:
void renderingSurface();
void scanoutSuccessful(SurfaceInterface *surface);
void scanoutFailed(SurfaceInterface *surface, const QMap<uint32_t, QVector<uint64_t>> &formats);
void scanoutFailed(SurfaceInterface *surface, const QMap<uint32_t, QList<uint64_t>> &formats);
private:
QPointer<SurfaceInterface> m_surface;
QMap<uint32_t, QVector<uint64_t>> m_attemptedFormats;
QMap<uint32_t, QList<uint64_t>> m_attemptedFormats;
bool m_attemptedThisFrame = false;
DrmGpu *const m_gpu;

36
src/backends/drm/drm_egl_layer_surface.cpp
View file

@ -27,9 +27,9 @@
namespace KWin
{
static const QVector<uint64_t> linearModifier = {DRM_FORMAT_MOD_LINEAR};
static const QVector<uint64_t> implicitModifier = {DRM_FORMAT_MOD_INVALID};
static const QVector<uint32_t> cpuCopyFormats = {DRM_FORMAT_ARGB8888, DRM_FORMAT_XRGB8888};
static const QList<uint64_t> linearModifier = {DRM_FORMAT_MOD_LINEAR};
static const QList<uint64_t> implicitModifier = {DRM_FORMAT_MOD_INVALID};
static const QList<uint32_t> cpuCopyFormats = {DRM_FORMAT_ARGB8888, DRM_FORMAT_XRGB8888};
static const bool bufferAgeEnabled = qEnvironmentVariable("KWIN_USE_BUFFER_AGE") != QStringLiteral("0");
@ -69,7 +69,7 @@ void EglGbmLayerSurface::destroyResources()
m_oldSurface = {};
}
std::optional<OutputLayerBeginFrameInfo> EglGbmLayerSurface::startRendering(const QSize &bufferSize, TextureTransforms transformation, const QMap<uint32_t, QVector<uint64_t>> &formats, const ColorDescription &colorDescription, const QVector3D &channelFactors, bool enableColormanagement)
std::optional<OutputLayerBeginFrameInfo> EglGbmLayerSurface::startRendering(const QSize &bufferSize, TextureTransforms transformation, const QMap<uint32_t, QList<uint64_t>> &formats, const ColorDescription &colorDescription, const QVector3D &channelFactors, bool enableColormanagement)
{
if (!checkSurface(bufferSize, formats)) {
return std::nullopt;
@ -206,7 +206,7 @@ const ColorDescription &EglGbmLayerSurface::colorDescription() const
}
}
bool EglGbmLayerSurface::doesSurfaceFit(const QSize &size, const QMap<uint32_t, QVector<uint64_t>> &formats) const
bool EglGbmLayerSurface::doesSurfaceFit(const QSize &size, const QMap<uint32_t, QList<uint64_t>> &formats) const
{
return doesSurfaceFit(m_surface.get(), size, formats);
}
@ -220,7 +220,7 @@ std::shared_ptr<GLTexture> EglGbmLayerSurface::texture() const
}
}
std::shared_ptr<DrmFramebuffer> EglGbmLayerSurface::renderTestBuffer(const QSize &bufferSize, const QMap<uint32_t, QVector<uint64_t>> &formats)
std::shared_ptr<DrmFramebuffer> EglGbmLayerSurface::renderTestBuffer(const QSize &bufferSize, const QMap<uint32_t, QList<uint64_t>> &formats)
{
if (checkSurface(bufferSize, formats)) {
return m_surface->currentFramebuffer;
@ -229,7 +229,7 @@ std::shared_ptr<DrmFramebuffer> EglGbmLayerSurface::renderTestBuffer(const QSize
}
}
bool EglGbmLayerSurface::checkSurface(const QSize &size, const QMap<uint32_t, QVector<uint64_t>> &formats)
bool EglGbmLayerSurface::checkSurface(const QSize &size, const QMap<uint32_t, QList<uint64_t>> &formats)
{
if (doesSurfaceFit(m_surface.get(), size, formats)) {
return true;
@ -246,7 +246,7 @@ bool EglGbmLayerSurface::checkSurface(const QSize &size, const QMap<uint32_t, QV
return false;
}
bool EglGbmLayerSurface::doesSurfaceFit(Surface *surface, const QSize &size, const QMap<uint32_t, QVector<uint64_t>> &formats) const
bool EglGbmLayerSurface::doesSurfaceFit(Surface *surface, const QSize &size, const QMap<uint32_t, QList<uint64_t>> &formats) const
{
if (!surface) {
return false;
@ -258,10 +258,10 @@ bool EglGbmLayerSurface::doesSurfaceFit(Surface *surface, const QSize &size, con
&& (surface->forceLinear || swapchain->modifier() == DRM_FORMAT_MOD_INVALID || formats[swapchain->format()].contains(swapchain->modifier()));
}
std::unique_ptr<EglGbmLayerSurface::Surface> EglGbmLayerSurface::createSurface(const QSize &size, const QMap<uint32_t, QVector<uint64_t>> &formats) const
std::unique_ptr<EglGbmLayerSurface::Surface> EglGbmLayerSurface::createSurface(const QSize &size, const QMap<uint32_t, QList<uint64_t>> &formats) const
{
QVector<FormatInfo> preferredFormats;
QVector<FormatInfo> fallbackFormats;
QList<FormatInfo> preferredFormats;
QList<FormatInfo> fallbackFormats;
for (auto it = formats.begin(); it != formats.end(); it++) {
const auto format = formatInfo(it.key());
if (format.has_value() && format->bitsPerColor >= 8) {
@ -284,7 +284,7 @@ std::unique_ptr<EglGbmLayerSurface::Surface> EglGbmLayerSurface::createSurface(c
return lhs.bitsPerPixel < rhs.bitsPerPixel;
}
};
const auto doTestFormats = [this, &size, &formats](const QVector<FormatInfo> &gbmFormats, MultiGpuImportMode importMode) -> std::unique_ptr<Surface> {
const auto doTestFormats = [this, &size, &formats](const QList<FormatInfo> &gbmFormats, MultiGpuImportMode importMode) -> std::unique_ptr<Surface> {
for (const auto &format : gbmFormats) {
if (m_formatOption == FormatOption::RequireAlpha && format.alphaBits == 0) {
continue;
@ -296,7 +296,7 @@ std::unique_ptr<EglGbmLayerSurface::Surface> EglGbmLayerSurface::createSurface(c
}
return nullptr;
};
const auto testFormats = [this, &sort, &doTestFormats](QVector<FormatInfo> &formats) -> std::unique_ptr<Surface> {
const auto testFormats = [this, &sort, &doTestFormats](QList<FormatInfo> &formats) -> std::unique_ptr<Surface> {
std::sort(formats.begin(), formats.end(), sort);
if (m_gpu == m_eglBackend->gpu()) {
return doTestFormats(formats, MultiGpuImportMode::None);
@ -328,9 +328,9 @@ std::unique_ptr<EglGbmLayerSurface::Surface> EglGbmLayerSurface::createSurface(c
}
}
static QVector<uint64_t> filterModifiers(const QVector<uint64_t> &one, const QVector<uint64_t> &two)
static QList<uint64_t> filterModifiers(const QList<uint64_t> &one, const QList<uint64_t> &two)
{
QVector<uint64_t> ret = one;
QList<uint64_t> ret = one;
ret.erase(std::remove_if(ret.begin(), ret.end(), [&two](uint64_t mod) {
return !two.contains(mod);
}),
@ -338,10 +338,10 @@ static QVector<uint64_t> filterModifiers(const QVector<uint64_t> &one, const QVe
return ret;
}
std::unique_ptr<EglGbmLayerSurface::Surface> EglGbmLayerSurface::createSurface(const QSize &size, uint32_t format, const QVector<uint64_t> &modifiers, MultiGpuImportMode importMode) const
std::unique_ptr<EglGbmLayerSurface::Surface> EglGbmLayerSurface::createSurface(const QSize &size, uint32_t format, const QList<uint64_t> &modifiers, MultiGpuImportMode importMode) const
{
const bool cpuCopy = importMode == MultiGpuImportMode::DumbBuffer || m_bufferTarget == BufferTarget::Dumb;
QVector<uint64_t> renderModifiers;
QList<uint64_t> renderModifiers;
auto ret = std::make_unique<Surface>();
if (importMode == MultiGpuImportMode::Egl) {
ret->importContext = m_eglBackend->contextForGpu(m_gpu);
@ -384,7 +384,7 @@ std::unique_ptr<EglGbmLayerSurface::Surface> EglGbmLayerSurface::createSurface(c
return ret;
}
std::shared_ptr<EglSwapchain> EglGbmLayerSurface::createGbmSwapchain(DrmGpu *gpu, EglContext *context, const QSize &size, uint32_t format, const QVector<uint64_t> &modifiers, bool preferLinear) const
std::shared_ptr<EglSwapchain> EglGbmLayerSurface::createGbmSwapchain(DrmGpu *gpu, EglContext *context, const QSize &size, uint32_t format, const QList<uint64_t> &modifiers, bool preferLinear) const
{
static bool modifiersEnvSet = false;
static const bool modifiersEnv = qEnvironmentVariableIntValue("KWIN_DRM_USE_MODIFIERS", &modifiersEnvSet) != 0;

16
src/backends/drm/drm_egl_layer_surface.h
View file

@ -53,15 +53,15 @@ public:
EglGbmLayerSurface(DrmGpu *gpu, EglGbmBackend *eglBackend, BufferTarget target = BufferTarget::Normal, FormatOption formatOption = FormatOption::PreferAlpha);
~EglGbmLayerSurface();
std::optional<OutputLayerBeginFrameInfo> startRendering(const QSize &bufferSize, TextureTransforms transformation, const QMap<uint32_t, QVector<uint64_t>> &formats, const ColorDescription &colorDescription, const QVector3D &channelFactors, bool enableColormanagement);
std::optional<OutputLayerBeginFrameInfo> startRendering(const QSize &bufferSize, TextureTransforms transformation, const QMap<uint32_t, QList<uint64_t>> &formats, const ColorDescription &colorDescription, const QVector3D &channelFactors, bool enableColormanagement);
bool endRendering(const QRegion &damagedRegion);
std::chrono::nanoseconds queryRenderTime() const;
bool doesSurfaceFit(const QSize &size, const QMap<uint32_t, QVector<uint64_t>> &formats) const;
bool doesSurfaceFit(const QSize &size, const QMap<uint32_t, QList<uint64_t>> &formats) const;
std::shared_ptr<GLTexture> texture() const;
void destroyResources();
EglGbmBackend *eglBackend() const;
std::shared_ptr<DrmFramebuffer> renderTestBuffer(const QSize &bufferSize, const QMap<uint32_t, QVector<uint64_t>> &formats);
std::shared_ptr<DrmFramebuffer> renderTestBuffer(const QSize &bufferSize, const QMap<uint32_t, QList<uint64_t>> &formats);
std::shared_ptr<DrmFramebuffer> currentBuffer() const;
const ColorDescription &colorDescription() const;
@ -103,11 +103,11 @@ private:
std::chrono::steady_clock::time_point renderStart;
std::chrono::steady_clock::time_point renderEnd;
};
bool checkSurface(const QSize &size, const QMap<uint32_t, QVector<uint64_t>> &formats);
bool doesSurfaceFit(Surface *surface, const QSize &size, const QMap<uint32_t, QVector<uint64_t>> &formats) const;
std::unique_ptr<Surface> createSurface(const QSize &size, const QMap<uint32_t, QVector<uint64_t>> &formats) const;
std::unique_ptr<Surface> createSurface(const QSize &size, uint32_t format, const QVector<uint64_t> &modifiers, MultiGpuImportMode importMode) const;
std::shared_ptr<EglSwapchain> createGbmSwapchain(DrmGpu *gpu, EglContext *context, const QSize &size, uint32_t format, const QVector<uint64_t> &modifiers, bool forceLinear) const;
bool checkSurface(const QSize &size, const QMap<uint32_t, QList<uint64_t>> &formats);
bool doesSurfaceFit(Surface *surface, const QSize &size, const QMap<uint32_t, QList<uint64_t>> &formats) const;
std::unique_ptr<Surface> createSurface(const QSize &size, const QMap<uint32_t, QList<uint64_t>> &formats) const;
std::unique_ptr<Surface> createSurface(const QSize &size, uint32_t format, const QList<uint64_t> &modifiers, MultiGpuImportMode importMode) const;
std::shared_ptr<EglSwapchain> createGbmSwapchain(DrmGpu *gpu, EglContext *context, const QSize &size, uint32_t format, const QList<uint64_t> &modifiers, bool forceLinear) const;
std::shared_ptr<DrmFramebuffer> doRenderTestBuffer(Surface *surface) const;
std::shared_ptr<DrmFramebuffer> importBuffer(Surface *surface, EglSwapchainSlot *source) const;

36
src/backends/drm/drm_gpu.cpp
View file

@ -180,11 +180,11 @@ void DrmGpu::initDrmResources()
qCCritical(KWIN_DRM) << "drmModeGetResources for getting CRTCs failed on GPU" << m_devNode;
return;
}
QVector<DrmPlane *> assignedPlanes;
QList<DrmPlane *> assignedPlanes;
for (int i = 0; i < resources->count_crtcs; ++i) {
uint32_t crtcId = resources->crtcs[i];
QVector<DrmPlane *> primaryCandidates;
QVector<DrmPlane *> cursorCandidates;
QList<DrmPlane *> primaryCandidates;
QList<DrmPlane *> cursorCandidates;
for (const auto &plane : m_planes) {
if (plane->isCrtcSupported(i) && !assignedPlanes.contains(plane.get())) {
if (plane->type.enumValue() == DrmPlane::TypeIndex::Primary) {
@ -198,7 +198,7 @@ void DrmGpu::initDrmResources()
qCWarning(KWIN_DRM) << "Could not find a suitable primary plane for crtc" << resources->crtcs[i];
continue;
}
const auto findBestPlane = [crtcId](const QVector<DrmPlane *> &list) {
const auto findBestPlane = [crtcId](const QList<DrmPlane *> &list) {
// if the plane is already used with this crtc, prefer it
const auto connected = std::find_if(list.begin(), list.end(), [crtcId](DrmPlane *plane) {
return plane->crtcId.value() == crtcId;
@ -261,8 +261,8 @@ bool DrmGpu::updateOutputs()
}
// check for added and removed connectors
QVector<DrmConnector *> existing;
QVector<DrmOutput *> addedOutputs;
QList<DrmConnector *> existing;
QList<DrmOutput *> addedOutputs;
for (int i = 0; i < resources->count_connectors; ++i) {
const uint32_t currentConnector = resources->connectors[i];
const auto it = std::find_if(m_connectors.begin(), m_connectors.end(), [currentConnector](const auto &connector) {
@ -367,7 +367,7 @@ void DrmGpu::removeOutputs()
}
}
DrmPipeline::Error DrmGpu::checkCrtcAssignment(QVector<DrmConnector *> connectors, const QVector<DrmCrtc *> &crtcs)
DrmPipeline::Error DrmGpu::checkCrtcAssignment(QList<DrmConnector *> connectors, const QList<DrmCrtc *> &crtcs)
{
if (connectors.isEmpty() || crtcs.isEmpty()) {
if (m_pipelines.isEmpty()) {
@ -426,8 +426,8 @@ DrmPipeline::Error DrmGpu::checkCrtcAssignment(QVector<DrmConnector *> connector
DrmPipeline::Error DrmGpu::testPendingConfiguration()
{
QVector<DrmConnector *> connectors;
QVector<DrmCrtc *> crtcs;
QList<DrmConnector *> connectors;
QList<DrmCrtc *> crtcs;
// only change resources that aren't currently leased away
for (const auto &conn : m_connectors) {
bool isLeased = std::any_of(m_drmOutputs.cbegin(), m_drmOutputs.cend(), [&conn](const auto output) {
@ -456,7 +456,7 @@ DrmPipeline::Error DrmGpu::testPendingConfiguration()
DrmPipeline::Error DrmGpu::testPipelines()
{
QVector<DrmPipeline *> inactivePipelines;
QList<DrmPipeline *> inactivePipelines;
std::copy_if(m_pipelines.constBegin(), m_pipelines.constEnd(), std::back_inserter(inactivePipelines), [](const auto pipeline) {
return pipeline->enabled() && !pipeline->active();
});
@ -582,7 +582,7 @@ DrmBackend *DrmGpu::platform() const
return m_platform;
}
const QVector<DrmPipeline *> DrmGpu::pipelines() const
const QList<DrmPipeline *> DrmGpu::pipelines() const
{
return m_pipelines;
}
@ -603,9 +603,9 @@ void DrmGpu::removeVirtualOutput(DrmVirtualOutput *output)
}
}
std::unique_ptr<DrmLease> DrmGpu::leaseOutputs(const QVector<DrmOutput *> &outputs)
std::unique_ptr<DrmLease> DrmGpu::leaseOutputs(const QList<DrmOutput *> &outputs)
{
QVector<uint32_t> objects;
QList<uint32_t> objects;
for (DrmOutput *output : outputs) {
if (output->lease() || !output->addLeaseObjects(objects)) {
return nullptr;
@ -630,12 +630,12 @@ std::unique_ptr<DrmLease> DrmGpu::leaseOutputs(const QVector<DrmOutput *> &outpu
}
}
QVector<DrmVirtualOutput *> DrmGpu::virtualOutputs() const
QList<DrmVirtualOutput *> DrmGpu::virtualOutputs() const
{
return m_virtualOutputs;
}
QVector<DrmOutput *> DrmGpu::drmOutputs() const
QList<DrmOutput *> DrmGpu::drmOutputs() const
{
return m_drmOutputs;
}
@ -773,12 +773,12 @@ bool DrmGpu::maybeModeset()
}
}
QVector<DrmObject *> DrmGpu::unusedObjects() const
QList<DrmObject *> DrmGpu::unusedObjects() const
{
if (!m_atomicModeSetting) {
return {};
}
QVector<DrmObject *> ret = m_allObjects;
QList<DrmObject *> ret = m_allObjects;
for (const auto &pipeline : m_pipelines) {
ret.removeOne(pipeline->connector());
if (pipeline->crtc()) {
@ -906,7 +906,7 @@ std::shared_ptr<DrmFramebuffer> DrmGpu::importBuffer(GraphicsBuffer *buffer)
return std::make_shared<DrmFramebuffer>(this, framebufferId, buffer);
}
DrmLease::DrmLease(DrmGpu *gpu, FileDescriptor &&fd, uint32_t lesseeId, const QVector<DrmOutput *> &outputs)
DrmLease::DrmLease(DrmGpu *gpu, FileDescriptor &&fd, uint32_t lesseeId, const QList<DrmOutput *> &outputs)
: m_gpu(gpu)
, m_fd(std::move(fd))
, m_lesseeId(lesseeId)

26
src/backends/drm/drm_gpu.h
View file

@ -11,10 +11,10 @@
#include "drm_pipeline.h"
#include "utils/filedescriptor.h"
#include <QList>
#include <QPointer>
#include <QSize>
#include <QSocketNotifier>
#include <QVector>
#include <qobject.h>
#include <epoxy/egl.h>
@ -43,7 +43,7 @@ class DrmLease : public QObject
{
Q_OBJECT
public:
DrmLease(DrmGpu *gpu, FileDescriptor &&fd, uint32_t lesseeId, const QVector<DrmOutput *> &outputs);
DrmLease(DrmGpu *gpu, FileDescriptor &&fd, uint32_t lesseeId, const QList<DrmOutput *> &outputs);
~DrmLease();
FileDescriptor &fd();
@ -56,7 +56,7 @@ private:
DrmGpu *const m_gpu;
FileDescriptor m_fd;
const uint32_t m_lesseeId;
const QVector<DrmOutput *> m_outputs;
const QList<DrmOutput *> m_outputs;
};
class DrmGpu : public QObject
@ -89,9 +89,9 @@ public:
clockid_t presentationClock() const;
QSize cursorSize() const;
QVector<DrmVirtualOutput *> virtualOutputs() const;
QVector<DrmOutput *> drmOutputs() const;
const QVector<DrmPipeline *> pipelines() const;
QList<DrmVirtualOutput *> virtualOutputs() const;
QList<DrmOutput *> drmOutputs() const;
const QList<DrmPipeline *> pipelines() const;
void setEglDisplay(std::unique_ptr<EglDisplay> &&display);
@ -111,7 +111,7 @@ public:
void recreateSurfaces();
FileDescriptor createNonMasterFd() const;
std::unique_ptr<DrmLease> leaseOutputs(const QVector<DrmOutput *> &outputs);
std::unique_ptr<DrmLease> leaseOutputs(const QList<DrmOutput *> &outputs);
void waitIdle();
Q_SIGNALS:
@ -125,9 +125,9 @@ private:
void removeOutput(DrmOutput *output);
void initDrmResources();
DrmPipeline::Error checkCrtcAssignment(QVector<DrmConnector *> connectors, const QVector<DrmCrtc *> &crtcs);
DrmPipeline::Error checkCrtcAssignment(QList<DrmConnector *> connectors, const QList<DrmCrtc *> &crtcs);
DrmPipeline::Error testPipelines();
QVector<DrmObject *> unusedObjects() const;
QList<DrmObject *> unusedObjects() const;
static void pageFlipHandler(int fd, unsigned int sequence, unsigned int sec, unsigned int usec, unsigned int crtc_id, void *user_data);
@ -151,11 +151,11 @@ private:
std::vector<std::unique_ptr<DrmPlane>> m_planes;
std::vector<std::unique_ptr<DrmCrtc>> m_crtcs;
std::vector<std::shared_ptr<DrmConnector>> m_connectors;
QVector<DrmObject *> m_allObjects;
QVector<DrmPipeline *> m_pipelines;
QList<DrmObject *> m_allObjects;
QList<DrmPipeline *> m_pipelines;
QVector<DrmOutput *> m_drmOutputs;
QVector<DrmVirtualOutput *> m_virtualOutputs;
QList<DrmOutput *> m_drmOutputs;
QList<DrmVirtualOutput *> m_virtualOutputs;
std::unique_ptr<QSocketNotifier> m_socketNotifier;
QSize m_cursorSize;

2
src/backends/drm/drm_object.h
View file

@ -9,8 +9,8 @@
#pragma once
#include <QByteArray>
#include <QList>
#include <QMap>
#include <QVector>
#include <vector>

2
src/backends/drm/drm_output.cpp
View file

@ -105,7 +105,7 @@ DrmOutput::~DrmOutput()
m_pipeline->setOutput(nullptr);
}
bool DrmOutput::addLeaseObjects(QVector<uint32_t> &objectList)
bool DrmOutput::addLeaseObjects(QList<uint32_t> &objectList)
{
if (!m_pipeline->crtc()) {
qCWarning(KWIN_DRM) << "Can't lease connector: No suitable crtc available";

4
src/backends/drm/drm_output.h
View file

@ -12,12 +12,12 @@
#include "drm_object.h"
#include "drm_plane.h"
#include <QList>
#include <QObject>
#include <QPoint>
#include <QPointer>
#include <QSize>
#include <QTimer>
#include <QVector>
#include <chrono>
#include <xf86drmMode.h>
@ -54,7 +54,7 @@ public:
bool updateCursorLayer() override;
DrmLease *lease() const;
bool addLeaseObjects(QVector<uint32_t> &objectList);
bool addLeaseObjects(QList<uint32_t> &objectList);
void leased(DrmLease *lease);
void leaseEnded();

24
src/backends/drm/drm_pipeline.cpp
View file

@ -33,9 +33,9 @@ using namespace std::literals;
namespace KWin
{
static const QVector<uint64_t> implicitModifier = {DRM_FORMAT_MOD_INVALID};
static const QMap<uint32_t, QVector<uint64_t>> legacyFormats = {{DRM_FORMAT_XRGB8888, implicitModifier}};
static const QMap<uint32_t, QVector<uint64_t>> legacyCursorFormats = {{DRM_FORMAT_ARGB8888, implicitModifier}};
static const QList<uint64_t> implicitModifier = {DRM_FORMAT_MOD_INVALID};
static const QMap<uint32_t, QList<uint64_t>> legacyFormats = {{DRM_FORMAT_XRGB8888, implicitModifier}};
static const QMap<uint32_t, QList<uint64_t>> legacyCursorFormats = {{DRM_FORMAT_ARGB8888, implicitModifier}};
DrmPipeline::DrmPipeline(DrmConnector *conn)
: m_connector(conn)
@ -79,7 +79,7 @@ DrmPipeline::Error DrmPipeline::present()
Q_ASSERT(m_pending.crtc);
if (gpu()->atomicModeSetting()) {
// test the full state, to take pending commits into account
auto fullState = std::make_unique<DrmAtomicCommit>(QVector<DrmPipeline *>{this});
auto fullState = std::make_unique<DrmAtomicCommit>(QList<DrmPipeline *>{this});
if (Error err = prepareAtomicPresentation(fullState.get()); err != Error::None) {
return err;
}
@ -90,7 +90,7 @@ DrmPipeline::Error DrmPipeline::present()
return errnoToError();
}
// only give the actual state update to the commit thread, so that it can potentially reorder the commits
auto primaryPlaneUpdate = std::make_unique<DrmAtomicCommit>(QVector<DrmPipeline *>{this});
auto primaryPlaneUpdate = std::make_unique<DrmAtomicCommit>(QList<DrmPipeline *>{this});
if (Error err = prepareAtomicPresentation(primaryPlaneUpdate.get()); err != Error::None) {
return err;
}
@ -111,7 +111,7 @@ bool DrmPipeline::maybeModeset()
return gpu()->maybeModeset();
}
DrmPipeline::Error DrmPipeline::commitPipelines(const QVector<DrmPipeline *> &pipelines, CommitMode mode, const QVector<DrmObject *> &unusedObjects)
DrmPipeline::Error DrmPipeline::commitPipelines(const QList<DrmPipeline *> &pipelines, CommitMode mode, const QList<DrmObject *> &unusedObjects)
{
Q_ASSERT(!pipelines.isEmpty());
if (pipelines[0]->gpu()->atomicModeSetting()) {
@ -121,7 +121,7 @@ DrmPipeline::Error DrmPipeline::commitPipelines(const QVector<DrmPipeline *> &pi
}
}
DrmPipeline::Error DrmPipeline::commitPipelinesAtomic(const QVector<DrmPipeline *> &pipelines, CommitMode mode, const QVector<DrmObject *> &unusedObjects)
DrmPipeline::Error DrmPipeline::commitPipelinesAtomic(const QList<DrmPipeline *> &pipelines, CommitMode mode, const QList<DrmObject *> &unusedObjects)
{
auto commit = std::make_unique<DrmAtomicCommit>(pipelines);
if (mode == CommitMode::Test) {
@ -376,7 +376,7 @@ bool DrmPipeline::updateCursor()
return false;
}
// test the full state, to take pending commits into account
auto fullState = std::make_unique<DrmAtomicCommit>(QVector<DrmPipeline *>{this});
auto fullState = std::make_unique<DrmAtomicCommit>(QList<DrmPipeline *>{this});
if (prepareAtomicPresentation(fullState.get()) != Error::None) {
return false;
}
@ -385,7 +385,7 @@ bool DrmPipeline::updateCursor()
return false;
}
// only give the actual state update to the commit thread, so that it can potentially reorder the commits
auto cursorOnly = std::make_unique<DrmAtomicCommit>(QVector<DrmPipeline *>{this});
auto cursorOnly = std::make_unique<DrmAtomicCommit>(QList<DrmPipeline *>{this});
prepareAtomicCursor(cursorOnly.get());
cursorOnly->setCursorOnly(true);
m_commitThread->addCommit(std::move(cursorOnly));
@ -434,12 +434,12 @@ DrmOutput *DrmPipeline::output() const
return m_output;
}
QMap<uint32_t, QVector<uint64_t>> DrmPipeline::formats() const
QMap<uint32_t, QList<uint64_t>> DrmPipeline::formats() const
{
return m_pending.formats;
}
QMap<uint32_t, QVector<uint64_t>> DrmPipeline::cursorFormats() const
QMap<uint32_t, QList<uint64_t>> DrmPipeline::cursorFormats() const
{
if (m_pending.crtc && m_pending.crtc->cursorPlane()) {
return m_pending.crtc->cursorPlane()->formats();
@ -502,7 +502,7 @@ DrmGammaRamp::DrmGammaRamp(DrmCrtc *crtc, const std::shared_ptr<ColorTransformat
: m_lut(transformation, crtc->gammaRampSize())
{
if (crtc->gpu()->atomicModeSetting()) {
QVector<drm_color_lut> atomicLut(m_lut.size());
QList<drm_color_lut> atomicLut(m_lut.size());
for (uint32_t i = 0; i < m_lut.size(); i++) {
atomicLut[i].red = m_lut.red()[i];
atomicLut[i].green = m_lut.green()[i];

14
src/backends/drm/drm_pipeline.h
View file

@ -9,9 +9,9 @@
#pragma once
#include <QList>
#include <QPoint>
#include <QSize>
#include <QVector>
#include <chrono>
#include <xf86drmMode.h>
@ -93,8 +93,8 @@ public:
bool modesetPresentPending() const;
void resetModesetPresentPending();
QMap<uint32_t, QVector<uint64_t>> formats() const;
QMap<uint32_t, QVector<uint64_t>> cursorFormats() const;
QMap<uint32_t, QList<uint64_t>> formats() const;
QMap<uint32_t, QList<uint64_t>> cursorFormats() const;
bool pruneModifier();
void setOutput(DrmOutput *output);
@ -139,7 +139,7 @@ public:
CommitModeset
};
Q_ENUM(CommitMode)
static Error commitPipelines(const QVector<DrmPipeline *> &pipelines, CommitMode mode, const QVector<DrmObject *> &unusedObjects = {});
static Error commitPipelines(const QList<DrmPipeline *> &pipelines, CommitMode mode, const QList<DrmObject *> &unusedObjects = {});
private:
bool isBufferForDirectScanout() const;
@ -153,7 +153,7 @@ private:
Error legacyModeset();
Error applyPendingChangesLegacy();
bool setCursorLegacy();
static Error commitPipelinesLegacy(const QVector<DrmPipeline *> &pipelines, CommitMode mode);
static Error commitPipelinesLegacy(const QList<DrmPipeline *> &pipelines, CommitMode mode);
// atomic modesetting only
void atomicCommitSuccessful();
@ -161,7 +161,7 @@ private:
Error prepareAtomicPresentation(DrmAtomicCommit *commit);
void prepareAtomicCursor(DrmAtomicCommit *commit);
void prepareAtomicDisable(DrmAtomicCommit *commit);
static Error commitPipelinesAtomic(const QVector<DrmPipeline *> &pipelines, CommitMode mode, const QVector<DrmObject *> &unusedObjects);
static Error commitPipelinesAtomic(const QList<DrmPipeline *> &pipelines, CommitMode mode, const QList<DrmObject *> &unusedObjects);
DrmOutput *m_output = nullptr;
DrmConnector *m_connector = nullptr;
@ -172,7 +172,7 @@ private:
struct State
{
DrmCrtc *crtc = nullptr;
QMap<uint32_t, QVector<uint64_t>> formats;
QMap<uint32_t, QList<uint64_t>> formats;
bool active = true; // whether or not the pipeline should be currently used
bool enabled = true; // whether or not the pipeline needs a crtc
bool needsModeset = false;

2
src/backends/drm/drm_pipeline_legacy.cpp
View file

@ -65,7 +65,7 @@ DrmPipeline::Error DrmPipeline::legacyModeset()
return Error::None;
}
DrmPipeline::Error DrmPipeline::commitPipelinesLegacy(const QVector<DrmPipeline *> &pipelines, CommitMode mode)
DrmPipeline::Error DrmPipeline::commitPipelinesLegacy(const QList<DrmPipeline *> &pipelines, CommitMode mode)
{
Error err = Error::None;
for (const auto &pipeline : pipelines) {

4
src/backends/drm/drm_plane.cpp
View file

@ -96,7 +96,7 @@ bool DrmPlane::updateProperties()
}
} else {
// if we don't have modifier support, assume the cursor needs a linear buffer
const QVector<uint64_t> modifiers = {type.enumValue() == TypeIndex::Cursor ? DRM_FORMAT_MOD_LINEAR : DRM_FORMAT_MOD_INVALID};
const QList<uint64_t> modifiers = {type.enumValue() == TypeIndex::Cursor ? DRM_FORMAT_MOD_LINEAR : DRM_FORMAT_MOD_INVALID};
for (uint32_t i = 0; i < p->count_formats; i++) {
m_supportedFormats.insert(p->formats[i], modifiers);
}
@ -127,7 +127,7 @@ bool DrmPlane::isCrtcSupported(int pipeIndex) const
return (m_possibleCrtcs & (1 << pipeIndex));
}
QMap<uint32_t, QVector<uint64_t>> DrmPlane::formats() const
QMap<uint32_t, QList<uint64_t>> DrmPlane::formats() const
{
return m_supportedFormats;
}

4
src/backends/drm/drm_plane.h
View file

@ -33,7 +33,7 @@ public:
void disable(DrmAtomicCommit *commit) override;
bool isCrtcSupported(int pipeIndex) const;
QMap<uint32_t, QVector<uint64_t>> formats() const;
QMap<uint32_t, QList<uint64_t>> formats() const;
std::shared_ptr<DrmFramebuffer> currentBuffer() const;
void setCurrentBuffer(const std::shared_ptr<DrmFramebuffer> &b);
@ -83,7 +83,7 @@ public:
private:
std::shared_ptr<DrmFramebuffer> m_current;
QMap<uint32_t, QVector<uint64_t>> m_supportedFormats;
QMap<uint32_t, QList<uint64_t>> m_supportedFormats;
uint32_t m_possibleCrtcs;
};

2
src/backends/drm/drm_property.cpp
View file

@ -17,7 +17,7 @@
namespace KWin
{
DrmProperty::DrmProperty(DrmObject *obj, const QByteArray &name, const QVector<QByteArray> &enumNames)
DrmProperty::DrmProperty(DrmObject *obj, const QByteArray &name, const QList<QByteArray> &enumNames)
: m_obj(obj)
, m_propName(name)
, m_enumNames(enumNames)

8
src/backends/drm/drm_property.h
View file

@ -13,8 +13,8 @@
#include "drm_logging.h"
#include <QByteArray>
#include <QList>
#include <QMap>
#include <QVector>
#include <xf86drmMode.h>
@ -27,7 +27,7 @@ class DrmPropertyList;
class DrmProperty
{
public:
DrmProperty(DrmObject *obj, const QByteArray &name, const QVector<QByteArray> &enumNames = {});
DrmProperty(DrmObject *obj, const QByteArray &name, const QList<QByteArray> &enumNames = {});
const QByteArray &name() const;
DrmObject *drmObject() const;
@ -48,7 +48,7 @@ public:
protected:
DrmObject *const m_obj;
const QByteArray m_propName;
const QVector<QByteArray> m_enumNames;
const QList<QByteArray> m_enumNames;
uint32_t m_propId = 0;
// the last known value from the kernel
@ -69,7 +69,7 @@ template<typename Enum>
class DrmEnumProperty : public DrmProperty
{
public:
DrmEnumProperty(DrmObject *obj, const QByteArray &name, const QVector<QByteArray> &enumNames)
DrmEnumProperty(DrmObject *obj, const QByteArray &name, const QList<QByteArray> &enumNames)
: DrmProperty(obj, name, enumNames)
{
}

2
src/backends/drm/drm_qpainter_backend.h
View file

@ -10,8 +10,8 @@
#include "drm_render_backend.h"
#include "platformsupport/scenes/qpainter/qpainterbackend.h"
#include <QList>
#include <QObject>
#include <QVector>
namespace KWin
{

2
src/backends/drm/drm_virtual_egl_layer.cpp
View file

@ -117,7 +117,7 @@ std::shared_ptr<EglSwapchain> VirtualEglGbmLayer::createGbmSwapchain() const
}
}
static const QVector<uint64_t> implicitModifier{DRM_FORMAT_MOD_INVALID};
static const QList<uint64_t> implicitModifier{DRM_FORMAT_MOD_INVALID};
if (auto swapchain = EglSwapchain::create(m_eglBackend->gpu()->graphicsBufferAllocator(), m_eglBackend->contextObject(), size, format, implicitModifier)) {
return swapchain;
}

4
src/backends/libinput/connection.cpp
View file

@ -226,7 +226,7 @@ KWin::TabletToolId createTabletId(libinput_tablet_tool *tool, Device *dev)
toolType = InputRedirection::Totem;
break;
}
QVector<InputRedirection::Capability> capabilities;
QList<InputRedirection::Capability> capabilities;
if (libinput_tablet_tool_has_pressure(tool)) {
capabilities << InputRedirection::Pressure;
}
@ -586,7 +586,7 @@ void Connection::applyScreenToDevice(Device *device)
}
Output *deviceOutput = nullptr;
const QVector<Output *> outputs = kwinApp()->outputBackend()->outputs();
const QList<Output *> outputs = kwinApp()->outputBackend()->outputs();
// let's try to find a screen for it
if (!device->outputName().isEmpty()) {

4
src/backends/libinput/connection.h
View file

@ -12,12 +12,12 @@
#include <KSharedConfig>
#include <QList>
#include <QObject>
#include <QPointer>
#include <QRecursiveMutex>
#include <QSize>
#include <QStringList>
#include <QVector>
#include <deque>
class QSocketNotifier;
@ -76,7 +76,7 @@ private:
std::unique_ptr<QSocketNotifier> m_notifier;
QRecursiveMutex m_mutex;
std::deque<std::unique_ptr<Event>> m_eventQueue;
QVector<Device *> m_devices;
QList<Device *> m_devices;
KSharedConfigPtr m_config;
std::unique_ptr<ConnectionAdaptor> m_connectionAdaptor;
std::unique_ptr<Context> m_input;

2
src/backends/libinput/device.h
View file

@ -14,11 +14,11 @@
#include <KConfigGroup>
#include <QList>
#include <QMatrix4x4>
#include <QObject>
#include <QPointer>
#include <QSizeF>
#include <QVector>
struct libinput_device;

4
src/backends/libinput/events.cpp
View file

@ -186,9 +186,9 @@ InputRedirection::PointerButtonState PointerEvent::buttonState() const
}
}
QVector<InputRedirection::PointerAxis> PointerEvent::axis() const
QList<InputRedirection::PointerAxis> PointerEvent::axis() const
{
QVector<InputRedirection::PointerAxis> a;
QList<InputRedirection::PointerAxis> a;
if (libinput_event_pointer_has_axis(m_pointerEvent, LIBINPUT_POINTER_AXIS_SCROLL_HORIZONTAL)) {
a << InputRedirection::PointerAxisHorizontal;
}

2
src/backends/libinput/events.h
View file

@ -84,7 +84,7 @@ public:
uint32_t button() const;
InputRedirection::PointerButtonState buttonState() const;
std::chrono::microseconds time() const;
QVector<InputRedirection::PointerAxis> axis() const;
QList<InputRedirection::PointerAxis> axis() const;
qreal scrollValue(InputRedirection::PointerAxis a) const;
qint32 scrollValueV120(InputRedirection::PointerAxis axis) const;

10
src/backends/virtual/virtual_backend.cpp
View file

@ -26,7 +26,7 @@ static FileDescriptor findRenderDevice()
return FileDescriptor{};
}
QVector<drmDevice *> devices(deviceCount);
QList<drmDevice *> devices(deviceCount);
if (drmGetDevices2(0, devices.data(), devices.size()) < 0) {
return FileDescriptor{};
}
@ -76,9 +76,9 @@ bool VirtualBackend::initialize()
return true;
}
QVector<CompositingType> VirtualBackend::supportedCompositors() const
QList<CompositingType> VirtualBackend::supportedCompositors() const
{
QVector<CompositingType> compositingTypes;
QList<CompositingType> compositingTypes;
if (m_gbmDevice) {
compositingTypes.append(OpenGLCompositing);
}
@ -123,9 +123,9 @@ Output *VirtualBackend::addOutput(const OutputInfo &info)
return output;
}
void VirtualBackend::setVirtualOutputs(const QVector<OutputInfo> &infos)
void VirtualBackend::setVirtualOutputs(const QList<OutputInfo> &infos)
{
const QVector<VirtualOutput *> removed = m_outputs;
const QList<VirtualOutput *> removed = m_outputs;
for (const auto &info : infos) {
createOutput(info);

6
src/backends/virtual/virtual_backend.h
View file

@ -40,11 +40,11 @@ public:
bool internal = false;
};
Output *addOutput(const OutputInfo &info);
void setVirtualOutputs(const QVector<OutputInfo> &infos);
void setVirtualOutputs(const QList<OutputInfo> &infos);
Outputs outputs() const override;
QVector<CompositingType> supportedCompositors() const override;
QList<CompositingType> supportedCompositors() const override;
void setEglDisplay(std::unique_ptr<EglDisplay> &&display);
EglDisplay *sceneEglDisplayObject() const override;
@ -57,7 +57,7 @@ Q_SIGNALS:
private:
VirtualOutput *createOutput(const OutputInfo &info);
QVector<VirtualOutput *> m_outputs;
QList<VirtualOutput *> m_outputs;
std::unique_ptr<EglDisplay> m_display;
FileDescriptor m_drmFileDescriptor;
gbm_device *m_gbmDevice = nullptr;

2
src/backends/virtual/virtual_qpainter_backend.h
View file

@ -11,9 +11,9 @@
#include "core/outputlayer.h"
#include "platformsupport/scenes/qpainter/qpainterbackend.h"
#include <QList>
#include <QMap>
#include <QObject>
#include <QVector>
#include <chrono>
#include <memory>

4
src/backends/wayland/wayland_backend.cpp
View file

@ -562,9 +562,9 @@ void WaylandBackend::togglePointerLock()
m_pointerLockRequested = !m_pointerLockRequested;
}
QVector<CompositingType> WaylandBackend::supportedCompositors() const
QList<CompositingType> WaylandBackend::supportedCompositors() const
{
QVector<CompositingType> ret;
QList<CompositingType> ret;
if (m_display->linuxDmabuf() && m_gbmDevice) {
ret.append(OpenGLCompositing);
}

6
src/backends/wayland/wayland_backend.h
View file

@ -227,11 +227,11 @@ public:
bool supportsPointerLock();
void togglePointerLock();
QVector<CompositingType> supportedCompositors() const override;
QList<CompositingType> supportedCompositors() const override;
WaylandOutput *findOutput(KWayland::Client::Surface *nativeSurface) const;
Outputs outputs() const override;
QVector<WaylandOutput *> waylandOutputs() const
QList<WaylandOutput *> waylandOutputs() const
{
return m_outputs;
}
@ -265,7 +265,7 @@ private:
std::unique_ptr<WaylandDisplay> m_display;
std::unique_ptr<WaylandSeat> m_seat;
WaylandEglBackend *m_eglBackend = nullptr;
QVector<WaylandOutput *> m_outputs;
QList<WaylandOutput *> m_outputs;
bool m_pointerLockRequested = false;
FileDescriptor m_drmFileDescriptor;
gbm_device *m_gbmDevice = nullptr;

4
src/backends/wayland/wayland_display.cpp
View file

@ -187,7 +187,7 @@ public:
dev_t mainDeviceId = 0;
dev_t trancheDeviceId = 0;
MemoryMap formatTable;
QHash<uint32_t, QVector<uint64_t>> formats;
QHash<uint32_t, QList<uint64_t>> formats;
private:
static void done(void *data, zwp_linux_dmabuf_feedback_v1 *zwp_linux_dmabuf_feedback_v1)
@ -299,7 +299,7 @@ QByteArray WaylandLinuxDmabufV1::mainDevice() const
return m_defaultFeedback->mainDevice;
}
QHash<uint32_t, QVector<uint64_t>> WaylandLinuxDmabufV1::formats() const
QHash<uint32_t, QList<uint64_t>> WaylandLinuxDmabufV1::formats() const
{
return m_defaultFeedback->formats;
}

2
src/backends/wayland/wayland_display.h
View file

@ -46,7 +46,7 @@ public:
zwp_linux_dmabuf_v1 *handle() const;
QByteArray mainDevice() const;
QHash<uint32_t, QVector<uint64_t>> formats() const;
QHash<uint32_t, QList<uint64_t>> formats() const;
private:
static void format(void *data, struct zwp_linux_dmabuf_v1 *zwp_linux_dmabuf_v1, uint32_t format);

8
src/backends/wayland/wayland_egl_backend.cpp
View file

@ -62,9 +62,9 @@ std::optional<OutputLayerBeginFrameInfo> WaylandEglPrimaryLayer::beginFrame()
const QSize nativeSize = m_waylandOutput->modeSize();
if (!m_swapchain || m_swapchain->size() != nativeSize) {
const QHash<uint32_t, QVector<uint64_t>> formatTable = m_backend->backend()->display()->linuxDmabuf()->formats();
const QHash<uint32_t, QList<uint64_t>> formatTable = m_backend->backend()->display()->linuxDmabuf()->formats();
uint32_t format = DRM_FORMAT_INVALID;
QVector<uint64_t> modifiers;
QList<uint64_t> modifiers;
for (const uint32_t &candidateFormat : {DRM_FORMAT_XRGB2101010, DRM_FORMAT_XRGB8888}) {
auto it = formatTable.constFind(candidateFormat);
if (it != formatTable.constEnd()) {
@ -156,9 +156,9 @@ std::optional<OutputLayerBeginFrameInfo> WaylandEglCursorLayer::beginFrame()
const auto tmp = size().expandedTo(QSize(64, 64));
const QSize bufferSize(std::ceil(tmp.width()), std::ceil(tmp.height()));
if (!m_swapchain || m_swapchain->size() != bufferSize) {
const QHash<uint32_t, QVector<uint64_t>> formatTable = m_backend->backend()->display()->linuxDmabuf()->formats();
const QHash<uint32_t, QList<uint64_t>> formatTable = m_backend->backend()->display()->linuxDmabuf()->formats();
uint32_t format = DRM_FORMAT_INVALID;
QVector<uint64_t> modifiers;
QList<uint64_t> modifiers;
for (const uint32_t &candidateFormat : {DRM_FORMAT_ARGB2101010, DRM_FORMAT_ARGB8888}) {
auto it = formatTable.constFind(candidateFormat);
if (it != formatTable.constEnd()) {

12
src/backends/x11/standalone/x11_standalone_backend.cpp
View file

@ -256,9 +256,9 @@ void X11StandaloneBackend::createEffectsHandler(Compositor *compositor, Workspac
new EffectsHandlerImplX11(compositor, scene);
}
QVector<CompositingType> X11StandaloneBackend::supportedCompositors() const
QList<CompositingType> X11StandaloneBackend::supportedCompositors() const
{
QVector<CompositingType> compositors;
QList<CompositingType> compositors;
#if HAVE_GLX
compositors << OpenGLCompositing;
#endif
@ -286,9 +286,9 @@ void X11StandaloneBackend::updateOutputs()
template<typename T>
void X11StandaloneBackend::doUpdateOutputs()
{
QVector<Output *> changed;
QVector<Output *> added;
QVector<Output *> removed = m_outputs;
QList<Output *> changed;
QList<Output *> added;
QList<Output *> removed = m_outputs;
if (Xcb::Extensions::self()->isRandrAvailable()) {
T resources(rootWindow());
@ -481,7 +481,7 @@ static int currentRefreshRate()
return refreshRate;
}
const QVector<Output *> outputs = kwinApp()->outputBackend()->outputs();
const QList<Output *> outputs = kwinApp()->outputBackend()->outputs();
if (outputs.isEmpty()) {
return 60000;
}

4
src/backends/x11/standalone/x11_standalone_backend.h
View file

@ -52,7 +52,7 @@ public:
xcb_window_t rootWindow() const;
std::unique_ptr<OpenGLBackend> createOpenGLBackend() override;
QVector<CompositingType> supportedCompositors() const override;
QList<CompositingType> supportedCompositors() const override;
void initOutputs();
void scheduleUpdateOutputs();
@ -101,7 +101,7 @@ private:
std::unique_ptr<X11EventFilter> m_randrEventFilter;
std::unique_ptr<X11Keyboard> m_keyboard;
std::unique_ptr<RenderLoop> m_renderLoop;
QVector<Output *> m_outputs;
QList<Output *> m_outputs;
std::unique_ptr<EglDisplay> m_eglDisplay;
};

2
src/backends/x11/standalone/x11_standalone_effects_keyboard_interception_filter.cpp
View file

@ -16,7 +16,7 @@ namespace KWin
{
EffectsKeyboardInterceptionX11Filter::EffectsKeyboardInterceptionX11Filter(EffectsHandlerImpl *effects, X11Keyboard *keyboard)
: X11EventFilter(QVector<int>{XCB_KEY_PRESS, XCB_KEY_RELEASE})
: X11EventFilter(QList<int>{XCB_KEY_PRESS, XCB_KEY_RELEASE})
, m_effects(effects)
, m_keyboard(keyboard)
{

2
src/backends/x11/standalone/x11_standalone_effects_mouse_interception_filter.cpp
View file

@ -16,7 +16,7 @@ namespace KWin
{
EffectsMouseInterceptionX11Filter::EffectsMouseInterceptionX11Filter(xcb_window_t window, EffectsHandlerImpl *effects)
: X11EventFilter(QVector<int>{XCB_BUTTON_PRESS, XCB_BUTTON_RELEASE, XCB_MOTION_NOTIFY})
: X11EventFilter(QList<int>{XCB_BUTTON_PRESS, XCB_BUTTON_RELEASE, XCB_MOTION_NOTIFY})
, m_effects(effects)
, m_window(window)
{

6
src/backends/x11/standalone/x11_standalone_overlaywindow.cpp
View file

@ -17,7 +17,7 @@
#include "workspace.h"
#include "x11_standalone_backend.h"
#include <QVector>
#include <QList>
#include <xcb/composite.h>
#include <xcb/shape.h>
@ -29,7 +29,7 @@ namespace KWin
{
OverlayWindowX11::OverlayWindowX11(X11StandaloneBackend *backend)
: OverlayWindow()
, X11EventFilter(QVector<int>{XCB_EXPOSE, XCB_VISIBILITY_NOTIFY})
, X11EventFilter(QList<int>{XCB_EXPOSE, XCB_VISIBILITY_NOTIFY})
, m_backend(backend)
, m_visible(true)
, m_shown(false)
@ -120,7 +120,7 @@ void OverlayWindowX11::setShape(const QRegion &reg)
if (reg == m_shape) {
return;
}
const QVector<xcb_rectangle_t> xrects = Xcb::regionToRects(reg);
const QList<xcb_rectangle_t> xrects = Xcb::regionToRects(reg);
xcb_shape_rectangles(connection(), XCB_SHAPE_SO_SET, XCB_SHAPE_SK_BOUNDING, XCB_CLIP_ORDERING_UNSORTED,
m_window, 0, 0, xrects.count(), xrects.data());
setupInputShape(m_window);

2
src/backends/x11/standalone/x11_standalone_screenedges_filter.cpp
View file

@ -18,7 +18,7 @@ namespace KWin
{
ScreenEdgesFilter::ScreenEdgesFilter()
: X11EventFilter(QVector<int>{XCB_MOTION_NOTIFY, XCB_ENTER_NOTIFY, XCB_CLIENT_MESSAGE})
: X11EventFilter(QList<int>{XCB_MOTION_NOTIFY, XCB_ENTER_NOTIFY, XCB_CLIENT_MESSAGE})
{
}

2
src/backends/x11/standalone/x11_standalone_windowselector.cpp
View file

@ -24,7 +24,7 @@ namespace KWin
{
WindowSelector::WindowSelector()
: X11EventFilter(QVector<int>{
: X11EventFilter(QList<int>{
XCB_BUTTON_PRESS,
XCB_BUTTON_RELEASE,
XCB_MOTION_NOTIFY,

2
src/backends/x11/standalone/x11_standalone_xfixes_cursor_event_filter.cpp
View file

@ -14,7 +14,7 @@ namespace KWin
{
XFixesCursorEventFilter::XFixesCursorEventFilter(X11Cursor *cursor)
: X11EventFilter(QVector<int>{Xcb::Extensions::self()->fixesCursorNotifyEvent()})
: X11EventFilter(QList<int>{Xcb::Extensions::self()->fixesCursorNotifyEvent()})
, m_cursor(cursor)
{
}

2
src/backends/x11/standalone/x11_standalone_xinputintegration.cpp
View file

@ -42,7 +42,7 @@ class XInputEventFilter : public X11EventFilter
{
public:
XInputEventFilter(int xi_opcode)
: X11EventFilter(XCB_GE_GENERIC, xi_opcode, QVector<int>{XI_RawMotion, XI_RawButtonPress, XI_RawButtonRelease, XI_RawKeyPress, XI_RawKeyRelease, XI_TouchBegin, XI_TouchUpdate, XI_TouchOwnership, XI_TouchEnd})
: X11EventFilter(XCB_GE_GENERIC, xi_opcode, QList<int>{XI_RawMotion, XI_RawButtonPress, XI_RawButtonRelease, XI_RawKeyPress, XI_RawKeyRelease, XI_TouchBegin, XI_TouchUpdate, XI_TouchOwnership, XI_TouchEnd})
{
}
~XInputEventFilter() override = default;

8
src/backends/x11/windowed/x11_windowed_backend.cpp
View file

@ -324,7 +324,7 @@ void X11WindowedBackend::initDri3()
while (it.rem > 0) {
uint32_t format = driFormatForDepth(it.data->depth);
if (format) {
QVector<uint64_t> &mods = m_driFormats[format];
QList<uint64_t> &mods = m_driFormats[format];
if (m_driMajorVersion > 1 || m_driMinorVersion >= 2) {
xcb_dri3_get_supported_modifiers_cookie_t cookie = xcb_dri3_get_supported_modifiers(m_connection, m_screen->root, it.data->depth, 32);
@ -754,7 +754,7 @@ bool X11WindowedBackend::hasXInput() const
return m_hasXInput;
}
QHash<uint32_t, QVector<uint64_t>> X11WindowedBackend::driFormats() const
QHash<uint32_t, QList<uint64_t>> X11WindowedBackend::driFormats() const
{
return m_driFormats;
}
@ -781,9 +781,9 @@ int X11WindowedBackend::driMinorVersion() const
return m_driMinorVersion;
}
QVector<CompositingType> X11WindowedBackend::supportedCompositors() const
QList<CompositingType> X11WindowedBackend::supportedCompositors() const
{
QVector<CompositingType> ret;
QList<CompositingType> ret;
if (m_gbmDevice) {
ret.append(OpenGLCompositing);
}

8
src/backends/x11/windowed/x11_windowed_backend.h
View file

@ -108,7 +108,7 @@ public:
bool hasXInput() const;
QHash<uint32_t, QVector<uint64_t>> driFormats() const;
QHash<uint32_t, QList<uint64_t>> driFormats() const;
uint32_t driFormatForDepth(int depth) const;
int driMajorVersion() const;
int driMinorVersion() const;
@ -117,7 +117,7 @@ public:
std::unique_ptr<OpenGLBackend> createOpenGLBackend() override;
std::unique_ptr<QPainterBackend> createQPainterBackend() override;
std::unique_ptr<InputBackend> createInputBackend() override;
QVector<CompositingType> supportedCompositors() const override;
QList<CompositingType> supportedCompositors() const override;
Outputs outputs() const override;
X11WindowedInputDevice *pointerDevice() const;
@ -173,13 +173,13 @@ private:
bool m_hasDri = false;
int m_driMajorVersion = 0;
int m_driMinorVersion = 0;
QHash<uint32_t, QVector<uint64_t>> m_driFormats;
QHash<uint32_t, QList<uint64_t>> m_driFormats;
FileDescriptor m_drmFileDescriptor;
gbm_device *m_gbmDevice = nullptr;
std::unique_ptr<EglDisplay> m_eglDisplay;
QVector<X11WindowedOutput *> m_outputs;
QList<X11WindowedOutput *> m_outputs;
};
} // namespace KWin

2
src/backends/x11/windowed/x11_windowed_egl_backend.cpp
View file

@ -39,7 +39,7 @@ std::optional<OutputLayerBeginFrameInfo> X11WindowedEglPrimaryLayer::beginFrame(
const QSize bufferSize = m_output->modeSize();
if (!m_swapchain || m_swapchain->size() != bufferSize) {
const uint32_t format = DRM_FORMAT_XRGB8888;
const QHash<uint32_t, QVector<uint64_t>> formatTable = m_backend->backend()->driFormats();
const QHash<uint32_t, QList<uint64_t>> formatTable = m_backend->backend()->driFormats();
if (!formatTable.contains(format)) {
return std::nullopt;
}

2
src/backends/x11/windowed/x11_windowed_qpainter_backend.h
View file

@ -12,8 +12,8 @@
#include "platformsupport/scenes/qpainter/qpainterbackend.h"
#include <QImage>
#include <QList>
#include <QObject>
#include <QVector>
#include <chrono>
#include <memory>

4
src/colors/colormanager.cpp
View file

@ -18,7 +18,7 @@ namespace KWin
class ColorManagerPrivate
{
public:
QVector<ColorDevice *> devices;
QList<ColorDevice *> devices;
};
ColorManager::ColorManager()
@ -36,7 +36,7 @@ ColorManager::ColorManager()
ColorManager::~ColorManager() = default;
QVector<ColorDevice *> ColorManager::devices() const
QList<ColorDevice *> ColorManager::devices() const
{
return d->devices;
}

2
src/colors/colormanager.h
View file

@ -38,7 +38,7 @@ public:
/**
* Returns the list of all available color devices.
*/
QVector<ColorDevice *> devices() const;
QList<ColorDevice *> devices() const;
Q_SIGNALS:
/**

4
src/compositor_wayland.cpp
View file

@ -120,8 +120,8 @@ void WaylandCompositor::start()
m_state = State::Starting;
// If compositing has been restarted, try to use the last used compositing type.
const QVector<CompositingType> availableCompositors = kwinApp()->outputBackend()->supportedCompositors();
QVector<CompositingType> candidateCompositors;
const QList<CompositingType> availableCompositors = kwinApp()->outputBackend()->supportedCompositors();
QList<CompositingType> candidateCompositors;
if (m_selectedCompositor != NoCompositing) {
candidateCompositors.append(m_selectedCompositor);

2
src/compositor_x11.cpp
View file

@ -280,7 +280,7 @@ void X11Compositor::start()
XCB_COMPOSITE_REDIRECT_MANUAL);
// Decide what compositing types can be used.
QVector<CompositingType> candidateCompositors = kwinApp()->outputBackend()->supportedCompositors();
QList<CompositingType> candidateCompositors = kwinApp()->outputBackend()->supportedCompositors();
const auto userConfigIt = std::find(candidateCompositors.begin(), candidateCompositors.end(), options->compositingMode());
if (userConfigIt != candidateCompositors.end()) {
candidateCompositors.erase(userConfigIt);

4
src/core/colorlut.h
View file

@ -8,7 +8,7 @@
*/
#pragma once
#include <QVector>
#include <QList>
#include <memory>
#include "kwin_export.h"
@ -30,7 +30,7 @@ public:
std::shared_ptr<ColorTransformation> transformation() const;
private:
QVector<uint16_t> m_data;
QList<uint16_t> m_data;
const std::shared_ptr<ColorTransformation> m_transformation;
};

4
src/core/graphicsbufferallocator.h
View file

@ -8,8 +8,8 @@
#include "kwin_export.h"
#include <QList>
#include <QSize>
#include <QVector>
namespace KWin
{
@ -28,7 +28,7 @@ struct GraphicsBufferOptions
uint32_t format;
/// An optional list of modifiers, see DRM_FORMAT_MOD_*.
QVector<uint64_t> modifiers;
QList<uint64_t> modifiers;
/// Whether the graphics buffer should be suitable for software rendering.
bool software = false;

2
src/core/output.h
View file

@ -14,13 +14,13 @@
#include "utils/edid.h"
#include <QDebug>
#include <QList>
#include <QMatrix3x3>
#include <QMatrix4x4>
#include <QObject>
#include <QRect>
#include <QSize>
#include <QUuid>
#include <QVector>
namespace KWin
{

4
src/core/outputbackend.cpp
View file

@ -46,8 +46,8 @@ std::unique_ptr<QPainterBackend> OutputBackend::createQPainterBackend()
bool OutputBackend::applyOutputChanges(const OutputConfiguration &config)
{
const auto availableOutputs = outputs();
QVector<Output *> toBeEnabledOutputs;
QVector<Output *> toBeDisabledOutputs;
QList<Output *> toBeEnabledOutputs;
QList<Output *> toBeDisabledOutputs;
for (const auto &output : availableOutputs) {
if (const auto changeset = config.constChangeSet(output)) {
if (changeset->enabled) {

6
src/core/outputbackend.h
View file

@ -29,12 +29,12 @@ class OutputConfiguration;
class EglDisplay;
class Session;
class KWIN_EXPORT Outputs : public QVector<Output *>
class KWIN_EXPORT Outputs : public QList<Output *>
{
public:
Outputs(){};
template<typename T>
Outputs(const QVector<T> &other)
Outputs(const QList<T> &other)
{
resize(other.size());
std::copy(other.constBegin(), other.constEnd(), begin());
@ -72,7 +72,7 @@ public:
* The first item should be the most preferred one.
* @since 5.11
*/
virtual QVector<CompositingType> supportedCompositors() const = 0;
virtual QList<CompositingType> supportedCompositors() const = 0;
virtual Outputs outputs() const = 0;
Output *findOutput(const QString &name) const;

4
src/core/renderbackend.cpp
View file

@ -42,9 +42,9 @@ bool RenderBackend::testImportBuffer(GraphicsBuffer *buffer)
return false;
}
QHash<uint32_t, QVector<uint64_t>> RenderBackend::supportedFormats() const
QHash<uint32_t, QList<uint64_t>> RenderBackend::supportedFormats() const
{
return QHash<uint32_t, QVector<uint64_t>>{{DRM_FORMAT_XRGB8888, QVector<uint64_t>{DRM_FORMAT_MOD_LINEAR}}};
return QHash<uint32_t, QList<uint64_t>>{{DRM_FORMAT_XRGB8888, QList<uint64_t>{DRM_FORMAT_MOD_LINEAR}}};
}
std::unique_ptr<SurfaceTexture> RenderBackend::createSurfaceTextureX11(SurfacePixmapX11 *pixmap)

2
src/core/renderbackend.h
View file

@ -47,7 +47,7 @@ public:
virtual GraphicsBufferAllocator *graphicsBufferAllocator() const;
virtual bool testImportBuffer(GraphicsBuffer *buffer);
virtual QHash<uint32_t, QVector<uint64_t>> supportedFormats() const;
virtual QHash<uint32_t, QList<uint64_t>> supportedFormats() const;
virtual std::unique_ptr<SurfaceTexture> createSurfaceTextureX11(SurfacePixmapX11 *pixmap);
virtual std::unique_ptr<SurfaceTexture> createSurfaceTextureWayland(SurfacePixmap *pixmap);

6
src/cursor.cpp
View file

@ -330,9 +330,9 @@ void Cursor::doStopCursorTracking()
{
}
QVector<QByteArray> Cursor::cursorAlternativeNames(const QByteArray &name)
QList<QByteArray> Cursor::cursorAlternativeNames(const QByteArray &name)
{
static const QHash<QByteArray, QVector<QByteArray>> alternatives = {
static const QHash<QByteArray, QList<QByteArray>> alternatives = {
{
QByteArrayLiteral("left_ptr"),
{
@ -604,7 +604,7 @@ QVector<QByteArray> Cursor::cursorAlternativeNames(const QByteArray &name)
if (it != alternatives.end()) {
return it.value();
}
return QVector<QByteArray>();
return QList<QByteArray>();
}
QString Cursor::defaultThemeName()

4
src/cursor.h
View file

@ -139,7 +139,7 @@ public:
/**
* @return list of alternative names for the cursor with @p name
*/
static QVector<QByteArray> cursorAlternativeNames(const QByteArray &name);
static QList<QByteArray> cursorAlternativeNames(const QByteArray &name);
/**
* Returns the default Xcursor theme name.
*/
@ -304,7 +304,7 @@ private:
static Cursors *s_self;
Cursor *m_currentCursor = nullptr;
Cursor *m_mouse = nullptr;
QVector<Cursor *> m_cursors;
QList<Cursor *> m_cursors;
int m_cursorHideCounter = 0;
};

2
src/cursorsource.h
View file

@ -66,7 +66,7 @@ private:
KXcursorTheme m_theme;
QByteArray m_shape;
QVector<KXcursorSprite> m_sprites;
QList<KXcursorSprite> m_sprites;
QTimer m_delayTimer;
QImage m_image;
int m_currentSprite = -1;

2
src/dbusinterface.cpp
View file

@ -361,7 +361,7 @@ VirtualDesktopManagerDBusInterface::VirtualDesktopManagerDBusInterface(VirtualDe
connect(m_manager, &VirtualDesktopManager::rowsChanged, this, &VirtualDesktopManagerDBusInterface::rowsChanged);
const QVector<VirtualDesktop *> allDesks = m_manager->desktops();
const QList<VirtualDesktop *> allDesks = m_manager->desktops();
for (auto *vd : allDesks) {
connect(vd, &VirtualDesktop::x11DesktopNumberChanged, this, [this, vd]() {
DBusDesktopDataStruct data{.position = vd->x11DesktopNumber() - 1, .id = vd->id(), .name = vd->name()};

12
src/debug_console.cpp
View file

@ -899,7 +899,7 @@ static const quint32 s_windowBitMask = 0x0000FFFF;
static const quint32 s_idDistance = 10000;
template<class T>
void DebugConsoleModel::add(int parentRow, QVector<T *> &windows, T *window)
void DebugConsoleModel::add(int parentRow, QList<T *> &windows, T *window)
{
beginInsertRows(index(parentRow, 0, QModelIndex()), windows.count(), windows.count());
windows.append(window);
@ -907,7 +907,7 @@ void DebugConsoleModel::add(int parentRow, QVector<T *> &windows, T *window)
}
template<class T>
void DebugConsoleModel::remove(int parentRow, QVector<T *> &windows, T *window)
void DebugConsoleModel::remove(int parentRow, QList<T *> &windows, T *window)
{
const int remove = windows.indexOf(window);
if (remove == -1) {
@ -1032,7 +1032,7 @@ int DebugConsoleModel::rowCount(const QModelIndex &parent) const
}
template<class T>
QModelIndex DebugConsoleModel::indexForWindow(int row, int column, const QVector<T *> &windows, int id) const
QModelIndex DebugConsoleModel::indexForWindow(int row, int column, const QList<T *> &windows, int id) const
{
if (column != 0) {
return QModelIndex();
@ -1187,7 +1187,7 @@ QVariant DebugConsoleModel::propertyData(QObject *object, const QModelIndex &ind
}
template<class T>
QVariant DebugConsoleModel::windowData(const QModelIndex &index, int role, const QVector<T *> windows, const std::function<QString(T *)> &toString) const
QVariant DebugConsoleModel::windowData(const QModelIndex &index, int role, const QList<T *> windows, const std::function<QString(T *)> &toString) const
{
if (index.row() >= windows.count()) {
return QVariant();
@ -1273,7 +1273,7 @@ QVariant DebugConsoleModel::data(const QModelIndex &index, int role) const
}
template<class T>
static T *windowForIndex(const QModelIndex &index, const QVector<T *> &windows, int id)
static T *windowForIndex(const QModelIndex &index, const QList<T *> &windows, int id)
{
const qint32 row = (index.internalId() & s_windowBitMask) - (s_idDistance * id);
if (row < 0 || row >= windows.count()) {
@ -1561,7 +1561,7 @@ void InputDeviceModel::slotPropertyChanged()
if (metaProperty.notifySignalIndex() == senderSignalIndex()) {
const QModelIndex parent = index(m_devices.indexOf(device), 0, QModelIndex());
const QModelIndex child = index(i, 1, parent);
Q_EMIT dataChanged(child, child, QVector<int>{Qt::DisplayRole});
Q_EMIT dataChanged(child, child, QList<int>{Qt::DisplayRole});
}
}
}

20
src/debug_console.h
View file

@ -14,8 +14,8 @@
#include <kwin_export.h>
#include <QAbstractItemModel>
#include <QList>
#include <QStyledItemDelegate>
#include <QVector>
#include <functional>
#include <memory>
@ -55,28 +55,28 @@ private Q_SLOTS:
private:
template<class T>
QModelIndex indexForWindow(int row, int column, const QVector<T *> &windows, int id) const;
QModelIndex indexForWindow(int row, int column, const QList<T *> &windows, int id) const;
template<class T>
QModelIndex indexForProperty(int row, int column, const QModelIndex &parent, T *(DebugConsoleModel::*filter)(const QModelIndex &) const) const;
template<class T>
int propertyCount(const QModelIndex &parent, T *(DebugConsoleModel::*filter)(const QModelIndex &) const) const;
QVariant propertyData(QObject *object, const QModelIndex &index, int role) const;
template<class T>
QVariant windowData(const QModelIndex &index, int role, const QVector<T *> windows, const std::function<QString(T *)> &toString) const;
QVariant windowData(const QModelIndex &index, int role, const QList<T *> windows, const std::function<QString(T *)> &toString) const;
template<class T>
void add(int parentRow, QVector<T *> &windows, T *window);
void add(int parentRow, QList<T *> &windows, T *window);
template<class T>
void remove(int parentRow, QVector<T *> &windows, T *window);
void remove(int parentRow, QList<T *> &windows, T *window);
WaylandWindow *waylandWindow(const QModelIndex &index) const;
InternalWindow *internalWindow(const QModelIndex &index) const;
X11Window *x11Window(const QModelIndex &index) const;
X11Window *unmanaged(const QModelIndex &index) const;
int topLevelRowCount() const;
QVector<WaylandWindow *> m_waylandWindows;
QVector<InternalWindow *> m_internalWindows;
QVector<X11Window *> m_x11Windows;
QVector<X11Window *> m_unmanageds;
QList<WaylandWindow *> m_waylandWindows;
QList<InternalWindow *> m_internalWindows;
QList<X11Window *> m_x11Windows;
QList<X11Window *> m_unmanageds;
};
class DebugConsoleDelegate : public QStyledItemDelegate
@ -196,6 +196,6 @@ public:
private:
AbstractDataSource *m_source = nullptr;
QVector<QByteArray> m_data;
QList<QByteArray> m_data;
};
}

4
src/decorations/decorationbridge.cpp
View file

@ -251,8 +251,8 @@ static QString settingsProperty(const QVariant &variant)
{
if (QLatin1String(variant.typeName()) == QLatin1String("KDecoration2::BorderSize")) {
return QString::number(variant.toInt());
} else if (QLatin1String(variant.typeName()) == QLatin1String("QVector<KDecoration2::DecorationButtonType>")) {
const auto &b = variant.value<QVector<KDecoration2::DecorationButtonType>>();
} else if (QLatin1String(variant.typeName()) == QLatin1String("QList<KDecoration2::DecorationButtonType>")) {
const auto &b = variant.value<QList<KDecoration2::DecorationButtonType>>();
QString buffer;
for (auto it = b.begin(); it != b.end(); ++it) {
if (it != b.begin()) {

14
src/decorations/settings.cpp
View file

@ -82,7 +82,7 @@ static void initButtons()
s_buttonNames[KDecoration2::DecorationButtonType::Shade] = QChar('L');
}
static QString buttonsToString(const QVector<KDecoration2::DecorationButtonType> &buttons)
static QString buttonsToString(const QList<KDecoration2::DecorationButtonType> &buttons)
{
auto buttonToString = [](KDecoration2::DecorationButtonType button) -> QChar {
const auto it = s_buttonNames.constFind(button);
@ -98,13 +98,13 @@ static QString buttonsToString(const QVector<KDecoration2::DecorationButtonType>
return ret;
}
QVector<KDecoration2::DecorationButtonType> SettingsImpl::readDecorationButtons(const KConfigGroup &config,
QList<KDecoration2::DecorationButtonType> SettingsImpl::readDecorationButtons(const KConfigGroup &config,
const char *key,
const QVector<KDecoration2::DecorationButtonType> &defaultValue) const
const QList<KDecoration2::DecorationButtonType> &defaultValue) const
{
initButtons();
auto buttonsFromString = [](const QString &buttons) -> QVector<KDecoration2::DecorationButtonType> {
QVector<KDecoration2::DecorationButtonType> ret;
auto buttonsFromString = [](const QString &buttons) -> QList<KDecoration2::DecorationButtonType> {
QList<KDecoration2::DecorationButtonType> ret;
for (auto it = buttons.begin(); it != buttons.end(); ++it) {
for (auto it2 = s_buttonNames.constBegin(); it2 != s_buttonNames.constEnd(); ++it2) {
if (it2.value() == (*it)) {
@ -139,12 +139,12 @@ static KDecoration2::BorderSize stringToSize(const QString &name)
void SettingsImpl::readSettings()
{
KConfigGroup config = kwinApp()->config()->group(QStringLiteral("org.kde.kdecoration2"));
const auto &left = readDecorationButtons(config, "ButtonsOnLeft", QVector<KDecoration2::DecorationButtonType>({KDecoration2::DecorationButtonType::Menu, KDecoration2::DecorationButtonType::OnAllDesktops}));
const auto &left = readDecorationButtons(config, "ButtonsOnLeft", QList<KDecoration2::DecorationButtonType>({KDecoration2::DecorationButtonType::Menu, KDecoration2::DecorationButtonType::OnAllDesktops}));
if (left != m_leftButtons) {
m_leftButtons = left;
Q_EMIT decorationSettings()->decorationButtonsLeftChanged(m_leftButtons);
}
const auto &right = readDecorationButtons(config, "ButtonsOnRight", QVector<KDecoration2::DecorationButtonType>({KDecoration2::DecorationButtonType::ContextHelp, KDecoration2::DecorationButtonType::Minimize, KDecoration2::DecorationButtonType::Maximize, KDecoration2::DecorationButtonType::Close}));
const auto &right = readDecorationButtons(config, "ButtonsOnRight", QList<KDecoration2::DecorationButtonType>({KDecoration2::DecorationButtonType::ContextHelp, KDecoration2::DecorationButtonType::Minimize, KDecoration2::DecorationButtonType::Maximize, KDecoration2::DecorationButtonType::Close}));
if (right != m_rightButtons) {
m_rightButtons = right;
Q_EMIT decorationSettings()->decorationButtonsRightChanged(m_rightButtons);

12
src/decorations/settings.h
View file

@ -32,11 +32,11 @@ public:
{
return m_borderSize;
}
QVector<KDecoration2::DecorationButtonType> decorationButtonsLeft() const override
QList<KDecoration2::DecorationButtonType> decorationButtonsLeft() const override
{
return m_leftButtons;
}
QVector<KDecoration2::DecorationButtonType> decorationButtonsRight() const override
QList<KDecoration2::DecorationButtonType> decorationButtonsRight() const override
{
return m_rightButtons;
}
@ -47,11 +47,11 @@ public:
private:
void readSettings();
QVector<KDecoration2::DecorationButtonType> readDecorationButtons(const KConfigGroup &config,
QList<KDecoration2::DecorationButtonType> readDecorationButtons(const KConfigGroup &config,
const char *key,
const QVector<KDecoration2::DecorationButtonType> &defaultValue) const;
QVector<KDecoration2::DecorationButtonType> m_leftButtons;
QVector<KDecoration2::DecorationButtonType> m_rightButtons;
const QList<KDecoration2::DecorationButtonType> &defaultValue) const;
QList<KDecoration2::DecorationButtonType> m_leftButtons;
QList<KDecoration2::DecorationButtonType> m_rightButtons;
KDecoration2::BorderSize m_borderSize;
bool m_autoBorderSize = true;
bool m_closeDoubleClickMenu = false;

2
src/dpmsinputeventfilter.h
View file

@ -36,7 +36,7 @@ public:
private:
void notify();
QElapsedTimer m_doubleTapTimer;
QVector<qint32> m_touchPoints;
QList<qint32> m_touchPoints;
bool m_secondTap = false;
bool m_enableDoubleTap;
};

2
src/effectloader.cpp
View file

@ -390,7 +390,7 @@ void PluginEffectLoader::queryAndLoadAll()
}
}
QVector<KPluginMetaData> PluginEffectLoader::findAllEffects() const
QList<KPluginMetaData> PluginEffectLoader::findAllEffects() const
{
return KPluginMetaData::findPlugins(m_pluginSubDirectory);
}

2
src/effectloader.h
View file

@ -317,7 +317,7 @@ public:
void setPluginSubDirectory(const QString &directory);
private:
QVector<KPluginMetaData> findAllEffects() const;
QList<KPluginMetaData> findAllEffects() const;
KPluginMetaData findEffect(const QString &name) const;
EffectPluginFactory *factory(const KPluginMetaData &info) const;
QStringList m_loadedEffects;

24
src/effects.cpp
View file

@ -128,7 +128,7 @@ EffectsHandlerImpl::EffectsHandlerImpl(Compositor *compositor, WorkspaceScene *s
, m_effectLoader(new EffectLoader(this))
, m_trackingCursorChanges(0)
{
qRegisterMetaType<QVector<KWin::EffectWindow *>>();
qRegisterMetaType<QList<KWin::EffectWindow *>>();
qRegisterMetaType<KWin::SessionState>();
connect(m_effectLoader, &AbstractEffectLoader::effectLoaded, this, [this](Effect *effect, const QString &name) {
effect_order.insert(effect->requestedEffectChainPosition(), EffectPair(name, effect));
@ -369,7 +369,7 @@ void EffectsHandlerImpl::startPaint()
{
m_activeEffects.clear();
m_activeEffects.reserve(loaded_effects.count());
for (QVector<KWin::EffectPair>::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
for (QList<KWin::EffectPair>::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
if (it->second->isActive()) {
m_activeEffects << it->second;
}
@ -720,20 +720,20 @@ void EffectsHandlerImpl::moveWindow(EffectWindow *w, const QPoint &pos, bool sna
void EffectsHandlerImpl::windowToDesktop(EffectWindow *w, int desktop)
{
QVector<uint> desktopIds;
QList<uint> desktopIds;
if (desktop != -1) {
desktopIds.append(desktop);
}
windowToDesktops(w, desktopIds);
}
void EffectsHandlerImpl::windowToDesktops(EffectWindow *w, const QVector<uint> &desktopIds)
void EffectsHandlerImpl::windowToDesktops(EffectWindow *w, const QList<uint> &desktopIds)
{
auto window = static_cast<EffectWindowImpl *>(w)->window();
if (!window->isClient() || window->isDesktop() || window->isDock()) {
return;
}
QVector<VirtualDesktop *> desktops;
QList<VirtualDesktop *> desktops;
desktops.reserve(desktopIds.count());
for (uint x11Id : desktopIds) {
if (x11Id > VirtualDesktopManager::self()->count()) {
@ -1242,7 +1242,7 @@ void EffectsHandlerImpl::destroyEffect(Effect *effect)
void EffectsHandlerImpl::reconfigureEffect(const QString &name)
{
for (QVector<EffectPair>::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
for (QList<EffectPair>::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
if ((*it).first == name) {
kwinApp()->config()->reparseConfiguration();
makeOpenGLContextCurrent();
@ -1289,7 +1289,7 @@ QList<bool> EffectsHandlerImpl::areEffectsSupported(const QStringList &names)
void EffectsHandlerImpl::reloadEffect(Effect *effect)
{
QString effectName;
for (QVector<EffectPair>::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
for (QList<EffectPair>::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
if ((*it).second == effect) {
effectName = (*it).first;
break;
@ -1320,7 +1320,7 @@ void EffectsHandlerImpl::effectsChanged()
QStringList EffectsHandlerImpl::activeEffects() const
{
QStringList ret;
for (QVector<KWin::EffectPair>::const_iterator it = loaded_effects.constBegin(),
for (QList<KWin::EffectPair>::const_iterator it = loaded_effects.constBegin(),
end = loaded_effects.constEnd();
it != end; ++it) {
if (it->second->isActive()) {
@ -1413,7 +1413,7 @@ bool EffectsHandlerImpl::isScreenLocked() const
QString EffectsHandlerImpl::debug(const QString &name, const QString &parameter) const
{
QString internalName = name.toLower();
for (QVector<EffectPair>::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
for (QList<EffectPair>::const_iterator it = loaded_effects.constBegin(); it != loaded_effects.constEnd(); ++it) {
if ((*it).first == internalName) {
return it->second->debug(parameter);
}
@ -1441,7 +1441,7 @@ bool EffectsHandlerImpl::animationsSupported() const
return m_scene->animationsSupported();
}
void EffectsHandlerImpl::highlightWindows(const QVector<EffectWindow *> &windows)
void EffectsHandlerImpl::highlightWindows(const QList<EffectWindow *> &windows)
{
Effect *e = provides(Effect::HighlightWindows);
if (!e) {
@ -1955,10 +1955,10 @@ qlonglong EffectWindowImpl::windowId() const
return 0;
}
QVector<uint> EffectWindowImpl::desktops() const
QList<uint> EffectWindowImpl::desktops() const
{
const auto desks = m_window->desktops();
QVector<uint> ids;
QList<uint> ids;
ids.reserve(desks.count());
std::transform(desks.constBegin(), desks.constEnd(), std::back_inserter(ids), [](const VirtualDesktop *vd) {
return vd->x11DesktopNumber();

Some files were not shown because too many files have changed in this diff Show more