feat: import a local image for UltraFix

Long-pressing the upscale or UltraFix button on the result page opens an
import dialog: pick a local image, adjust a scale slider, and use it as
the UltraFix source instead of only images generated in-app.

The slider spans from "shrink to upscale-eligible" up to a 4096 long-side
cap (bounding decode memory and upload size). There is no minimum size:
an import too small for the UltraFix window (long side above 1024, short
side at least the tile) simply lands on the result page upscale-eligible,
so the user upscales it first and then runs UltraFix. Oversized sources
are decoded pre-scaled to the cap, EXIF rotation is applied, and output
dimensions are aligned to multiples of 8 for the VAE. The imported image
is not written to history; only the repaired result is.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>

Author: xororz

app/src/main/java/io/github/xororz/localdream/ui/screens/ModelRunPages.kt

@@ -63,6 +63,7 @@ import androidx.compose.material3.LocalMinimumInteractiveComponentSize
 import androidx.compose.material3.MaterialTheme
 import androidx.compose.material3.Surface
 import androidx.compose.material3.Text
+import androidx.compose.material3.minimumInteractiveComponentSize
 import androidx.compose.runtime.Composable
 import androidx.compose.runtime.CompositionLocalProvider
 import androidx.compose.runtime.LaunchedEffect
@@ -74,8 +75,10 @@ import androidx.compose.runtime.withFrameNanos
 import androidx.compose.ui.Alignment
 import androidx.compose.ui.Modifier
 import androidx.compose.ui.draw.alpha
+import androidx.compose.ui.draw.clip
 import androidx.compose.ui.graphics.Color
 import androidx.compose.ui.graphics.graphicsLayer
+import androidx.compose.ui.graphics.vector.ImageVector
 import androidx.compose.ui.platform.LocalConfiguration
 import androidx.compose.ui.platform.LocalContext
 import androidx.compose.ui.res.pluralStringResource
@@ -105,6 +108,10 @@ internal fun ModelRunResultPage(
     upscaleEnabled: Boolean,
     showUltrafixButton: Boolean,
     ultrafixEnabled: Boolean,
+    // Long-pressing either the upscale or the UltraFix button opens the
+    // local-image import dialog for UltraFix.
+    onUpscaleLongClick: () -> Unit,
+    onUltrafixLongClick: () -> Unit,
     // null when the displayed image has no history row to mark (hides the
     // favorite button).
     isFavorite: Boolean?,
@@ -230,27 +237,23 @@ internal fun ModelRunResultPage(
                                     }
 
                                     if (showUpscaleButton) {
-                                        FilledTonalIconButton(
-                                            onClick = onUpscaleClick,
+                                        LongPressableTonalIconButton(
                                             enabled = upscaleEnabled,
-                                        ) {
-                                            Icon(
-                                                imageVector = Icons.Default.AutoFixHigh,
-                                                contentDescription = "upscale image",
-                                            )
-                                        }
+                                            onClick = onUpscaleClick,
+                                            onLongClick = onUpscaleLongClick,
+                                            icon = Icons.Default.AutoFixHigh,
+                                            contentDescription = "upscale image",
+                                        )
                                     }
 
                                     if (showUltrafixButton) {
-                                        FilledTonalIconButton(
-                                            onClick = onUltrafixClick,
+                                        LongPressableTonalIconButton(
                                             enabled = ultrafixEnabled,
-                                        ) {
-                                            Icon(
-                                                imageVector = Icons.Default.AutoAwesome,
-                                                contentDescription = "ultrafix image",
-                                            )
-                                        }
+                                            onClick = onUltrafixClick,
+                                            onLongClick = onUltrafixLongClick,
+                                            icon = Icons.Default.AutoAwesome,
+                                            contentDescription = "ultrafix image",
+                                        )
                                     }
 
                                     FilledTonalIconButton(
@@ -724,3 +727,39 @@ internal fun ModelRunHistoryPage(
         }
     }
 }
+
+// FilledTonalIconButton look-alike with a long-press slot (M3 icon buttons
+// expose none). Both result-page image actions use it so a long press on
+// either can open the UltraFix local-image import dialog.
+@Composable
+private fun LongPressableTonalIconButton(
+    enabled: Boolean,
+    onClick: () -> Unit,
+    onLongClick: () -> Unit,
+    icon: ImageVector,
+    contentDescription: String,
+) {
+    val colors = IconButtonDefaults.filledTonalIconButtonColors()
+    Box(
+        modifier = Modifier
+            .minimumInteractiveComponentSize()
+            // Standard M3 icon-button container.
+            .size(40.dp)
+            .clip(CircleShape)
+            .background(
+                if (enabled) colors.containerColor else colors.disabledContainerColor,
+            )
+            .combinedClickable(
+                enabled = enabled,
+                onClick = onClick,
+                onLongClick = onLongClick,
+            ),
+        contentAlignment = Alignment.Center,
+    ) {
+        Icon(
+            imageVector = icon,
+            contentDescription = contentDescription,
+            tint = if (enabled) colors.contentColor else colors.disabledContentColor,
+        )
+    }
+}

