667 lines
20 KiB
QML
667 lines
20 KiB
QML
pragma Singleton
|
|
|
|
import QtQuick
|
|
import Quickshell
|
|
import Quickshell.Io
|
|
import Quickshell.Hyprland
|
|
import qs.Commons
|
|
import qs.Services
|
|
|
|
Singleton {
|
|
id: root
|
|
|
|
// Generic compositor properties
|
|
property string compositorType: "unknown" // "hyprland", "niri", or "unknown"
|
|
property bool isHyprland: false
|
|
property bool isNiri: false
|
|
|
|
readonly property string hyprlandSignature: Quickshell.env("HYPRLAND_INSTANCE_SIGNATURE")
|
|
|
|
// Generic workspace and window data
|
|
property ListModel workspaces: ListModel {}
|
|
property var windows: []
|
|
property int focusedWindowIndex: -1
|
|
property string focusedWindowTitle: "n/a"
|
|
property bool inOverview: false
|
|
|
|
// Generic events
|
|
signal workspaceChanged
|
|
signal activeWindowChanged
|
|
signal overviewStateChanged
|
|
signal windowListChanged
|
|
signal windowTitleChanged
|
|
|
|
// Debounce timer for updates
|
|
property Timer updateTimer: Timer {
|
|
interval: 50 // 50ms debounce
|
|
repeat: false
|
|
onTriggered: {
|
|
try {
|
|
updateHyprlandWindows()
|
|
updateHyprlandWorkspaces()
|
|
windowListChanged()
|
|
} catch (e) {
|
|
Logger.error("Compositor", "Error in debounced update:", e)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Compositor detection
|
|
Component.onCompleted: {
|
|
detectCompositor()
|
|
}
|
|
|
|
// Hyprland connections
|
|
Loader {
|
|
active: isHyprland
|
|
sourceComponent: Component {
|
|
Item {
|
|
Connections {
|
|
target: Hyprland.workspaces
|
|
enabled: isHyprland
|
|
function onValuesChanged() {
|
|
try {
|
|
updateHyprlandWorkspaces()
|
|
workspaceChanged()
|
|
} catch (e) {
|
|
Logger.error("Compositor", "Error in workspaces onValuesChanged:", e)
|
|
}
|
|
}
|
|
}
|
|
|
|
Connections {
|
|
target: Hyprland.toplevels
|
|
enabled: isHyprland
|
|
function onValuesChanged() {
|
|
try {
|
|
// Use debounced update to prevent too frequent calls
|
|
updateTimer.restart()
|
|
} catch (e) {
|
|
Logger.error("Compositor", "Error in toplevels onValuesChanged:", e)
|
|
}
|
|
}
|
|
}
|
|
|
|
Connections {
|
|
target: Hyprland
|
|
enabled: isHyprland
|
|
function onRawEvent(event) {
|
|
try {
|
|
updateHyprlandWorkspaces()
|
|
workspaceChanged()
|
|
updateTimer.restart()
|
|
} catch (e) {
|
|
Logger.error("Compositor", "Error in rawEvent:", e)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function detectCompositor() {
|
|
try {
|
|
// Try Hyprland first
|
|
if (hyprlandSignature && hyprlandSignature.length > 0) {
|
|
compositorType = "hyprland"
|
|
isHyprland = true
|
|
isNiri = false
|
|
initHyprland()
|
|
return
|
|
}
|
|
} catch (e) {
|
|
|
|
// Hyprland not available
|
|
}
|
|
|
|
// Try Niri (always available since we handle it directly)
|
|
compositorType = "niri"
|
|
isHyprland = false
|
|
isNiri = true
|
|
initNiri()
|
|
return
|
|
|
|
// No supported compositor found
|
|
compositorType = "unknown"
|
|
isHyprland = false
|
|
isNiri = false
|
|
Logger.warn("Compositor", "No supported compositor detected")
|
|
}
|
|
|
|
// Hyprland integration
|
|
function initHyprland() {
|
|
try {
|
|
Hyprland.refreshWorkspaces()
|
|
Hyprland.refreshToplevels()
|
|
updateHyprlandWorkspaces()
|
|
updateHyprlandWindows()
|
|
setupHyprlandConnections()
|
|
Logger.log("Compositor", "Hyprland initialized successfully")
|
|
} catch (e) {
|
|
Logger.error("Compositor", "Error initializing Hyprland:", e)
|
|
compositorType = "unknown"
|
|
isHyprland = false
|
|
}
|
|
}
|
|
|
|
function setupHyprlandConnections() {// Connections are set up at the top level, this function just marks that Hyprland is ready
|
|
}
|
|
|
|
function updateHyprlandWorkspaces() {
|
|
if (!isHyprland)
|
|
return
|
|
|
|
workspaces.clear()
|
|
try {
|
|
const hlWorkspaces = Hyprland.workspaces.values
|
|
|
|
// Determine occupied workspace ids from current toplevels
|
|
const occupiedIds = {}
|
|
try {
|
|
const hlToplevels = Hyprland.toplevels.values
|
|
for (var t = 0; t < hlToplevels.length; t++) {
|
|
const toplevel = hlToplevels[t]
|
|
if (toplevel) {
|
|
try {
|
|
const tws = toplevel.workspace?.id
|
|
if (tws !== undefined && tws !== null) {
|
|
occupiedIds[tws] = true
|
|
}
|
|
} catch (toplevelError) {
|
|
// Ignore errors from individual toplevels
|
|
continue
|
|
}
|
|
}
|
|
}
|
|
} catch (e2) {
|
|
|
|
// ignore occupancy errors; fall back to false
|
|
}
|
|
|
|
for (var i = 0; i < hlWorkspaces.length; i++) {
|
|
const ws = hlWorkspaces[i]
|
|
if (!ws)
|
|
continue
|
|
|
|
try {
|
|
// Only append workspaces with id >= 1
|
|
if (ws.id >= 1) {
|
|
workspaces.append({
|
|
"id": i,
|
|
"idx": ws.id,
|
|
"name": ws.name || "",
|
|
"output": ws.monitor?.name || "",
|
|
"isActive": ws.active === true,
|
|
"isFocused": ws.focused === true,
|
|
"isUrgent": ws.urgent === true,
|
|
"isOccupied": occupiedIds[ws.id] === true
|
|
})
|
|
}
|
|
} catch (workspaceError) {
|
|
Logger.warn("Compositor", "Error processing workspace at index", i, ":", workspaceError)
|
|
continue
|
|
}
|
|
}
|
|
} catch (e) {
|
|
Logger.error("Compositor", "Error updating Hyprland workspaces:", e)
|
|
}
|
|
}
|
|
|
|
function updateHyprlandWindows() {
|
|
if (!isHyprland)
|
|
return
|
|
|
|
try {
|
|
const hlToplevels = Hyprland.toplevels.values
|
|
const windowsList = []
|
|
|
|
for (var i = 0; i < hlToplevels.length; i++) {
|
|
const toplevel = hlToplevels[i]
|
|
|
|
// Skip if toplevel is null or invalid
|
|
if (!toplevel) {
|
|
continue
|
|
}
|
|
|
|
try {
|
|
// Try to get appId from various sources with proper null checks
|
|
let appId = ""
|
|
|
|
// First try the direct properties with null/undefined checks
|
|
try {
|
|
if (toplevel.class !== undefined && toplevel.class !== null) {
|
|
appId = String(toplevel.class)
|
|
} else if (toplevel.initialClass !== undefined && toplevel.initialClass !== null) {
|
|
appId = String(toplevel.initialClass)
|
|
} else if (toplevel.appId !== undefined && toplevel.appId !== null) {
|
|
appId = String(toplevel.appId)
|
|
}
|
|
} catch (propertyError) {
|
|
|
|
// Ignore property access errors and continue with empty appId
|
|
}
|
|
|
|
// If still no appId, try to get it from the lastIpcObject
|
|
if (!appId) {
|
|
try {
|
|
const ipcData = toplevel.lastIpcObject
|
|
if (ipcData) {
|
|
appId = String(ipcData.class || ipcData.initialClass || ipcData.appId || ipcData.wm_class || "")
|
|
}
|
|
} catch (ipcError) {
|
|
|
|
// Ignore errors when accessing lastIpcObject
|
|
}
|
|
}
|
|
|
|
// Safely get other properties with fallbacks
|
|
let windowId = ""
|
|
let windowTitle = ""
|
|
let workspaceId = null
|
|
let isActivated = false
|
|
|
|
try {
|
|
windowId = (toplevel.address !== undefined && toplevel.address !== null) ? String(toplevel.address) : ""
|
|
} catch (e) {
|
|
windowId = ""
|
|
}
|
|
|
|
try {
|
|
windowTitle = (toplevel.title !== undefined && toplevel.title !== null) ? String(toplevel.title) : ""
|
|
} catch (e) {
|
|
windowTitle = ""
|
|
}
|
|
|
|
try {
|
|
workspaceId = toplevel.workspace?.id || null
|
|
} catch (e) {
|
|
workspaceId = null
|
|
}
|
|
|
|
try {
|
|
isActivated = toplevel.activated === true
|
|
} catch (e) {
|
|
isActivated = false
|
|
}
|
|
|
|
windowsList.push({
|
|
"id": windowId,
|
|
"title": windowTitle,
|
|
"appId": appId,
|
|
"workspaceId": workspaceId,
|
|
"isFocused": isActivated
|
|
})
|
|
} catch (toplevelError) {
|
|
// Log the error but continue processing other toplevels
|
|
Logger.warn("Compositor", "Error processing toplevel at index", i, ":", toplevelError)
|
|
continue
|
|
}
|
|
}
|
|
|
|
windows = windowsList
|
|
|
|
// Update focused window index
|
|
focusedWindowIndex = -1
|
|
for (var j = 0; j < windowsList.length; j++) {
|
|
if (windowsList[j].isFocused) {
|
|
focusedWindowIndex = j
|
|
break
|
|
}
|
|
}
|
|
|
|
updateFocusedWindowTitle()
|
|
activeWindowChanged()
|
|
} catch (e) {
|
|
Logger.error("Compositor", "Error updating Hyprland windows:", e)
|
|
// Don't crash, just keep the previous windows list
|
|
}
|
|
}
|
|
|
|
// Niri integration
|
|
function initNiri() {
|
|
try {
|
|
// Start the event stream to receive Niri events
|
|
niriEventStream.running = true
|
|
// Initial load of workspaces and windows
|
|
updateNiriWorkspaces()
|
|
updateNiriWindows()
|
|
Logger.log("Compositor", "Niri initialized successfully")
|
|
} catch (e) {
|
|
Logger.error("Compositor", "Error initializing Niri:", e)
|
|
compositorType = "unknown"
|
|
isNiri = false
|
|
}
|
|
}
|
|
|
|
function updateNiriWorkspaces() {
|
|
if (!isNiri)
|
|
return
|
|
|
|
// Get workspaces from the Niri process
|
|
niriWorkspaceProcess.running = true
|
|
}
|
|
|
|
function updateNiriWindows() {
|
|
if (!isNiri)
|
|
return
|
|
|
|
// Get windows from the Niri process
|
|
niriWindowsProcess.running = true
|
|
}
|
|
|
|
// Niri workspace process
|
|
Process {
|
|
id: niriWorkspaceProcess
|
|
running: false
|
|
command: ["niri", "msg", "--json", "workspaces"]
|
|
|
|
stdout: SplitParser {
|
|
onRead: function (line) {
|
|
try {
|
|
const workspacesData = JSON.parse(line)
|
|
const workspacesList = []
|
|
|
|
for (const ws of workspacesData) {
|
|
workspacesList.push({
|
|
"id": ws.id,
|
|
"idx": ws.idx,
|
|
"name": ws.name || "",
|
|
"output": ws.output || "",
|
|
"isFocused": ws.is_focused === true,
|
|
"isActive": ws.is_active === true,
|
|
"isUrgent": ws.is_urgent === true,
|
|
"isOccupied": ws.active_window_id ? true : false
|
|
})
|
|
}
|
|
|
|
workspacesList.sort((a, b) => {
|
|
if (a.output !== b.output) {
|
|
return a.output.localeCompare(b.output)
|
|
}
|
|
return a.idx - b.idx
|
|
})
|
|
|
|
// Update the workspaces ListModel
|
|
workspaces.clear()
|
|
for (var i = 0; i < workspacesList.length; i++) {
|
|
workspaces.append(workspacesList[i])
|
|
}
|
|
workspaceChanged()
|
|
} catch (e) {
|
|
Logger.error("Compositor", "Failed to parse workspaces:", e, line)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Niri event stream process
|
|
Process {
|
|
id: niriEventStream
|
|
running: false
|
|
command: ["niri", "msg", "--json", "event-stream"]
|
|
|
|
stdout: SplitParser {
|
|
onRead: data => {
|
|
try {
|
|
const event = JSON.parse(data.trim())
|
|
|
|
if (event.WorkspacesChanged) {
|
|
niriWorkspaceProcess.running = true
|
|
} else if (event.WindowOpenedOrChanged) {
|
|
try {
|
|
const windowData = event.WindowOpenedOrChanged.window
|
|
|
|
// Find if this window already exists
|
|
const existingIndex = windows.findIndex(w => w.id === windowData.id)
|
|
|
|
const newWindow = {
|
|
"id": windowData.id,
|
|
"title": windowData.title || "",
|
|
"appId": windowData.app_id || "",
|
|
"workspaceId": windowData.workspace_id || null,
|
|
"isFocused": windowData.is_focused === true
|
|
}
|
|
|
|
if (existingIndex >= 0) {
|
|
// Update existing window
|
|
windows[existingIndex] = newWindow
|
|
} else {
|
|
// Add new window
|
|
windows.push(newWindow)
|
|
windows.sort((a, b) => a.id - b.id)
|
|
}
|
|
|
|
// Update focused window index if this window is focused
|
|
if (newWindow.isFocused) {
|
|
const oldFocusedIndex = focusedWindowIndex
|
|
focusedWindowIndex = windows.findIndex(w => w.id === windowData.id)
|
|
updateFocusedWindowTitle()
|
|
|
|
// Only emit activeWindowChanged if the focused window actually changed
|
|
if (oldFocusedIndex !== focusedWindowIndex) {
|
|
activeWindowChanged()
|
|
}
|
|
} else if (existingIndex >= 0 && existingIndex === focusedWindowIndex) {
|
|
// If this is the currently focused window (but not newly focused),
|
|
// still update the title in case it changed, but don't emit activeWindowChanged
|
|
updateFocusedWindowTitle()
|
|
}
|
|
|
|
windowListChanged()
|
|
} catch (e) {
|
|
Logger.error("Compositor", "Error parsing WindowOpenedOrChanged event:", e)
|
|
}
|
|
} else if (event.WindowClosed) {
|
|
try {
|
|
const windowId = event.WindowClosed.id
|
|
|
|
// Remove the window from the list
|
|
const windowIndex = windows.findIndex(w => w.id === windowId)
|
|
if (windowIndex >= 0) {
|
|
// If this was the focused window, clear focus
|
|
if (windowIndex === focusedWindowIndex) {
|
|
focusedWindowIndex = -1
|
|
updateFocusedWindowTitle()
|
|
activeWindowChanged()
|
|
}
|
|
|
|
// Remove the window
|
|
windows.splice(windowIndex, 1)
|
|
|
|
// Adjust focused window index if needed
|
|
if (focusedWindowIndex > windowIndex) {
|
|
focusedWindowIndex--
|
|
}
|
|
|
|
windowListChanged()
|
|
}
|
|
} catch (e) {
|
|
Logger.error("Compositor", "Error parsing WindowClosed event:", e)
|
|
}
|
|
} else if (event.WindowsChanged) {
|
|
try {
|
|
const windowsData = event.WindowsChanged.windows
|
|
const windowsList = []
|
|
for (const win of windowsData) {
|
|
windowsList.push({
|
|
"id": win.id,
|
|
"title": win.title || "",
|
|
"appId": win.app_id || "",
|
|
"workspaceId": win.workspace_id || null,
|
|
"isFocused": win.is_focused === true
|
|
})
|
|
}
|
|
|
|
windowsList.sort((a, b) => a.id - b.id)
|
|
windows = windowsList
|
|
windowListChanged()
|
|
|
|
// Update focused window index
|
|
for (var i = 0; i < windowsList.length; i++) {
|
|
if (windowsList[i].isFocused) {
|
|
focusedWindowIndex = i
|
|
break
|
|
}
|
|
}
|
|
updateFocusedWindowTitle()
|
|
activeWindowChanged()
|
|
} catch (e) {
|
|
Logger.error("Compositor", "Error parsing windows event:", e)
|
|
}
|
|
} else if (event.WorkspaceActivated) {
|
|
niriWorkspaceProcess.running = true
|
|
} else if (event.WindowFocusChanged) {
|
|
try {
|
|
const focusedId = event.WindowFocusChanged.id
|
|
if (focusedId) {
|
|
focusedWindowIndex = windows.findIndex(w => w.id === focusedId)
|
|
if (focusedWindowIndex < 0) {
|
|
focusedWindowIndex = 0
|
|
}
|
|
} else {
|
|
focusedWindowIndex = -1
|
|
}
|
|
updateFocusedWindowTitle()
|
|
activeWindowChanged()
|
|
} catch (e) {
|
|
Logger.error("Compositor", "Error parsing window focus event:", e)
|
|
}
|
|
} else if (event.OverviewOpenedOrClosed) {
|
|
try {
|
|
inOverview = event.OverviewOpenedOrClosed.is_open === true
|
|
overviewStateChanged()
|
|
} catch (e) {
|
|
Logger.error("Compositor", "Error parsing overview state:", e)
|
|
}
|
|
}
|
|
} catch (e) {
|
|
Logger.error("Compositor", "Error parsing event stream:", e, data)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Niri windows process (for initial load)
|
|
Process {
|
|
id: niriWindowsProcess
|
|
running: false
|
|
command: ["niri", "msg", "--json", "windows"]
|
|
|
|
stdout: SplitParser {
|
|
onRead: function (line) {
|
|
try {
|
|
const windowsData = JSON.parse(line)
|
|
const windowsList = []
|
|
for (const win of windowsData) {
|
|
windowsList.push({
|
|
"id": win.id,
|
|
"title": win.title || "",
|
|
"appId": win.app_id || "",
|
|
"workspaceId": win.workspace_id || null,
|
|
"isFocused": win.is_focused === true
|
|
})
|
|
}
|
|
|
|
windowsList.sort((a, b) => a.id - b.id)
|
|
windows = windowsList
|
|
windowListChanged()
|
|
|
|
// Update focused window index
|
|
for (var i = 0; i < windowsList.length; i++) {
|
|
if (windowsList[i].isFocused) {
|
|
focusedWindowIndex = i
|
|
break
|
|
}
|
|
}
|
|
updateFocusedWindowTitle()
|
|
activeWindowChanged()
|
|
} catch (e) {
|
|
Logger.error("Compositor", "Failed to parse windows:", e, line)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function updateFocusedWindowTitle() {
|
|
const oldTitle = focusedWindowTitle
|
|
if (focusedWindowIndex >= 0 && focusedWindowIndex < windows.length) {
|
|
focusedWindowTitle = windows[focusedWindowIndex].title || "(Unnamed window)"
|
|
} else {
|
|
focusedWindowTitle = "(No active window)"
|
|
}
|
|
|
|
// Emit signal if title actually changed
|
|
if (oldTitle !== focusedWindowTitle) {
|
|
windowTitleChanged()
|
|
}
|
|
}
|
|
|
|
// Generic workspace switching
|
|
function switchToWorkspace(workspaceId) {
|
|
if (isHyprland) {
|
|
try {
|
|
Hyprland.dispatch(`workspace ${workspaceId}`)
|
|
} catch (e) {
|
|
Logger.error("Compositor", "Error switching Hyprland workspace:", e)
|
|
}
|
|
} else if (isNiri) {
|
|
try {
|
|
Quickshell.execDetached(["niri", "msg", "action", "focus-workspace", workspaceId.toString()])
|
|
} catch (e) {
|
|
Logger.error("Compositor", "Error switching Niri workspace:", e)
|
|
}
|
|
} else {
|
|
Logger.warn("Compositor", "No supported compositor detected for workspace switching")
|
|
}
|
|
}
|
|
|
|
// Get current workspace
|
|
function getCurrentWorkspace() {
|
|
for (var i = 0; i < workspaces.count; i++) {
|
|
const ws = workspaces.get(i)
|
|
if (ws.isFocused) {
|
|
return ws
|
|
}
|
|
}
|
|
return null
|
|
}
|
|
|
|
// Get focused window
|
|
function getFocusedWindow() {
|
|
if (focusedWindowIndex >= 0 && focusedWindowIndex < windows.length) {
|
|
return windows[focusedWindowIndex]
|
|
}
|
|
return null
|
|
}
|
|
|
|
// Generic logout/shutdown commands
|
|
function logout() {
|
|
if (isHyprland) {
|
|
try {
|
|
Quickshell.execDetached(["hyprctl", "dispatch", "exit"])
|
|
} catch (e) {
|
|
Logger.error("Compositor", "Error logging out from Hyprland:", e)
|
|
}
|
|
} else if (isNiri) {
|
|
try {
|
|
Quickshell.execDetached(["niri", "msg", "action", "quit", "--skip-confirmation"])
|
|
} catch (e) {
|
|
Logger.error("Compositor", "Error logging out from Niri:", e)
|
|
}
|
|
} else {
|
|
Logger.warn("Compositor", "No supported compositor detected for logout")
|
|
}
|
|
}
|
|
|
|
function shutdown() {
|
|
Quickshell.execDetached(["shutdown", "-h", "now"])
|
|
}
|
|
|
|
function reboot() {
|
|
Quickshell.execDetached(["reboot"])
|
|
}
|
|
|
|
function suspend() {
|
|
Quickshell.execDetached(["systemctl", "suspend"])
|
|
}
|
|
}
|