arcane-os 0.59.0 → 0.60.0

package/runtime/arcane/modules/ThemeBootstrap.js

@@ -3,11 +3,12 @@ const is=new Is(false);
 
 import { arcaneLogging } from 'arcane-os/logging';
 import {applyUserSkin,loadAndApplyTheme} from './ThemeManager.js';
-import {createArcaneEventSource} from 'arcane-os/event-manager';
+import {arcaneEvents,createArcaneEventSource} from 'arcane-os/event-manager';
 
 const sharedKey='arcaneThemeReady';
 const listenerKey='arcaneThemeAppearanceListener';
 const userListenerKey='arcaneThemeUserListener';
+const windowListenerKey='arcaneThemeWindowListener';
 const THEME_BOOTSTRAP_EVENT_OWNER={};
 let themeBootstrapOperationSequence=0;
 const themeBootstrapEvents=createArcaneEventSource(
@@ -99,11 +100,222 @@ function installUserSkinListener(){
     applyReadyUserSkin();
 }
 
+function installWindowThemeListener(ready){
+    const host=globalThis.Arcane;
+    const document=globalThis.document;
+    if(globalThis[windowListenerKey]||!host?.runtime?.current?.().native
+        ||!is.function(host?.window?.setTheme)||!document?.documentElement) return;
+
+    let active=true;
+    let suspended=false;
+    let scheduled=false;
+    let lastPresentation=null;
+    let pending=null;
+    let observedBody=null;
+    let canvasContext=null;
+    const root=document.documentElement;
+    const scheme=globalThis.matchMedia('(prefers-color-scheme: dark)');
+    const print=globalThis.matchMedia('print');
+    const probe=document.createElement('span');
+    probe.style.setProperty('display','none','important');
+
+    function report(error){
+        arcaneLogging.warn('[Arcane theme] Unable to update the native window colors.',error);
+    }
+    function colorRecord(resolved){
+        // Read the browser's resolved color, not an authored CSS grammar. Keep
+        // its alpha separately so raster conversion cannot round translucency away.
+        const rgb=resolved.match(/^rgba?\(([^)]+)\)$/u);
+        if(rgb){
+            const values=rgb[1].split(/[\s,/]+/u).filter(Boolean).map(Number);
+            if((values.length===3||values.length===4)&&values.every(Number.isFinite)){
+                return {red:values[0],green:values[1],blue:values[2],alpha:values[3]??1};
+            }
+        }
+        const alphaMatch=resolved.match(/\/\s*(none|[-+\d.eE]+%?)\s*\)$/u);
+        const alphaValue=alphaMatch?.[1];
+        const alpha=alphaValue===undefined?1:alphaValue==='none'?0:
+            Number.parseFloat(alphaValue)/(alphaValue.endsWith('%')?100:1);
+        if(!Number.isFinite(alpha)||(resolved.includes('/')&&!alphaMatch)){
+            throw new TypeError(`Unable to read the resolved CSS color: ${resolved}`);
+        }
+        const opaque=alphaMatch?resolved.replace(/\/[^/]*\)$/u,'/ 1)'):resolved;
+        if(!canvasContext){
+            const canvas=document.createElement('canvas');
+            canvas.width=1;
+            canvas.height=1;
+            canvasContext=canvas.getContext(
+                '2d',
+                {colorSpace:'srgb'}
+            );
+            if(!canvasContext) throw new Error('The browser cannot convert the resolved color to sRGB.');
+        }
+        // An unsupported fillStyle assignment leaves the old value intact.
+        // Two different starting values distinguish rejection from a valid black.
+        canvasContext.fillStyle='#000000';
+        canvasContext.fillStyle=opaque;
+        const accepted=canvasContext.fillStyle;
+        canvasContext.fillStyle='#ffffff';
+        canvasContext.fillStyle=opaque;
+        if(canvasContext.fillStyle!==accepted){
+            throw new TypeError(`The browser canvas cannot convert the resolved CSS color: ${resolved}`);
+        }
+        canvasContext.clearRect(0,0,1,1);
+        canvasContext.fillRect(0,0,1,1);
+        const [red,green,blue]=canvasContext.getImageData(0,0,1,1).data;
+        return {red,green,blue,alpha};
+    }
+    function readPresentation(){
+        const target=document.body;
+        if(!target) return {};
+        const styles=globalThis.getComputedStyle(target);
+        const presentation={};
+        target.appendChild(probe);
+        try {
+            const properties=[
+                ['backgroundColor','--background'],
+                ['textColor','--text-color']
+            ];
+            for(const [field,property] of properties){
+                const authored=styles.getPropertyValue(property);
+                if(!authored.trim()) continue;
+                if(!globalThis.CSS.supports('color',authored)){
+                    report(
+                        new TypeError(`The app theme ${property} is not a supported CSS color: ${authored}`)
+                    );
+                    continue;
+                }
+                // Use the target's resolved value: registered properties may
+                // deliberately not inherit into this child resolution element.
+                probe.style.setProperty('color',authored,'important');
+                try {
+                    const resolved=globalThis.getComputedStyle(probe).color;
+                    presentation[field]=colorRecord(resolved);
+                } catch (error) {
+                    report(error);
+                }
+            }
+        } finally {
+            probe.remove();
+        }
+        return presentation;
+    }
+    function samePresentation(next){
+        return lastPresentation&&['backgroundColor','textColor'].every(
+            function sameColor(field){
+                const before=lastPresentation[field];
+                const after=next[field];
+                if(before===after) return true;
+                if(!before||!after) return false;
+                return ['red','green','blue','alpha'].every(
+                    function sameChannel(channel){
+                        return before[channel]===after[channel];
+                    }
+                );
+            }
+        );
+    }
+    function observeElements(){
+        if(observedBody===document.body) return;
+        observer.disconnect();
+        observer.observe(
+            root,
+            {attributes:true,childList:true,attributeFilter:['class','style','data-color-scheme','data-user-skin','data-arcane-skin']}
+        );
+        observedBody=document.body;
+        if(observedBody) observer.observe(
+            observedBody,
+            {attributes:true,attributeFilter:['class','style']}
+        );
+    }
+    function sample(){
+        scheduled=false;
+        if(!active||suspended||print.matches) return;
+        observeElements();
+        const presentation=readPresentation();
+        if(!Object.keys(presentation).length||samePresentation(presentation)) return;
+        lastPresentation=presentation;
+        pending?.abort();
+        const controller=new AbortController();
+        pending=controller;
+        try {
+            const operation=host.window.setTheme(
+                presentation,
+                {signal:controller.signal}
+            );
+            Promise.resolve(operation).catch(
+                function reportWindowFailure(error){
+                    if(error?.code==='ARCANE_REQUEST_ABORTED'||(controller.signal.aborted&&error?.name==='AbortError')) return;
+                    report(error);
+                    if(error?.code==='METHOD_NOT_ALLOWED') dispose();
+                }
+            ).finally(
+                function finishWindowUpdate(){
+                    if(pending===controller) pending=null;
+                }
+            );
+        } catch (error) {
+            if(pending===controller) pending=null;
+            report(error);
+        }
+    }
+    function schedule(){
+        if(!active||suspended||scheduled) return;
+        scheduled=true;
+        Promise.resolve().then(sample).catch(report);
+    }
+    function stylesheetLoaded(event){
+        if(event.target?.tagName==='LINK'&&event.target.relList?.contains('stylesheet')) schedule();
+    }
+    function hide(){
+        suspended=true;
+        pending?.abort();
+    }
+    function show(){
+        suspended=false;
+        lastPresentation=null;
+        schedule();
+    }
+    function dispose(){
+        if(!active) return false;
+        active=false;
+        pending?.abort();
+        observer.disconnect();
+        unsubscribe();
+        scheme.removeEventListener('change',schedule);
+        print.removeEventListener('change',schedule);
+        document.removeEventListener('DOMContentLoaded',schedule);
+        document.removeEventListener('load',stylesheetLoaded,true);
+        globalThis.removeEventListener('pagehide',hide);
+        globalThis.removeEventListener('pageshow',show);
+        canvasContext=null;
+        if(globalThis[windowListenerKey]===dispose) delete globalThis[windowListenerKey];
+        return true;
+    }
+    const observer=new globalThis.MutationObserver(schedule);
+    const unsubscribe=arcaneEvents.subscribe('arcane-theme-change',schedule);
+    observer.observe(
+        root,
+        {attributes:true,childList:true,attributeFilter:['class','style','data-color-scheme','data-user-skin','data-arcane-skin']}
+    );
+    observeElements();
+    scheme.addEventListener('change',schedule);
+    print.addEventListener('change',schedule);
+    document.addEventListener('DOMContentLoaded',schedule);
+    document.addEventListener('load',stylesheetLoaded,true);
+    globalThis.addEventListener('pagehide',hide);
+    globalThis.addEventListener('pageshow',show);
+    globalThis[windowListenerKey]=dispose;
+    schedule();
+    Promise.resolve(ready).then(schedule).catch(report);
+}
+
 export function bootstrapArcaneTheme(options={}){
     const useSharedPromise=Object.keys(options).length===0;
     if(useSharedPromise&&globalThis[sharedKey]){
         installAppearanceListener(globalThis[sharedKey]);
         installUserSkinListener();
+        installWindowThemeListener(globalThis[sharedKey]);
         return globalThis[sharedKey];
     }
 
@@ -116,6 +328,7 @@ export function bootstrapArcaneTheme(options={}){
     if(useSharedPromise){
         installAppearanceListener(ready);
         installUserSkinListener();
+        installWindowThemeListener(ready);
     }
     return ready;
 }
@@ -123,9 +336,11 @@ export function bootstrapArcaneTheme(options={}){
 export function disposeArcaneThemeBootstrap(){
     const dispose=globalThis[listenerKey];
     const disposeUser=globalThis[userListenerKey];
+    const disposeWindow=globalThis[windowListenerKey];
     const appearanceDisposed=is.function(dispose)?dispose():false;
     const userDisposed=is.function(disposeUser)?disposeUser():false;
-    return appearanceDisposed||userDisposed;
+    const windowDisposed=is.function(disposeWindow)?disposeWindow():false;
+    return appearanceDisposed||userDisposed||windowDisposed;
 }
 
 export const arcaneThemeReady=bootstrapArcaneTheme();

package/src/core/hosts/windows/ArcaneHost.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
+using System.Drawing;
 using System.IO;
 using System.Runtime.InteropServices;
 using System.Threading;
@@ -20,6 +21,7 @@ namespace Arcane.Core.Hosts.Windows
         public string OriginHost { get; set; }
         public string ProfileDirectory { get; set; }
         public string Title { get; set; }
+        public string IconPath { get; set; }
         public string ClassicClientSource { get; set; }
         public string CoreExecutable { get; set; }
         public string CoreArguments { get; set; }
@@ -106,6 +108,8 @@ namespace Arcane.Core.Hosts.Windows
         private Task initialization;
         private Task coreLifetime;
         private Task shutdown;
+        private Task iconLoading;
+        private Icon applicationIcon;
         private string injectedScript;
         private Exception transportFailure;
         private long generation;
@@ -162,6 +166,8 @@ namespace Arcane.Core.Hosts.Windows
                 string profile = Path.GetFullPath(options.ProfileDirectory);
                 Uri origin = new UriBuilder(Uri.UriSchemeHttps, options.OriginHost).Uri;
                 Uri start = new Uri(origin, options.StartPath);
+                iconLoading = LoadApplicationIconAsync();
+                iconLoading.ContinueWith(ObserveUnexpectedFailure, TaskContinuationOptions.OnlyOnFaulted);
                 core = ArcaneCoreProcess.Start(options.CoreExecutable, options.CoreArguments,
                     options.CoreWorkingDirectory, ReceiveCoreMessage, DeliverDiagnostic, CoreFailed);
                 coreLifetime = ObserveCoreLifetimeAsync();
@@ -228,6 +234,18 @@ namespace Arcane.Core.Hosts.Windows
             {
                 if (documentGeneration != generation || closing)
                     throw new InvalidOperationException("The requesting document is no longer connected.");
+                if (requestId != null && EnvelopeString(envelope, "protocol") == "arcane/1"
+                    && EnvelopeString(envelope, "method") == "window.setTheme")
+                {
+                    // This method belongs to this exact window, not the Core
+                    // child or a machine-wide appearance service.
+                    string response = WindowThemeResponse(envelope, requestId);
+                    pending.Enqueue(
+                        new CoreDelivery(documentGeneration, response)
+                    );
+                    ScheduleDelivery();
+                    return Task.FromResult<object>(null);
+                }
                 Task accepted = core.SendAsync(json);
                 // Hold the same lock used by the reader so an immediate response
                 // cannot overtake its accepted transport correlation record.
@@ -237,6 +255,181 @@ namespace Arcane.Core.Hosts.Windows
             }
         }
 
+        private async Task LoadApplicationIconAsync()
+        {
+            if (String.IsNullOrEmpty(options.IconPath)) return;
+            try
+            {
+                Icon loaded = await Task.Run(new Func<Icon>(ReadApplicationIcon));
+                if (closing)
+                {
+                    loaded.Dispose();
+                    return;
+                }
+                applicationIcon = loaded;
+                Icon = loaded;
+            }
+            catch (Exception error)
+            {
+                // Image codec availability is separate from application
+                // execution. Preserve ordinary startup and complete diagnostics.
+                object record = ArcaneHost.ErrorRecord(error, "ARCANE_WINDOW_ICON_UNAVAILABLE");
+                string diagnostic = ArcaneHost.Serializer().Serialize(record);
+                DeliverDiagnostic(diagnostic + Environment.NewLine);
+            }
+        }
+
+        private Icon ReadApplicationIcon()
+        {
+            string extension = Path.GetExtension(options.IconPath);
+            if (String.Equals(extension, ".ico", StringComparison.OrdinalIgnoreCase))
+                return new Icon(options.IconPath);
+            using (Bitmap bitmap = new Bitmap(options.IconPath))
+            {
+                IntPtr handle = bitmap.GetHicon();
+                try
+                {
+                    using (Icon borrowed = System.Drawing.Icon.FromHandle(handle))
+                    {
+                        return (Icon)borrowed.Clone();
+                    }
+                }
+                finally
+                {
+                    DestroyIcon(handle);
+                }
+            }
+        }
+
+        private string WindowThemeResponse(Dictionary<string, object> request, string id)
+        {
+            Dictionary<string, object> applied = new Dictionary<string, object>();
+            List<string> unsupported = new List<string>();
+            Dictionary<string, object> response = new Dictionary<string, object>
+            {
+                { "protocol", "arcane/1" },
+                { "type", "response" },
+                { "id", id }
+            };
+            try
+            {
+                object parameters;
+                Dictionary<string, object> presentation = request.TryGetValue("parameters", out parameters)
+                    ? parameters as Dictionary<string, object> : null;
+                if (presentation == null) throw new ArgumentException("Window presentation must be an object.");
+                ApplyWindowColor(presentation, "backgroundColor", 35, applied, unsupported);
+                ApplyWindowColor(presentation, "textColor", 36, applied, unsupported);
+                response["ok"] = true;
+                response["result"] = new Dictionary<string, object>
+                {
+                    { "platform", "windows" },
+                    { "supported", applied.Count != 0 },
+                    { "applied", applied },
+                    { "unsupported", unsupported }
+                };
+            }
+            catch (Exception error)
+            {
+                Dictionary<string, object> record = (Dictionary<string, object>)ArcaneHost.ErrorRecord(error,
+                    error is ArgumentException ? "INVALID_ARGUMENT" : "ARCANE_WINDOW_THEME_FAILED");
+                record["details"] = new Dictionary<string, object>
+                {
+                    { "applied", applied },
+                    { "unsupported", unsupported }
+                };
+                response["ok"] = false;
+                response["error"] = record;
+            }
+            return ArcaneHost.Serializer().Serialize(response);
+        }
+
+        private void ApplyWindowColor(Dictionary<string, object> presentation, string field, int attribute,
+            Dictionary<string, object> applied, List<string> unsupported)
+        {
+            object supplied;
+            if (!presentation.TryGetValue(field, out supplied)) return;
+            uint nativeColor = UInt32.MaxValue;
+            object accepted = null;
+            double alpha = 1;
+            if (supplied != null)
+            {
+                Dictionary<string, object> color = supplied as Dictionary<string, object>;
+                if (color == null) throw new ArgumentException(field + " must be an RGBA record or null.");
+                int red = (int)Math.Round(
+                    ColorChannel(color, "red", 255),
+                    MidpointRounding.AwayFromZero
+                );
+                int green = (int)Math.Round(
+                    ColorChannel(color, "green", 255),
+                    MidpointRounding.AwayFromZero
+                );
+                int blue = (int)Math.Round(
+                    ColorChannel(color, "blue", 255),
+                    MidpointRounding.AwayFromZero
+                );
+                alpha = ColorChannel(color, "alpha", 1);
+                nativeColor = (uint)(red | green << 8 | blue << 16);
+                accepted = new Dictionary<string, object>
+                {
+                    { "red", red },
+                    { "green", green },
+                    { "blue", blue },
+                    { "alpha", alpha }
+                };
+            }
+            if (alpha != 1 || !WindowColorsSupported())
+            {
+                unsupported.Add(field);
+                return;
+            }
+            int result = DwmSetWindowAttribute(Handle, attribute, ref nativeColor, sizeof(uint));
+            if (result < 0) throw new COMException("Applying window " + field + " failed.", result);
+            applied[field] = accepted;
+        }
+
+        private static double ColorChannel(Dictionary<string, object> color, string name, double maximum)
+        {
+            object value;
+            if (!color.TryGetValue(name, out value)
+                || !(value is int || value is long || value is double || value is decimal))
+                throw new ArgumentException("Window color " + name + " must be numeric.");
+            double number = Convert.ToDouble(value);
+            if (Double.IsNaN(number) || Double.IsInfinity(number) || number < 0 || number > maximum)
+                throw new ArgumentException("Window color " + name + " is outside its color-channel range.");
+            return number;
+        }
+
+        private static bool WindowColorsSupported()
+        {
+            WindowsVersion version = new WindowsVersion();
+            version.StructureSize = (uint)Marshal.SizeOf(typeof(WindowsVersion));
+            int result = RtlGetVersion(ref version);
+            if (result != 0) throw new ExternalException("Reading the Windows version failed.", result);
+            return version.Major > 10 || (version.Major == 10 && version.Build >= 22000);
+        }
+
+        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+        private struct WindowsVersion
+        {
+            internal uint StructureSize;
+            internal uint Major;
+            internal uint Minor;
+            internal uint Build;
+            internal uint Platform;
+            [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 128)]
+            internal string ServicePack;
+        }
+
+        [DllImport("ntdll.dll", CharSet = CharSet.Unicode, ExactSpelling = true)]
+        private static extern int RtlGetVersion(ref WindowsVersion version);
+
+        [DllImport("dwmapi.dll")]
+        private static extern int DwmSetWindowAttribute(IntPtr window, int attribute, ref uint value, int valueSize);
+
+        [DllImport("user32.dll", SetLastError = true)]
+        [return: MarshalAs(UnmanagedType.Bool)]
+        private static extern bool DestroyIcon(IntPtr icon);
+
         private void DocumentConnected(long documentGeneration)
         {
             ArcaneBridge previous;
@@ -498,6 +691,19 @@ namespace Arcane.Core.Hosts.Windows
                     catch (Exception error) { ReportTaskFailure(coreLifetime, error); }
                 }
             }
