Avalonia v11 + Editor rewrite

RogueEssence.Editor.Avalonia/App.axaml

@@ -1,24 +1,56 @@
 <Application xmlns="https://github.com/avaloniaui"
              xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
-             xmlns:local="clr-namespace:RogueEssence.Dev"
-             x:Class="RogueEssence.Dev.App">
+             x:Class="RogueEssence.Dev.App"
+             xmlns:local="using:RogueEssence.Dev"
+             xmlns:fluent="clr-namespace:Tabalonia.Themes.Custom;assembly=Tabalonia"
+             RequestedThemeVariant="Dark">
+
     <Application.DataTemplates>
         <local:ViewLocator/>
     </Application.DataTemplates>
+
+
+    <Application.Resources>
+        <ResourceDictionary>
+
+            <ResourceDictionary.MergedDictionaries>
+                <ResourceInclude Source="/Assets/Icons.axaml"/>
+                <ResourceInclude Source="/Assets/Themes.axaml"/>
+                <ResourceInclude Source="/Assets/NodeTemplates.axaml"/>
+                <ResourceInclude Source="/Assets/MenuItemStylesResource.axaml" />
+            </ResourceDictionary.MergedDictionaries>
+            <ResourceDictionary.ThemeDictionaries>
+                <ResourceDictionary x:Key="Light">
+                    <SolidColorBrush x:Key="TabControlWindowActiveBackgroundBrush" Color="#FFF6F6F6" />
+                    <SolidColorBrush x:Key="TabControlWindowInactiveBackgroundBrush" Color="#FFF6F6F6" />
+                    <SolidColorBrush x:Key="TabItemBackgroundBrush" Color="#FFF6F6F6" />
+                    <SolidColorBrush x:Key="TabItemBackgroundBrushWindowInactive" Color="#FFF6F6F6" />
+                    <SolidColorBrush x:Key="SelectedTabItemBackgroundBrush" Color="#FFFDFDFD" />
+                    <SolidColorBrush x:Key="TabItemHeaderBackgroundUnselectedPointerOver" Color="#FFDFDFDF" />
 
-    <Application.Styles>
-        <StyleInclude Source="avares://Avalonia.Themes.Default/DefaultTheme.xaml"/>
-        <StyleInclude Source="avares://Avalonia.Themes.Default/Accents/BaseLight.xaml"/>
-        <StyleInclude Source="avares://Avalonia.Controls.DataGrid/Themes/Default.xaml"/>
-        <Style Selector="TabItem">
-            <Setter Property="Foreground" Value="Black" />
-            <Setter Property="FontSize" Value="12"/>
-        </Style>
-      <Style Selector="DataGridRow">
-        <Setter Property="Background" Value="#FFFFFF"/>
-      </Style>
-      <Style Selector="DataGridTextColumn">
-        <Setter Property="TextBlock.TextWrapping" Value="Wrap"/>
-      </Style>
-    </Application.Styles>
-</Application>
+                </ResourceDictionary>
+
+                <ResourceDictionary x:Key="Dark">
+                    <SolidColorBrush x:Key="TabControlWindowActiveBackgroundBrush" Color="#202020" />
+                    <SolidColorBrush x:Key="TabControlWindowInactiveBackgroundBrush" Color="#202020" />
+                    <SolidColorBrush x:Key="TabItemBackgroundBrush" Color="#202020" />
+                    <SolidColorBrush x:Key="TabItemBackgroundBrushWindowInactive" Color="#202020" />
+                </ResourceDictionary>
+            </ResourceDictionary.ThemeDictionaries>
+        </ResourceDictionary>
+
+    </Application.Resources>
+
+     <Application.Styles>
+         <FluentTheme />
+         <fluent:CustomTheme/>
+         <StyleInclude Source="/Assets/Styles.axaml"/>
+         <StyleInclude Source="/Assets/ListBoxStyles.axaml"/>
+         <StyleInclude Source="/Assets/MenuItemStyles.axaml"/>
+         <StyleInclude Source="avares://Avalonia.Controls.TreeDataGrid/Themes/Fluent.axaml"/>
+         <StyleInclude Source="avares://Avalonia.Controls.DataGrid/Themes/Fluent.xaml"/>
+         <StyleInclude Source="/Assets/TreeStyles.axaml"/>
+         <StyleInclude Source="/Assets/DataGridStyles.axaml"/>
+     </Application.Styles>
+
+</Application>

RogueEssence.Editor.Avalonia/App.axaml.cs

@@ -1,29 +1,285 @@
-using Avalonia;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reactive.Linq;
+using System.Reflection;
+using System.Text.Json;
+using Avalonia;
+using Avalonia.Controls;
 using Avalonia.Controls.ApplicationLifetimes;
+using Avalonia.Input.Platform;
 using Avalonia.Markup.Xaml;
+using Avalonia.Media;
+using Avalonia.Styling;
+using RogueEssence.Dev.Services;
 using RogueEssence.Dev.ViewModels;
 using RogueEssence.Dev.Views;
