Begin work on file extension registration

1. Extend DesktopIntegrationProvider Interface

Added three new methods to DesktopIntegrationProvider:
- boolean isFileExtensionsEnabled() - Check registered file associations
- boolean isFileExtensionsToggleable() - Check if platform can toggle
- void setFileExtensionsEnabled(boolean) - Toggle file associations

2. macOS Implementation (Read-Only)

- Returns true for isFileExtensionsEnabled() (declared in Info.plist)
- Returns false for isFileExtensionsToggleable() (immutable bundle)
- setFileExtensionsEnabled() is a no-op with documentation

3. Windows Implementation (SupportedTypes Approach)

- Register: HKCU\Software\Classes\Applications\<app>.exe\SupportedTypes
- Safety: Create/delete our own registry tree (no over-deletion risk)
- Extension Collection: Add collectFileExtensions() method stub
- Helper Methods: getExecutableName(), execRegistryCommand()
- Makes app appear in "Open With" for all registered extensions

4. Linux Implementation (MIME Types + .desktop file)

- Standard formats: Use existing MIME types (e.g. image/png)
- Custom formats: Create ~/.local/share/mime/packages/<app>.xml for PFFs
- Run update-mime-database to register custom MIME types
- Add MIME types to .desktop file's MimeType= field
- Preserve URI scheme handlers when unregistering file extensions

5. Update OptionsDesktop UI

- Added "Enable file type associations" checkbox
- Integrated into load/run/validate flow
- Automatically grays out if not toggleable on current platform

Key Design Decisions:

1. Single checkbox enables/disables ALL file extensions
2. Windows safety: Uses Applications\SupportedTypes (separate tree)
3. Linux custom MIME types: Register formats that lack standard types
4. Extension source: Currently placeholder - will use IOPlugin later

Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: ctrueden

src/main/java/org/scijava/desktop/DesktopIntegrationProvider.java

@@ -82,6 +82,29 @@ public interface DesktopIntegrationProvider {
 	 */
 	void setDesktopIconPresent(final boolean install) throws IOException;
 
+	boolean isFileExtensionsEnabled();
+
+	boolean isFileExtensionsToggleable();
+
+	/**
+	 * Enables or disables file extension associations (e.g., {@code .tif}, {@code .png}).
+	 * <p>
+	 * This operation only works if {@link #isFileExtensionsToggleable()}
+	 * returns true. Otherwise, calling this method may throw
+	 * {@link UnsupportedOperationException}.
+	 * </p>
+	 * <p>
+	 * When enabled, the application will be registered as a handler for all
+	 * supported file extensions. The application appears in "Open With" menus,
+	 * allowing users to choose it for specific file types.
+	 * </p>
+	 *
+	 * @param enable whether to enable or disable file extension associations
+	 * @throws IOException if the operation fails
+	 * @throws UnsupportedOperationException if not supported on this platform
+	 */
+	void setFileExtensionsEnabled(final boolean enable) throws IOException;
+
 	/**
 	 * Creates a SchemeInstaller for this platform.
 	 *

src/main/java/org/scijava/desktop/options/OptionsDesktop.java

@@ -71,16 +71,22 @@ public class OptionsDesktop extends OptionsPlugin {
 		description = "Install application icon in the system menu")
 	private boolean desktopIconPresent;
 
+	@Parameter(label = "Enable file type associations", persist = false, validater = "validateFileExtensions", //
+		description = "Register supported file extensions with the operating system")
+	private boolean fileExtensionsEnabled;
+
 	@Override
 	public void load() {
 		webLinksEnabled = true;
 		desktopIconPresent = true;
+		fileExtensionsEnabled = true;
 		for (final Platform platform : platformService.getTargetPlatforms()) {
 			if (!(platform instanceof DesktopIntegrationProvider)) continue;
 			final DesktopIntegrationProvider dip = (DesktopIntegrationProvider) platform;
 			// If any toggleable platform setting is off, uncheck that box.
 			if (dip.isDesktopIconToggleable() && !dip.isDesktopIconPresent()) desktopIconPresent = false;
 			if (dip.isWebLinksToggleable() && !dip.isWebLinksEnabled()) webLinksEnabled = false;
+			if (dip.isFileExtensionsToggleable() && !dip.isFileExtensionsEnabled()) fileExtensionsEnabled = false;
 		}
 	}
 
@@ -92,6 +98,7 @@ public void run() {
 			try {
 				dip.setWebLinksEnabled(webLinksEnabled);
 				dip.setDesktopIconPresent(desktopIconPresent);
+				dip.setFileExtensionsEnabled(fileExtensionsEnabled);
 			}
 			catch (final IOException e) {
 				if (log != null) {
@@ -120,6 +127,14 @@ public void validateDesktopIcon() {
 			"Desktop icon presence");
 	}
 
+	public void validateFileExtensions() {
+		validateSetting(
+			DesktopIntegrationProvider::isFileExtensionsToggleable,
+			DesktopIntegrationProvider::isFileExtensionsEnabled,
+			fileExtensionsEnabled,
+			"File extensions setting");
+	}
+
 	// -- Helper methods --
 
 	private String name(Platform platform) {

src/main/java/org/scijava/desktop/platform/linux/LinuxPlatform.java

@@ -42,12 +42,18 @@
 import org.scijava.plugin.Plugin;
 
 import java.io.IOException;
+import java.io.InputStream;
 import java.net.URL;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedHashMap;
 import java.util.List;
+import java.util.Map;
+import java.util.Properties;
 import java.util.Set;
 
 /**
@@ -79,6 +85,9 @@ public class LinuxPlatform extends AbstractPlatform
 	@Parameter(required = false)
 	private LogService log;
 
+	/** Cached MIME type mapping */
+	private static Map<String, String> extensionToMime = null;
+
 	// -- Platform methods --
 
 	@Override
@@ -211,6 +220,77 @@ public void setDesktopIconPresent(final boolean install) throws IOException {
 		}
 	}
 