+            // Joining the independent image owner belongs after Core input has
+            // closed; image I/O must never delay accepted service work draining.
+            if (iconLoading != null)
+            {
+                try
+                {
+                    await iconLoading;
+                }
+                catch (Exception error)
+                {
+                    ReportTaskFailure(iconLoading, error);
+                }
+            }
             Task notifications = Task.WhenAll(failureNotifications);
             try { await notifications; }
             catch (Exception error) { ReportTaskFailure(notifications, error); }
@@ -546,6 +752,11 @@ namespace Arcane.Core.Hosts.Windows
         protected override void OnFormClosed(FormClosedEventArgs args)
         {
             base.OnFormClosed(args);
+            if (applicationIcon != null)
+            {
+                applicationIcon.Dispose();
+                applicationIcon = null;
+            }
             CompleteWindow();
         }
 

package/src/core/hosts/windows/ArcaneLauncher.cs

@@ -51,6 +51,10 @@ namespace Arcane.Core.Hosts.Windows
                 string appId = RequiredString(app, "id");
                 object title;
                 string name = app.TryGetValue("displayName", out title) && title is string ? (string)title : appId;
+                object hostValue;
+                object iconValue;
+                Dictionary<string, object> host = manifest.TryGetValue("host", out hostValue) ? hostValue as Dictionary<string, object> : null;
+                string icon = host != null && host.TryGetValue("icon", out iconValue) ? iconValue as string : null;
 
                 // Core rereads this exact selected file. Do not normalize,
                 // rewrite, filter or copy the application's launch record.
@@ -67,6 +71,7 @@ namespace Arcane.Core.Hosts.Windows
                     OriginHost = "arcane.local",
                     ProfileDirectory = Path.Combine(profileParent, "WebView2"),
                     Title = name,
+                    IconPath = String.IsNullOrEmpty(icon) ? null : Path.Combine(directory, icon),
                     ClassicClientSource = File.ReadAllText(Path.Combine(directory, RequiredString(client, "source"))),
                     CoreExecutable = Path.Combine(directory, "runtime", "ArcaneCore.exe"),
                     // Forward the actual host selection separately; Core keeps