Workshop implementation, relative mouse movement toggle, and ControlsProfile binding fix

app/src/main/java/app/gamenative/ui/PluviaMain.kt

@@ -97,6 +97,7 @@ import app.gamenative.utils.UpdateChecker
 import app.gamenative.utils.UpdateInfo
 import app.gamenative.utils.UpdateInstaller
 import app.gamenative.utils.LaunchDependencies
+import app.gamenative.workshop.WorkshopManager
 import com.google.android.play.core.splitcompat.SplitCompat
 import com.winlator.container.Container
 import com.winlator.container.ContainerData
@@ -106,6 +107,7 @@ import com.winlator.xenvironment.ImageFs
 import com.winlator.xenvironment.ImageFsInstaller
 import `in`.dragonbra.javasteam.protobufs.steamclient.SteammessagesClientObjects.ECloudPendingRemoteOperation
 import java.io.File
+import java.util.Locale
 import java.util.Date
 import java.util.EnumSet
 import kotlin.reflect.KFunction2
@@ -1039,6 +1041,26 @@ fun PluviaMain(
                                 openContainerConfigForAppId = null
                             }
                         },
+                        onDeleteWorkshopMods = {
+                            scope.launch {
+                                try {
+                                    withContext(Dispatchers.IO) {
+                                        val appIdInt = appId.toIntOrNull()
+                                        val gameRootDir = appIdInt?.let { SteamService.getAppDirPath(it) }
+                                            ?.let { File(it) }
+                                        val gameName = appIdInt?.let { SteamService.getAppInfoOf(it)?.name } ?: ""
+                                        WorkshopManager.deleteWorkshopMods(
+                                            context, appId,
+                                            gameRootDir, gameName,
+                                        )
+                                    }
+                                    SnackbarManager.show("Workshop mods deleted")
+                                } catch (e: Exception) {
+                                    Timber.e(e, "Failed to delete workshop mods")
+                                    SnackbarManager.show("Failed to delete workshop mods")
+                                }
+                            }
+                        },
                     )
                 }
             }