+	@Override
+	public boolean isFileExtensionsEnabled() {
+		try {
+			final DesktopFile df = getOrCreateDesktopFile();
+			final Map<String, String> mimeMapping = loadMimeTypeMapping();
+
+			// Check if any file extension MIME types are in the .desktop file
+			for (final String mimeType : mimeMapping.values()) {
+				if (df.hasMimeType(mimeType)) return true;
+			}
+			return false;
+		} catch (final IOException e) {
+			if (log != null) {
+				log.debug("Failed to check file extensions status", e);
+			}
+			return false;
+		}
+	}
+
+	@Override
+	public boolean isFileExtensionsToggleable() {
+		return true;
+	}
+
+	@Override
+	public void setFileExtensionsEnabled(final boolean enable) throws IOException {
+		final Map<String, String> mimeMapping = loadMimeTypeMapping();
+		if (mimeMapping.isEmpty()) {
+			if (log != null) {
+				log.warn("No file extensions to register");
+			}
+			return;
+		}
+
+		if (enable) {
+			// Register custom MIME types for formats without standard types
+			registerCustomMimeTypes(mimeMapping);
+
+			// Add MIME types to .desktop file
+			final DesktopFile df = getOrCreateDesktopFile();
+			for (final String mimeType : mimeMapping.values()) {
+				df.addMimeType(mimeType);
+			}
+			df.save();
+
+			if (log != null) {
+				log.info("Registered " + mimeMapping.size() + " file extension MIME types");
+			}
+		} else {
+			// Remove file extension MIME types from .desktop file
+			// Keep URI scheme handlers (x-scheme-handler/...)
+			final DesktopFile df = getOrCreateDesktopFile();
+			final Set<String> uriSchemes = collectSchemes();
+
+			for (final String mimeType : mimeMapping.values()) {
+				df.removeMimeType(mimeType);
+			}
+
+			// Re-add URI scheme handlers
+			for (final String scheme : uriSchemes) {
+				df.addMimeType("x-scheme-handler/" + scheme);
+			}
+
+			df.save();
+
+			if (log != null) {
+				log.info("Unregistered file extension MIME types");
+			}
+		}
+	}
+
 	@Override
 	public SchemeInstaller getSchemeInstaller() {
 		return new LinuxSchemeInstaller(log);
@@ -335,4 +415,127 @@ private Set<String> collectSchemes() {
 		}
 		return schemes;
 	}