+using Microsoft.Extensions.DependencyInjection;
+using ReactiveUI;
 
 namespace RogueEssence.Dev
 {
-    public class App : Application
+
+    public static class ServiceCollectionExtensions
+    {
+        public static void AddCommonServices(this IServiceCollection collection)
+        {
+            collection.AddSingleton<TabEvents>();
+            collection.AddSingleton<PageFactory>();
+            collection.AddSingleton<NodeFactory>();
+            collection.AddSingleton<EditorContext>();
+            collection.AddSingleton<DevFormViewModel>();
+
+
+            AddDevTabViewModels(collection);
+            AddMapEditViewModels(collection);
+            AddGroundEditViewModels(collection);
+
+            collection.AddTransient<TabSwitcherViewModel>();
+
+            collection.AddTransient<ModSwitcherViewModel>();
+
+
+            collection.AddTransient<NodeBase>();
+            collection.AddTransient<DataRootNode>();
+            collection.AddTransient<DataItemNode>();
+            collection.AddTransient<OpenEditorNode>();
+            collection.AddTransient<PageNode>();
+            collection.AddTransient<ModItemNode>();
+
+            // TODO: remove?
+            // collection.AddSingleton<Func<Type, NodeBase>>(x => type => type switch
+            // {
+            //     _ when type == typeof(NodeBase) => x.GetRequiredService<NodeBase>(),
+            //     _ when type == typeof(DataRootNode) => x.GetRequiredService<DataRootNode>(),
+            //     _ when type == typeof(DataItemNode) => x.GetRequiredService<DataItemNode>(),
+            //     _ when type == typeof(OpenEditorNode) => x.GetRequiredService<OpenEditorNode>(),
+            //     _ when type == typeof(PageNode) => x.GetRequiredService<PageNode>(),
+            //     _ => throw new InvalidOperationException($"Page of type {type?.FullName} has no view model"),
+            // });
+
+            collection.AddSingleton<ViewLocator>();
+            collection.AddSingleton<IDialogService, DialogService>();
+
+            collection.AddTransient<DevControlPageViewModel>();
+            collection.AddTransient<MapEditPageViewModel>();
+            collection.AddTransient<RandomInfoPageViewModel>();
+            collection.AddTransient<SpritePageViewModel>();
+            collection.AddTransient<ModListPageViewModel>();
+            collection.AddTransient<ModConfigPageViewModel>();
+            collection.AddTransient<SpeciesEditPageViewModel>();
+            collection.AddTransient<DataListPageViewModel>();
+            collection.AddTransient<ReflectedDataPageViewModel>();
+            collection.AddTransient<StringEditPageViewModel>();
+        }
+
+        private static void AddMapEditViewModels(this IServiceCollection services)
+        {
+            services.AddTransient<MapTabTexturesViewModel>();
+            services.AddTransient<MapTabDecorationsViewModel>();
+            services.AddTransient<MapTabTerrainViewModel>();
+            services.AddTransient<MapTabTilesViewModel>();
+            services.AddTransient<MapTabItemsViewModel>();
+            services.AddTransient<MapTabEntitiesViewModel>();
+            services.AddTransient<MapTabEntrancesViewModel>();
+            services.AddTransient<MapTabSpawnsViewModel>();
+            services.AddTransient<MapTabEffectsViewModel>();
+            services.AddTransient<MapTabPropertiesViewModel>();
+            services.AddTransient<MapEditPageViewModel>();
+        }
+
+        private static void AddGroundEditViewModels(this IServiceCollection services)
+        {
+            services.AddTransient<GroundTabDecorationsViewModel>();
+            services.AddTransient<GroundTabWallsViewModel>();
+            services.AddTransient<GroundTabEntitiesViewModel>();
+            services.AddTransient<GroundTabPropertiesViewModel>();
+            services.AddTransient<GroundTabStringsViewModel>();
+            services.AddTransient<GroundTabScriptViewModel>();
+            services.AddTransient<GroundEditPageViewModel>();
+        }
+
+        private static void AddDevTabViewModels(this IServiceCollection services)
+        {
+            services.AddSingleton<DevTabGameViewModel>();
+            services.AddSingleton<DevTabPlayerViewModel>();
+            services.AddSingleton<DevTabTravelViewModel>();
+            services.AddSingleton<DevTabScriptViewModel>();
+            services.AddSingleton<ModManagerViewModel>();
+        }
+
+        public static void RegisterPages(this IServiceProvider provider)
+        {
+            var pageFactory = provider.GetRequiredService<PageFactory>();
+
+            pageFactory.Register<DevControlPageViewModel>();
+            pageFactory.Register<MapEditPageViewModel>();
+            pageFactory.Register<ReflectedDataPageViewModel>();
+            pageFactory.Register<GroundEditPageViewModel>();
+            pageFactory.Register<RandomInfoPageViewModel>();
+            pageFactory.Register<SpritePageViewModel>();
+            pageFactory.Register<ModListPageViewModel>();
+            pageFactory.Register<ModConfigPageViewModel>();
+            pageFactory.Register<SpeciesEditPageViewModel>();
+            pageFactory.Register<DataListPageViewModel>();
+            pageFactory.Register<StringEditPageViewModel>();
+        }
+    }
+
+    public partial class App : Application
     {
+        public static Action<IServiceCollection>? RegisterServices { get; set; }
+        public static Action<IServiceProvider>? OnServicesReady { get; set; }
+
         public override void Initialize()
         {
             AvaloniaXamlLoader.Load(this);
+            var pref = PreferencesWindowViewModel.Instance;
+
+            // SetLocale(pref.Locale);
+
+            pref.Changed
+                .Where(_ => !pref.IsLoading)
+                .Subscribe(_ => { pref.Save(); });
+        }
+
+        public static async void CopyText(string data)
+        {
+            if (Current.ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
+            {
+                if (desktop.MainWindow.Clipboard is IClipboard clipbord)
+                {
+                    await clipbord.SetTextAsync(data);
+                }
+            }
         }
 
+
         public override void OnFrameworkInitializationCompleted()
         {
+            var collection = new ServiceCollection();
+            collection.AddCommonServices();
+
+
+
+            RegisterServices?.Invoke(collection);
+
+            // TopLevel provider
+            collection.AddSingleton<Func<TopLevel?>>(x => () =>
+            {
+                if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime topWindow)
+                    return TopLevel.GetTopLevel(topWindow.MainWindow);
+
+                if (ApplicationLifetime is ISingleViewApplicationLifetime singleViewPlatform)
+                    return TopLevel.GetTopLevel(singleViewPlatform.MainView);
+
+                return null;
+            });
+
+            var services = collection.BuildServiceProvider();
+
+            services.RegisterPages();
+
+            OnServicesReady?.Invoke(services);
+            var vm = services.GetRequiredService<DevFormViewModel>();
+
             if (ApplicationLifetime is IClassicDesktopStyleApplicationLifetime desktop)
             {
                 desktop.MainWindow = new DevForm
                 {
-                    DataContext = new DevFormViewModel(),
+                    DataContext = vm
+                };
+            }
+            else if (ApplicationLifetime is ISingleViewApplicationLifetime singleViewPlatform)
+            {
+                singleViewPlatform.MainView = new DevForm
+                {
+                    DataContext = vm
                 };
             }
 
             base.OnFrameworkInitializationCompleted();
         }
+
+
+        public static void SetLocale(string localeKey)
+        {
+            if (Current is not App app ||
+                app.Resources[localeKey] is not ResourceDictionary targetLocale ||
+                targetLocale == app._activeLocale)
+                return;
+
+            if (app._activeLocale != null)
+                app.Resources.MergedDictionaries.Remove(app._activeLocale);
+
+            app.Resources.MergedDictionaries.Add(targetLocale);
+            app._activeLocale = targetLocale;
+        }
+
+        public static Avalonia.Controls.Shapes.Path CreateMenuIcon(string key)
+        {
+
+            var icon = new Avalonia.Controls.Shapes.Path();
+            icon.Width = 12;
+            icon.Height = 12;
+            icon.Stretch = Stretch.Uniform;
+
+            if (Current?.FindResource(key) is StreamGeometry geo)
+                icon.Data = geo;
+
+            return icon;
+        }
+
+        public static void SetTheme(string theme, string _)
+        {
+            if (Current is not App app)
+                return;
+            if (theme.Equals("Light", StringComparison.OrdinalIgnoreCase))
+                app.RequestedThemeVariant = ThemeVariant.Light;
+            else if (theme.Equals("Dark", StringComparison.OrdinalIgnoreCase))
+                app.RequestedThemeVariant = ThemeVariant.Dark;
+            else
+                app.RequestedThemeVariant = ThemeVariant.Default;
+
+            if (app._themeOverrides != null)
+            {
+                app.Resources.MergedDictionaries.Remove(app._themeOverrides);
+                app._themeOverrides = null;
+            }
+            // if (app._themeOverrides != null)
+            // {
+            //     app.Resources.MergedDictionaries.Remove(app._themeOverrides);
+            //     app._themeOverrides = null;
+            // }
+            //
+            // if (!string.IsNullOrEmpty(themeOverridesFile) && File.Exists(themeOverridesFile))
+            // {
+            //     try
+            //     {
+            //         var resDic = new ResourceDictionary();
+            //         using var stream = File.OpenRead(themeOverridesFile);
+            //         var overrides = JsonSerializer.Deserialize(stream, JsonCodeGen.Default.ThemeOverrides);
+            //         foreach (var kv in overrides.BasicColors)
+            //         {
+            //             if (kv.Key.Equals("SystemAccentColor", StringComparison.Ordinal))
+            //                 resDic["SystemAccentColor"] = kv.Value;
+            //             else
+            //                 resDic[$"Color.{kv.Key}"] = kv.Value;
+            //         }
+            //
+            //         app.Resources.MergedDictionaries.Add(resDic);
+            //         app._themeOverrides = resDic;
+            //     }
+            //     catch
+            //     {
+            //         // ignore
+            //     }
+            // }
+            //
+        }
+
+        private ResourceDictionary _activeLocale = null;
+        private ResourceDictionary _themeOverrides = null;
     }
-}
+}