@@ -1740,6 +1762,163 @@ fun preLaunchApp(
         val prefixToPath: (String) -> String = { prefix ->
             PathType.from(prefix).toAbsPath(context, gameId, SteamService.userSteamId!!.accountID)
         }
+
+        // Workshop mod sync: download subscribed mods and configure symlinks
+        if (container.isWorkshopMods) {
+            try {
+                setLoadingMessage("Checking Workshop mods...")
+                setLoadingProgress(-1f)
+                val steamClient = SteamService.instance?.steamClient
+                val steamId = SteamService.userSteamId
+                if (steamClient != null && steamId != null) {
+                    val imageFs = ImageFs.find(context)
+                    val winePrefix = imageFs.wineprefix
+                    val fetchResult = WorkshopManager.getSubscribedItems(gameId, steamClient, steamId)
+                    val items = fetchResult.items
+                    if (items.isNotEmpty()) {
+                        Timber.tag("Workshop").i("Found ${items.size} subscribed workshop items for appId=$gameId")
+                        val workshopContentDir = WorkshopManager.getWorkshopContentDir(winePrefix, gameId)
+
+                        if (fetchResult.isComplete) {
+                            WorkshopManager.cleanupUnsubscribedItems(items, workshopContentDir)
+                        } else {
+                            Timber.tag("Workshop").w(
+                                "Subscription fetch incomplete, skipping cleanup to preserve existing mods"
+                            )
+                        }
+                        val itemsToSync = WorkshopManager.getItemsNeedingSync(items, workshopContentDir)
+
+                        if (itemsToSync.isNotEmpty()) {
+                            // Check available disk space before downloading
+                            // Use 2x safety margin to account for LZMA decompression
+                            // and CKM extraction creating temp files alongside originals
+                            val requiredBytes = itemsToSync.sumOf { it.fileSizeBytes } * 2
+                            // usableSpace returns 0 for non-existent dirs; walk up to an existing ancestor.
+                            // Use -1L sentinel so a truly-full volume (0 bytes) still triggers the guard.
+                            val spaceDir = generateSequence(workshopContentDir) { it.parentFile }
+                                .firstOrNull { it.exists() }
+                            val availableBytes = spaceDir?.usableSpace ?: -1L
+                            if (requiredBytes > 0 && availableBytes >= 0 && requiredBytes > availableBytes) {
+                                val reqMB = String.format(Locale.US, "%.0f", requiredBytes / 1_048_576.0)
+                                val avlMB = String.format(Locale.US, "%.0f", availableBytes / 1_048_576.0)
+                                Timber.tag("Workshop").e(
+                                    "Insufficient disk space: need ${reqMB}MB, have ${avlMB}MB"
+                                )
+                                SnackbarManager.show(
+                                    "Not enough space for workshop mods (need ${reqMB} MB, have ${avlMB} MB)"
+                                )
+                            } else {
+                                Timber.tag("Workshop").i("Downloading ${itemsToSync.size} workshop items...")
+                                setLoadingMessage("Downloading Workshop Mods (0/${itemsToSync.size})")
+                                val licenses = SteamService.getLicensesFromDb()
+
+                                // Track item-level progress so byte callbacks can include it
+                                var currentCompleted = 0
+                                var currentTitle = itemsToSync.firstOrNull()?.title ?: ""
+
+                                val successCount = WorkshopManager.downloadItems(
+                                    items = itemsToSync,
+                                    steamClient = steamClient,
+                                    licenses = licenses,
+                                    workshopContentDir = workshopContentDir,
+                                    onItemProgress = { completed, total, title ->
+                                        currentCompleted = completed
+                                        currentTitle = title
+                                        Timber.tag("Workshop").d("Progress: $completed/$total - $title")
+                                        setLoadingMessage("Downloading Workshop Mods ($completed/$total)\n$title")
+                                    },
+                                    onBytesProgress = { downloaded, total ->
+                                        if (total > 0) {
+                                            setLoadingProgress(downloaded.toFloat() / total.toFloat())
+                                            val dlMB = String.format(Locale.US, "%.1f", downloaded / 1_048_576.0)
+                                            val totalMB = String.format(Locale.US, "%.1f", total / 1_048_576.0)
+                                            setLoadingMessage(
+                                                "Downloading Workshop Mods ($currentCompleted/${itemsToSync.size})\n" +
+                                                    "$currentTitle\n" +
+                                                    "${dlMB} MB / ${totalMB} MB"
+                                            )
+                                        }
+                                    },
+                                    onOverallProgress = { progress ->
+                                        Timber.tag("Workshop").d("Overall: ${(progress * 100).toInt()}%")
+                                    },
+                                )
+
+                                val failedCount = itemsToSync.size - successCount
+                                if (failedCount > 0) {
+                                    Timber.tag("Workshop").w("$failedCount workshop mod(s) failed to download")
+                                    SnackbarManager.show(
+                                        "$failedCount workshop mod(s) failed to download"
+                                    )
+                                }
+
+                                WorkshopManager.fixItemFileNames(itemsToSync, workshopContentDir)
+                            }
+                        }
+
+                        // Post-processing runs every launch (not just after downloads) so
+                        // that files from a previous broken run get fixed retroactively.
+                        // Order matters: decompress LZMA first so fixFileExtensions can
+                        // read the real magic bytes (e.g. GMAD) instead of LZMA's 0x5D.
+                        WorkshopManager.extractCkmFiles(workshopContentDir)
+                        WorkshopManager.decompressLzmaFiles(workshopContentDir)
+                        WorkshopManager.fixFileExtensions(workshopContentDir)
+
+                        WorkshopManager.updateMarkerTimestamps(items, workshopContentDir)
+
+                        setLoadingMessage("Configuring Workshop mods...")
+                        setLoadingProgress(-1f)
+                        val gameRootDir = File(SteamService.getAppDirPath(gameId))
+                        val gameName = SteamService.getAppInfoOf(gameId)?.name ?: ""
+                        WorkshopManager.configureModSymlinks(
+                            gameRootDir = gameRootDir,
+                            workshopContentDir = workshopContentDir,
+                            items = items,
+                            winePrefix = winePrefix,
+                            gameName = gameName,
+                        )
+                        Timber.tag("Workshop").i("Workshop mod sync complete for appId=$gameId")
+                    } else if (!fetchResult.succeeded) {
+                        // Fetch failed and returned no items — don't wipe existing mods.
+                        // Still configure symlinks so previously downloaded mods work offline.
+                        Timber.tag("Workshop").w(
+                            "Workshop fetch failed for appId=$gameId, preserving existing on-disk mods"
+                        )
+                        val workshopContentDir = WorkshopManager.getWorkshopContentDir(winePrefix, gameId)
+                        if (workshopContentDir.exists()) {
+                            setLoadingMessage("Configuring Workshop mods...")
+                            setLoadingProgress(-1f)
+                            val gameRootDir = File(SteamService.getAppDirPath(gameId))
+                            val gameName = SteamService.getAppInfoOf(gameId)?.name ?: ""
+                            WorkshopManager.configureModSymlinks(
+                                gameRootDir = gameRootDir,
+                                workshopContentDir = workshopContentDir,
+                                items = emptyList(),
+                                winePrefix = winePrefix,
+                                gameName = gameName,
+                            )
+                        }
+                    } else {
+                        Timber.tag("Workshop").d("No subscribed workshop items for appId=$gameId")
+                        // Clean up previously downloaded mods and installed symlinks/copies
+                        val gameRootDir = File(SteamService.getAppDirPath(gameId))
+                        val gameName = SteamService.getAppInfoOf(gameId)?.name ?: ""
+                        WorkshopManager.deleteWorkshopMods(
+                            context = context,
+                            containerId = gameId.toString(),
+                            gameRootDir = gameRootDir,
+                            gameName = gameName,
+                        )
+                        Timber.tag("Workshop").i("Cleaned up workshop content for appId=$gameId")
+                    }
+                } else {
+                    Timber.tag("Workshop").w("Steam client or Steam ID not available, skipping workshop sync")
+                }
+            } catch (e: Exception) {
+                Timber.tag("Workshop").e(e, "Workshop mod sync failed, continuing without mods")
+            }
+        }
+
         setLoadingMessage("Syncing cloud saves")
         setLoadingProgress(-1f)
         val postSyncInfo = SteamService.beginLaunchApp(

app/src/main/java/app/gamenative/ui/component/dialog/ContainerConfigDialog.kt

@@ -145,6 +145,7 @@ fun ContainerConfigDialog(
     initialConfig: ContainerData = ContainerData(),
     onDismissRequest: () -> Unit,
     onSave: (ContainerData) -> Unit,
+    onDeleteWorkshopMods: (() -> Unit)? = null,
 ) {
     if (visible) {
         val context = LocalContext.current
@@ -1127,7 +1128,7 @@ fun ContainerConfigDialog(
                                 .verticalScroll(scrollState)
                                 .weight(1f),
                         ) {
-                            if (selectedTab == 0) GeneralTabContent(state, nonzeroResolutionError, aspectResolutionError)
+                            if (selectedTab == 0) GeneralTabContent(state, nonzeroResolutionError, aspectResolutionError, onDeleteWorkshopMods)
                             if (selectedTab == 1) GraphicsTabContent(state)
                             if (selectedTab == 2) EmulationTabContent(state)
                             if (selectedTab == 3) ControllerTabContent(state, default)

app/src/main/java/app/gamenative/ui/component/dialog/ControllerTab.kt

@@ -98,6 +98,13 @@ fun ControllerTabContent(state: ContainerConfigState, default: Boolean) {
             state = config.shooterMode,
             onCheckedChange = { state.config.value = config.copy(shooterMode = it) },
         )
+        SettingsSwitch(
+            colors = settingsTileColors(),
+            title = { Text(text = stringResource(R.string.relative_mouse_movement)) },
+            subtitle = { Text(text = stringResource(R.string.relative_mouse_movement_description)) },
+            state = config.relativeMouseMovement,
+            onCheckedChange = { state.config.value = config.copy(relativeMouseMovement = it) },
+        )
         SettingsListDropdown(
             colors = settingsTileColors(),
             title = { Text(text = stringResource(R.string.external_display_input)) },

app/src/main/java/app/gamenative/ui/component/dialog/GeneralTab.kt

@@ -43,6 +43,7 @@ fun GeneralTabContent(
     state: ContainerConfigState,
     nonzeroResolutionError: String,
     aspectResolutionError: String,
+    onDeleteWorkshopMods: (() -> Unit)? = null,
 ) {
     val config = state.config.value
     val graphicsDrivers = state.graphicsDrivers.value
@@ -335,6 +336,46 @@ fun GeneralTabContent(
                 onCheckedChange = { state.config.value = config.copy(unpackFiles = it) },
             )
         }
+        SettingsSwitch(
+            colors = settingsTileColorsAlt(),
+            title = { Text(text = stringResource(R.string.workshop_mods)) },
+            subtitle = { Text(text = stringResource(R.string.workshop_mods_description)) },
+            state = config.workshopMods,
+            onCheckedChange = { state.config.value = config.copy(workshopMods = it) },
+        )
+        if (onDeleteWorkshopMods != null) {
+            var showDeleteConfirmation by rememberSaveable { mutableStateOf(false) }
+            if (showDeleteConfirmation) {
+                AlertDialog(
+                    onDismissRequest = { showDeleteConfirmation = false },
+                    title = { Text(text = stringResource(R.string.delete_workshop_mods)) },
+                    text = { Text(text = stringResource(R.string.delete_workshop_mods_confirm)) },
+                    confirmButton = {
+                        TextButton(onClick = {
+                            showDeleteConfirmation = false
+                            onDeleteWorkshopMods()
+                            state.config.value = state.config.value.copy(workshopMods = false)
+                        }) {
+                            Text(text = stringResource(R.string.delete))
+                        }
+                    },
+                    dismissButton = {
+                        TextButton(onClick = { showDeleteConfirmation = false }) {
+                            Text(text = stringResource(R.string.cancel))
+                        }
+                    },
+                )
+            }
+            TextButton(
+                onClick = { showDeleteConfirmation = true },
+                modifier = Modifier.fillMaxWidth().padding(horizontal = 16.dp),
+            ) {
+                Text(
+                    text = stringResource(R.string.delete_workshop_mods),
+                    color = androidx.compose.material3.MaterialTheme.colorScheme.error,
+                )
+            }
+        }
         SettingsSwitch(
             colors = settingsTileColorsAlt(),
             title = { Text(text = stringResource(R.string.steam_offline_mode)) },

app/src/main/java/app/gamenative/ui/screen/library/appscreen/BaseAppScreen.kt

@@ -35,10 +35,12 @@ import app.gamenative.ui.data.GameDisplayInfo
 import app.gamenative.ui.enums.AppOptionMenuType
 import app.gamenative.utils.ContainerUtils
 import app.gamenative.utils.createPinnedShortcut
+import app.gamenative.workshop.WorkshopManager
 import com.winlator.container.ContainerData
 import java.io.File
 import kotlin.text.Charsets
 import kotlinx.coroutines.CoroutineScope
+import timber.log.Timber
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
@@ -785,6 +787,32 @@ abstract class BaseAppScreen {
                     saveContainerConfig(context, libraryItem, it)
                     showConfigDialog = false
                 },
+                onDeleteWorkshopMods = if (libraryItem.gameSource == GameSource.STEAM) {
+                    {
+                        uiScope.launch {
+                            try {
+                                withContext(Dispatchers.IO) {
+                                    val gameRootDir = File(
+                                        app.gamenative.service.SteamService.getAppDirPath(
+                                            displayInfo.gameId
+                                        )
+                                    )
+                                    val gameName = displayInfo.name
+                                    WorkshopManager.deleteWorkshopMods(
+                                        context, libraryItem.appId,
+                                        gameRootDir, gameName,
+                                    )
+                                }
+                                SnackbarManager.show("Workshop mods deleted")
+                            } catch (e: Exception) {
+                                Timber.e(e, "Failed to delete workshop mods")
+                                SnackbarManager.show("Failed to delete workshop mods")
+                            }
+                        }
+                    }
+                } else {
+                    null
+                },
             )
         }
 

app/src/main/java/app/gamenative/ui/screen/xserver/XServerScreen.kt

@@ -1657,6 +1657,9 @@ fun XServerScreen(
 
                 // Set container-level shooter mode
                 setContainerShooterMode(container.isShooterMode)
+
+                // Set relative mouse movement from container setting
+                xServerView.getxServer().setRelativeMouseMovement(container.isRelativeMouseMovement)
             }
             PluviaApp.inputControlsView = icView