+
+	/**
+	 * Loads the file extension to MIME type mapping.
+	 */
+	private synchronized Map<String, String> loadMimeTypeMapping() throws IOException {
+		if (extensionToMime != null) return extensionToMime;
+
+		extensionToMime = new LinkedHashMap<>();
+
+		// TODO: Query IOService for formats
+
+		return extensionToMime;
+	}
+
+	/**
+	 * Registers custom MIME types for formats that don't have standard types.
+	 * Creates ~/.local/share/mime/packages/[appName].xml and runs update-mime-database.
+	 */
+	private void registerCustomMimeTypes(final Map<String, String> mimeMapping) throws IOException {
+		// Separate standard from custom MIME types
+		final Map<String, String> customTypes = new LinkedHashMap<>();
+		for (final Map.Entry<String, String> entry : mimeMapping.entrySet()) {
+			final String mimeType = entry.getValue();
+			// Custom types use application/x- prefix
+			if (mimeType.startsWith("application/x-")) {
+				customTypes.put(entry.getKey(), mimeType);
+			}
+		}
+
+		if (customTypes.isEmpty()) {
+			// No custom types to register
+			return;
+		}
+
+		// Generate MIME types XML
+		final String appName = System.getProperty("scijava.app.name", "SciJava");
+		final String mimeXml = generateMimeTypesXml(customTypes, appName);
+
+		// Write to ~/.local/share/mime/packages/<app>.xml
+		final Path mimeDir = Paths.get(System.getProperty("user.home"),
+			".local/share/mime/packages");
+		Files.createDirectories(mimeDir);
+
+		final Path mimeFile = mimeDir.resolve(sanitizeFileName(appName) + ".xml");
+		Files.writeString(mimeFile, mimeXml, StandardOpenOption.CREATE,
+			StandardOpenOption.TRUNCATE_EXISTING);
+
+		// Update MIME database
+		try {
+			final ProcessBuilder pb = new ProcessBuilder(
+				"update-mime-database",
+				Paths.get(System.getProperty("user.home"), ".local/share/mime").toString()
+			);
+			final Process process = pb.start();
+			final int exitCode = process.waitFor();
+
+			if (exitCode != 0) {
+				if (log != null) {
+					log.warn("update-mime-database exited with code " + exitCode);
+				}
+			} else if (log != null) {
+				log.info("Registered " + customTypes.size() + " custom MIME types");
+			}
+		} catch (final Exception e) {
+			if (log != null) {
+				log.error("Failed to run update-mime-database", e);
+			}
+		}
+	}
+
+	/**
+	 * Generates MIME types XML for custom file formats.
+	 */
+	private String generateMimeTypesXml(final Map<String, String> customTypes,
+		final String appName)
+	{
+		final StringBuilder xml = new StringBuilder();
+		xml.append("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
+		xml.append("<mime-info xmlns=\"http://www.freedesktop.org/standards/shared-mime-info\">\n");
+
+		for (final Map.Entry<String, String> entry : customTypes.entrySet()) {
+			final String extension = entry.getKey();
+			final String mimeType = entry.getValue();
+
+			// Generate human-readable comment from MIME type
+			final String comment = generateMimeTypeComment(mimeType);
+
+			xml.append("  <mime-type type=\"").append(mimeType).append("\">\n");
+			xml.append("    <comment>").append(comment).append("</comment>\n");
+			xml.append("    <glob pattern=\"*.").append(extension).append("\"/>\n");
+			xml.append("  </mime-type>\n");
+		}
+
+		xml.append("</mime-info>\n");
+		return xml.toString();
+	}
+
+	/**
+	 * Generates a human-readable comment from a MIME type.
+	 * For example, "application/x-zeiss-czi" becomes "Zeiss CZI File".
+	 */
+	private String generateMimeTypeComment(final String mimeType) {
+		// Extract the format part (e.g., "zeiss-czi" from "application/x-zeiss-czi")
+		final String format = mimeType.substring(mimeType.lastIndexOf('/') + 1);
+
+		// Remove "x-" prefix if present
+		final String cleanFormat = format.startsWith("x-") ?
+			format.substring(2) : format;
+
+		// Convert to title case
+		final String[] parts = cleanFormat.split("-");
+		final StringBuilder comment = new StringBuilder();
+		for (final String part : parts) {
+			if (comment.length() > 0) comment.append(' ');
+			comment.append(Character.toUpperCase(part.charAt(0)));
+			if (part.length() > 1) {
+				comment.append(part.substring(1));
+			}
+		}
+		comment.append(" File");
+
+		return comment.toString();
+	}
 }

src/main/java/org/scijava/desktop/platform/macos/MacOSPlatform.java

@@ -159,6 +159,24 @@ public void setDesktopIconPresent(final boolean install) {
 		// Desktop icon installation is not supported on macOS (use Dock pinning instead).
 	}
 
+	@Override
+	public boolean isFileExtensionsEnabled() {
+		// File extensions are declared in Info.plist, which is immutable.
+		return true;
+	}
+
+	@Override
+	public boolean isFileExtensionsToggleable() {
+		// File extensions are declared in Info.plist, which is immutable.
+		return false;
+	}
+
+	@Override
+	public void setFileExtensionsEnabled(final boolean enable) {
+		// Note: Operation has no effect here.
+		// File extension registration is immutable on macOS (configured in .app bundle).
+	}
+
 	@Override
 	public SchemeInstaller getSchemeInstaller() {
 		// macOS uses Info.plist for URI scheme registration (build-time only)