app/src/main/java/io/github/xororz/localdream/ui/screens/ModelRunScreen.kt

@@ -518,6 +518,7 @@ fun ModelRunScreen(
     // pendingUltrafix marks the in-flight generation as an ultrafix run so the
     // completion handler can record the right mode.
     var showUltrafixConfirmDialog by remember { mutableStateOf(false) }
+    var showUltrafixImportDialog by remember { mutableStateOf(false) }
     var pendingUltrafix by remember { mutableStateOf(false) }
     var isUltrafixPreparing by remember { mutableStateOf(false) }
     // UltraFix runs with its own steps/denoise (defaults 10 / 0.4), persisted
@@ -983,6 +984,31 @@ fun ModelRunScreen(
         uri?.let { processSelectedImage(it) }
     }
 
+    // Places an imported (already size-validated and resized) local image
+    // into the result slot as the UltraFix source. Synthetic params: only the
+    // dimensions matter (they drive the size gating); everything else marks
+    // "not generated by this app". The import itself is never written to
+    // history - only the repaired result is.
+    fun applyUltrafixImport(bitmap: Bitmap) {
+        currentBitmap = bitmap
+        generationParams = GenerationParameters(
+            steps = 0,
+            cfg = cfg,
+            seed = null,
+            prompt = "",
+            negativePrompt = "",
+            generationTime = null,
+            width = bitmap.width,
+            height = bitmap.height,
+            runOnCpu = false,
+            mode = GenerationMode.UNKNOWN,
+        )
+        generationParamsModelId = modelId
+        currentDisplayedHistoryId = null
+        stitchableHistoryIds = emptySet()
+        imageVersion++
+    }
+
     val contentPickerLauncher = rememberLauncherForActivityResult(
         ActivityResultContracts.GetContent(),
     ) { uri ->
@@ -2495,6 +2521,15 @@ fun ModelRunScreen(
                                         maxOf(currentWidth, currentHeight, 512)
                                 } == true,
                             ultrafixEnabled = !isRunning && !isUpscaling && !isUltrafixPreparing,
+                            // The upscale button also exists on models that
+                            // can't run UltraFix (SD1.5 NPU); its long press
+                            // only opens the import dialog when the model can.
+                            onUpscaleLongClick = {
+                                if (useImg2img && model.isSdxl && cfg == 1f) {
+                                    showUltrafixImportDialog = true
+                                }
+                            },
+                            onUltrafixLongClick = { showUltrafixImportDialog = true },
                             isFavorite = if (currentDisplayedHistoryId != null) {
                                 displayedFavorite
                             } else {
@@ -2733,6 +2768,27 @@ fun ModelRunScreen(
         )
     }
 
+    // Import-and-resize a local image for UltraFix. A confirmed image that
+    // already satisfies the UltraFix window goes straight to the parameter
+    // dialog; a smaller one just lands on the result page, where the visible
+    // upscale button is the natural next step.
+    if (showUltrafixImportDialog) {
+        UltrafixImportDialog(
+            tileSize = maxOf(currentWidth, currentHeight, 512),
+            onDismiss = { showUltrafixImportDialog = false },
+            onConfirm = { bitmap ->
+                applyUltrafixImport(bitmap)
+                showUltrafixImportDialog = false
+                val tile = maxOf(currentWidth, currentHeight, 512)
+                if (maxOf(bitmap.width, bitmap.height) > 1024 &&
+                    minOf(bitmap.width, bitmap.height) >= tile
+                ) {
+                    showUltrafixConfirmDialog = true
+                }
+            },
+        )
+    }
+
     // Ultrafix parameter confirmation.
     if (showUltrafixConfirmDialog) {
         AlertDialog(
@@ -2755,6 +2811,12 @@ fun ModelRunScreen(
                         color = MaterialTheme.colorScheme.onSurfaceVariant,
                     )
 
+                    Text(
+                        stringResource(R.string.ultrafix_longpress_hint),
+                        style = MaterialTheme.typography.bodySmall,
+                        color = MaterialTheme.colorScheme.onSurfaceVariant,
+                    )
+
                     // Independent UltraFix steps (1..20). Lowering steps also
                     // tightens the denoise-step cap below.
                     val denoiseStepsMax =