From 3988362e58ac49781cd33ad8f3416232189eddb5 Mon Sep 17 00:00:00 2001 From: Jerome Laban Date: Tue, 31 Oct 2023 14:25:54 -0400 Subject: [PATCH] chore: Update to uno 5 --- src/.editorconfig | 167 ++++++++ src/.gitignore | 403 ++++++++++++++++++ src/.vscode/launch.json | 15 +- src/.vscode/settings.json | 2 +- src/.vsconfig | 19 +- src/Directory.Build.props | 77 ++++ src/Directory.Build.targets | 6 + src/Directory.Packages.props | 27 ++ src/MyApp.Base/AppHead.xaml | 17 + src/MyApp.Base/AppHead.xaml.cs | 103 +++++ src/MyApp.Base/Icons/icon.svg | 42 ++ src/MyApp.Base/Icons/icon_foreground.svg | 137 ++++++ src/MyApp.Base/MyApp.Base.csproj | 12 + src/MyApp.Base/Splash/splash_screen.svg | 137 ++++++ src/MyApp.Base/base.props | 42 +- src/MyApp.Mobile/Android/AndroidManifest.xml | 2 +- src/MyApp.Mobile/Android/Main.Android.cs | 11 +- .../Android/MainActivity.Android.cs | 11 +- .../Android/Resources/values/Strings.xml | 4 +- .../Android/Resources/values/Styles.xml | 9 +- src/MyApp.Mobile/MacCatalyst/Info.plist | 51 +-- .../MacCatalyst/Main.maccatalyst.cs | 8 +- .../LaunchImages.launchimage/Contents.json | 58 +++ src/MyApp.Mobile/MyApp.Mobile.csproj | 78 ++-- src/MyApp.Mobile/iOS/Info.plist | 90 ++-- src/MyApp.Mobile/iOS/Main.iOS.cs | 8 +- src/MyApp.Skia.Gtk/MyApp.Skia.Gtk.csproj | 23 +- src/MyApp.Skia.Gtk/Package.appxmanifest | 43 ++ src/MyApp.Skia.Gtk/Program.cs | 10 +- src/MyApp.Skia.Gtk/app.manifest | 77 ++++ .../MyApp.Skia.Linux.FrameBuffer.csproj | 21 +- .../Package.appxmanifest | 43 ++ src/MyApp.Skia.Linux.FrameBuffer/Program.cs | 35 +- src/MyApp.Skia.Wpf/MyApp.Skia.Wpf.csproj | 23 +- src/MyApp.Skia.Wpf/Package.appxmanifest | 43 ++ src/MyApp.Skia.Wpf/Wpf/App.xaml | 11 +- src/MyApp.Skia.Wpf/Wpf/App.xaml.cs | 19 +- src/MyApp.Skia.Wpf/app.manifest | 25 ++ src/MyApp.Wasm/LinkerConfig.xml | 11 +- src/MyApp.Wasm/MyApp.Wasm.csproj | 53 ++- src/MyApp.Wasm/Program.cs | 11 +- src/MyApp.Wasm/Properties/launchSettings.json | 4 +- src/MyApp.Wasm/WasmCSS/Fonts.css | 31 +- src/MyApp.Wasm/WasmScripts/AppManifest.js | 6 +- src/MyApp.Wasm/manifest.webmanifest | 10 + .../wwwroot/staticwebapp.config.json | 30 ++ src/MyApp.Wasm/wwwroot/web.config | 2 +- src/MyApp.Windows/MyApp.Windows.csproj | 73 +++- src/MyApp.Windows/Package.appxmanifest | 21 +- .../PublishProfiles/win-arm64.pubxml | 22 + .../Properties/PublishProfiles/win-x64.pubxml | 22 + .../Properties/PublishProfiles/win-x86.pubxml | 22 + .../Properties/launchSettings.json | 15 +- src/MyApp.Windows/Resources.lang-en-us.resw | 123 ++++++ src/MyApp.Windows/app.manifest | 12 +- src/MyApp.sln | 338 ++++++++------- src/MyApp/App.cs | 55 +++ src/MyApp/AppResources.xaml | 11 + src/MyApp/Assets/Icons/back.svg | 3 + src/MyApp/Assets/SharedAssets.md | 32 ++ src/MyApp/GlobalUsings.cs | 13 + src/MyApp/MainPage.xaml | 25 +- src/MyApp/MainPage.xaml.cs | 20 - src/MyApp/MyApp.csproj | 97 +++-- src/MyApp/Strings/en/Resources.resw | 58 +-- 65 files changed, 2415 insertions(+), 614 deletions(-) create mode 100644 src/.editorconfig create mode 100644 src/.gitignore create mode 100644 src/Directory.Build.props create mode 100644 src/Directory.Build.targets create mode 100644 src/Directory.Packages.props create mode 100644 src/MyApp.Base/AppHead.xaml create mode 100644 src/MyApp.Base/AppHead.xaml.cs create mode 100644 src/MyApp.Base/Icons/icon.svg create mode 100644 src/MyApp.Base/Icons/icon_foreground.svg create mode 100644 src/MyApp.Base/MyApp.Base.csproj create mode 100644 src/MyApp.Base/Splash/splash_screen.svg create mode 100644 src/MyApp.Mobile/MacCatalyst/Media.xcassets/LaunchImages.launchimage/Contents.json create mode 100644 src/MyApp.Skia.Gtk/Package.appxmanifest create mode 100644 src/MyApp.Skia.Gtk/app.manifest create mode 100644 src/MyApp.Skia.Linux.FrameBuffer/Package.appxmanifest create mode 100644 src/MyApp.Skia.Wpf/Package.appxmanifest create mode 100644 src/MyApp.Skia.Wpf/app.manifest create mode 100644 src/MyApp.Wasm/manifest.webmanifest create mode 100644 src/MyApp.Wasm/wwwroot/staticwebapp.config.json create mode 100644 src/MyApp.Windows/Properties/PublishProfiles/win-arm64.pubxml create mode 100644 src/MyApp.Windows/Properties/PublishProfiles/win-x64.pubxml create mode 100644 src/MyApp.Windows/Properties/PublishProfiles/win-x86.pubxml create mode 100644 src/MyApp.Windows/Resources.lang-en-us.resw create mode 100644 src/MyApp/App.cs create mode 100644 src/MyApp/AppResources.xaml create mode 100644 src/MyApp/Assets/Icons/back.svg create mode 100644 src/MyApp/Assets/SharedAssets.md create mode 100644 src/MyApp/GlobalUsings.cs diff --git a/src/.editorconfig b/src/.editorconfig new file mode 100644 index 0000000..ed52b20 --- /dev/null +++ b/src/.editorconfig @@ -0,0 +1,167 @@ +; This file is for unifying the coding style for different editors and IDEs. +; More information at http://editorconfig.org + +# This file is the top-most EditorConfig file +root = true + +########################################## +# Common Settings +########################################## + +[*] +indent_style = space +end_of_line = crlf +trim_trailing_whitespace = true +insert_final_newline = true +charset = utf-8 + +########################################## +# File Extension Settings +########################################## + +[*.{yml,yaml}] +indent_size = 2 + +[.vsconfig] +indent_size = 2 +end_of_line = lf + +[*.sln] +indent_style = tab +indent_size = 2 + +[*.{csproj,proj,projitems,shproj}] +indent_size = 2 + +[*.{json,slnf}] +indent_size = 2 +end_of_line = lf + +[*.{props,targets}] +indent_size = 2 + +[*.xaml] +indent_size = 2 +charset = utf-8-bom + +[*.xml] +indent_size = 2 +end_of_line = lf + +[*.plist] +indent_size = 2 +indent_style = tab +end_of_line = lf + +[*.manifest] +indent_size = 2 + +[*.appxmanifest] +indent_size = 2 + +[*.{json,css,webmanifest}] +indent_size = 2 +end_of_line = lf + +[web.config] +indent_size = 2 +end_of_line = lf + +[*.sh] +indent_size = 2 +end_of_line = lf + +[*.cs] +# EOL should be normalized by Git. See https://github.com/dotnet/format/issues/1099 +end_of_line = unset + +# See https://github.com/dotnet/roslyn/issues/20356#issuecomment-310143926 +trim_trailing_whitespace = false + +tab_width = 4 +indent_size = 4 + +# Sort using and Import directives with System.* appearing first +dotnet_sort_system_directives_first = true + +# Avoid "this." and "Me." if not necessary +dotnet_style_qualification_for_field = false:suggestion +dotnet_style_qualification_for_property = false:suggestion +dotnet_style_qualification_for_method = false:suggestion +dotnet_style_qualification_for_event = false:suggestion + +#### Naming styles #### + +# Naming rules + +dotnet_naming_rule.interface_should_be_begins_with_i.severity = suggestion +dotnet_naming_rule.interface_should_be_begins_with_i.symbols = interface +dotnet_naming_rule.interface_should_be_begins_with_i.style = begins_with_i + +dotnet_naming_rule.types_should_be_pascal_case.severity = suggestion +dotnet_naming_rule.types_should_be_pascal_case.symbols = types +dotnet_naming_rule.types_should_be_pascal_case.style = pascal_case + +dotnet_naming_rule.non_field_members_should_be_pascal_case.severity = suggestion +dotnet_naming_rule.non_field_members_should_be_pascal_case.symbols = non_field_members +dotnet_naming_rule.non_field_members_should_be_pascal_case.style = pascal_case + +# Symbol specifications + +dotnet_naming_symbols.interface.applicable_kinds = interface +dotnet_naming_symbols.interface.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected +dotnet_naming_symbols.interface.required_modifiers = + +dotnet_naming_symbols.types.applicable_kinds = class, struct, interface, enum +dotnet_naming_symbols.types.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected +dotnet_naming_symbols.types.required_modifiers = + +dotnet_naming_symbols.non_field_members.applicable_kinds = property, event, method +dotnet_naming_symbols.non_field_members.applicable_accessibilities = public, internal, private, protected, protected_internal, private_protected +dotnet_naming_symbols.non_field_members.required_modifiers = + +# Naming styles + +dotnet_naming_style.begins_with_i.required_prefix = I +dotnet_naming_style.begins_with_i.required_suffix = +dotnet_naming_style.begins_with_i.word_separator = +dotnet_naming_style.begins_with_i.capitalization = pascal_case + +dotnet_naming_style.pascal_case.required_prefix = +dotnet_naming_style.pascal_case.required_suffix = +dotnet_naming_style.pascal_case.word_separator = +dotnet_naming_style.pascal_case.capitalization = pascal_case + +dotnet_naming_style.pascal_case.required_prefix = +dotnet_naming_style.pascal_case.required_suffix = +dotnet_naming_style.pascal_case.word_separator = +dotnet_naming_style.pascal_case.capitalization = pascal_case +dotnet_style_operator_placement_when_wrapping = beginning_of_line +dotnet_style_coalesce_expression = true:suggestion +dotnet_style_null_propagation = true:suggestion +dotnet_style_prefer_is_null_check_over_reference_equality_method = true:suggestion +dotnet_style_prefer_auto_properties = true:silent +dotnet_style_object_initializer = true:suggestion +dotnet_style_collection_initializer = true:suggestion +dotnet_style_prefer_simplified_boolean_expressions = true:suggestion +dotnet_style_prefer_conditional_expression_over_assignment = true:silent +dotnet_style_prefer_conditional_expression_over_return = true:silent +dotnet_style_explicit_tuple_names = true:suggestion +dotnet_style_prefer_inferred_tuple_names = true:suggestion + +csharp_indent_labels = one_less_than_current +csharp_using_directive_placement = outside_namespace:silent +csharp_prefer_simple_using_statement = true:suggestion +csharp_prefer_braces = true:silent +csharp_style_namespace_declarations = block_scoped:silent +csharp_style_prefer_method_group_conversion = true:silent +csharp_style_prefer_top_level_statements = true:silent +csharp_style_prefer_primary_constructors = true:suggestion +csharp_style_expression_bodied_methods = false:silent +csharp_style_expression_bodied_constructors = false:silent +csharp_style_expression_bodied_operators = false:silent +csharp_style_expression_bodied_properties = true:silent +csharp_style_expression_bodied_indexers = true:silent +csharp_style_expression_bodied_accessors = true:silent +csharp_style_expression_bodied_lambdas = true:silent +csharp_style_expression_bodied_local_functions = false:silent diff --git a/src/.gitignore b/src/.gitignore new file mode 100644 index 0000000..4fa7c7e --- /dev/null +++ b/src/.gitignore @@ -0,0 +1,403 @@ +## Ignore Visual Studio temporary files, build results, and +## files generated by popular Visual Studio add-ons. +## +## Get latest from https://github.com/github/gitignore/blob/main/VisualStudio.gitignore + +# User-specific files +*.rsuser +*.suo +*.user +*.userosscache +*.sln.docstates + +# User-specific files (MonoDevelop/Xamarin Studio) +*.userprefs + +# Mono auto generated files +mono_crash.* + +# Build results +[Dd]ebug/ +[Dd]ebugPublic/ +[Rr]elease/ +[Rr]eleases/ +x64/ +x86/ +[Ww][Ii][Nn]32/ +[Aa][Rr][Mm]/ +[Aa][Rr][Mm]64/ +bld/ +[Bb]in/ +[Oo]bj/ +[Ll]og/ +[Ll]ogs/ + +# Visual Studio 2015/2017 cache/options directory +.vs/ +# Uncomment if you have tasks that create the project's static files in wwwroot +#wwwroot/ + +# Visual Studio 2017 auto generated files +Generated\ Files/ + +# MSTest test Results +[Tt]est[Rr]esult*/ +[Bb]uild[Ll]og.* + +# NUnit +*.VisualState.xml +TestResult.xml +nunit-*.xml + +# Build Results of an ATL Project +[Dd]ebugPS/ +[Rr]eleasePS/ +dlldata.c + +# Benchmark Results +BenchmarkDotNet.Artifacts/ + +# .NET Core +project.lock.json +project.fragment.lock.json +artifacts/ + +# ASP.NET Scaffolding +ScaffoldingReadMe.txt + +# StyleCop +StyleCopReport.xml + +# Files built by Visual Studio +*_i.c +*_p.c +*_h.h +*.ilk +*.meta +*.obj +*.iobj +*.pch +*.pdb +*.ipdb +*.pgc +*.pgd +*.rsp +*.sbr +*.tlb +*.tli +*.tlh +*.tmp +*.tmp_proj +*_wpftmp.csproj +*.log +*.tlog +*.vspscc +*.vssscc +.builds +*.pidb +*.svclog +*.scc + +# Chutzpah Test files +_Chutzpah* + +# Visual C++ cache files +ipch/ +*.aps +*.ncb +*.opendb +*.opensdf +*.sdf +*.cachefile +*.VC.db +*.VC.VC.opendb + +# Visual Studio profiler +*.psess +*.vsp +*.vspx +*.sap + +# Visual Studio Trace Files +*.e2e + +# TFS 2012 Local Workspace +$tf/ + +# Guidance Automation Toolkit +*.gpState + +# ReSharper is a .NET coding add-in +_ReSharper*/ +*.[Rr]e[Ss]harper +*.DotSettings.user + +# TeamCity is a build add-in +_TeamCity* + +# DotCover is a Code Coverage Tool +*.dotCover + +# AxoCover is a Code Coverage Tool +.axoCover/* +!.axoCover/settings.json + +# Coverlet is a free, cross platform Code Coverage Tool +coverage*.json +coverage*.xml +coverage*.info + +# Visual Studio code coverage results +*.coverage +*.coveragexml + +# NCrunch +_NCrunch_* +.*crunch*.local.xml +nCrunchTemp_* + +# MightyMoose +*.mm.* +AutoTest.Net/ + +# Web workbench (sass) +.sass-cache/ + +# Installshield output folder +[Ee]xpress/ + +# DocProject is a documentation generator add-in +DocProject/buildhelp/ +DocProject/Help/*.HxT +DocProject/Help/*.HxC +DocProject/Help/*.hhc +DocProject/Help/*.hhk +DocProject/Help/*.hhp +DocProject/Help/Html2 +DocProject/Help/html + +# Click-Once directory +publish/ + +# Publish Web Output +*.[Pp]ublish.xml +*.azurePubxml +# Note: Comment the next line if you want to checkin your web deploy settings, +# but database connection strings (with potential passwords) will be unencrypted +*.pubxml +*.publishproj + +# Microsoft Azure Web App publish settings. Comment the next line if you want to +# checkin your Azure Web App publish settings, but sensitive information contained +# in these scripts will be unencrypted +PublishScripts/ + +# NuGet Packages +*.nupkg +# NuGet Symbol Packages +*.snupkg +# The packages folder can be ignored because of Package Restore +**/[Pp]ackages/* +# except build/, which is used as an MSBuild target. +!**/[Pp]ackages/build/ +# Uncomment if necessary however generally it will be regenerated when needed +#!**/[Pp]ackages/repositories.config +# NuGet v3's project.json files produces more ignorable files +*.nuget.props +*.nuget.targets + +# Microsoft Azure Build Output +csx/ +*.build.csdef + +# Microsoft Azure Emulator +ecf/ +rcf/ + +# Windows Store app package directories and files +AppPackages/ +BundleArtifacts/ +Package.StoreAssociation.xml +_pkginfo.txt +*.appx +*.appxbundle +*.appxupload + +# Visual Studio cache files +# files ending in .cache can be ignored +*.[Cc]ache +# but keep track of directories ending in .cache +!?*.[Cc]ache/ + +# Others +ClientBin/ +~$* +*~ +*.dbmdl +*.dbproj.schemaview +*.jfm +*.pfx +*.publishsettings +orleans.codegen.cs + +# Including strong name files can present a security risk +# (https://github.com/github/gitignore/pull/2483#issue-259490424) +#*.snk + +# Since there are multiple workflows, uncomment next line to ignore bower_components +# (https://github.com/github/gitignore/pull/1529#issuecomment-104372622) +#bower_components/ + +# RIA/Silverlight projects +Generated_Code/ + +# Backup & report files from converting an old project file +# to a newer Visual Studio version. Backup files are not needed, +# because we have git ;-) +_UpgradeReport_Files/ +Backup*/ +UpgradeLog*.XML +UpgradeLog*.htm +ServiceFabricBackup/ +*.rptproj.bak + +# SQL Server files +*.mdf +*.ldf +*.ndf + +# Business Intelligence projects +*.rdl.data +*.bim.layout +*.bim_*.settings +*.rptproj.rsuser +*- [Bb]ackup.rdl +*- [Bb]ackup ([0-9]).rdl +*- [Bb]ackup ([0-9][0-9]).rdl + +# Microsoft Fakes +FakesAssemblies/ + +# GhostDoc plugin setting file +*.GhostDoc.xml + +# Node.js Tools for Visual Studio +.ntvs_analysis.dat +node_modules/ + +# Visual Studio 6 build log +*.plg + +# Visual Studio 6 workspace options file +*.opt + +# Visual Studio 6 auto-generated workspace file (contains which files were open etc.) +*.vbw + +# Visual Studio 6 auto-generated project file (contains which files were open etc.) +*.vbp + +# Visual Studio 6 workspace and project file (working project files containing files to include in project) +*.dsw +*.dsp + +# Visual Studio 6 technical files +*.ncb +*.aps + +# Visual Studio LightSwitch build output +**/*.HTMLClient/GeneratedArtifacts +**/*.DesktopClient/GeneratedArtifacts +**/*.DesktopClient/ModelManifest.xml +**/*.Server/GeneratedArtifacts +**/*.Server/ModelManifest.xml +_Pvt_Extensions + +# Paket dependency manager +.paket/paket.exe +paket-files/ + +# FAKE - F# Make +.fake/ + +# CodeRush personal settings +.cr/personal + +# Python Tools for Visual Studio (PTVS) +__pycache__/ +*.pyc + +# Cake - Uncomment if you are using it +# tools/** +# !tools/packages.config + +# Tabs Studio +*.tss + +# Telerik's JustMock configuration file +*.jmconfig + +# BizTalk build output +*.btp.cs +*.btm.cs +*.odx.cs +*.xsd.cs + +# OpenCover UI analysis results +OpenCover/ + +# Azure Stream Analytics local run output +ASALocalRun/ + +# MSBuild Binary and Structured Log +*.binlog + +# NVidia Nsight GPU debugger configuration file +*.nvuser + +# MFractors (Xamarin productivity tool) working folder +.mfractor/ + +# Local History for Visual Studio +.localhistory/ + +# Visual Studio History (VSHistory) files +.vshistory/ + +# BeatPulse healthcheck temp database +healthchecksdb + +# Backup folder for Package Reference Convert tool in Visual Studio 2017 +MigrationBackup/ + +# Ionide (cross platform F# VS Code tools) working folder +.ionide/ + +# Fody - auto-generated XML schema +FodyWeavers.xsd + +# VS Code files for those working on multiple tools +.vscode/* +!.vscode/settings.json +!.vscode/tasks.json +!.vscode/launch.json +!.vscode/extensions.json +*.code-workspace + +# Local History for Visual Studio Code +.history/ + +# Windows Installer files from build outputs +*.cab +*.msi +*.msix +*.msm +*.msp + +# JetBrains Rider +*.sln.iml + +# Single Target Config +solution-config.props +# Windows Publish Profiles +!**/*.Windows/Properties/PublishProfiles/*.pubxml diff --git a/src/.vscode/launch.json b/src/.vscode/launch.json index 5f93663..1b54643 100644 --- a/src/.vscode/launch.json +++ b/src/.vscode/launch.json @@ -4,14 +4,21 @@ // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md "version": "0.2.0", "configurations": [ + { + "name": "Uno Platform Mobile", + "type": "Uno", + "request": "launch", + // any Uno* task will do, this is simply to satisfy vscode requirement when a launch.json is present + "preLaunchTask": "Uno: android | Debug | android-x64" + }, { // Use IntelliSense to find out which attributes exist for C# debugging // Use hover for the description of the existing attributes // For further information visit https://github.com/OmniSharp/omnisharp-vscode/blob/master/debugger-launchjson.md "name": "Debug (Chrome, WebAssembly)", - "type": "pwa-chrome", + "type": "chrome", "request": "launch", - "url": "http://localhost:5000", + "url": "http://localhost:5001", "webRoot": "${workspaceFolder}/MyApp.Wasm", "inspectUri": "{wsProtocol}://{url.hostname}:{url.port}/_framework/debug/ws-proxy?browser={browserInspectUri}", "timeout": 30000, @@ -32,7 +39,7 @@ "request": "launch", "preLaunchTask": "build-skia-gtk", // If you have changed target frameworks, make sure to update the program path. - "program": "${workspaceFolder}/MyApp.Skia.Gtk/bin/Debug/net6.0/MyApp.Skia.Gtk.dll", + "program": "${workspaceFolder}/MyApp.Skia.Gtk/bin/Debug/net7.0/MyApp.Skia.Gtk.dll", "args": [], "env": { "DOTNET_MODIFIABLE_ASSEMBLIES": "debug" @@ -41,6 +48,6 @@ // For more information about the 'console' field, see https://aka.ms/VSCode-CS-LaunchJson-Console "console": "internalConsole", "stopAtEntry": false - } + }, ] } diff --git a/src/.vscode/settings.json b/src/.vscode/settings.json index f58161f..23133fc 100644 --- a/src/.vscode/settings.json +++ b/src/.vscode/settings.json @@ -2,6 +2,6 @@ "explorer.fileNesting.enabled": true, "explorer.fileNesting.expand": false, "explorer.fileNesting.patterns": { - "*.xaml": "$(capture).xaml.cs" + "*.xaml": "$(capture).xaml.cs" } } diff --git a/src/.vsconfig b/src/.vsconfig index 1c9c228..072b0c8 100644 --- a/src/.vsconfig +++ b/src/.vsconfig @@ -5,10 +5,10 @@ "Microsoft.VisualStudio.Workload.CoreEditor", "Microsoft.NetCore.Component.SDK", "Microsoft.NetCore.Component.DevelopmentTools", - "Microsoft.VisualStudio.ComponentGroup.WebToolsExtensions", - "Microsoft.NetCore.Component.Web", "Microsoft.Net.ComponentGroup.DevelopmentPrerequisites", "Microsoft.VisualStudio.Component.TextTemplating", + "Microsoft.VisualStudio.ComponentGroup.WebToolsExtensions", + "Microsoft.NetCore.Component.Web", "Microsoft.VisualStudio.Component.IISExpress", "Component.Microsoft.Web.LibraryManager", "Microsoft.VisualStudio.ComponentGroup.Web", @@ -17,22 +17,23 @@ "Microsoft.VisualStudio.Workload.NetWeb", "Microsoft.VisualStudio.ComponentGroup.Azure.Prerequisites", "Microsoft.VisualStudio.Workload.Azure", + "Microsoft.VisualStudio.ComponentGroup.WebToolsExtensions.TemplateEngine", "Microsoft.VisualStudio.Component.Windows10SDK.19041", + "Microsoft.VisualStudio.ComponentGroup.MSIX.Packaging", "Microsoft.VisualStudio.Component.ManagedDesktop.Prerequisites", "Microsoft.VisualStudio.Component.Debugger.JustInTime", - "Microsoft.VisualStudio.ComponentGroup.MSIX.Packaging", "Microsoft.VisualStudio.Workload.ManagedDesktop", "Microsoft.Component.NetFX.Native", "Microsoft.VisualStudio.Component.Graphics", - "Component.OpenJDK", - "Microsoft.VisualStudio.Component.MonoDebugger", "Microsoft.VisualStudio.Component.Merq", "Component.Xamarin.RemotedSimulator", - "Microsoft.VisualStudio.ComponentGroup.WebToolsExtensions.TemplateEngine", + "Microsoft.VisualStudio.Component.MonoDebugger", "Component.Xamarin", - "Component.Android.SDK32", + "Microsoft.VisualStudio.ComponentGroup.Maui.All", + "Component.Android.SDK34", + "Component.Android.SDK33", + "Component.OpenJDK", "Microsoft.VisualStudio.Workload.NetCrossPlat", - "Microsoft.VisualStudio.Workload.NetCoreTools", - "Microsoft.VisualStudio.ComponentGroup.Maui.All" + "Microsoft.VisualStudio.Workload.NetCoreTools" ] } diff --git a/src/Directory.Build.props b/src/Directory.Build.props new file mode 100644 index 0000000..6c93b6d --- /dev/null +++ b/src/Directory.Build.props @@ -0,0 +1,77 @@ + + + + + + + + enable + enable + + portable + True + + true + + + $(NoWarn);NU1507;NETSDK1201;PRI257 + + en + + false + false + false + false + false + + + false + + + + + + true + 21.0 + + + + + true + 14.2 + + + + + true + 10.14 + + + + + true + 14.0 + + + + + true + 10.0.18362.0 + 10.0.18362.0 + win-x86;win-x64;win-arm64 + false + + + + + diff --git a/src/Directory.Build.targets b/src/Directory.Build.targets new file mode 100644 index 0000000..f624a92 --- /dev/null +++ b/src/Directory.Build.targets @@ -0,0 +1,6 @@ + + + + + + diff --git a/src/Directory.Packages.props b/src/Directory.Packages.props new file mode 100644 index 0000000..f8e54db --- /dev/null +++ b/src/Directory.Packages.props @@ -0,0 +1,27 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/MyApp.Base/AppHead.xaml b/src/MyApp.Base/AppHead.xaml new file mode 100644 index 0000000..6fa12e4 --- /dev/null +++ b/src/MyApp.Base/AppHead.xaml @@ -0,0 +1,17 @@ + + + + + + + + + + + diff --git a/src/MyApp.Base/AppHead.xaml.cs b/src/MyApp.Base/AppHead.xaml.cs new file mode 100644 index 0000000..c8c5416 --- /dev/null +++ b/src/MyApp.Base/AppHead.xaml.cs @@ -0,0 +1,103 @@ +using System; +using Microsoft.Extensions.Logging; +using Microsoft.UI.Xaml; +using Uno.Resizetizer; + +namespace MyApp +{ + public sealed partial class AppHead : App + { + static AppHead() => + InitializeLogging(); + + /// + /// Initializes the singleton application object. This is the first line of authored code + /// executed, and as such is the logical equivalent of main() or WinMain(). + /// + public AppHead() + { + this.InitializeComponent(); + } + + /// + /// Invoked when the application is launched normally by the end user. Other entry points + /// will be used such as when the application is launched to open a specific file. + /// + /// Details about the launch request and process. + protected override void OnLaunched(LaunchActivatedEventArgs args) + { + base.OnLaunched(args); + + MainWindow.SetWindowIcon(); + } + + /// + /// Configures global Uno Platform logging + /// + private static void InitializeLogging() + { +#if DEBUG + // Logging is disabled by default for release builds, as it incurs a significant + // initialization cost from Microsoft.Extensions.Logging setup. If startup performance + // is a concern for your application, keep this disabled. If you're running on the web or + // desktop targets, you can use URL or command line parameters to enable it. + // + // For more performance documentation: https://platform.uno/docs/articles/Uno-UI-Performance.html + + var factory = LoggerFactory.Create(builder => + { +#if __WASM__ + builder.AddProvider(new global::Uno.Extensions.Logging.WebAssembly.WebAssemblyConsoleLoggerProvider()); +#elif __IOS__ || __MACCATALYST__ + builder.AddProvider(new global::Uno.Extensions.Logging.OSLogLoggerProvider()); +#elif NETFX_CORE + builder.AddDebug(); +#else + builder.AddConsole(); +#endif + + // Exclude logs below this level + builder.SetMinimumLevel(LogLevel.Information); + + // Default filters for Uno Platform namespaces + builder.AddFilter("Uno", LogLevel.Warning); + builder.AddFilter("Windows", LogLevel.Warning); + builder.AddFilter("Microsoft", LogLevel.Warning); + + // Generic Xaml events + // builder.AddFilter("Microsoft.UI.Xaml", LogLevel.Debug ); + // builder.AddFilter("Microsoft.UI.Xaml.VisualStateGroup", LogLevel.Debug ); + // builder.AddFilter("Microsoft.UI.Xaml.StateTriggerBase", LogLevel.Debug ); + // builder.AddFilter("Microsoft.UI.Xaml.UIElement", LogLevel.Debug ); + // builder.AddFilter("Microsoft.UI.Xaml.FrameworkElement", LogLevel.Trace ); + + // Layouter specific messages + // builder.AddFilter("Microsoft.UI.Xaml.Controls", LogLevel.Debug ); + // builder.AddFilter("Microsoft.UI.Xaml.Controls.Layouter", LogLevel.Debug ); + // builder.AddFilter("Microsoft.UI.Xaml.Controls.Panel", LogLevel.Debug ); + + // builder.AddFilter("Windows.Storage", LogLevel.Debug ); + + // Binding related messages + // builder.AddFilter("Microsoft.UI.Xaml.Data", LogLevel.Debug ); + // builder.AddFilter("Microsoft.UI.Xaml.Data", LogLevel.Debug ); + + // Binder memory references tracking + // builder.AddFilter("Uno.UI.DataBinding.BinderReferenceHolder", LogLevel.Debug ); + + // DevServer and HotReload related + // builder.AddFilter("Uno.UI.RemoteControl", LogLevel.Information); + + // Debug JS interop + // builder.AddFilter("Uno.Foundation.WebAssemblyRuntime", LogLevel.Debug ); + }); + + global::Uno.Extensions.LogExtensionPoint.AmbientLoggerFactory = factory; + +#if HAS_UNO + global::Uno.UI.Adapter.Microsoft.Extensions.Logging.LoggingAdapter.Initialize(); +#endif +#endif + } + } +} diff --git a/src/MyApp.Base/Icons/icon.svg b/src/MyApp.Base/Icons/icon.svg new file mode 100644 index 0000000..a15af53 --- /dev/null +++ b/src/MyApp.Base/Icons/icon.svg @@ -0,0 +1,42 @@ + + + + + + diff --git a/src/MyApp.Base/Icons/icon_foreground.svg b/src/MyApp.Base/Icons/icon_foreground.svg new file mode 100644 index 0000000..8ffc41a --- /dev/null +++ b/src/MyApp.Base/Icons/icon_foreground.svg @@ -0,0 +1,137 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/MyApp.Base/MyApp.Base.csproj b/src/MyApp.Base/MyApp.Base.csproj new file mode 100644 index 0000000..8d78f51 --- /dev/null +++ b/src/MyApp.Base/MyApp.Base.csproj @@ -0,0 +1,12 @@ + + + + net7.0 + false + + + + + + + diff --git a/src/MyApp.Base/Splash/splash_screen.svg b/src/MyApp.Base/Splash/splash_screen.svg new file mode 100644 index 0000000..8ffc41a --- /dev/null +++ b/src/MyApp.Base/Splash/splash_screen.svg @@ -0,0 +1,137 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/MyApp.Base/base.props b/src/MyApp.Base/base.props index fa5476e..1846763 100644 --- a/src/MyApp.Base/base.props +++ b/src/MyApp.Base/base.props @@ -1,16 +1,30 @@ - - - - - + + + + + + + + + + + + + + + diff --git a/src/MyApp.Mobile/Android/AndroidManifest.xml b/src/MyApp.Mobile/Android/AndroidManifest.xml index 418df2c..95ae075 100644 --- a/src/MyApp.Mobile/Android/AndroidManifest.xml +++ b/src/MyApp.Mobile/Android/AndroidManifest.xml @@ -1,4 +1,4 @@ - + diff --git a/src/MyApp.Mobile/Android/Main.Android.cs b/src/MyApp.Mobile/Android/Main.Android.cs index 8f0b7ec..287f53d 100644 --- a/src/MyApp.Mobile/Android/Main.Android.cs +++ b/src/MyApp.Mobile/Android/Main.Android.cs @@ -1,3 +1,7 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; using Android.App; using Android.Content; using Android.OS; @@ -6,10 +10,6 @@ using Android.Widget; using Com.Nostra13.Universalimageloader.Core; using Microsoft.UI.Xaml.Media; -using System; -using System.Collections.Generic; -using System.Linq; -using System.Text; namespace MyApp.Droid { @@ -23,7 +23,7 @@ namespace MyApp.Droid public class Application : Microsoft.UI.Xaml.NativeApplication { public Application(IntPtr javaReference, JniHandleOwnership transfer) - : base(() => new App(), javaReference, transfer) + : base(() => new AppHead(), javaReference, transfer) { ConfigureUniversalImageLoader(); } @@ -40,4 +40,5 @@ private static void ConfigureUniversalImageLoader() ImageSource.DefaultImageLoader = ImageLoader.Instance.LoadImageAsync; } } + } diff --git a/src/MyApp.Mobile/Android/MainActivity.Android.cs b/src/MyApp.Mobile/Android/MainActivity.Android.cs index c7c1458..2dee938 100644 --- a/src/MyApp.Mobile/Android/MainActivity.Android.cs +++ b/src/MyApp.Mobile/Android/MainActivity.Android.cs @@ -4,15 +4,14 @@ using Android.Views; using Android.Widget; -namespace MyApp +namespace MyApp.Droid { [Activity( - MainLauncher = true, - ConfigurationChanges = global::Uno.UI.ActivityHelper.AllConfigChanges, - WindowSoftInputMode = SoftInput.AdjustPan | SoftInput.StateHidden - )] + MainLauncher = true, + ConfigurationChanges = global::Uno.UI.ActivityHelper.AllConfigChanges, + WindowSoftInputMode = SoftInput.AdjustNothing | SoftInput.StateHidden + )] public class MainActivity : Microsoft.UI.Xaml.ApplicationActivity { } } - diff --git a/src/MyApp.Mobile/Android/Resources/values/Strings.xml b/src/MyApp.Mobile/Android/Resources/values/Strings.xml index daad16b..6232170 100644 --- a/src/MyApp.Mobile/Android/Resources/values/Strings.xml +++ b/src/MyApp.Mobile/Android/Resources/values/Strings.xml @@ -1,5 +1,5 @@ - Hello World, Click Me! - UnoQuickStart + Hello World, Click Me! + MyApp diff --git a/src/MyApp.Mobile/Android/Resources/values/Styles.xml b/src/MyApp.Mobile/Android/Resources/values/Styles.xml index f24b9a0..c02bd06 100644 --- a/src/MyApp.Mobile/Android/Resources/values/Styles.xml +++ b/src/MyApp.Mobile/Android/Resources/values/Styles.xml @@ -1,6 +1,6 @@ - - \ No newline at end of file + diff --git a/src/MyApp.Mobile/MacCatalyst/Info.plist b/src/MyApp.Mobile/MacCatalyst/Info.plist index 758cb50..1bb02dd 100644 --- a/src/MyApp.Mobile/MacCatalyst/Info.plist +++ b/src/MyApp.Mobile/MacCatalyst/Info.plist @@ -1,33 +1,26 @@ - + - - UIDeviceFamily - - 2 - - LSApplicationCategoryType - public.app-category.utilities - UILaunchStoryboardName - LaunchScreen - UISupportedInterfaceOrientations - - UIInterfaceOrientationPortrait - UIInterfaceOrientationLandscapeLeft - UIInterfaceOrientationLandscapeRight - - XSAppIconAssets - Media.xcassets/AppIcon.appiconset - UIAppFonts - - Fonts/uno-fluentui-assets.ttf - + + UIDeviceFamily + + 2 + + LSApplicationCategoryType + public.app-category.utilities + UISupportedInterfaceOrientations + + UIInterfaceOrientationPortrait + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + XSAppIconAssets + Assets.xcassets/icon.appiconset - - - + + diff --git a/src/MyApp.Mobile/MacCatalyst/Main.maccatalyst.cs b/src/MyApp.Mobile/MacCatalyst/Main.maccatalyst.cs index 2abf47f..8edea5d 100644 --- a/src/MyApp.Mobile/MacCatalyst/Main.maccatalyst.cs +++ b/src/MyApp.Mobile/MacCatalyst/Main.maccatalyst.cs @@ -1,15 +1,15 @@ -using UIKit; +using UIKit; -namespace MyApp +namespace MyApp.MacCatalyst { public class EntryPoint { // This is the main entry point of the application. - static void Main(string[] args) + public static void Main(string[] args) { // if you want to use a different Application Delegate class from "AppDelegate" // you can specify it here. - UIApplication.Main(args, null, typeof(App)); + UIApplication.Main(args, null, typeof(AppHead)); } } } diff --git a/src/MyApp.Mobile/MacCatalyst/Media.xcassets/LaunchImages.launchimage/Contents.json b/src/MyApp.Mobile/MacCatalyst/Media.xcassets/LaunchImages.launchimage/Contents.json new file mode 100644 index 0000000..69555e4 --- /dev/null +++ b/src/MyApp.Mobile/MacCatalyst/Media.xcassets/LaunchImages.launchimage/Contents.json @@ -0,0 +1,58 @@ +{ + "images": [ + { + "orientation": "portrait", + "extent": "full-screen", + "minimum-system-version": "7.0", + "scale": "2x", + "size": "640x960", + "idiom": "iphone" + }, + { + "orientation": "portrait", + "extent": "full-screen", + "minimum-system-version": "7.0", + "subtype": "retina4", + "scale": "2x", + "size": "640x1136", + "idiom": "iphone" + }, + { + "orientation": "portrait", + "extent": "full-screen", + "minimum-system-version": "7.0", + "scale": "1x", + "size": "768x1024", + "idiom": "ipad" + }, + { + "orientation": "landscape", + "extent": "full-screen", + "minimum-system-version": "7.0", + "scale": "1x", + "size": "1024x768", + "idiom": "ipad" + }, + { + "orientation": "portrait", + "extent": "full-screen", + "minimum-system-version": "7.0", + "scale": "2x", + "size": "1536x2048", + "idiom": "ipad" + }, + { + "orientation": "landscape", + "extent": "full-screen", + "minimum-system-version": "7.0", + "scale": "2x", + "size": "2048x1536", + "idiom": "ipad" + } + ], + "properties": {}, + "info": { + "version": 1, + "author": "" + } +} \ No newline at end of file diff --git a/src/MyApp.Mobile/MyApp.Mobile.csproj b/src/MyApp.Mobile/MyApp.Mobile.csproj index 92037b0..076fcd9 100644 --- a/src/MyApp.Mobile/MyApp.Mobile.csproj +++ b/src/MyApp.Mobile/MyApp.Mobile.csproj @@ -1,86 +1,70 @@ - net7.0-android - $(TargetFrameworks);net7.0-ios - $(TargetFrameworks);net7.0-maccatalyst - - - - - + net7.0-android;net7.0-ios;net7.0-maccatalyst + $(OverrideTargetFrameworks) true Exe MyApp com.companyname.MyApp - d424dc51-40ad-4f27-ad81-79bcd3e26ae8 + 5166AB59-6ABF-43FE-9035-42754DA451DB 1.0 1 + + Android\AndroidManifest.xml + + + + + True true - 14.2 - 14.0 - 21.0 - 10.14 - - - - iossimulator-x64 - maccatalyst-x64 - osx-x64 + - - - - - + + + + + - - - - android-arm64 - + - - + + + - - + + $(MtouchExtraArgs) --setenv=MONO_GC_PARAMS=soft-heap-limit=512m,nursery-size=64m,evacuation-threshold=66,major=marksweep,concurrent-sweep $(MtouchExtraArgs) --registrar:static + iossimulator-x64 + + $(MtouchExtraArgs) --marshal-objectivec-exceptions:disable - - - - + $(MtouchExtraArgs) --setenv=MONO_GC_PARAMS=soft-heap-limit=512m,nursery-size=64m,evacuation-threshold=66,major=marksweep,concurrent-sweep $(MtouchExtraArgs) --registrar:static - - $(MtouchExtraArgs) --marshal-objectivec-exceptions:disable false + maccatalyst-x64 - - - - - - - link + + + $(MtouchExtraArgs) --marshal-objectivec-exceptions:disable @@ -88,4 +72,4 @@ - \ No newline at end of file + diff --git a/src/MyApp.Mobile/iOS/Info.plist b/src/MyApp.Mobile/iOS/Info.plist index 74d5be5..ea3dcb4 100644 --- a/src/MyApp.Mobile/iOS/Info.plist +++ b/src/MyApp.Mobile/iOS/Info.plist @@ -1,55 +1,43 @@ - + - - LSRequiresIPhoneOS - - UIDeviceFamily - - 1 - 2 - - UILaunchStoryboardName - LaunchScreen - UIRequiredDeviceCapabilities - - armv7 - arm64 - - UISupportedInterfaceOrientations - - UIInterfaceOrientationPortrait - UIInterfaceOrientationLandscapeLeft - UIInterfaceOrientationLandscapeRight - - UISupportedInterfaceOrientations~ipad - - UIInterfaceOrientationPortrait - UIInterfaceOrientationPortraitUpsideDown - UIInterfaceOrientationLandscapeLeft - UIInterfaceOrientationLandscapeRight - - UIAppFonts - - Fonts/uno-fluentui-assets.ttf - - UIViewControllerBasedStatusBarAppearance - - UILaunchImageMinimumOSVersion - 9.0 - UILaunchImageOrientation - Portrait - UILaunchImageSize - {320, 568} - XSAppIconAssets - Media.xcassets/AppIcons.appiconset - UIApplicationSupportsIndirectInputEvents - + + LSRequiresIPhoneOS + + UIDeviceFamily + + 1 + 2 + + UIRequiredDeviceCapabilities + + armv7 + arm64 + + UISupportedInterfaceOrientations + + UIInterfaceOrientationPortrait + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + UISupportedInterfaceOrientations~ipad + + UIInterfaceOrientationPortrait + UIInterfaceOrientationPortraitUpsideDown + UIInterfaceOrientationLandscapeLeft + UIInterfaceOrientationLandscapeRight + + UIViewControllerBasedStatusBarAppearance + + XSAppIconAssets + Assets.xcassets/icon.appiconset + UIApplicationSupportsIndirectInputEvents + - - + + diff --git a/src/MyApp.Mobile/iOS/Main.iOS.cs b/src/MyApp.Mobile/iOS/Main.iOS.cs index 2abf47f..0ebe6a6 100644 --- a/src/MyApp.Mobile/iOS/Main.iOS.cs +++ b/src/MyApp.Mobile/iOS/Main.iOS.cs @@ -1,15 +1,15 @@ -using UIKit; +using UIKit; -namespace MyApp +namespace MyApp.iOS { public class EntryPoint { // This is the main entry point of the application. - static void Main(string[] args) + public static void Main(string[] args) { // if you want to use a different Application Delegate class from "AppDelegate" // you can specify it here. - UIApplication.Main(args, null, typeof(App)); + UIApplication.Main(args, null, typeof(AppHead)); } } } diff --git a/src/MyApp.Skia.Gtk/MyApp.Skia.Gtk.csproj b/src/MyApp.Skia.Gtk/MyApp.Skia.Gtk.csproj index 133b442..0103096 100644 --- a/src/MyApp.Skia.Gtk/MyApp.Skia.Gtk.csproj +++ b/src/MyApp.Skia.Gtk/MyApp.Skia.Gtk.csproj @@ -3,22 +3,23 @@ WinExe Exe net7.0 + app.manifest - - - + + + + - - - - - - - + + + + + + - \ No newline at end of file + diff --git a/src/MyApp.Skia.Gtk/Package.appxmanifest b/src/MyApp.Skia.Gtk/Package.appxmanifest new file mode 100644 index 0000000..db9211a --- /dev/null +++ b/src/MyApp.Skia.Gtk/Package.appxmanifest @@ -0,0 +1,43 @@ + + + + + + + + MyApp + MyApp + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/MyApp.Skia.Gtk/Program.cs b/src/MyApp.Skia.Gtk/Program.cs index e3b5b14..7b9ed8e 100644 --- a/src/MyApp.Skia.Gtk/Program.cs +++ b/src/MyApp.Skia.Gtk/Program.cs @@ -1,12 +1,12 @@ -using GLib; using System; -using Uno.UI.Runtime.Skia; +using GLib; +using Uno.UI.Runtime.Skia.Gtk; namespace MyApp.Skia.Gtk { - public sealed class Program + public class Program { - static void Main(string[] args) + public static void Main(string[] args) { ExceptionManager.UnhandledException += delegate (UnhandledExceptionArgs expArgs) { @@ -14,7 +14,7 @@ static void Main(string[] args) expArgs.ExitApplication = true; }; - var host = new GtkHost(() => new App()); + var host = new GtkHost(() => new AppHead()); host.Run(); } diff --git a/src/MyApp.Skia.Gtk/app.manifest b/src/MyApp.Skia.Gtk/app.manifest new file mode 100644 index 0000000..cd59480 --- /dev/null +++ b/src/MyApp.Skia.Gtk/app.manifest @@ -0,0 +1,77 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + true/PM + PerMonitorV2, PerMonitor + + + + + + + + diff --git a/src/MyApp.Skia.Linux.FrameBuffer/MyApp.Skia.Linux.FrameBuffer.csproj b/src/MyApp.Skia.Linux.FrameBuffer/MyApp.Skia.Linux.FrameBuffer.csproj index d9b2cbd..573a72f 100644 --- a/src/MyApp.Skia.Linux.FrameBuffer/MyApp.Skia.Linux.FrameBuffer.csproj +++ b/src/MyApp.Skia.Linux.FrameBuffer/MyApp.Skia.Linux.FrameBuffer.csproj @@ -4,21 +4,20 @@ Exe net7.0 - - - + + + - - - - - - - + + + + + + - \ No newline at end of file + diff --git a/src/MyApp.Skia.Linux.FrameBuffer/Package.appxmanifest b/src/MyApp.Skia.Linux.FrameBuffer/Package.appxmanifest new file mode 100644 index 0000000..db9211a --- /dev/null +++ b/src/MyApp.Skia.Linux.FrameBuffer/Package.appxmanifest @@ -0,0 +1,43 @@ + + + + + + + + MyApp + MyApp + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/MyApp.Skia.Linux.FrameBuffer/Program.cs b/src/MyApp.Skia.Linux.FrameBuffer/Program.cs index 5a79330..ab62f49 100644 --- a/src/MyApp.Skia.Linux.FrameBuffer/Program.cs +++ b/src/MyApp.Skia.Linux.FrameBuffer/Program.cs @@ -1,13 +1,13 @@ -using Microsoft.UI.Xaml; using System; -using Uno.UI.Runtime.Skia; +using Microsoft.UI.Xaml; +using Uno.UI.Runtime.Skia.Linux.FrameBuffer; using Windows.UI.Core; -namespace MyApp +namespace MyApp.Skia.Framebuffer { - public sealed class Program + public class Program { - static void Main(string[] args) + public static void Main(string[] args) { try { @@ -15,20 +15,23 @@ static void Main(string[] args) var host = new FrameBufferHost(() => { - // Framebuffer applications don't have a WindowManager to rely - // on. To close the application, we can hook onto CoreWindow events - // which dispatch keyboard input, and close the application as a result. - // This block can be moved to App.xaml.cs if it does not interfere with other - // platforms that may use the same keys. - CoreWindow.GetForCurrentThread().KeyDown += (s, e) => + if (CoreWindow.GetForCurrentThread() is { } window) { - if (e.VirtualKey == Windows.System.VirtualKey.F12) + // Framebuffer applications don't have a WindowManager to rely + // on. To close the application, we can hook onto CoreWindow events + // which dispatch keyboard input, and close the application as a result. + // This block can be moved to App.xaml.cs if it does not interfere with other + // platforms that may use the same keys. + window.KeyDown += (s, e) => { - Application.Current.Exit(); - } - }; + if (e.VirtualKey == Windows.System.VirtualKey.F12) + { + Application.Current.Exit(); + } + }; + } - return new App(); + return new AppHead(); }); host.Run(); } diff --git a/src/MyApp.Skia.Wpf/MyApp.Skia.Wpf.csproj b/src/MyApp.Skia.Wpf/MyApp.Skia.Wpf.csproj index 0d0bb76..2582c09 100644 --- a/src/MyApp.Skia.Wpf/MyApp.Skia.Wpf.csproj +++ b/src/MyApp.Skia.Wpf/MyApp.Skia.Wpf.csproj @@ -1,9 +1,10 @@ - + WinExe Exe net7.0-windows true + app.manifest @@ -17,13 +18,17 @@ - - - - - - - + + + + + + + + + + + @@ -32,4 +37,4 @@ - \ No newline at end of file + diff --git a/src/MyApp.Skia.Wpf/Package.appxmanifest b/src/MyApp.Skia.Wpf/Package.appxmanifest new file mode 100644 index 0000000..db9211a --- /dev/null +++ b/src/MyApp.Skia.Wpf/Package.appxmanifest @@ -0,0 +1,43 @@ + + + + + + + + MyApp + MyApp + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/MyApp.Skia.Wpf/Wpf/App.xaml b/src/MyApp.Skia.Wpf/Wpf/App.xaml index 65b7ffb..c6b6174 100644 --- a/src/MyApp.Skia.Wpf/Wpf/App.xaml +++ b/src/MyApp.Skia.Wpf/Wpf/App.xaml @@ -1,9 +1,8 @@  - + xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" + xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" + xmlns:local="clr-namespace:MyApp.WPF"> + - + diff --git a/src/MyApp.Skia.Wpf/Wpf/App.xaml.cs b/src/MyApp.Skia.Wpf/Wpf/App.xaml.cs index 0466479..05eb2d3 100644 --- a/src/MyApp.Skia.Wpf/Wpf/App.xaml.cs +++ b/src/MyApp.Skia.Wpf/Wpf/App.xaml.cs @@ -1,17 +1,14 @@ -using System; -using System.Collections.Generic; -using System.Configuration; -using System.Data; -using System.Linq; -using System.Threading.Tasks; -using System.Windows; +using Uno.UI.Runtime.Skia.Wpf; +using WpfApp = System.Windows.Application; namespace MyApp.WPF { - /// - /// Interaction logic for App.xaml - /// - public partial class App : Application + public partial class App : WpfApp { + public App() + { + var host = new WpfHost(Dispatcher, () => new AppHead()); + host.Run(); + } } } diff --git a/src/MyApp.Skia.Wpf/app.manifest b/src/MyApp.Skia.Wpf/app.manifest new file mode 100644 index 0000000..f611ae6 --- /dev/null +++ b/src/MyApp.Skia.Wpf/app.manifest @@ -0,0 +1,25 @@ + + + + + + + + + + + + + + + true/PM + PerMonitorV2, PerMonitor + + + diff --git a/src/MyApp.Wasm/LinkerConfig.xml b/src/MyApp.Wasm/LinkerConfig.xml index c3d1341..42e5b0c 100644 --- a/src/MyApp.Wasm/LinkerConfig.xml +++ b/src/MyApp.Wasm/LinkerConfig.xml @@ -1,10 +1,11 @@ - + + - - + - + + --> diff --git a/src/MyApp.Wasm/MyApp.Wasm.csproj b/src/MyApp.Wasm/MyApp.Wasm.csproj index b803613..5fc6509 100644 --- a/src/MyApp.Wasm/MyApp.Wasm.csproj +++ b/src/MyApp.Wasm/MyApp.Wasm.csproj @@ -2,18 +2,26 @@ Exe net7.0 - NU1701 - - + $(NoWarn);NU1504;NU1505;NU1701 + + disable + manifest.webmanifest + Properties + + / + true $(DefineConstants);TRACE;DEBUG portable true + IL Linking is disabled in Debug configuration. + When building in Release, see https://platform.uno/docs/articles/features/using-il-linker-WebAssembly.html + --> false @@ -25,9 +33,8 @@ - - - + + @@ -37,28 +44,28 @@ + You can safely remove this ItemGroup completely. + --> + - - - - - - - - - + + + + + + + + - \ No newline at end of file + diff --git a/src/MyApp.Wasm/Program.cs b/src/MyApp.Wasm/Program.cs index bae9944..5a6e5f8 100644 --- a/src/MyApp.Wasm/Program.cs +++ b/src/MyApp.Wasm/Program.cs @@ -1,15 +1,12 @@ -using Microsoft.UI.Xaml; -using System; - namespace MyApp.Wasm { - public sealed class Program + public class Program { - private static App _app; + private static App? _app; - static int Main(string[] args) + public static int Main(string[] args) { - Microsoft.UI.Xaml.Application.Start(_ => _app = new App()); + Microsoft.UI.Xaml.Application.Start(_ => _app = new AppHead()); return 0; } diff --git a/src/MyApp.Wasm/Properties/launchSettings.json b/src/MyApp.Wasm/Properties/launchSettings.json index 5925e3c..58c3562 100644 --- a/src/MyApp.Wasm/Properties/launchSettings.json +++ b/src/MyApp.Wasm/Properties/launchSettings.json @@ -1,4 +1,4 @@ -{ +{ "iisSettings": { "windowsAuthentication": false, "anonymousAuthentication": true, @@ -12,7 +12,7 @@ "commandName": "Project", "dotnetRunMessages": true, "launchBrowser": true, - "applicationUrl": "http://localhost:5000", + "applicationUrl": "http://localhost:5001", "inspectUri": "{wsProtocol}://{url.hostname}:{url.port}/_framework/debug/ws-proxy?browser={browserInspectUri}", "environmentVariables": { "ASPNETCORE_ENVIRONMENT": "Development" diff --git a/src/MyApp.Wasm/WasmCSS/Fonts.css b/src/MyApp.Wasm/WasmCSS/Fonts.css index f235ecd..4fdd605 100644 --- a/src/MyApp.Wasm/WasmCSS/Fonts.css +++ b/src/MyApp.Wasm/WasmCSS/Fonts.css @@ -3,25 +3,26 @@ fonts loading are delayed, and text may get displayed incorrectly. */ +/* https://github.com/unoplatform/uno/issues/3954 */ @font-face { - font-family: "Symbols"; - /* uno-fluentui-assets.woff2 */ - src:url(data:application/x-font-woff;charset=utf-8;base64,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) format('woff2'); + font-family: 'Segoe UI'; + src: local('Segoe UI'), local('-apple-system'), local('BlinkMacSystemFont'), local('Inter'), local('Cantarell'), local('Ubuntu'), local('Roboto'), local('Open Sans'), local('Noto Sans'), local('Helvetica Neue'), local('sans-serif'); } +@font-face { + font-family: 'Roboto'; + src: url(./Uno.Fonts.Roboto/Fonts/Roboto-Light.ttf) format('truetype'); + font-weight: 300; +} -/* Workaround for uno issue https://github.com/unoplatform/uno/issues/693 */ -body::before { - font-family: 'Symbols'; - background: transparent; - content: ""; - opacity: 0; - pointer-events: none; - position: absolute; +@font-face { + font-family: 'Roboto'; + src: url(./Uno.Fonts.Roboto/Fonts/Roboto-Regular.ttf) format('truetype'); + font-weight: 400; } -/* https://github.com/unoplatform/uno/issues/4304 */ @font-face { - font-family: 'Segoe UI'; - src: local('system-ui'), local('Segoe UI'), local('-apple-system'), local('BlinkMacSystemFont'), local('Inter'), local('Cantarell'), local('Ubuntu'), local('Roboto'), local('Open Sans'), local('Noto Sans'), local('Helvetica Neue'), local('sans-serif'); -} \ No newline at end of file + font-family: 'Roboto'; + src: url(./Uno.Fonts.Roboto/Fonts/Roboto-Medium.ttf) format('truetype'); + font-weight: 500; +} diff --git a/src/MyApp.Wasm/WasmScripts/AppManifest.js b/src/MyApp.Wasm/WasmScripts/AppManifest.js index c7fa6a0..97d43bb 100644 --- a/src/MyApp.Wasm/WasmScripts/AppManifest.js +++ b/src/MyApp.Wasm/WasmScripts/AppManifest.js @@ -1,7 +1,3 @@ -var UnoAppManifest = { - - splashScreenImage: "Assets/SplashScreen.png", - splashScreenColor: "transparent", +var UnoAppManifest = { displayName: "MyApp" - } diff --git a/src/MyApp.Wasm/manifest.webmanifest b/src/MyApp.Wasm/manifest.webmanifest new file mode 100644 index 0000000..d987f13 --- /dev/null +++ b/src/MyApp.Wasm/manifest.webmanifest @@ -0,0 +1,10 @@ +{ + "background_color": "#ffffff", + "description": "MyApp", + "display": "standalone", + "name": "MyApp", + "short_name": "MyApp", + "start_url": "/index.html", + "theme_color": "#ffffff", + "scope": "/" +} diff --git a/src/MyApp.Wasm/wwwroot/staticwebapp.config.json b/src/MyApp.Wasm/wwwroot/staticwebapp.config.json new file mode 100644 index 0000000..79c1b17 --- /dev/null +++ b/src/MyApp.Wasm/wwwroot/staticwebapp.config.json @@ -0,0 +1,30 @@ +{ + "navigationFallback": { + "rewrite": "/index.html", + "exclude": [ + "*.{css,js}", + "*.{png}", + "*.{c,h,wasm,clr,pdb,dat,txt}" + ] + }, + "routes": [ + { + "route": "/package_*", + "headers": { + "cache-control": "public, immutable, max-age=31536000" + } + }, + { + "route": "/*.ttf", + "headers": { + "cache-control": "public, immutable, max-age=31536000" + } + }, + { + "route": "/*", + "headers": { + "cache-control": "must-revalidate, max-age=3600" + } + } + ] +} diff --git a/src/MyApp.Wasm/wwwroot/web.config b/src/MyApp.Wasm/wwwroot/web.config index 2b57336..8f5a860 100644 --- a/src/MyApp.Wasm/wwwroot/web.config +++ b/src/MyApp.Wasm/wwwroot/web.config @@ -21,7 +21,7 @@ - + diff --git a/src/MyApp.Windows/MyApp.Windows.csproj b/src/MyApp.Windows/MyApp.Windows.csproj index f433d46..aeacb2f 100644 --- a/src/MyApp.Windows/MyApp.Windows.csproj +++ b/src/MyApp.Windows/MyApp.Windows.csproj @@ -2,43 +2,70 @@ WinExe net7.0-windows10.0.19041.0 - 10.0.18362.0 - MyApp + MyApp.Windows + app.manifest x86;x64;arm64 - win10-x86;win10-x64;win10-arm64 - win10-$(Platform).pubxml - en + win-x86;win-x64;win-arm64 + win-$(Platform).pubxml true true - MSIX + + true + + + + + - - - - - - + + + + + + + - - + If you encounter this error message: + + error NETSDK1148: A referenced assembly was compiled using a newer version of Microsoft.Windows.SDK.NET.dll. + Please update to a newer .NET SDK in order to reference this assembly. + + This means that the two packages below must be aligned with the "build" version number of + the "Microsoft.Windows.SDK.BuildTools" package above, and the "revision" version number + must be the highest found in https://www.nuget.org/packages/Microsoft.Windows.SDK.NET.Ref. + --> + + + + + + + + + + + true + + - \ No newline at end of file + diff --git a/src/MyApp.Windows/Package.appxmanifest b/src/MyApp.Windows/Package.appxmanifest index cef0860..db9211a 100644 --- a/src/MyApp.Windows/Package.appxmanifest +++ b/src/MyApp.Windows/Package.appxmanifest @@ -7,19 +7,18 @@ IgnorableNamespaces="uap rescap"> - MyApp - MyApp - Images\StoreLogo.png + MyApp + MyApp - - + + @@ -32,12 +31,8 @@ EntryPoint="$targetentrypoint$"> - - + Description="MyApp"> + diff --git a/src/MyApp.Windows/Properties/PublishProfiles/win-arm64.pubxml b/src/MyApp.Windows/Properties/PublishProfiles/win-arm64.pubxml new file mode 100644 index 0000000..d5147f1 --- /dev/null +++ b/src/MyApp.Windows/Properties/PublishProfiles/win-arm64.pubxml @@ -0,0 +1,22 @@ + + + + + FileSystem + arm64 + win-arm64 + bin\$(Configuration)\$(TargetFramework)\$(RuntimeIdentifier)\publish\ + true + False + False + True + + + + diff --git a/src/MyApp.Windows/Properties/PublishProfiles/win-x64.pubxml b/src/MyApp.Windows/Properties/PublishProfiles/win-x64.pubxml new file mode 100644 index 0000000..4fea954 --- /dev/null +++ b/src/MyApp.Windows/Properties/PublishProfiles/win-x64.pubxml @@ -0,0 +1,22 @@ + + + + + FileSystem + x64 + win-x64 + bin\$(Configuration)\$(TargetFramework)\$(RuntimeIdentifier)\publish\ + true + False + False + True + + + + diff --git a/src/MyApp.Windows/Properties/PublishProfiles/win-x86.pubxml b/src/MyApp.Windows/Properties/PublishProfiles/win-x86.pubxml new file mode 100644 index 0000000..928cb25 --- /dev/null +++ b/src/MyApp.Windows/Properties/PublishProfiles/win-x86.pubxml @@ -0,0 +1,22 @@ + + + + + FileSystem + x86 + win-x86 + bin\$(Configuration)\$(TargetFramework)\$(RuntimeIdentifier)\publish\ + true + False + False + True + + + + diff --git a/src/MyApp.Windows/Properties/launchSettings.json b/src/MyApp.Windows/Properties/launchSettings.json index 77576db..c554a21 100644 --- a/src/MyApp.Windows/Properties/launchSettings.json +++ b/src/MyApp.Windows/Properties/launchSettings.json @@ -1,7 +1,10 @@ { - "profiles": { - "MyApp.Windows": { - "commandName": "MsixPackage" - } - } -} + "profiles": { + "MyApp.Windows (Unpackaged)": { + "commandName": "Project" + }, + "MyApp.Windows (Package)": { + "commandName": "MsixPackage" + } + } +} \ No newline at end of file diff --git a/src/MyApp.Windows/Resources.lang-en-us.resw b/src/MyApp.Windows/Resources.lang-en-us.resw new file mode 100644 index 0000000..fad04be --- /dev/null +++ b/src/MyApp.Windows/Resources.lang-en-us.resw @@ -0,0 +1,123 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + Hello World! + + \ No newline at end of file diff --git a/src/MyApp.Windows/app.manifest b/src/MyApp.Windows/app.manifest index bd538e1..63958c5 100644 --- a/src/MyApp.Windows/app.manifest +++ b/src/MyApp.Windows/app.manifest @@ -1,6 +1,16 @@ - + + + + + + + + diff --git a/src/MyApp.sln b/src/MyApp.sln index c2c59c4..860a3fc 100644 --- a/src/MyApp.sln +++ b/src/MyApp.sln @@ -1,25 +1,35 @@ - + Microsoft Visual Studio Solution File, Format Version 12.00 # Visual Studio Version 17 -VisualStudioVersion = 17.4.33213.308 +VisualStudioVersion = 17.8.34219.65 MinimumVisualStudioVersion = 10.0.40219.1 -Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Platforms", "Platforms", "{2490273D-7672-4DF1-B3F3-720A561E8316}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Source", "Source", "{84F15EB1-CE8C-4878-87BA-7D130358B2A3}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MyApp", "MyApp\MyApp.csproj", "{D407FD64-DEAC-4B84-B4E5-F7CE3779EFEB}" +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Platforms", "Platforms", "{05F510E0-0B6C-4CAE-B0E8-CD2AE8ABE52F}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MyApp.Wasm", "MyApp.Wasm\MyApp.Wasm.csproj", "{58DE019C-166F-4474-98D2-618F1E2D72CA}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MyApp", "MyApp\MyApp.csproj", "{C20B1B14-D6C2-429E-83F3-31F284A1EBA8}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MyApp.Server", "MyApp.Server\MyApp.Server.csproj", "{72E1DF09-7828-473D-A760-5462D87FB791}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MyApp.Base", "MyApp.Base\MyApp.Base.csproj", "{FC5FFE6F-61F4-41B3-B63B-031E5974ABB5}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MyApp.Mobile", "MyApp.Mobile\MyApp.Mobile.csproj", "{C92D2F8C-0B13-4E8A-8A9C-1119461392EB}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MyApp.Mobile", "MyApp.Mobile\MyApp.Mobile.csproj", "{1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MyApp.Skia.Gtk", "MyApp.Skia.Gtk\MyApp.Skia.Gtk.csproj", "{98604AD0-9118-4326-8CE1-E38A4031FD61}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MyApp.Windows", "MyApp.Windows\MyApp.Windows.csproj", "{3F909E22-A03E-48CC-BCDE-EEED95899953}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MyApp.Skia.Linux.FrameBuffer", "MyApp.Skia.Linux.FrameBuffer\MyApp.Skia.Linux.FrameBuffer.csproj", "{504DAA38-2F16-4A63-87DA-EF5F524C45CE}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MyApp.Wasm", "MyApp.Wasm\MyApp.Wasm.csproj", "{6D87ED7C-0B45-4C47-B5E8-F42094030D18}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MyApp.Windows", "MyApp.Windows\MyApp.Windows.csproj", "{FF26EE74-D2C7-4402-93CD-15B3713B6D4C}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MyApp.Skia.Gtk", "MyApp.Skia.Gtk\MyApp.Skia.Gtk.csproj", "{420B5325-6D01-4A86-B3A3-A5F95A291263}" EndProject -Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "MyApp.Skia.Wpf", "MyApp.Skia.Wpf\MyApp.Skia.Wpf.csproj", "{3DAE2BC3-A5FF-4F08-B471-373DD87DC313}" +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MyApp.Skia.Wpf", "MyApp.Skia.WPF\MyApp.Skia.Wpf.csproj", "{9D15802A-2CB2-41DA-B4C6-158F304588CB}" +EndProject +Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "MyApp.Skia.Linux.FrameBuffer", "MyApp.Skia.Linux.FrameBuffer\MyApp.Skia.Linux.FrameBuffer.csproj", "{88BF4A41-ABA6-427A-A581-A8BA2E4AC6A6}" +EndProject +Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{6B60D281-0A73-4D8A-868A-F8761B81E814}" + ProjectSection(SolutionItems) = preProject + .gitignore = .gitignore + Directory.Build.props = Directory.Build.props + Directory.Build.targets = Directory.Build.targets + Directory.Packages.props = Directory.Packages.props + EndProjectSection EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution @@ -33,164 +43,166 @@ Global Release|x86 = Release|x86 EndGlobalSection GlobalSection(ProjectConfigurationPlatforms) = postSolution - {D407FD64-DEAC-4B84-B4E5-F7CE3779EFEB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {D407FD64-DEAC-4B84-B4E5-F7CE3779EFEB}.Debug|Any CPU.Build.0 = Debug|Any CPU - {D407FD64-DEAC-4B84-B4E5-F7CE3779EFEB}.Debug|arm64.ActiveCfg = Debug|Any CPU - {D407FD64-DEAC-4B84-B4E5-F7CE3779EFEB}.Debug|arm64.Build.0 = Debug|Any CPU - {D407FD64-DEAC-4B84-B4E5-F7CE3779EFEB}.Debug|x64.ActiveCfg = Debug|Any CPU - {D407FD64-DEAC-4B84-B4E5-F7CE3779EFEB}.Debug|x64.Build.0 = Debug|Any CPU - {D407FD64-DEAC-4B84-B4E5-F7CE3779EFEB}.Debug|x86.ActiveCfg = Debug|Any CPU - {D407FD64-DEAC-4B84-B4E5-F7CE3779EFEB}.Debug|x86.Build.0 = Debug|Any CPU - {D407FD64-DEAC-4B84-B4E5-F7CE3779EFEB}.Release|Any CPU.ActiveCfg = Release|Any CPU - {D407FD64-DEAC-4B84-B4E5-F7CE3779EFEB}.Release|Any CPU.Build.0 = Release|Any CPU - {D407FD64-DEAC-4B84-B4E5-F7CE3779EFEB}.Release|arm64.ActiveCfg = Release|Any CPU - {D407FD64-DEAC-4B84-B4E5-F7CE3779EFEB}.Release|arm64.Build.0 = Release|Any CPU - {D407FD64-DEAC-4B84-B4E5-F7CE3779EFEB}.Release|x64.ActiveCfg = Release|Any CPU - {D407FD64-DEAC-4B84-B4E5-F7CE3779EFEB}.Release|x64.Build.0 = Release|Any CPU - {D407FD64-DEAC-4B84-B4E5-F7CE3779EFEB}.Release|x86.ActiveCfg = Release|Any CPU - {D407FD64-DEAC-4B84-B4E5-F7CE3779EFEB}.Release|x86.Build.0 = Release|Any CPU - {58DE019C-166F-4474-98D2-618F1E2D72CA}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {58DE019C-166F-4474-98D2-618F1E2D72CA}.Debug|Any CPU.Build.0 = Debug|Any CPU - {58DE019C-166F-4474-98D2-618F1E2D72CA}.Debug|arm64.ActiveCfg = Debug|Any CPU - {58DE019C-166F-4474-98D2-618F1E2D72CA}.Debug|arm64.Build.0 = Debug|Any CPU - {58DE019C-166F-4474-98D2-618F1E2D72CA}.Debug|x64.ActiveCfg = Debug|Any CPU - {58DE019C-166F-4474-98D2-618F1E2D72CA}.Debug|x64.Build.0 = Debug|Any CPU - {58DE019C-166F-4474-98D2-618F1E2D72CA}.Debug|x86.ActiveCfg = Debug|Any CPU - {58DE019C-166F-4474-98D2-618F1E2D72CA}.Debug|x86.Build.0 = Debug|Any CPU - {58DE019C-166F-4474-98D2-618F1E2D72CA}.Release|Any CPU.ActiveCfg = Release|Any CPU - {58DE019C-166F-4474-98D2-618F1E2D72CA}.Release|Any CPU.Build.0 = Release|Any CPU - {58DE019C-166F-4474-98D2-618F1E2D72CA}.Release|arm64.ActiveCfg = Release|Any CPU - {58DE019C-166F-4474-98D2-618F1E2D72CA}.Release|arm64.Build.0 = Release|Any CPU - {58DE019C-166F-4474-98D2-618F1E2D72CA}.Release|x64.ActiveCfg = Release|Any CPU - {58DE019C-166F-4474-98D2-618F1E2D72CA}.Release|x64.Build.0 = Release|Any CPU - {58DE019C-166F-4474-98D2-618F1E2D72CA}.Release|x86.ActiveCfg = Release|Any CPU - {58DE019C-166F-4474-98D2-618F1E2D72CA}.Release|x86.Build.0 = Release|Any CPU - {72E1DF09-7828-473D-A760-5462D87FB791}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {72E1DF09-7828-473D-A760-5462D87FB791}.Debug|Any CPU.Build.0 = Debug|Any CPU - {72E1DF09-7828-473D-A760-5462D87FB791}.Debug|arm64.ActiveCfg = Debug|Any CPU - {72E1DF09-7828-473D-A760-5462D87FB791}.Debug|arm64.Build.0 = Debug|Any CPU - {72E1DF09-7828-473D-A760-5462D87FB791}.Debug|x64.ActiveCfg = Debug|Any CPU - {72E1DF09-7828-473D-A760-5462D87FB791}.Debug|x64.Build.0 = Debug|Any CPU - {72E1DF09-7828-473D-A760-5462D87FB791}.Debug|x86.ActiveCfg = Debug|Any CPU - {72E1DF09-7828-473D-A760-5462D87FB791}.Debug|x86.Build.0 = Debug|Any CPU - {72E1DF09-7828-473D-A760-5462D87FB791}.Release|Any CPU.ActiveCfg = Release|Any CPU - {72E1DF09-7828-473D-A760-5462D87FB791}.Release|Any CPU.Build.0 = Release|Any CPU - {72E1DF09-7828-473D-A760-5462D87FB791}.Release|arm64.ActiveCfg = Release|Any CPU - {72E1DF09-7828-473D-A760-5462D87FB791}.Release|arm64.Build.0 = Release|Any CPU - {72E1DF09-7828-473D-A760-5462D87FB791}.Release|x64.ActiveCfg = Release|Any CPU - {72E1DF09-7828-473D-A760-5462D87FB791}.Release|x64.Build.0 = Release|Any CPU - {72E1DF09-7828-473D-A760-5462D87FB791}.Release|x86.ActiveCfg = Release|Any CPU - {72E1DF09-7828-473D-A760-5462D87FB791}.Release|x86.Build.0 = Release|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Debug|Any CPU.Build.0 = Debug|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Debug|Any CPU.Deploy.0 = Debug|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Debug|arm64.ActiveCfg = Debug|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Debug|arm64.Build.0 = Debug|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Debug|arm64.Deploy.0 = Debug|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Debug|x64.ActiveCfg = Debug|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Debug|x64.Build.0 = Debug|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Debug|x64.Deploy.0 = Debug|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Debug|x86.ActiveCfg = Debug|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Debug|x86.Build.0 = Debug|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Debug|x86.Deploy.0 = Debug|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Release|Any CPU.ActiveCfg = Release|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Release|Any CPU.Build.0 = Release|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Release|Any CPU.Deploy.0 = Release|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Release|arm64.ActiveCfg = Release|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Release|arm64.Build.0 = Release|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Release|arm64.Deploy.0 = Release|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Release|x64.ActiveCfg = Release|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Release|x64.Build.0 = Release|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Release|x64.Deploy.0 = Release|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Release|x86.ActiveCfg = Release|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Release|x86.Build.0 = Release|Any CPU - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB}.Release|x86.Deploy.0 = Release|Any CPU - {98604AD0-9118-4326-8CE1-E38A4031FD61}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {98604AD0-9118-4326-8CE1-E38A4031FD61}.Debug|Any CPU.Build.0 = Debug|Any CPU - {98604AD0-9118-4326-8CE1-E38A4031FD61}.Debug|arm64.ActiveCfg = Debug|Any CPU - {98604AD0-9118-4326-8CE1-E38A4031FD61}.Debug|arm64.Build.0 = Debug|Any CPU - {98604AD0-9118-4326-8CE1-E38A4031FD61}.Debug|x64.ActiveCfg = Debug|Any CPU - {98604AD0-9118-4326-8CE1-E38A4031FD61}.Debug|x64.Build.0 = Debug|Any CPU - {98604AD0-9118-4326-8CE1-E38A4031FD61}.Debug|x86.ActiveCfg = Debug|Any CPU - {98604AD0-9118-4326-8CE1-E38A4031FD61}.Debug|x86.Build.0 = Debug|Any CPU - {98604AD0-9118-4326-8CE1-E38A4031FD61}.Release|Any CPU.ActiveCfg = Release|Any CPU - {98604AD0-9118-4326-8CE1-E38A4031FD61}.Release|Any CPU.Build.0 = Release|Any CPU - {98604AD0-9118-4326-8CE1-E38A4031FD61}.Release|arm64.ActiveCfg = Release|Any CPU - {98604AD0-9118-4326-8CE1-E38A4031FD61}.Release|arm64.Build.0 = Release|Any CPU - {98604AD0-9118-4326-8CE1-E38A4031FD61}.Release|x64.ActiveCfg = Release|Any CPU - {98604AD0-9118-4326-8CE1-E38A4031FD61}.Release|x64.Build.0 = Release|Any CPU - {98604AD0-9118-4326-8CE1-E38A4031FD61}.Release|x86.ActiveCfg = Release|Any CPU - {98604AD0-9118-4326-8CE1-E38A4031FD61}.Release|x86.Build.0 = Release|Any CPU - {504DAA38-2F16-4A63-87DA-EF5F524C45CE}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {504DAA38-2F16-4A63-87DA-EF5F524C45CE}.Debug|Any CPU.Build.0 = Debug|Any CPU - {504DAA38-2F16-4A63-87DA-EF5F524C45CE}.Debug|arm64.ActiveCfg = Debug|Any CPU - {504DAA38-2F16-4A63-87DA-EF5F524C45CE}.Debug|arm64.Build.0 = Debug|Any CPU - {504DAA38-2F16-4A63-87DA-EF5F524C45CE}.Debug|x64.ActiveCfg = Debug|Any CPU - {504DAA38-2F16-4A63-87DA-EF5F524C45CE}.Debug|x64.Build.0 = Debug|Any CPU - {504DAA38-2F16-4A63-87DA-EF5F524C45CE}.Debug|x86.ActiveCfg = Debug|Any CPU - {504DAA38-2F16-4A63-87DA-EF5F524C45CE}.Debug|x86.Build.0 = Debug|Any CPU - {504DAA38-2F16-4A63-87DA-EF5F524C45CE}.Release|Any CPU.ActiveCfg = Release|Any CPU - {504DAA38-2F16-4A63-87DA-EF5F524C45CE}.Release|Any CPU.Build.0 = Release|Any CPU - {504DAA38-2F16-4A63-87DA-EF5F524C45CE}.Release|arm64.ActiveCfg = Release|Any CPU - {504DAA38-2F16-4A63-87DA-EF5F524C45CE}.Release|arm64.Build.0 = Release|Any CPU - {504DAA38-2F16-4A63-87DA-EF5F524C45CE}.Release|x64.ActiveCfg = Release|Any CPU - {504DAA38-2F16-4A63-87DA-EF5F524C45CE}.Release|x64.Build.0 = Release|Any CPU - {504DAA38-2F16-4A63-87DA-EF5F524C45CE}.Release|x86.ActiveCfg = Release|Any CPU - {504DAA38-2F16-4A63-87DA-EF5F524C45CE}.Release|x86.Build.0 = Release|Any CPU - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Debug|Any CPU.ActiveCfg = Debug|x64 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Debug|Any CPU.Build.0 = Debug|x64 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Debug|Any CPU.Deploy.0 = Debug|x64 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Debug|arm64.ActiveCfg = Debug|arm64 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Debug|arm64.Build.0 = Debug|arm64 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Debug|arm64.Deploy.0 = Debug|arm64 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Debug|x64.ActiveCfg = Debug|x64 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Debug|x64.Build.0 = Debug|x64 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Debug|x64.Deploy.0 = Debug|x64 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Debug|x86.ActiveCfg = Debug|x86 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Debug|x86.Build.0 = Debug|x86 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Debug|x86.Deploy.0 = Debug|x86 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Release|Any CPU.ActiveCfg = Release|x64 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Release|Any CPU.Build.0 = Release|x64 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Release|Any CPU.Deploy.0 = Release|x64 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Release|arm64.ActiveCfg = Release|arm64 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Release|arm64.Build.0 = Release|arm64 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Release|arm64.Deploy.0 = Release|arm64 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Release|x64.ActiveCfg = Release|x64 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Release|x64.Build.0 = Release|x64 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Release|x64.Deploy.0 = Release|x64 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Release|x86.ActiveCfg = Release|x86 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Release|x86.Build.0 = Release|x86 - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C}.Release|x86.Deploy.0 = Release|x86 - {3DAE2BC3-A5FF-4F08-B471-373DD87DC313}.Debug|Any CPU.ActiveCfg = Debug|Any CPU - {3DAE2BC3-A5FF-4F08-B471-373DD87DC313}.Debug|Any CPU.Build.0 = Debug|Any CPU - {3DAE2BC3-A5FF-4F08-B471-373DD87DC313}.Debug|arm64.ActiveCfg = Debug|Any CPU - {3DAE2BC3-A5FF-4F08-B471-373DD87DC313}.Debug|arm64.Build.0 = Debug|Any CPU - {3DAE2BC3-A5FF-4F08-B471-373DD87DC313}.Debug|x64.ActiveCfg = Debug|Any CPU - {3DAE2BC3-A5FF-4F08-B471-373DD87DC313}.Debug|x64.Build.0 = Debug|Any CPU - {3DAE2BC3-A5FF-4F08-B471-373DD87DC313}.Debug|x86.ActiveCfg = Debug|Any CPU - {3DAE2BC3-A5FF-4F08-B471-373DD87DC313}.Debug|x86.Build.0 = Debug|Any CPU - {3DAE2BC3-A5FF-4F08-B471-373DD87DC313}.Release|Any CPU.ActiveCfg = Release|Any CPU - {3DAE2BC3-A5FF-4F08-B471-373DD87DC313}.Release|Any CPU.Build.0 = Release|Any CPU - {3DAE2BC3-A5FF-4F08-B471-373DD87DC313}.Release|arm64.ActiveCfg = Release|Any CPU - {3DAE2BC3-A5FF-4F08-B471-373DD87DC313}.Release|arm64.Build.0 = Release|Any CPU - {3DAE2BC3-A5FF-4F08-B471-373DD87DC313}.Release|x64.ActiveCfg = Release|Any CPU - {3DAE2BC3-A5FF-4F08-B471-373DD87DC313}.Release|x64.Build.0 = Release|Any CPU - {3DAE2BC3-A5FF-4F08-B471-373DD87DC313}.Release|x86.ActiveCfg = Release|Any CPU - {3DAE2BC3-A5FF-4F08-B471-373DD87DC313}.Release|x86.Build.0 = Release|Any CPU + {C20B1B14-D6C2-429E-83F3-31F284A1EBA8}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {C20B1B14-D6C2-429E-83F3-31F284A1EBA8}.Debug|Any CPU.Build.0 = Debug|Any CPU + {C20B1B14-D6C2-429E-83F3-31F284A1EBA8}.Debug|arm64.ActiveCfg = Debug|Any CPU + {C20B1B14-D6C2-429E-83F3-31F284A1EBA8}.Debug|arm64.Build.0 = Debug|Any CPU + {C20B1B14-D6C2-429E-83F3-31F284A1EBA8}.Debug|x64.ActiveCfg = Debug|Any CPU + {C20B1B14-D6C2-429E-83F3-31F284A1EBA8}.Debug|x64.Build.0 = Debug|Any CPU + {C20B1B14-D6C2-429E-83F3-31F284A1EBA8}.Debug|x86.ActiveCfg = Debug|Any CPU + {C20B1B14-D6C2-429E-83F3-31F284A1EBA8}.Debug|x86.Build.0 = Debug|Any CPU + {C20B1B14-D6C2-429E-83F3-31F284A1EBA8}.Release|Any CPU.ActiveCfg = Release|Any CPU + {C20B1B14-D6C2-429E-83F3-31F284A1EBA8}.Release|Any CPU.Build.0 = Release|Any CPU + {C20B1B14-D6C2-429E-83F3-31F284A1EBA8}.Release|arm64.ActiveCfg = Release|Any CPU + {C20B1B14-D6C2-429E-83F3-31F284A1EBA8}.Release|arm64.Build.0 = Release|Any CPU + {C20B1B14-D6C2-429E-83F3-31F284A1EBA8}.Release|x64.ActiveCfg = Release|Any CPU + {C20B1B14-D6C2-429E-83F3-31F284A1EBA8}.Release|x64.Build.0 = Release|Any CPU + {C20B1B14-D6C2-429E-83F3-31F284A1EBA8}.Release|x86.ActiveCfg = Release|Any CPU + {C20B1B14-D6C2-429E-83F3-31F284A1EBA8}.Release|x86.Build.0 = Release|Any CPU + {FC5FFE6F-61F4-41B3-B63B-031E5974ABB5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {FC5FFE6F-61F4-41B3-B63B-031E5974ABB5}.Debug|Any CPU.Build.0 = Debug|Any CPU + {FC5FFE6F-61F4-41B3-B63B-031E5974ABB5}.Debug|arm64.ActiveCfg = Debug|Any CPU + {FC5FFE6F-61F4-41B3-B63B-031E5974ABB5}.Debug|arm64.Build.0 = Debug|Any CPU + {FC5FFE6F-61F4-41B3-B63B-031E5974ABB5}.Debug|x64.ActiveCfg = Debug|Any CPU + {FC5FFE6F-61F4-41B3-B63B-031E5974ABB5}.Debug|x64.Build.0 = Debug|Any CPU + {FC5FFE6F-61F4-41B3-B63B-031E5974ABB5}.Debug|x86.ActiveCfg = Debug|Any CPU + {FC5FFE6F-61F4-41B3-B63B-031E5974ABB5}.Debug|x86.Build.0 = Debug|Any CPU + {FC5FFE6F-61F4-41B3-B63B-031E5974ABB5}.Release|Any CPU.ActiveCfg = Release|Any CPU + {FC5FFE6F-61F4-41B3-B63B-031E5974ABB5}.Release|Any CPU.Build.0 = Release|Any CPU + {FC5FFE6F-61F4-41B3-B63B-031E5974ABB5}.Release|arm64.ActiveCfg = Release|Any CPU + {FC5FFE6F-61F4-41B3-B63B-031E5974ABB5}.Release|arm64.Build.0 = Release|Any CPU + {FC5FFE6F-61F4-41B3-B63B-031E5974ABB5}.Release|x64.ActiveCfg = Release|Any CPU + {FC5FFE6F-61F4-41B3-B63B-031E5974ABB5}.Release|x64.Build.0 = Release|Any CPU + {FC5FFE6F-61F4-41B3-B63B-031E5974ABB5}.Release|x86.ActiveCfg = Release|Any CPU + {FC5FFE6F-61F4-41B3-B63B-031E5974ABB5}.Release|x86.Build.0 = Release|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Debug|Any CPU.Build.0 = Debug|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Debug|Any CPU.Deploy.0 = Debug|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Debug|arm64.ActiveCfg = Debug|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Debug|arm64.Build.0 = Debug|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Debug|arm64.Deploy.0 = Debug|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Debug|x64.ActiveCfg = Debug|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Debug|x64.Build.0 = Debug|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Debug|x64.Deploy.0 = Debug|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Debug|x86.ActiveCfg = Debug|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Debug|x86.Build.0 = Debug|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Debug|x86.Deploy.0 = Debug|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Release|Any CPU.ActiveCfg = Release|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Release|Any CPU.Build.0 = Release|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Release|Any CPU.Deploy.0 = Release|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Release|arm64.ActiveCfg = Release|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Release|arm64.Build.0 = Release|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Release|arm64.Deploy.0 = Release|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Release|x64.ActiveCfg = Release|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Release|x64.Build.0 = Release|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Release|x64.Deploy.0 = Release|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Release|x86.ActiveCfg = Release|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Release|x86.Build.0 = Release|Any CPU + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67}.Release|x86.Deploy.0 = Release|Any CPU + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Debug|Any CPU.ActiveCfg = Debug|x64 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Debug|Any CPU.Build.0 = Debug|x64 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Debug|Any CPU.Deploy.0 = Debug|x64 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Debug|arm64.ActiveCfg = Debug|arm64 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Debug|arm64.Build.0 = Debug|arm64 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Debug|arm64.Deploy.0 = Debug|arm64 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Debug|x64.ActiveCfg = Debug|x64 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Debug|x64.Build.0 = Debug|x64 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Debug|x64.Deploy.0 = Debug|x64 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Debug|x86.ActiveCfg = Debug|x86 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Debug|x86.Build.0 = Debug|x86 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Debug|x86.Deploy.0 = Debug|x86 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Release|Any CPU.ActiveCfg = Release|x64 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Release|Any CPU.Build.0 = Release|x64 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Release|Any CPU.Deploy.0 = Release|x64 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Release|arm64.ActiveCfg = Release|arm64 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Release|arm64.Build.0 = Release|arm64 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Release|arm64.Deploy.0 = Release|arm64 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Release|x64.ActiveCfg = Release|x64 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Release|x64.Build.0 = Release|x64 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Release|x64.Deploy.0 = Release|x64 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Release|x86.ActiveCfg = Release|x86 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Release|x86.Build.0 = Release|x86 + {3F909E22-A03E-48CC-BCDE-EEED95899953}.Release|x86.Deploy.0 = Release|x86 + {6D87ED7C-0B45-4C47-B5E8-F42094030D18}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {6D87ED7C-0B45-4C47-B5E8-F42094030D18}.Debug|Any CPU.Build.0 = Debug|Any CPU + {6D87ED7C-0B45-4C47-B5E8-F42094030D18}.Debug|arm64.ActiveCfg = Debug|Any CPU + {6D87ED7C-0B45-4C47-B5E8-F42094030D18}.Debug|arm64.Build.0 = Debug|Any CPU + {6D87ED7C-0B45-4C47-B5E8-F42094030D18}.Debug|x64.ActiveCfg = Debug|Any CPU + {6D87ED7C-0B45-4C47-B5E8-F42094030D18}.Debug|x64.Build.0 = Debug|Any CPU + {6D87ED7C-0B45-4C47-B5E8-F42094030D18}.Debug|x86.ActiveCfg = Debug|Any CPU + {6D87ED7C-0B45-4C47-B5E8-F42094030D18}.Debug|x86.Build.0 = Debug|Any CPU + {6D87ED7C-0B45-4C47-B5E8-F42094030D18}.Release|Any CPU.ActiveCfg = Release|Any CPU + {6D87ED7C-0B45-4C47-B5E8-F42094030D18}.Release|Any CPU.Build.0 = Release|Any CPU + {6D87ED7C-0B45-4C47-B5E8-F42094030D18}.Release|arm64.ActiveCfg = Release|Any CPU + {6D87ED7C-0B45-4C47-B5E8-F42094030D18}.Release|arm64.Build.0 = Release|Any CPU + {6D87ED7C-0B45-4C47-B5E8-F42094030D18}.Release|x64.ActiveCfg = Release|Any CPU + {6D87ED7C-0B45-4C47-B5E8-F42094030D18}.Release|x64.Build.0 = Release|Any CPU + {6D87ED7C-0B45-4C47-B5E8-F42094030D18}.Release|x86.ActiveCfg = Release|Any CPU + {6D87ED7C-0B45-4C47-B5E8-F42094030D18}.Release|x86.Build.0 = Release|Any CPU + {420B5325-6D01-4A86-B3A3-A5F95A291263}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {420B5325-6D01-4A86-B3A3-A5F95A291263}.Debug|Any CPU.Build.0 = Debug|Any CPU + {420B5325-6D01-4A86-B3A3-A5F95A291263}.Debug|arm64.ActiveCfg = Debug|Any CPU + {420B5325-6D01-4A86-B3A3-A5F95A291263}.Debug|arm64.Build.0 = Debug|Any CPU + {420B5325-6D01-4A86-B3A3-A5F95A291263}.Debug|x64.ActiveCfg = Debug|Any CPU + {420B5325-6D01-4A86-B3A3-A5F95A291263}.Debug|x64.Build.0 = Debug|Any CPU + {420B5325-6D01-4A86-B3A3-A5F95A291263}.Debug|x86.ActiveCfg = Debug|Any CPU + {420B5325-6D01-4A86-B3A3-A5F95A291263}.Debug|x86.Build.0 = Debug|Any CPU + {420B5325-6D01-4A86-B3A3-A5F95A291263}.Release|Any CPU.ActiveCfg = Release|Any CPU + {420B5325-6D01-4A86-B3A3-A5F95A291263}.Release|Any CPU.Build.0 = Release|Any CPU + {420B5325-6D01-4A86-B3A3-A5F95A291263}.Release|arm64.ActiveCfg = Release|Any CPU + {420B5325-6D01-4A86-B3A3-A5F95A291263}.Release|arm64.Build.0 = Release|Any CPU + {420B5325-6D01-4A86-B3A3-A5F95A291263}.Release|x64.ActiveCfg = Release|Any CPU + {420B5325-6D01-4A86-B3A3-A5F95A291263}.Release|x64.Build.0 = Release|Any CPU + {420B5325-6D01-4A86-B3A3-A5F95A291263}.Release|x86.ActiveCfg = Release|Any CPU + {420B5325-6D01-4A86-B3A3-A5F95A291263}.Release|x86.Build.0 = Release|Any CPU + {9D15802A-2CB2-41DA-B4C6-158F304588CB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {9D15802A-2CB2-41DA-B4C6-158F304588CB}.Debug|Any CPU.Build.0 = Debug|Any CPU + {9D15802A-2CB2-41DA-B4C6-158F304588CB}.Debug|arm64.ActiveCfg = Debug|Any CPU + {9D15802A-2CB2-41DA-B4C6-158F304588CB}.Debug|arm64.Build.0 = Debug|Any CPU + {9D15802A-2CB2-41DA-B4C6-158F304588CB}.Debug|x64.ActiveCfg = Debug|Any CPU + {9D15802A-2CB2-41DA-B4C6-158F304588CB}.Debug|x64.Build.0 = Debug|Any CPU + {9D15802A-2CB2-41DA-B4C6-158F304588CB}.Debug|x86.ActiveCfg = Debug|Any CPU + {9D15802A-2CB2-41DA-B4C6-158F304588CB}.Debug|x86.Build.0 = Debug|Any CPU + {9D15802A-2CB2-41DA-B4C6-158F304588CB}.Release|Any CPU.ActiveCfg = Release|Any CPU + {9D15802A-2CB2-41DA-B4C6-158F304588CB}.Release|Any CPU.Build.0 = Release|Any CPU + {9D15802A-2CB2-41DA-B4C6-158F304588CB}.Release|arm64.ActiveCfg = Release|Any CPU + {9D15802A-2CB2-41DA-B4C6-158F304588CB}.Release|arm64.Build.0 = Release|Any CPU + {9D15802A-2CB2-41DA-B4C6-158F304588CB}.Release|x64.ActiveCfg = Release|Any CPU + {9D15802A-2CB2-41DA-B4C6-158F304588CB}.Release|x64.Build.0 = Release|Any CPU + {9D15802A-2CB2-41DA-B4C6-158F304588CB}.Release|x86.ActiveCfg = Release|Any CPU + {9D15802A-2CB2-41DA-B4C6-158F304588CB}.Release|x86.Build.0 = Release|Any CPU + {88BF4A41-ABA6-427A-A581-A8BA2E4AC6A6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {88BF4A41-ABA6-427A-A581-A8BA2E4AC6A6}.Debug|Any CPU.Build.0 = Debug|Any CPU + {88BF4A41-ABA6-427A-A581-A8BA2E4AC6A6}.Debug|arm64.ActiveCfg = Debug|Any CPU + {88BF4A41-ABA6-427A-A581-A8BA2E4AC6A6}.Debug|arm64.Build.0 = Debug|Any CPU + {88BF4A41-ABA6-427A-A581-A8BA2E4AC6A6}.Debug|x64.ActiveCfg = Debug|Any CPU + {88BF4A41-ABA6-427A-A581-A8BA2E4AC6A6}.Debug|x64.Build.0 = Debug|Any CPU + {88BF4A41-ABA6-427A-A581-A8BA2E4AC6A6}.Debug|x86.ActiveCfg = Debug|Any CPU + {88BF4A41-ABA6-427A-A581-A8BA2E4AC6A6}.Debug|x86.Build.0 = Debug|Any CPU + {88BF4A41-ABA6-427A-A581-A8BA2E4AC6A6}.Release|Any CPU.ActiveCfg = Release|Any CPU + {88BF4A41-ABA6-427A-A581-A8BA2E4AC6A6}.Release|Any CPU.Build.0 = Release|Any CPU + {88BF4A41-ABA6-427A-A581-A8BA2E4AC6A6}.Release|arm64.ActiveCfg = Release|Any CPU + {88BF4A41-ABA6-427A-A581-A8BA2E4AC6A6}.Release|arm64.Build.0 = Release|Any CPU + {88BF4A41-ABA6-427A-A581-A8BA2E4AC6A6}.Release|x64.ActiveCfg = Release|Any CPU + {88BF4A41-ABA6-427A-A581-A8BA2E4AC6A6}.Release|x64.Build.0 = Release|Any CPU + {88BF4A41-ABA6-427A-A581-A8BA2E4AC6A6}.Release|x86.ActiveCfg = Release|Any CPU + {88BF4A41-ABA6-427A-A581-A8BA2E4AC6A6}.Release|x86.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE EndGlobalSection GlobalSection(NestedProjects) = preSolution - {58DE019C-166F-4474-98D2-618F1E2D72CA} = {2490273D-7672-4DF1-B3F3-720A561E8316} - {72E1DF09-7828-473D-A760-5462D87FB791} = {2490273D-7672-4DF1-B3F3-720A561E8316} - {C92D2F8C-0B13-4E8A-8A9C-1119461392EB} = {2490273D-7672-4DF1-B3F3-720A561E8316} - {98604AD0-9118-4326-8CE1-E38A4031FD61} = {2490273D-7672-4DF1-B3F3-720A561E8316} - {504DAA38-2F16-4A63-87DA-EF5F524C45CE} = {2490273D-7672-4DF1-B3F3-720A561E8316} - {FF26EE74-D2C7-4402-93CD-15B3713B6D4C} = {2490273D-7672-4DF1-B3F3-720A561E8316} - {3DAE2BC3-A5FF-4F08-B471-373DD87DC313} = {2490273D-7672-4DF1-B3F3-720A561E8316} + {05F510E0-0B6C-4CAE-B0E8-CD2AE8ABE52F} = {84F15EB1-CE8C-4878-87BA-7D130358B2A3} + {C20B1B14-D6C2-429E-83F3-31F284A1EBA8} = {84F15EB1-CE8C-4878-87BA-7D130358B2A3} + {FC5FFE6F-61F4-41B3-B63B-031E5974ABB5} = {05F510E0-0B6C-4CAE-B0E8-CD2AE8ABE52F} + {1E88CD48-F430-4C4A-BCC3-ECF8893EFA67} = {05F510E0-0B6C-4CAE-B0E8-CD2AE8ABE52F} + {3F909E22-A03E-48CC-BCDE-EEED95899953} = {05F510E0-0B6C-4CAE-B0E8-CD2AE8ABE52F} + {6D87ED7C-0B45-4C47-B5E8-F42094030D18} = {05F510E0-0B6C-4CAE-B0E8-CD2AE8ABE52F} + {420B5325-6D01-4A86-B3A3-A5F95A291263} = {05F510E0-0B6C-4CAE-B0E8-CD2AE8ABE52F} + {9D15802A-2CB2-41DA-B4C6-158F304588CB} = {05F510E0-0B6C-4CAE-B0E8-CD2AE8ABE52F} + {88BF4A41-ABA6-427A-A581-A8BA2E4AC6A6} = {05F510E0-0B6C-4CAE-B0E8-CD2AE8ABE52F} EndGlobalSection GlobalSection(ExtensibilityGlobals) = postSolution - SolutionGuid = {34B38CFE-34D5-417F-86A5-F3C6F6FA6C9C} + SolutionGuid = {6692CBF9-C1C6-4C82-9F42-67C7BF86FED0} EndGlobalSection EndGlobal diff --git a/src/MyApp/App.cs b/src/MyApp/App.cs new file mode 100644 index 0000000..aea811b --- /dev/null +++ b/src/MyApp/App.cs @@ -0,0 +1,55 @@ +namespace MyApp +{ + public class App : Application + { + protected Window? MainWindow { get; private set; } + + protected override void OnLaunched(LaunchActivatedEventArgs args) + { +#if NET6_0_OR_GREATER && WINDOWS && !HAS_UNO + MainWindow = new Window(); +#else + MainWindow = Microsoft.UI.Xaml.Window.Current; +#endif + +#if DEBUG + MainWindow.EnableHotReload(); +#endif + + + // Do not repeat app initialization when the Window already has content, + // just ensure that the window is active + if (MainWindow.Content is not Frame rootFrame) + { + // Create a Frame to act as the navigation context and navigate to the first page + rootFrame = new Frame(); + + // Place the frame in the current Window + MainWindow.Content = rootFrame; + + rootFrame.NavigationFailed += OnNavigationFailed; + } + + if (rootFrame.Content == null) + { + // When the navigation stack isn't restored navigate to the first page, + // configuring the new page by passing required information as a navigation + // parameter + rootFrame.Navigate(typeof(MainPage), args.Arguments); + } + + // Ensure the current window is active + MainWindow.Activate(); + } + + /// + /// Invoked when Navigation to a certain page fails + /// + /// The Frame which failed navigation + /// Details about the navigation failure + void OnNavigationFailed(object sender, NavigationFailedEventArgs e) + { + throw new InvalidOperationException($"Failed to load {e.SourcePageType.FullName}: {e.Exception}"); + } + } +} diff --git a/src/MyApp/AppResources.xaml b/src/MyApp/AppResources.xaml new file mode 100644 index 0000000..ab49df3 --- /dev/null +++ b/src/MyApp/AppResources.xaml @@ -0,0 +1,11 @@ + + + + + + + + + + diff --git a/src/MyApp/Assets/Icons/back.svg b/src/MyApp/Assets/Icons/back.svg new file mode 100644 index 0000000..bcd7851 --- /dev/null +++ b/src/MyApp/Assets/Icons/back.svg @@ -0,0 +1,3 @@ + + + diff --git a/src/MyApp/Assets/SharedAssets.md b/src/MyApp/Assets/SharedAssets.md new file mode 100644 index 0000000..1b84a74 --- /dev/null +++ b/src/MyApp/Assets/SharedAssets.md @@ -0,0 +1,32 @@ +# Shared Assets + +See documentation about assets here: https://github.com/unoplatform/uno/blob/master/doc/articles/features/working-with-assets.md + +## Here is a cheat sheet + +1. Add the image file to the `Assets` directory of a shared project. +2. Set the build action to `Content`. +3. (Recommended) Provide an asset for various scales/dpi + +### Examples + +```text +\Assets\Images\logo.scale-100.png +\Assets\Images\logo.scale-200.png +\Assets\Images\logo.scale-400.png + +\Assets\Images\scale-100\logo.png +\Assets\Images\scale-200\logo.png +\Assets\Images\scale-400\logo.png +``` + +### Table of scales + +| Scale | WinUI | iOS/MacCatalyst | Android | +|-------|:-----------:|:---------------:|:-------:| +| `100` | scale-100 | @1x | mdpi | +| `125` | scale-125 | N/A | N/A | +| `150` | scale-150 | N/A | hdpi | +| `200` | scale-200 | @2x | xhdpi | +| `300` | scale-300 | @3x | xxhdpi | +| `400` | scale-400 | N/A | xxxhdpi | diff --git a/src/MyApp/GlobalUsings.cs b/src/MyApp/GlobalUsings.cs new file mode 100644 index 0000000..99b25e4 --- /dev/null +++ b/src/MyApp/GlobalUsings.cs @@ -0,0 +1,13 @@ +global using System.Collections.Immutable; +global using System.Windows.Input; +global using Microsoft.Extensions.DependencyInjection; +global using Microsoft.Extensions.Logging; +global using Microsoft.UI.Xaml; +global using Microsoft.UI.Xaml.Controls; +global using Microsoft.UI.Xaml.Media; +global using Microsoft.UI.Xaml.Navigation; +global using Uno.UI; +global using Windows.ApplicationModel; +global using Windows.Networking.Connectivity; +global using Windows.Storage; +global using ApplicationExecutionState = Windows.ApplicationModel.Activation.ApplicationExecutionState; diff --git a/src/MyApp/MainPage.xaml b/src/MyApp/MainPage.xaml index faab7f3..06c1e7e 100644 --- a/src/MyApp/MainPage.xaml +++ b/src/MyApp/MainPage.xaml @@ -1,14 +1,13 @@ - - - - - + + + + diff --git a/src/MyApp/MainPage.xaml.cs b/src/MyApp/MainPage.xaml.cs index bfe31e7..3b1be18 100644 --- a/src/MyApp/MainPage.xaml.cs +++ b/src/MyApp/MainPage.xaml.cs @@ -1,25 +1,5 @@ -using Microsoft.UI.Xaml; -using Microsoft.UI.Xaml.Controls; -using Microsoft.UI.Xaml.Controls.Primitives; -using Microsoft.UI.Xaml.Data; -using Microsoft.UI.Xaml.Input; -using Microsoft.UI.Xaml.Media; -using Microsoft.UI.Xaml.Navigation; -using System; -using System.Collections.Generic; -using System.IO; -using System.Linq; -using System.Runtime.InteropServices.WindowsRuntime; -using Windows.Foundation; -using Windows.Foundation.Collections; - -// The Blank Page item template is documented at http://go.microsoft.com/fwlink/?LinkId=402352&clcid=0x409 - namespace MyApp { - /// - /// An empty page that can be used on its own or navigated to within a Frame. - /// public sealed partial class MainPage : Page { public MainPage() diff --git a/src/MyApp/MyApp.csproj b/src/MyApp/MyApp.csproj index e4bfb52..e73de4e 100644 --- a/src/MyApp/MyApp.csproj +++ b/src/MyApp/MyApp.csproj @@ -1,41 +1,58 @@ - - net7.0 - $(TargetFrameworks);net7.0-windows10.0.18362 - $(TargetFrameworks);net7.0-android - $(TargetFrameworks);net7.0-ios - $(TargetFrameworks);net7.0-maccatalyst - - en - 14.2 - 14.0 - 21.0 - 10.0.18362.0 - 10.0.18362.0 - - - - true - - - - - - - - - - - - - - - - - %(Filename) - - - - - - \ No newline at end of file + + $(TargetFrameworks);net7.0-windows10.0.19041 + $(TargetFrameworks);net7.0;net7.0-android;net7.0-ios;net7.0-maccatalyst + $(OverrideTargetFrameworks) + + + true + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + %(Filename) + + + + + + + + + + + diff --git a/src/MyApp/Strings/en/Resources.resw b/src/MyApp/Strings/en/Resources.resw index 78169d2..fd22157 100644 --- a/src/MyApp/Strings/en/Resources.resw +++ b/src/MyApp/Strings/en/Resources.resw @@ -1,17 +1,17 @@  - @@ -118,6 +118,6 @@ System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 - MyApp + MyApp-en - \ No newline at end of file +