add TODOs

package/metadata.json

@@ -9,7 +9,7 @@
             "Name": "Peter Fajdiga"
         }],
         "Id": "karousel",
-        "Version": "0.9.4",
+        "Version": "0.9.3",
         "License": "GPLv3",
         "Website": "https://github.com/peterfajdiga/karousel",
         "BugReportUrl": "https://github.com/peterfajdiga/karousel/issues"

src/lib/Actions.ts

@@ -252,12 +252,6 @@ namespace Actions {
                 });
             };
 
-            case "screen-switch": return () => {
-                world.do((clientManager, desktopManager) => {
-                    desktopManager.selectScreen(Workspace.activeScreen);
-                });
-            };
-
             default: throw new Error("unknown action: " + name);
         }
     }

src/lib/extern/kwin.ts

@@ -8,6 +8,7 @@ type Workspace = {
     readonly currentDesktop: KwinDesktop;
     readonly currentActivity: string;
     readonly activeScreen: Output;
+    readonly screens: Output[];
     readonly windows: KwinClient[];
     readonly cursorPos: Readonly<QmlPoint>;
 
@@ -45,7 +46,10 @@ const enum MaximizedMode {
 }
 
 type Tile = unknown;
-type Output = unknown;
+
+type Output = {
+    name: string;
+};
 
 interface KwinClient {
     readonly shadeable: boolean;
@@ -82,6 +86,7 @@ interface KwinClient {
 
     readonly fullScreenChanged: QSignal<[]>;
     readonly desktopsChanged: QSignal<[]>;
+    readonly outputChanged: QSignal<[]>;
     readonly activitiesChanged: QSignal<[]>;
     readonly minimizedChanged: QSignal<[]>;
     readonly maximizedAboutToChange: QSignal<[MaximizedMode]>

src/lib/keyBindings/definition.ts

@@ -146,11 +146,6 @@ const keyBindings: KeyBinding[] = [
         description: "Scroll to end",
         defaultKeySequence: "Meta+Alt+End",
     },
-    {
-        name: "screen-switch",
-        description: "Move Karousel grid to the current screen",
-        defaultKeySequence: "Meta+Ctrl+Return",
-    }
 ];
 
 const numKeyBindings: NumKeyBinding[] = [

src/lib/layout/Desktop.ts

@@ -1,5 +1,9 @@
 class Desktop {
     public readonly grid: Grid;
+    public readonly screen: Output;
+    public readonly kwinDesktop: KwinDesktop;
+    private readonly pinManager: PinManager;
+    private readonly config: Desktop.Config;
     private scrollX: number;
     private dirty: boolean;
     private dirtyScroll: boolean;
@@ -7,24 +11,22 @@ class Desktop {
     public clientArea: QmlRect;
     public tilingArea: QmlRect;
 
-    constructor(
-        public readonly kwinDesktop: KwinDesktop,
-        private readonly pinManager: PinManager,
-        private readonly config: Desktop.Config,
-        private readonly getScreen: () => Output,
-        layoutConfig: LayoutConfig,
-    ) {
+    constructor(screen: Output, kwinDesktop: KwinDesktop, pinManager: PinManager, config: Desktop.Config, layoutConfig: LayoutConfig) {
+        this.pinManager = pinManager;
+        this.config = config;
         this.scrollX = 0;
         this.dirty = true;
         this.dirtyScroll = true;
         this.dirtyPins = true;
+        this.screen = screen;
+        this.kwinDesktop = kwinDesktop;
         this.grid = new Grid(this, layoutConfig);
-        this.clientArea = Desktop.getClientArea(this.getScreen(), kwinDesktop);
+        this.clientArea = Desktop.getClientArea(screen, kwinDesktop);
         this.tilingArea = Desktop.getTilingArea(this.clientArea, kwinDesktop, pinManager, config);
     }
 
     private updateArea() {
-        const newClientArea = Desktop.getClientArea(this.getScreen(), this.kwinDesktop);
+        const newClientArea = Desktop.getClientArea(this.screen, this.kwinDesktop);
         if (newClientArea === this.clientArea && !this.dirtyPins) {
             return;
         }

src/lib/workspace.ts

@@ -34,25 +34,25 @@ function initWorkspaceSignalHandlers(world: World) {
         world.do(() => {}); // re-arrange desktop
     });
 
-    manager.connect(Workspace.screensChanged, () => {
+   manager.connect(Workspace.screensChanged, () => {
         world.do((clientManager, desktopManager) => {
-            desktopManager.selectScreen(Workspace.activeScreen);
-        });
+            desktopManager.updateScreens();
+        })
     });
 
-    manager.connect(Workspace.activitiesChanged, () => {
+   manager.connect(Workspace.activitiesChanged, () => {
         world.do((clientManager, desktopManager) => {
             desktopManager.updateActivities();
-        });
+        })
     });
 
     manager.connect(Workspace.desktopsChanged, () => {
         world.do((clientManager, desktopManager) => {
             desktopManager.updateDesktops();
-        });
+        })
     });
 
-    manager.connect(Workspace.virtualScreenSizeChanged, () => {
+     manager.connect(Workspace.virtualScreenSizeChanged, () => {
         world.onScreenResized();
     });
 

src/lib/world/DesktopManager.ts

@@ -1,63 +1,76 @@
 class DesktopManager {
+    // TODO: fix issue with removed and re-added screens
+
     private readonly pinManager: PinManager;
     private readonly config: Desktop.Config;
     public readonly layoutConfig: LayoutConfig;
     private readonly desktops: Map<string, Desktop>; // key is activityId|desktopId
-    private selectedScreen: Output;
+    private kwinScreens: Set<Output>;
     private kwinActivities: Set<string>;
     private kwinDesktops: Set<KwinDesktop>;
 
-    constructor(pinManager: PinManager, config: Desktop.Config, layoutConfig: LayoutConfig, currentActivity: string, currentDesktop: KwinDesktop) {
+    constructor(
+        pinManager: PinManager,
+        config: Desktop.Config,
+        layoutConfig: LayoutConfig,
+        currentScreen: Output,
+        currentActivity: string,
+        currentDesktop: KwinDesktop
+    ) {
         this.pinManager = pinManager;
         this.config = config;
         this.layoutConfig = layoutConfig;
         this.desktops = new Map();
-        this.selectedScreen = Workspace.activeScreen;
+        this.kwinScreens = new Set(Workspace.screens);
         this.kwinActivities = new Set(Workspace.activities);
         this.kwinDesktops = new Set(Workspace.desktops);
-        this.addDesktop(currentActivity, currentDesktop);
+        this.addDesktop(currentScreen, currentActivity, currentDesktop);
     }
 
-    public getDesktop(activity: string, kwinDesktop: KwinDesktop) {
-        const desktopKey = DesktopManager.getDesktopKey(activity, kwinDesktop);
+    public getDesktop(screen: Output, activity: string, kwinDesktop: KwinDesktop) {
+        const desktopKey = DesktopManager.getDesktopKey(screen, activity, kwinDesktop);
         const desktop = this.desktops.get(desktopKey);
         if (desktop !== undefined) {
             return desktop;
         } else {
-            return this.addDesktop(activity, kwinDesktop);
+            return this.addDesktop(screen, activity, kwinDesktop);
         }
     }
 
     public getCurrentDesktop() {
-        return this.getDesktop(Workspace.currentActivity, Workspace.currentDesktop);
+        return this.getDesktop(Workspace.activeScreen, Workspace.currentActivity, Workspace.currentDesktop);
     }
 
     public getDesktopInCurrentActivity(kwinDesktop: KwinDesktop) {
-        return this.getDesktop(Workspace.currentActivity, kwinDesktop);
+        return this.getDesktop(Workspace.activeScreen, Workspace.currentActivity, kwinDesktop);
     }
 
     public getDesktopForClient(kwinClient: KwinClient) {
         if (kwinClient.activities.length !== 1 || kwinClient.desktops.length !== 1) {
             return undefined;
         }
-        return this.getDesktop(kwinClient.activities[0], kwinClient.desktops[0]);
+        return this.getDesktop(kwinClient.output, kwinClient.activities[0], kwinClient.desktops[0]);
     }
 
-    private addDesktop(activity: string, kwinDesktop: KwinDesktop) {
-        const desktopKey = DesktopManager.getDesktopKey(activity, kwinDesktop);
-        const desktop = new Desktop(
-            kwinDesktop,
-            this.pinManager,
-            this.config,
-            () => this.selectedScreen,
-            this.layoutConfig,
-        );
+    private addDesktop(screen: Output, activity: string, kwinDesktop: KwinDesktop) {
+        const desktopKey = DesktopManager.getDesktopKey(screen, activity, kwinDesktop);
+        const desktop = new Desktop(screen, kwinDesktop, this.pinManager, this.config, this.layoutConfig);
         this.desktops.set(desktopKey, desktop);
         return desktop;
     }
 
-    private static getDesktopKey(activity: string, kwinDesktop: KwinDesktop) {
-        return activity + "|" + kwinDesktop.id;
+    private static getDesktopKey(screen: Output, activity: string, kwinDesktop: KwinDesktop) {
+        return screen.name + "|" + activity + "|" + kwinDesktop.id;
+    }
+
+    public updateScreens() {
+        const newScreens = new Set(Workspace.screens);
+        for (const screen of this.kwinScreens) {
+            if (!newScreens.has(screen)) {
+                this.removeScreen(screen);
+            }
+        }
+        this.kwinScreens = newScreens;
     }
 
     public updateActivities() {
@@ -80,24 +93,32 @@ class DesktopManager {
         this.kwinDesktops = newDesktops;
     }
 
-    public selectScreen(screen: Output) {
-        this.selectedScreen = screen;
+    private removeScreen(kwinScreen: Output) {
+        for (const activity of this.kwinActivities) {
+            for (const kwinDesktop of this.kwinDesktops) {
+                this.destroyDesktop(kwinScreen, activity, kwinDesktop);
+            }
+        }
     }
 
     private removeActivity(activity: string) {
-        for (const kwinDesktop of this.kwinDesktops) {
-            this.destroyDesktop(activity, kwinDesktop);
+        for (const kwinScreen of this.kwinScreens) {
+            for (const kwinDesktop of this.kwinDesktops) {
+                this.destroyDesktop(kwinScreen, activity, kwinDesktop);
+            }
         }
     }
 
     private removeKwinDesktop(kwinDesktop: KwinDesktop) {
-        for (const activity of this.kwinActivities) {
-            this.destroyDesktop(activity, kwinDesktop);
+        for (const kwinScreen of this.kwinScreens) {
+            for (const activity of this.kwinActivities) {
+                this.destroyDesktop(kwinScreen, activity, kwinDesktop);
+            }
         }
     }
 
-    private destroyDesktop(activity: string, kwinDesktop: KwinDesktop) {
-        const desktopKey = DesktopManager.getDesktopKey(activity, kwinDesktop);
+    private destroyDesktop(screen: Output, activity: string, kwinDesktop: KwinDesktop) {
+        const desktopKey = DesktopManager.getDesktopKey(screen, activity, kwinDesktop);
         const desktop = this.desktops.get(desktopKey);
         if (desktop !== undefined) {
             desktop.destroy();
@@ -118,20 +139,23 @@ class DesktopManager {
     }
 
     public getDesktopsForClient(kwinClient: KwinClient) {
-        const desktops = this.getDesktops(kwinClient.activities, kwinClient.desktops); // workaround for QTBUG-109880
+        const desktops = this.getDesktops([kwinClient.output], kwinClient.activities, kwinClient.desktops); // workaround for QTBUG-109880
         return desktops;
     }
 
     // empty array means all
-    public *getDesktops(activities: string[], kwinDesktops: KwinDesktop[]) {
+    public *getDesktops(screens: Output[], activities: string[], kwinDesktops: KwinDesktop[]) {
+        const matchedScreens = screens.length > 0 ? screens : this.kwinScreens.keys();
         const matchedActivities = activities.length > 0 ? activities : this.kwinActivities.keys();
         const matchedDesktops = kwinDesktops.length > 0 ? kwinDesktops : this.kwinDesktops.keys();
-        for (const matchedActivity of matchedActivities) {
-            for (const matchedDesktop of matchedDesktops) {
-                const desktopKey = DesktopManager.getDesktopKey(matchedActivity, matchedDesktop);
-                const desktop = this.desktops.get(desktopKey);
-                if (desktop !== undefined) {
-                    yield desktop;
+        for (const matchedScreen of matchedScreens) {
+            for (const matchedActivity of matchedActivities) {
+                for (const matchedDesktop of matchedDesktops) {
+                    const desktopKey = DesktopManager.getDesktopKey(matchedScreen, matchedActivity, matchedDesktop);
+                    const desktop = this.desktops.get(desktopKey);
+                    if (desktop !== undefined) {
+                        yield desktop;
+                    }
                 }
             }
         }

src/lib/world/PinManager.ts

@@ -1,4 +1,6 @@
 class PinManager {
+    // TODO: per-screen
+
     private readonly pinnedClients: Set<KwinClient>;
 
     constructor() {

src/lib/world/World.ts

@@ -49,6 +49,7 @@ class World {
                 clamper: config.scrollingLazy ? new EdgeClamper() : new CenterClamper(),
             },
             layoutConfig,
+            Workspace.activeScreen,
             Workspace.currentActivity,
             Workspace.currentDesktop,
         );

src/lib/world/clientState/Pinned.ts

@@ -61,7 +61,7 @@ namespace ClientState {
                     [] :
                     union(oldDesktops, kwinClient.desktops);
                 world.do((clientManager, desktopManager) => {
-                    for (const desktop of desktopManager.getDesktops(kwinClient.activities, changedDesktops)) {
+                    for (const desktop of desktopManager.getDesktops([kwinClient.output], kwinClient.activities, changedDesktops)) {
                         desktop.onPinsChanged();
                     }
                 });
@@ -73,13 +73,21 @@ namespace ClientState {
                     [] :
                     union(oldActivities, kwinClient.activities);
                 world.do((clientManager, desktopManager) => {
-                    for (const desktop of desktopManager.getDesktops(changedActivities, kwinClient.desktops)) {
+                    for (const desktop of desktopManager.getDesktops([kwinClient.output], changedActivities, kwinClient.desktops)) {
                         desktop.onPinsChanged();
                     }
                 });
                 oldActivities = kwinClient.activities;
             });
 
+            manager.connect(kwinClient.outputChanged, () => {
+                world.do((clientManager, desktopManager) => {
+                    for (const desktop of desktopManager.getDesktops([kwinClient.output], kwinClient.activities, kwinClient.desktops)) {
+                        desktop.onPinsChanged();
+                    }
+                });
+            });
+
             return manager;
         }
     }