Benedikt Stebner
4 years ago
committed by
GitHub
GitHub
117 changed files with 7745 additions and 356 deletions
@ -0,0 +1,148 @@ |
|||
{ |
|||
"$schema": "http://json-schema.org/draft-04/schema#", |
|||
"title": "Build Schema", |
|||
"$ref": "#/definitions/build", |
|||
"definitions": { |
|||
"build": { |
|||
"type": "object", |
|||
"properties": { |
|||
"Configuration": { |
|||
"type": "string", |
|||
"description": "configuration" |
|||
}, |
|||
"Continue": { |
|||
"type": "boolean", |
|||
"description": "Indicates to continue a previously failed build attempt" |
|||
}, |
|||
"ForceNugetVersion": { |
|||
"type": "string", |
|||
"description": "force-nuget-version" |
|||
}, |
|||
"Help": { |
|||
"type": "boolean", |
|||
"description": "Shows the help text for this build assembly" |
|||
}, |
|||
"Host": { |
|||
"type": "string", |
|||
"description": "Host for execution. Default is 'automatic'", |
|||
"enum": [ |
|||
"AppVeyor", |
|||
"AzurePipelines", |
|||
"Bamboo", |
|||
"Bitbucket", |
|||
"Bitrise", |
|||
"GitHubActions", |
|||
"GitLab", |
|||
"Jenkins", |
|||
"Rider", |
|||
"SpaceAutomation", |
|||
"TeamCity", |
|||
"Terminal", |
|||
"TravisCI", |
|||
"VisualStudio", |
|||
"VSCode" |
|||
] |
|||
}, |
|||
"NoLogo": { |
|||
"type": "boolean", |
|||
"description": "Disables displaying the NUKE logo" |
|||
}, |
|||
"Partition": { |
|||
"type": "string", |
|||
"description": "Partition to use on CI" |
|||
}, |
|||
"Plan": { |
|||
"type": "boolean", |
|||
"description": "Shows the execution plan (HTML)" |
|||
}, |
|||
"Profile": { |
|||
"type": "array", |
|||
"description": "Defines the profiles to load", |
|||
"items": { |
|||
"type": "string" |
|||
} |
|||
}, |
|||
"Root": { |
|||
"type": "string", |
|||
"description": "Root directory during build execution" |
|||
}, |
|||
"Skip": { |
|||
"type": "array", |
|||
"description": "List of targets to be skipped. Empty list skips all dependencies", |
|||
"items": { |
|||
"type": "string", |
|||
"enum": [ |
|||
"CiAzureLinux", |
|||
"CiAzureOSX", |
|||
"CiAzureWindows", |
|||
"Clean", |
|||
"Compile", |
|||
"CompileHtmlPreviewer", |
|||
"CompileNative", |
|||
"CreateIntermediateNugetPackages", |
|||
"CreateNugetPackages", |
|||
"GenerateCppHeaders", |
|||
"Package", |
|||
"RunCoreLibsTests", |
|||
"RunDesignerTests", |
|||
"RunHtmlPreviewerTests", |
|||
"RunLeakTests", |
|||
"RunRenderTests", |
|||
"RunTests", |
|||
"ZipFiles" |
|||
] |
|||
} |
|||
}, |
|||
"SkipPreviewer": { |
|||
"type": "boolean", |
|||
"description": "skip-previewer" |
|||
}, |
|||
"SkipTests": { |
|||
"type": "boolean", |
|||
"description": "skip-tests" |
|||
}, |
|||
"Solution": { |
|||
"type": "string", |
|||
"description": "Path to a solution file that is automatically loaded. Default is Avalonia.sln" |
|||
}, |
|||
"Target": { |
|||
"type": "array", |
|||
"description": "List of targets to be invoked. Default is '{default_target}'", |
|||
"items": { |
|||
"type": "string", |
|||
"enum": [ |
|||
"CiAzureLinux", |
|||
"CiAzureOSX", |
|||
"CiAzureWindows", |
|||
"Clean", |
|||
"Compile", |
|||
"CompileHtmlPreviewer", |
|||
"CompileNative", |
|||
"CreateIntermediateNugetPackages", |
|||
"CreateNugetPackages", |
|||
"GenerateCppHeaders", |
|||
"Package", |
|||
"RunCoreLibsTests", |
|||
"RunDesignerTests", |
|||
"RunHtmlPreviewerTests", |
|||
"RunLeakTests", |
|||
"RunRenderTests", |
|||
"RunTests", |
|||
"ZipFiles" |
|||
] |
|||
} |
|||
}, |
|||
"Verbosity": { |
|||
"type": "string", |
|||
"description": "Logging verbosity during build execution. Default is 'Normal'", |
|||
"enum": [ |
|||
"Minimal", |
|||
"Normal", |
|||
"Quiet", |
|||
"Verbose" |
|||
] |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,4 @@ |
|||
{ |
|||
"$schema": "./build.schema.json", |
|||
"Solution": "" |
|||
} |
|||
@ -0,0 +1,7 @@ |
|||
:; set -eo pipefail |
|||
:; SCRIPT_DIR=$(cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd) |
|||
:; ${SCRIPT_DIR}/build.sh "$@" |
|||
:; exit $? |
|||
|
|||
@ECHO OFF |
|||
powershell -ExecutionPolicy ByPass -NoProfile -File "%~dp0build.ps1" %* |
|||
@ -1,14 +0,0 @@ |
|||
using System.IO; |
|||
using MicroCom.CodeGenerator; |
|||
using Nuke.Common; |
|||
|
|||
partial class Build : NukeBuild |
|||
{ |
|||
Target GenerateCppHeaders => _ => _.Executes(() => |
|||
{ |
|||
var file = MicroComCodeGenerator.Parse( |
|||
File.ReadAllText(RootDirectory / "src" / "Avalonia.Native" / "avn.idl")); |
|||
File.WriteAllText(RootDirectory / "native" / "Avalonia.Native" / "inc" / "avalonia-native.h", |
|||
file.GenerateCppHeader()); |
|||
}); |
|||
} |
|||
@ -1,41 +1,48 @@ |
|||
<Project Sdk="Microsoft.NET.Sdk"> |
|||
|
|||
<PropertyGroup> |
|||
<OutputType>Exe</OutputType> |
|||
<TargetFramework>netcoreapp3.1</TargetFramework> |
|||
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath> |
|||
<RootNamespace></RootNamespace> |
|||
<IsPackable>False</IsPackable> |
|||
<NoWarn>CS0649;CS0169</NoWarn> |
|||
<NoWarn>CS0649;CS0169;SYSLIB0011</NoWarn> |
|||
<NukeTelemetryVersion>1</NukeTelemetryVersion> |
|||
<TargetFramework>net7.0</TargetFramework> |
|||
</PropertyGroup> |
|||
|
|||
<Import Project="..\build\JetBrains.dotMemoryUnit.props" /> |
|||
<ItemGroup> |
|||
<PackageReference Include="Nuke.Common" Version="5.0.0" /> |
|||
<PackageReference Include="xunit.runner.console" Version="2.3.1" /> |
|||
<PackageReference Include="Nuke.Common" Version="6.2.1" /> |
|||
<PackageReference Include="vswhere" Version="2.6.7" Condition=" '$(OS)' == 'Windows_NT' " /> |
|||
<PackageReference Include="ILRepack.NETStandard" Version="2.0.4" /> |
|||
<PackageReference Include="MicroCom.CodeGenerator" Version="0.10.4" /> |
|||
<!-- Keep in sync with Avalonia.Build.Tasks --> |
|||
<PackageReference Include="Mono.Cecil" Version="0.11.2" /> |
|||
<PackageReference Include="Mono.Cecil" Version="0.11.4" /> |
|||
<PackageReference Include="SourceLink" Version="1.1.0" GeneratePathProperty="true" /> |
|||
<PackageReference Include="Microsoft.Build.Framework" Version="17.3.1" PrivateAssets="All" /> |
|||
<PackageReference Include="xunit.runner.console" Version="2.4.2"> |
|||
<PrivateAssets>all</PrivateAssets> |
|||
<IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets> |
|||
</PackageReference> |
|||
</ItemGroup> |
|||
|
|||
<ItemGroup> |
|||
<NukeMetadata Include="**\*.json" Exclude="bin\**;obj\**" /> |
|||
<NukeExternalFiles Include="**\*.*.ext" Exclude="bin\**;obj\**" /> |
|||
<None Remove="*.csproj.DotSettings;*.ref.*.txt" /> |
|||
|
|||
<!-- Common build related files --> |
|||
<None Include="..\build.ps1" /> |
|||
<None Include="..\build.sh" /> |
|||
<None Include="..\.nuke" /> |
|||
<None Include="..\global.json" Condition="Exists('..\global.json')" /> |
|||
<None Include="..\nuget.config" Condition="Exists('..\nuget.config')" /> |
|||
<None Include="..\Jenkinsfile" Condition="Exists('..\Jenkinsfile')" /> |
|||
<None Include="..\appveyor.yml" Condition="Exists('..\appveyor.yml')" /> |
|||
<None Include="..\.travis.yml" Condition="Exists('..\.travis.yml')" /> |
|||
<None Include="..\GitVersion.yml" Condition="Exists('..\GitVersion.yml')" /> |
|||
<Compile Remove="Numerge/**/*.*" /> |
|||
<Compile Include="Numerge/Numerge/**/*.cs" /> |
|||
</ItemGroup> |
|||
|
|||
<ItemGroup> |
|||
<EmbeddedResource Include="$(NuGetPackageRoot)sourcelink/1.1.0/tools/pdbstr.exe"></EmbeddedResource> |
|||
</ItemGroup> |
|||
|
|||
<ItemGroup> |
|||
<Compile Remove="il-repack\ILRepack\Application.cs" /> |
|||
</ItemGroup> |
|||
|
|||
<ItemGroup> |
|||
<Folder Include="Numerge\Numerge.Console\" /> |
|||
</ItemGroup> |
|||
|
|||
</Project> |
|||
|
|||
@ -0,0 +1,66 @@ |
|||
<UserControl x:Class="ControlCatalog.Pages.AdornerLayerPage" |
|||
xmlns="https://github.com/avaloniaui" |
|||
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" |
|||
xmlns:d="http://schemas.microsoft.com/expression/blend/2008" |
|||
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" |
|||
d:DesignHeight="800" |
|||
d:DesignWidth="400" |
|||
mc:Ignorable="d"> |
|||
|
|||
<DockPanel> |
|||
<Grid ColumnDefinitions="Auto,*" RowDefinitions="Auto" Margin="16" DockPanel.Dock="Top"> |
|||
<TextBlock Grid.Column="0" Grid.Row="0">Rotation</TextBlock> |
|||
<Slider Name="rotation" Maximum="360" Grid.Column="1" Grid.Row="0"/> |
|||
</Grid> |
|||
|
|||
<StackPanel Orientation="Horizontal" HorizontalAlignment="Center" DockPanel.Dock="Top"> |
|||
<Button Name="AddAdorner" |
|||
Click="AddAdorner_OnClick" |
|||
Content="Add Adorner" |
|||
Margin="6" /> |
|||
<Button Name="RemoveAdorner" |
|||
Click="RemoveAdorner_OnClick" |
|||
Content="Remove Adorner" |
|||
Margin="6" /> |
|||
</StackPanel> |
|||
|
|||
<Grid ColumnDefinitions="24,Auto,24" |
|||
RowDefinitions="24,Auto,24" |
|||
HorizontalAlignment="Center" |
|||
VerticalAlignment="Center"> |
|||
<Border Background="{DynamicResource SystemAccentColor}" Grid.Column="1" Grid.Row="0"/> |
|||
<Border Background="{DynamicResource SystemAccentColor}" Grid.Column="0" Grid.Row="1"/> |
|||
<Border Background="{DynamicResource SystemAccentColor}" Grid.Column="2" Grid.Row="1"/> |
|||
<Border Background="{DynamicResource SystemAccentColor}" Grid.Column="1" Grid.Row="2"/> |
|||
|
|||
<LayoutTransformControl Name="layoutTransform" Grid.Column="1" Grid.Row="1"> |
|||
<LayoutTransformControl.LayoutTransform> |
|||
<RotateTransform Angle="{Binding #rotation.Value}"/> |
|||
</LayoutTransformControl.LayoutTransform> |
|||
|
|||
<Button Name="AdornerButton" |
|||
Content="Adorned Button" |
|||
HorizontalAlignment="Stretch" HorizontalContentAlignment="Center" |
|||
VerticalContentAlignment="Center" VerticalAlignment="Stretch" |
|||
Width="200" Height="42"> |
|||
<AdornerLayer.Adorner> |
|||
<Canvas x:Name="AdornerCanvas" |
|||
HorizontalAlignment="Stretch" |
|||
VerticalAlignment="Stretch" |
|||
Background="Cyan" |
|||
IsHitTestVisible="False" |
|||
Opacity="0.3" |
|||
IsVisible="True"> |
|||
<Line StartPoint="-10000,0" EndPoint="10000,0" Stroke="Cyan" StrokeThickness="1" /> |
|||
<Line StartPoint="-10000,42" EndPoint="10000,42" Stroke="Cyan" StrokeThickness="1" /> |
|||
<Line StartPoint="0,-10000" EndPoint="0,10000" Stroke="Cyan" StrokeThickness="1" /> |
|||
<Line StartPoint="200,-10000" EndPoint="200,10000" Stroke="Cyan" StrokeThickness="1" /> |
|||
</Canvas> |
|||
</AdornerLayer.Adorner> |
|||
</Button> |
|||
|
|||
</LayoutTransformControl> |
|||
</Grid> |
|||
</DockPanel> |
|||
|
|||
</UserControl> |
|||
@ -0,0 +1,48 @@ |
|||
using Avalonia.Controls; |
|||
using Avalonia.Controls.Primitives; |
|||
using Avalonia.Interactivity; |
|||
using Avalonia.Markup.Xaml; |
|||
|
|||
namespace ControlCatalog.Pages |
|||
{ |
|||
public class AdornerLayerPage : UserControl |
|||
{ |
|||
private Control? _adorner; |
|||
|
|||
public AdornerLayerPage() |
|||
{ |
|||
this.InitializeComponent(); |
|||
} |
|||
|
|||
private void InitializeComponent() |
|||
{ |
|||
AvaloniaXamlLoader.Load(this); |
|||
} |
|||
|
|||
private void RemoveAdorner_OnClick(object? sender, RoutedEventArgs e) |
|||
{ |
|||
var adornerButton = this.FindControl<Button>("AdornerButton"); |
|||
if (adornerButton is { }) |
|||
{ |
|||
var adorner = AdornerLayer.GetAdorner(adornerButton); |
|||
if (adorner is { }) |
|||
{ |
|||
_adorner = adorner; |
|||
} |
|||
AdornerLayer.SetAdorner(adornerButton, null); |
|||
} |
|||
} |
|||
|
|||
private void AddAdorner_OnClick(object? sender, RoutedEventArgs e) |
|||
{ |
|||
var adornerButton = this.FindControl<Button>("AdornerButton"); |
|||
if (adornerButton is { }) |
|||
{ |
|||
if (_adorner is { }) |
|||
{ |
|||
AdornerLayer.SetAdorner(adornerButton, _adorner); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -1,5 +1,4 @@ |
|||
<Window xmlns="https://github.com/avaloniaui" |
|||
xmlns:x='http://schemas.microsoft.com/winfx/2006/xaml' |
|||
x:Class="Sandbox.MainWindow"> |
|||
<TextBox /> |
|||
</Window> |
|||
|
|||
@ -0,0 +1,359 @@ |
|||
using Avalonia.Media; |
|||
using Avalonia.Utilities; |
|||
|
|||
namespace Avalonia.Controls |
|||
{ |
|||
/// <summary>
|
|||
/// Implements a reduced version of the 2014 Material Design color palette.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// This palette is based on the one outlined here:
|
|||
///
|
|||
/// https://material.io/design/color/the-color-system.html#tools-for-picking-colors
|
|||
///
|
|||
/// In order to make the palette uniform and rectangular the following
|
|||
/// alterations were made:
|
|||
///
|
|||
/// 1. The A100-A700 shades of each color are excluded.
|
|||
/// These shades do not exist for all colors (brown/gray).
|
|||
/// 2. Black/White are stand-alone and are also excluded.
|
|||
///
|
|||
/// </remarks>
|
|||
public class MaterialColorPalette : IColorPalette |
|||
{ |
|||
// See: https://material.io/design/color/the-color-system.html#tools-for-picking-colors
|
|||
// This is a reduced palette for uniformity
|
|||
private static Color[,]? _colorChart = null; |
|||
private static int _colorChartColorCount = 0; |
|||
private static int _colorChartShadeCount = 0; |
|||
private static object _colorChartMutex = new object(); |
|||
|
|||
/// <summary>
|
|||
/// Initializes all color chart colors.
|
|||
/// </summary>
|
|||
/// <remarks>
|
|||
/// This is pulled out separately to lazy load for performance.
|
|||
/// If no material color palette is ever used, no colors will be created.
|
|||
/// </remarks>
|
|||
private void InitColorChart() |
|||
{ |
|||
lock (_colorChartMutex) |
|||
{ |
|||
_colorChart = new Color[,] |
|||
{ |
|||
// Red
|
|||
{ |
|||
Color.FromArgb(0xFF, 0xFF, 0xEB, 0xEE), |
|||
Color.FromArgb(0xFF, 0xFF, 0xCD, 0xD2), |
|||
Color.FromArgb(0xFF, 0xEF, 0x9A, 0x9A), |
|||
Color.FromArgb(0xFF, 0xE5, 0x73, 0x73), |
|||
Color.FromArgb(0xFF, 0xEF, 0x53, 0x50), |
|||
Color.FromArgb(0xFF, 0xF4, 0x43, 0x36), |
|||
Color.FromArgb(0xFF, 0xE5, 0x39, 0x35), |
|||
Color.FromArgb(0xFF, 0xD3, 0x2F, 0x2F), |
|||
Color.FromArgb(0xFF, 0xC6, 0x28, 0x28), |
|||
Color.FromArgb(0xFF, 0xB7, 0x1C, 0x1C), |
|||
}, |
|||
|
|||
// Pink
|
|||
{ |
|||
Color.FromArgb(0xFF, 0xFC, 0xE4, 0xEC), |
|||
Color.FromArgb(0xFF, 0xF8, 0xBB, 0xD0), |
|||
Color.FromArgb(0xFF, 0xF4, 0x8F, 0xB1), |
|||
Color.FromArgb(0xFF, 0xF0, 0x62, 0x92), |
|||
Color.FromArgb(0xFF, 0xEC, 0x40, 0x7A), |
|||
Color.FromArgb(0xFF, 0xE9, 0x1E, 0x63), |
|||
Color.FromArgb(0xFF, 0xD8, 0x1B, 0x60), |
|||
Color.FromArgb(0xFF, 0xC2, 0x18, 0x5B), |
|||
Color.FromArgb(0xFF, 0xAD, 0x14, 0x57), |
|||
Color.FromArgb(0xFF, 0x88, 0x0E, 0x4F), |
|||
}, |
|||
|
|||
// Purple
|
|||
{ |
|||
Color.FromArgb(0xFF, 0xF3, 0xE5, 0xF5), |
|||
Color.FromArgb(0xFF, 0xE1, 0xBE, 0xE7), |
|||
Color.FromArgb(0xFF, 0xCE, 0x93, 0xD8), |
|||
Color.FromArgb(0xFF, 0xBA, 0x68, 0xC8), |
|||
Color.FromArgb(0xFF, 0xAB, 0x47, 0xBC), |
|||
Color.FromArgb(0xFF, 0x9C, 0x27, 0xB0), |
|||
Color.FromArgb(0xFF, 0x8E, 0x24, 0xAA), |
|||
Color.FromArgb(0xFF, 0x7B, 0x1F, 0xA2), |
|||
Color.FromArgb(0xFF, 0x6A, 0x1B, 0x9A), |
|||
Color.FromArgb(0xFF, 0x4A, 0x14, 0x8C), |
|||
}, |
|||
|
|||
// Deep Purple
|
|||
{ |
|||
Color.FromArgb(0xFF, 0xED, 0xE7, 0xF6), |
|||
Color.FromArgb(0xFF, 0xD1, 0xC4, 0xE9), |
|||
Color.FromArgb(0xFF, 0xB3, 0x9D, 0xDB), |
|||
Color.FromArgb(0xFF, 0x95, 0x75, 0xCD), |
|||
Color.FromArgb(0xFF, 0x7E, 0x57, 0xC2), |
|||
Color.FromArgb(0xFF, 0x67, 0x3A, 0xB7), |
|||
Color.FromArgb(0xFF, 0x5E, 0x35, 0xB1), |
|||
Color.FromArgb(0xFF, 0x51, 0x2D, 0xA8), |
|||
Color.FromArgb(0xFF, 0x45, 0x27, 0xA0), |
|||
Color.FromArgb(0xFF, 0x31, 0x1B, 0x92), |
|||
}, |
|||
|
|||
// Indigo
|
|||
{ |
|||
Color.FromArgb(0xFF, 0xE8, 0xEA, 0xF6), |
|||
Color.FromArgb(0xFF, 0xC5, 0xCA, 0xE9), |
|||
Color.FromArgb(0xFF, 0x9F, 0xA8, 0xDA), |
|||
Color.FromArgb(0xFF, 0x79, 0x86, 0xCB), |
|||
Color.FromArgb(0xFF, 0x5C, 0x6B, 0xC0), |
|||
Color.FromArgb(0xFF, 0x3F, 0x51, 0xB5), |
|||
Color.FromArgb(0xFF, 0x39, 0x49, 0xAB), |
|||
Color.FromArgb(0xFF, 0x30, 0x3F, 0x9F), |
|||
Color.FromArgb(0xFF, 0x28, 0x35, 0x93), |
|||
Color.FromArgb(0xFF, 0x1A, 0x23, 0x7E), |
|||
}, |
|||
|
|||
// Blue
|
|||
{ |
|||
Color.FromArgb(0xFF, 0xE3, 0xF2, 0xFD), |
|||
Color.FromArgb(0xFF, 0xBB, 0xDE, 0xFB), |
|||
Color.FromArgb(0xFF, 0x90, 0xCA, 0xF9), |
|||
Color.FromArgb(0xFF, 0x64, 0xB5, 0xF6), |
|||
Color.FromArgb(0xFF, 0x42, 0xA5, 0xF5), |
|||
Color.FromArgb(0xFF, 0x21, 0x96, 0xF3), |
|||
Color.FromArgb(0xFF, 0x1E, 0x88, 0xE5), |
|||
Color.FromArgb(0xFF, 0x19, 0x76, 0xD2), |
|||
Color.FromArgb(0xFF, 0x15, 0x65, 0xC0), |
|||
Color.FromArgb(0xFF, 0x0D, 0x47, 0xA1), |
|||
}, |
|||
|
|||
// Light Blue
|
|||
{ |
|||
Color.FromArgb(0xFF, 0xE1, 0xF5, 0xFE), |
|||
Color.FromArgb(0xFF, 0xB3, 0xE5, 0xFC), |
|||
Color.FromArgb(0xFF, 0x81, 0xD4, 0xFA), |
|||
Color.FromArgb(0xFF, 0x4F, 0xC3, 0xF7), |
|||
Color.FromArgb(0xFF, 0x29, 0xB6, 0xF6), |
|||
Color.FromArgb(0xFF, 0x03, 0xA9, 0xF4), |
|||
Color.FromArgb(0xFF, 0x03, 0x9B, 0xE5), |
|||
Color.FromArgb(0xFF, 0x02, 0x88, 0xD1), |
|||
Color.FromArgb(0xFF, 0x02, 0x77, 0xBD), |
|||
Color.FromArgb(0xFF, 0x01, 0x57, 0x9B), |
|||
}, |
|||
|
|||
// Cyan
|
|||
{ |
|||
Color.FromArgb(0xFF, 0xE0, 0xF7, 0xFA), |
|||
Color.FromArgb(0xFF, 0xB2, 0xEB, 0xF2), |
|||
Color.FromArgb(0xFF, 0x80, 0xDE, 0xEA), |
|||
Color.FromArgb(0xFF, 0x4D, 0xD0, 0xE1), |
|||
Color.FromArgb(0xFF, 0x26, 0xC6, 0xDA), |
|||
Color.FromArgb(0xFF, 0x00, 0xBC, 0xD4), |
|||
Color.FromArgb(0xFF, 0x00, 0xAC, 0xC1), |
|||
Color.FromArgb(0xFF, 0x00, 0x97, 0xA7), |
|||
Color.FromArgb(0xFF, 0x00, 0x83, 0x8F), |
|||
Color.FromArgb(0xFF, 0x00, 0x60, 0x64), |
|||
}, |
|||
|
|||
// Teal
|
|||
{ |
|||
Color.FromArgb(0xFF, 0xE0, 0xF2, 0xF1), |
|||
Color.FromArgb(0xFF, 0xB2, 0xDF, 0xDB), |
|||
Color.FromArgb(0xFF, 0x80, 0xCB, 0xC4), |
|||
Color.FromArgb(0xFF, 0x4D, 0xB6, 0xAC), |
|||
Color.FromArgb(0xFF, 0x26, 0xA6, 0x9A), |
|||
Color.FromArgb(0xFF, 0x00, 0x96, 0x88), |
|||
Color.FromArgb(0xFF, 0x00, 0x89, 0x7B), |
|||
Color.FromArgb(0xFF, 0x00, 0x79, 0x6B), |
|||
Color.FromArgb(0xFF, 0x00, 0x69, 0x5C), |
|||
Color.FromArgb(0xFF, 0x00, 0x4D, 0x40), |
|||
}, |
|||
|
|||
// Green
|
|||
{ |
|||
Color.FromArgb(0xFF, 0xE8, 0xF5, 0xE9), |
|||
Color.FromArgb(0xFF, 0xC8, 0xE6, 0xC9), |
|||
Color.FromArgb(0xFF, 0xA5, 0xD6, 0xA7), |
|||
Color.FromArgb(0xFF, 0x81, 0xC7, 0x84), |
|||
Color.FromArgb(0xFF, 0x66, 0xBB, 0x6A), |
|||
Color.FromArgb(0xFF, 0x4C, 0xAF, 0x50), |
|||
Color.FromArgb(0xFF, 0x43, 0xA0, 0x47), |
|||
Color.FromArgb(0xFF, 0x38, 0x8E, 0x3C), |
|||
Color.FromArgb(0xFF, 0x2E, 0x7D, 0x32), |
|||
Color.FromArgb(0xFF, 0x1B, 0x5E, 0x20), |
|||
}, |
|||
|
|||
// Light Green
|
|||
{ |
|||
Color.FromArgb(0xFF, 0xF1, 0xF8, 0xE9), |
|||
Color.FromArgb(0xFF, 0xDC, 0xED, 0xC8), |
|||
Color.FromArgb(0xFF, 0xC5, 0xE1, 0xA5), |
|||
Color.FromArgb(0xFF, 0xAE, 0xD5, 0x81), |
|||
Color.FromArgb(0xFF, 0x9C, 0xCC, 0x65), |
|||
Color.FromArgb(0xFF, 0x8B, 0xC3, 0x4A), |
|||
Color.FromArgb(0xFF, 0x7C, 0xB3, 0x42), |
|||
Color.FromArgb(0xFF, 0x68, 0x9F, 0x38), |
|||
Color.FromArgb(0xFF, 0x55, 0x8B, 0x2F), |
|||
Color.FromArgb(0xFF, 0x33, 0x69, 0x1E), |
|||
}, |
|||
|
|||
// Lime
|
|||
{ |
|||
Color.FromArgb(0xFF, 0xF9, 0xFB, 0xE7), |
|||
Color.FromArgb(0xFF, 0xF0, 0xF4, 0xC3), |
|||
Color.FromArgb(0xFF, 0xE6, 0xEE, 0x9C), |
|||
Color.FromArgb(0xFF, 0xDC, 0xE7, 0x75), |
|||
Color.FromArgb(0xFF, 0xD4, 0xE1, 0x57), |
|||
Color.FromArgb(0xFF, 0xCD, 0xDC, 0x39), |
|||
Color.FromArgb(0xFF, 0xC0, 0xCA, 0x33), |
|||
Color.FromArgb(0xFF, 0xAF, 0xB4, 0x2B), |
|||
Color.FromArgb(0xFF, 0x9E, 0x9D, 0x24), |
|||
Color.FromArgb(0xFF, 0x82, 0x77, 0x17), |
|||
}, |
|||
|
|||
// Yellow
|
|||
{ |
|||
Color.FromArgb(0xFF, 0xFF, 0xFD, 0xE7), |
|||
Color.FromArgb(0xFF, 0xFF, 0xF9, 0xC4), |
|||
Color.FromArgb(0xFF, 0xFF, 0xF5, 0x9D), |
|||
Color.FromArgb(0xFF, 0xFF, 0xF1, 0x76), |
|||
Color.FromArgb(0xFF, 0xFF, 0xEE, 0x58), |
|||
Color.FromArgb(0xFF, 0xFF, 0xEB, 0x3B), |
|||
Color.FromArgb(0xFF, 0xFD, 0xD8, 0x35), |
|||
Color.FromArgb(0xFF, 0xFB, 0xC0, 0x2D), |
|||
Color.FromArgb(0xFF, 0xF9, 0xA8, 0x25), |
|||
Color.FromArgb(0xFF, 0xF5, 0x7F, 0x17), |
|||
}, |
|||
|
|||
// Amber
|
|||
{ |
|||
Color.FromArgb(0xFF, 0xFF, 0xF8, 0xE1), |
|||
Color.FromArgb(0xFF, 0xFF, 0xEC, 0xB3), |
|||
Color.FromArgb(0xFF, 0xFF, 0xE0, 0x82), |
|||
Color.FromArgb(0xFF, 0xFF, 0xD5, 0x4F), |
|||
Color.FromArgb(0xFF, 0xFF, 0xCA, 0x28), |
|||
Color.FromArgb(0xFF, 0xFF, 0xC1, 0x07), |
|||
Color.FromArgb(0xFF, 0xFF, 0xB3, 0x00), |
|||
Color.FromArgb(0xFF, 0xFF, 0xA0, 0x00), |
|||
Color.FromArgb(0xFF, 0xFF, 0x8F, 0x00), |
|||
Color.FromArgb(0xFF, 0xFF, 0x6F, 0x00), |
|||
}, |
|||
|
|||
// Orange
|
|||
{ |
|||
Color.FromArgb(0xFF, 0xFF, 0xF3, 0xE0), |
|||
Color.FromArgb(0xFF, 0xFF, 0xE0, 0xB2), |
|||
Color.FromArgb(0xFF, 0xFF, 0xCC, 0x80), |
|||
Color.FromArgb(0xFF, 0xFF, 0xB7, 0x4D), |
|||
Color.FromArgb(0xFF, 0xFF, 0xA7, 0x26), |
|||
Color.FromArgb(0xFF, 0xFF, 0x98, 0x00), |
|||
Color.FromArgb(0xFF, 0xFB, 0x8C, 0x00), |
|||
Color.FromArgb(0xFF, 0xF5, 0x7C, 0x00), |
|||
Color.FromArgb(0xFF, 0xEF, 0x6C, 0x00), |
|||
Color.FromArgb(0xFF, 0xE6, 0x51, 0x00), |
|||
}, |
|||
|
|||
// Deep Orange
|
|||
{ |
|||
Color.FromArgb(0xFF, 0xFB, 0xE9, 0xE7), |
|||
Color.FromArgb(0xFF, 0xFF, 0xCC, 0xBC), |
|||
Color.FromArgb(0xFF, 0xFF, 0xAB, 0x91), |
|||
Color.FromArgb(0xFF, 0xFF, 0x8A, 0x65), |
|||
Color.FromArgb(0xFF, 0xFF, 0x70, 0x43), |
|||
Color.FromArgb(0xFF, 0xFF, 0x57, 0x22), |
|||
Color.FromArgb(0xFF, 0xF4, 0x51, 0x1E), |
|||
Color.FromArgb(0xFF, 0xE6, 0x4A, 0x19), |
|||
Color.FromArgb(0xFF, 0xD8, 0x43, 0x15), |
|||
Color.FromArgb(0xFF, 0xBF, 0x36, 0x0C), |
|||
}, |
|||
|
|||
// Brown
|
|||
{ |
|||
Color.FromArgb(0xFF, 0xEF, 0xEB, 0xE9), |
|||
Color.FromArgb(0xFF, 0xD7, 0xCC, 0xC8), |
|||
Color.FromArgb(0xFF, 0xBC, 0xAA, 0xA4), |
|||
Color.FromArgb(0xFF, 0xA1, 0x88, 0x7F), |
|||
Color.FromArgb(0xFF, 0x8D, 0x6E, 0x63), |
|||
Color.FromArgb(0xFF, 0x79, 0x55, 0x48), |
|||
Color.FromArgb(0xFF, 0x6D, 0x4C, 0x41), |
|||
Color.FromArgb(0xFF, 0x5D, 0x40, 0x37), |
|||
Color.FromArgb(0xFF, 0x4E, 0x34, 0x2E), |
|||
Color.FromArgb(0xFF, 0x3E, 0x27, 0x23), |
|||
}, |
|||
|
|||
// Gray
|
|||
{ |
|||
Color.FromArgb(0xFF, 0xFA, 0xFA, 0xFA), |
|||
Color.FromArgb(0xFF, 0xF5, 0xF5, 0xF5), |
|||
Color.FromArgb(0xFF, 0xEE, 0xEE, 0xEE), |
|||
Color.FromArgb(0xFF, 0xE0, 0xE0, 0xE0), |
|||
Color.FromArgb(0xFF, 0xBD, 0xBD, 0xBD), |
|||
Color.FromArgb(0xFF, 0x9E, 0x9E, 0x9E), |
|||
Color.FromArgb(0xFF, 0x75, 0x75, 0x75), |
|||
Color.FromArgb(0xFF, 0x61, 0x61, 0x61), |
|||
Color.FromArgb(0xFF, 0x42, 0x42, 0x42), |
|||
Color.FromArgb(0xFF, 0x21, 0x21, 0x21), |
|||
}, |
|||
|
|||
// Blue Gray
|
|||
{ |
|||
Color.FromArgb(0xFF, 0xEC, 0xEF, 0xF1), |
|||
Color.FromArgb(0xFF, 0xCF, 0xD8, 0xDC), |
|||
Color.FromArgb(0xFF, 0xB0, 0xBE, 0xC5), |
|||
Color.FromArgb(0xFF, 0x90, 0xA4, 0xAE), |
|||
Color.FromArgb(0xFF, 0x78, 0x90, 0x9C), |
|||
Color.FromArgb(0xFF, 0x60, 0x7D, 0x8B), |
|||
Color.FromArgb(0xFF, 0x54, 0x6E, 0x7A), |
|||
Color.FromArgb(0xFF, 0x45, 0x5A, 0x64), |
|||
Color.FromArgb(0xFF, 0x37, 0x47, 0x4F), |
|||
Color.FromArgb(0xFF, 0x26, 0x32, 0x38), |
|||
}, |
|||
}; |
|||
|
|||
_colorChartColorCount = _colorChart.GetLength(0); |
|||
_colorChartShadeCount = _colorChart.GetLength(1); |
|||
} |
|||
|
|||
return; |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public int ColorCount |
|||
{ |
|||
get |
|||
{ |
|||
if (_colorChart == null) |
|||
{ |
|||
InitColorChart(); |
|||
} |
|||
|
|||
return _colorChartColorCount; |
|||
} |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public int ShadeCount |
|||
{ |
|||
get |
|||
{ |
|||
if (_colorChart == null) |
|||
{ |
|||
InitColorChart(); |
|||
} |
|||
|
|||
return _colorChartShadeCount; |
|||
} |
|||
} |
|||
|
|||
/// <inheritdoc/>
|
|||
public Color GetColor(int colorIndex, int shadeIndex) |
|||
{ |
|||
if (_colorChart == null) |
|||
{ |
|||
InitColorChart(); |
|||
} |
|||
|
|||
return _colorChart![ |
|||
MathUtilities.Clamp(colorIndex, 0, _colorChartColorCount - 1), |
|||
MathUtilities.Clamp(shadeIndex, 0, _colorChartShadeCount - 1)]; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,41 @@ |
|||
<Project Sdk="Microsoft.NET.Sdk"> |
|||
<PropertyGroup> |
|||
<TargetFramework>net7.0</TargetFramework> |
|||
<RuntimeIdentifier>browser-wasm</RuntimeIdentifier> |
|||
<WasmMainJSPath>main.js</WasmMainJSPath> |
|||
<OutputType>Exe</OutputType> |
|||
<AllowUnsafeBlocks>true</AllowUnsafeBlocks> |
|||
<MSBuildEnableWorkloadResolver>true</MSBuildEnableWorkloadResolver> |
|||
<WasmBuildNative>true</WasmBuildNative> |
|||
<EmccFlags>-sVERBOSE -sERROR_ON_UNDEFINED_SYMBOLS=0</EmccFlags> |
|||
</PropertyGroup> |
|||
|
|||
<PropertyGroup Condition="'$(Configuration)'=='Release'"> |
|||
<RunAOTCompilation>true</RunAOTCompilation> |
|||
<PublishTrimmed>true</PublishTrimmed> |
|||
<TrimMode>full</TrimMode> |
|||
<WasmBuildNative>true</WasmBuildNative> |
|||
<InvariantGlobalization>true</InvariantGlobalization> |
|||
<WasmEnableSIMD>true</WasmEnableSIMD> |
|||
<EmccCompileOptimizationFlag>-O3</EmccCompileOptimizationFlag> |
|||
<EmccLinkOptimizationFlag>-O3</EmccLinkOptimizationFlag> |
|||
</PropertyGroup> |
|||
|
|||
<ItemGroup> |
|||
<ProjectReference Include="..\..\..\samples\ControlCatalog\ControlCatalog.csproj" /> |
|||
<ProjectReference Include="..\Avalonia.Web\Avalonia.Web.csproj" /> |
|||
<ProjectReference Include="..\..\..\src\Skia\Avalonia.Skia\Avalonia.Skia.csproj" /> |
|||
</ItemGroup> |
|||
|
|||
<ItemGroup> |
|||
<WasmExtraFilesToDeploy Include="index.html" /> |
|||
<WasmExtraFilesToDeploy Include="main.js" /> |
|||
<WasmExtraFilesToDeploy Include="embed.js" /> |
|||
<WasmExtraFilesToDeploy Include="favicon.ico" /> |
|||
<WasmExtraFilesToDeploy Include="Logo.svg" /> |
|||
<WasmExtraFilesToDeploy Include="app.css" /> |
|||
</ItemGroup> |
|||
|
|||
<Import Project="..\Avalonia.Web\Avalonia.Web.props" /> |
|||
<Import Project="..\Avalonia.Web\Avalonia.Web.targets" /> |
|||
</Project> |
|||
@ -0,0 +1,44 @@ |
|||
using System; |
|||
using System.Runtime.InteropServices.JavaScript; |
|||
|
|||
using Avalonia; |
|||
using Avalonia.Platform; |
|||
using Avalonia.Web; |
|||
|
|||
using ControlCatalog.Pages; |
|||
|
|||
namespace ControlCatalog.Web; |
|||
|
|||
public class EmbedSampleWeb : INativeDemoControl |
|||
{ |
|||
public IPlatformHandle CreateControl(bool isSecond, IPlatformHandle parent, Func<IPlatformHandle> createDefault) |
|||
{ |
|||
if (isSecond) |
|||
{ |
|||
var iframe = EmbedInterop.CreateElement("iframe"); |
|||
iframe.SetProperty("src", "https://www.youtube.com/embed/kZCIporjJ70"); |
|||
|
|||
return new JSObjectControlHandle(iframe); |
|||
} |
|||
else |
|||
{ |
|||
var defaultHandle = (JSObjectControlHandle)createDefault(); |
|||
|
|||
_ = JSHost.ImportAsync("embed.js", "./embed.js").ContinueWith(_ => |
|||
{ |
|||
EmbedInterop.AddAppButton(defaultHandle.Object); |
|||
}); |
|||
|
|||
return defaultHandle; |
|||
} |
|||
} |
|||
} |
|||
|
|||
internal static partial class EmbedInterop |
|||
{ |
|||
[JSImport("globalThis.document.createElement")] |
|||
public static partial JSObject CreateElement(string tagName); |
|||
|
|||
[JSImport("addAppButton", "embed.js")] |
|||
public static partial void AddAppButton(JSObject parentObject); |
|||
} |
|||
|
After Width: | Height: | Size: 1.2 KiB |
@ -0,0 +1,19 @@ |
|||
using Avalonia; |
|||
using Avalonia.Web; |
|||
using ControlCatalog; |
|||
using ControlCatalog.Web; |
|||
|
|||
internal partial class Program |
|||
{ |
|||
private static void Main(string[] args) |
|||
{ |
|||
BuildAvaloniaApp() |
|||
.AfterSetup(_ => |
|||
{ |
|||
ControlCatalog.Pages.EmbedSample.Implementation = new EmbedSampleWeb(); |
|||
}).SetupBrowserApp("out"); |
|||
} |
|||
|
|||
public static AppBuilder BuildAvaloniaApp() |
|||
=> AppBuilder.Configure<App>(); |
|||
} |
|||
@ -0,0 +1,38 @@ |
|||
#out { |
|||
height: 100vh; |
|||
width: 100vw |
|||
} |
|||
|
|||
#avalonia-splash { |
|||
position: absolute; |
|||
height: 100%; |
|||
width: 100%; |
|||
color: whitesmoke; |
|||
background: #171C2C; |
|||
font-family: 'Nunito', sans-serif; |
|||
} |
|||
|
|||
#avalonia-splash a{ |
|||
color: whitesmoke; |
|||
text-decoration: none; |
|||
} |
|||
|
|||
.center { |
|||
display: flex; |
|||
justify-content: center; |
|||
height: 250px; |
|||
} |
|||
|
|||
.splash-close { |
|||
animation: fadeOut 1s forwards; |
|||
} |
|||
|
|||
@keyframes fadeOut { |
|||
from { |
|||
opacity: 1; |
|||
} |
|||
|
|||
to { |
|||
opacity: 0; |
|||
} |
|||
} |
|||
@ -0,0 +1,11 @@ |
|||
export function addAppButton(parent) { |
|||
var button = globalThis.document.createElement('button'); |
|||
button.innerText = 'Hello world'; |
|||
var clickCount = 0; |
|||
button.onclick = () => { |
|||
clickCount++; |
|||
button.innerText = 'Click count ' + clickCount; |
|||
}; |
|||
parent.appendChild(button); |
|||
return button; |
|||
} |
|||
|
After Width: | Height: | Size: 172 KiB |
@ -0,0 +1,31 @@ |
|||
<!DOCTYPE html> |
|||
<!-- Licensed to the .NET Foundation under one or more agreements. --> |
|||
<!-- The .NET Foundation licenses this file to you under the MIT license. --> |
|||
<html> |
|||
|
|||
<head> |
|||
<title>Avalonia.Web.Sample</title> |
|||
<meta charset="UTF-8"> |
|||
<meta name="viewport" content="width=device-width, initial-scale=1.0"> |
|||
<link rel="modulepreload" href="./main.js" /> |
|||
<link rel="modulepreload" href="./dotnet.js" /> |
|||
<link rel="modulepreload" href="./avalonia.js" /> |
|||
<link rel="stylesheet" href="./app.css" /> |
|||
</head> |
|||
|
|||
<body style="margin: 0px"> |
|||
<div id="out"> |
|||
<div id="avalonia-splash"> |
|||
<div class="center"> |
|||
<h2>Powered by</h2> |
|||
<a class="navbar-brand" href="https://www.avaloniaui.net/" target="_blank"> |
|||
<img src="Logo.svg" alt="Avalonia Logo" width="30" height="24" /> |
|||
Avalonia |
|||
</a> |
|||
</div> |
|||
</div> |
|||
</div> |
|||
<script type='module' src="./main.js"></script> |
|||
</body> |
|||
|
|||
</html> |
|||
@ -0,0 +1,19 @@ |
|||
// Licensed to the .NET Foundation under one or more agreements.
|
|||
// The .NET Foundation licenses this file to you under the MIT license.
|
|||
|
|||
import { dotnet } from './dotnet.js' |
|||
import { createAvaloniaRuntime } from './avalonia.js'; |
|||
|
|||
const is_browser = typeof window != "undefined"; |
|||
if (!is_browser) throw new Error(`Expected to be running in a browser`); |
|||
|
|||
const dotnetRuntime = await dotnet |
|||
.withDiagnosticTracing(false) |
|||
.withApplicationArgumentsFromQuery() |
|||
.create(); |
|||
|
|||
await createAvaloniaRuntime(dotnetRuntime); |
|||
|
|||
const config = dotnetRuntime.getConfig(); |
|||
|
|||
await dotnetRuntime.runMainAndExit(config.mainAssemblyName, ["dotnet", "is", "great!"]); |
|||
@ -0,0 +1,11 @@ |
|||
{ |
|||
"wasmHostProperties": { |
|||
"perHostConfig": [ |
|||
{ |
|||
"name": "browser", |
|||
"html-path": "index.html", |
|||
"Host": "browser" |
|||
} |
|||
] |
|||
} |
|||
} |
|||
@ -0,0 +1,55 @@ |
|||
<Project Sdk="Microsoft.NET.Sdk"> |
|||
<PropertyGroup> |
|||
<TargetFramework>net7.0</TargetFramework> |
|||
<LangVersion>preview</LangVersion> |
|||
<Nullable>enable</Nullable> |
|||
<AllowUnsafeBlocks>true</AllowUnsafeBlocks> |
|||
</PropertyGroup> |
|||
|
|||
<ItemGroup> |
|||
<SupportedPlatform Include="browser" /> |
|||
</ItemGroup> |
|||
|
|||
<Import Project="..\..\..\build\BuildTargets.targets" /> |
|||
<Import Project="..\..\..\build\SkiaSharp.props" /> |
|||
<Import Project="..\..\..\build\HarfBuzzSharp.props" /> |
|||
<Import Project="..\..\..\build\NullableEnable.props" /> |
|||
|
|||
<ItemGroup> |
|||
<ProjectReference Include="..\..\..\packages\Avalonia\Avalonia.csproj" /> |
|||
<ProjectReference Include="..\..\Skia\Avalonia.Skia\Avalonia.Skia.csproj" /> |
|||
</ItemGroup> |
|||
|
|||
<ItemGroup> |
|||
<Content Include="*.props"> |
|||
<Pack>true</Pack> |
|||
<PackagePath>build\</PackagePath> |
|||
</Content> |
|||
<Content Include="*.targets"> |
|||
<Pack>true</Pack> |
|||
<PackagePath>build\;buildTransitive\</PackagePath> |
|||
</Content> |
|||
<Content Include="interop.js"> |
|||
<Pack>true</Pack> |
|||
<PackagePath>build/interop.js;buildTransitive/interop.js</PackagePath> |
|||
</Content> |
|||
<Content Include="wwwroot/**/*.*"> |
|||
<Pack>true</Pack> |
|||
<PackagePath>build\wwwroot;buildTransitive\wwwroot</PackagePath> |
|||
</Content> |
|||
</ItemGroup> |
|||
|
|||
<ItemGroup> |
|||
<Folder Include="wwwroot\" /> |
|||
</ItemGroup> |
|||
|
|||
<Target Name="NpmInstall" Inputs="webapp/package.json" Outputs="webapp/node_modules/.install-stamp"> |
|||
<Exec Command="npm install" WorkingDirectory="webapp" /> |
|||
<!-- Write the stamp file, so incremental builds work --> |
|||
<Touch Files="webapp/node_modules/.install-stamp" AlwaysCreate="true" /> |
|||
</Target> |
|||
<Target Name="NpmRunBuild" DependsOnTargets="NpmInstall" BeforeTargets="BeforeBuild"> |
|||
<Exec Command="npm run build" WorkingDirectory="webapp" /> |
|||
</Target> |
|||
|
|||
</Project> |
|||
@ -0,0 +1,5 @@ |
|||
<Project> |
|||
<PropertyGroup> |
|||
<EmccExtraLDFlags>$(EmccExtraLDFlags) --js-library="$(MSBuildThisFileDirectory)\interop.js"</EmccExtraLDFlags> |
|||
</PropertyGroup> |
|||
</Project> |
|||
@ -0,0 +1,7 @@ |
|||
<Project> |
|||
<ItemGroup> |
|||
<WasmExtraFilesToDeploy Include="$(MSBuildThisFileDirectory)/wwwroot/**/*.*" /> |
|||
<NativeFileReference Include="$(HarfBuzzSharpStaticLibraryPath)\3.1.7\libHarfBuzzSharp.a" /> |
|||
<NativeFileReference Include="$(SkiaSharpStaticLibraryPath)\3.1.7\libSkiaSharp.a" /> |
|||
</ItemGroup> |
|||
</Project> |
|||
@ -0,0 +1,451 @@ |
|||
using System; |
|||
using System.Runtime.InteropServices.JavaScript; |
|||
using Avalonia.Controls; |
|||
using Avalonia.Controls.Embedding; |
|||
using Avalonia.Controls.Platform; |
|||
using Avalonia.Input; |
|||
using Avalonia.Input.Raw; |
|||
using Avalonia.Input.TextInput; |
|||
using Avalonia.Rendering.Composition; |
|||
using Avalonia.Threading; |
|||
using Avalonia.Web.Interop; |
|||
using Avalonia.Web.Skia; |
|||
|
|||
using SkiaSharp; |
|||
|
|||
namespace Avalonia.Web |
|||
{ |
|||
[System.Runtime.Versioning.SupportedOSPlatform("browser")] // gets rid of callsite warnings
|
|||
public partial class AvaloniaView : ITextInputMethodImpl |
|||
{ |
|||
private readonly BrowserTopLevelImpl _topLevelImpl; |
|||
private EmbeddableControlRoot _topLevel; |
|||
|
|||
private readonly JSObject _containerElement; |
|||
private readonly JSObject _canvas; |
|||
private readonly JSObject _nativeControlsContainer; |
|||
private readonly JSObject _inputElement; |
|||
private readonly JSObject? _splash; |
|||
|
|||
private GLInfo? _jsGlInfo = null; |
|||
private double _dpi = 1; |
|||
private Size _canvasSize = new(100.0, 100.0); |
|||
|
|||
private GRContext? _context; |
|||
private GRGlInterface? _glInterface; |
|||
private const SKColorType ColorType = SKColorType.Rgba8888; |
|||
|
|||
private bool _useGL; |
|||
private ITextInputMethodClient? _client; |
|||
private static int _canvasCount; |
|||
|
|||
public AvaloniaView(string divId) |
|||
{ |
|||
var host = DomHelper.GetElementById(divId); |
|||
if (host == null) |
|||
{ |
|||
throw new Exception($"Element with id {divId} was not found in the html document."); |
|||
} |
|||
|
|||
var hostContent = DomHelper.CreateAvaloniaHost(host); |
|||
if (hostContent == null) |
|||
{ |
|||
throw new InvalidOperationException("Avalonia WASM host wasn't initialized."); |
|||
} |
|||
|
|||
_containerElement = hostContent.GetPropertyAsJSObject("host") |
|||
?? throw new InvalidOperationException("Host cannot be null"); |
|||
_canvas = hostContent.GetPropertyAsJSObject("canvas") |
|||
?? throw new InvalidOperationException("Canvas cannot be null"); |
|||
_nativeControlsContainer = hostContent.GetPropertyAsJSObject("nativeHost") |
|||
?? throw new InvalidOperationException("NativeHost cannot be null"); |
|||
_inputElement = hostContent.GetPropertyAsJSObject("inputElement") |
|||
?? throw new InvalidOperationException("InputElement cannot be null"); |
|||
|
|||
_splash = DomHelper.GetElementById("avalonia-splash"); |
|||
|
|||
_canvas.SetProperty("id", $"avaloniaCanvas{_canvasCount++}"); |
|||
|
|||
_topLevelImpl = new BrowserTopLevelImpl(this); |
|||
|
|||
_topLevel = new WebEmbeddableControlRoot(_topLevelImpl, () => |
|||
{ |
|||
Dispatcher.UIThread.Post(() => |
|||
{ |
|||
if (_splash != null) |
|||
{ |
|||
DomHelper.AddCssClass(_splash, "splash-close"); |
|||
} |
|||
}); |
|||
}); |
|||
|
|||
_topLevelImpl.SetCssCursor = (cursor) => |
|||
{ |
|||
InputHelper.SetCursor(_containerElement, cursor); // macOS
|
|||
InputHelper.SetCursor(_canvas, cursor); // windows
|
|||
}; |
|||
|
|||
_topLevel.Prepare(); |
|||
|
|||
_topLevel.Renderer.Start(); |
|||
|
|||
InputHelper.SubscribeKeyEvents( |
|||
_containerElement, |
|||
OnKeyDown, |
|||
OnKeyUp); |
|||
|
|||
InputHelper.SubscribeTextEvents( |
|||
_inputElement, |
|||
OnTextInput, |
|||
OnCompositionStart, |
|||
OnCompositionUpdate, |
|||
OnCompositionEnd); |
|||
|
|||
InputHelper.SubscribePointerEvents(_containerElement, OnPointerMove, OnPointerDown, OnPointerUp, OnWheel); |
|||
|
|||
var skiaOptions = AvaloniaLocator.Current.GetService<SkiaOptions>(); |
|||
|
|||
_dpi = DomHelper.ObserveDpi(OnDpiChanged); |
|||
|
|||
_useGL = skiaOptions?.CustomGpuFactory != null; |
|||
|
|||
if (_useGL) |
|||
{ |
|||
_jsGlInfo = CanvasHelper.InitialiseGL(_canvas, OnRenderFrame); |
|||
// create the SkiaSharp context
|
|||
if (_context == null) |
|||
{ |
|||
_glInterface = GRGlInterface.Create(); |
|||
_context = GRContext.CreateGl(_glInterface); |
|||
|
|||
// bump the default resource cache limit
|
|||
_context.SetResourceCacheLimit(skiaOptions?.MaxGpuResourceSizeBytes ?? 32 * 1024 * 1024); |
|||
} |
|||
|
|||
_topLevelImpl.Surfaces = new[] { new BrowserSkiaSurface(_context, _jsGlInfo, ColorType, new PixelSize((int)_canvasSize.Width, (int)_canvasSize.Height), _dpi, GRSurfaceOrigin.BottomLeft) }; |
|||
} |
|||
else |
|||
{ |
|||
//var rasterInitialized = _interop.InitRaster();
|
|||
//Console.WriteLine("raster initialized: {0}", rasterInitialized);
|
|||
|
|||
//_topLevelImpl.SetSurface(ColorType,
|
|||
// new PixelSize((int)_canvasSize.Width, (int)_canvasSize.Height), _dpi, _interop.PutImageData);
|
|||
} |
|||
|
|||
CanvasHelper.SetCanvasSize(_canvas, (int)(_canvasSize.Width * _dpi), (int)(_canvasSize.Height * _dpi)); |
|||
|
|||
_topLevelImpl.SetClientSize(_canvasSize, _dpi); |
|||
|
|||
DomHelper.ObserveSize(host, divId, OnSizeChanged); |
|||
|
|||
CanvasHelper.RequestAnimationFrame(_canvas, true); |
|||
} |
|||
|
|||
private static RawPointerPoint ExtractRawPointerFromJSArgs(JSObject args) |
|||
{ |
|||
var point = new RawPointerPoint |
|||
{ |
|||
Position = new Point(args.GetPropertyAsDouble("offsetX"), args.GetPropertyAsDouble("offsetY")), |
|||
Pressure = (float)args.GetPropertyAsDouble("pressure"), |
|||
XTilt = (float)args.GetPropertyAsDouble("tiltX"), |
|||
YTilt = (float)args.GetPropertyAsDouble("tiltY"), |
|||
Twist = (float)args.GetPropertyAsDouble("twist") |
|||
}; |
|||
|
|||
return point; |
|||
} |
|||
|
|||
private bool OnPointerMove(JSObject args) |
|||
{ |
|||
var type = args.GetPropertyAsString("pointertype"); |
|||
|
|||
var point = ExtractRawPointerFromJSArgs(args); |
|||
|
|||
return _topLevelImpl.RawPointerEvent(RawPointerEventType.Move, type!, point, GetModifiers(args), args.GetPropertyAsInt32("pointerId")); |
|||
} |
|||
|
|||
private bool OnPointerDown(JSObject args) |
|||
{ |
|||
var pointerType = args.GetPropertyAsString("pointerType"); |
|||
|
|||
var type = pointerType switch |
|||
{ |
|||
"touch" => RawPointerEventType.TouchBegin, |
|||
_ => args.GetPropertyAsInt32("button") switch |
|||
{ |
|||
0 => RawPointerEventType.LeftButtonDown, |
|||
1 => RawPointerEventType.MiddleButtonDown, |
|||
2 => RawPointerEventType.RightButtonDown, |
|||
3 => RawPointerEventType.XButton1Down, |
|||
4 => RawPointerEventType.XButton2Down, |
|||
// 5 => Pen eraser button,
|
|||
_ => RawPointerEventType.Move |
|||
} |
|||
}; |
|||
|
|||
var point = ExtractRawPointerFromJSArgs(args); |
|||
|
|||
return _topLevelImpl.RawPointerEvent(type, pointerType!, point, GetModifiers(args), args.GetPropertyAsInt32("pointerId")); |
|||
} |
|||
|
|||
private bool OnPointerUp(JSObject args) |
|||
{ |
|||
var pointerType = args.GetPropertyAsString("pointerType") ?? "mouse"; |
|||
|
|||
var type = pointerType switch |
|||
{ |
|||
"touch" => RawPointerEventType.TouchEnd, |
|||
_ => args.GetPropertyAsInt32("button") switch |
|||
{ |
|||
0 => RawPointerEventType.LeftButtonUp, |
|||
1 => RawPointerEventType.MiddleButtonUp, |
|||
2 => RawPointerEventType.RightButtonUp, |
|||
3 => RawPointerEventType.XButton1Up, |
|||
4 => RawPointerEventType.XButton2Up, |
|||
// 5 => Pen eraser button,
|
|||
_ => RawPointerEventType.Move |
|||
} |
|||
}; |
|||
|
|||
var point = ExtractRawPointerFromJSArgs(args); |
|||
|
|||
return _topLevelImpl.RawPointerEvent(type, pointerType, point, GetModifiers(args), args.GetPropertyAsInt32("pointerId")); |
|||
} |
|||
|
|||
private bool OnWheel(JSObject args) |
|||
{ |
|||
return _topLevelImpl.RawMouseWheelEvent(new Point(args.GetPropertyAsDouble("clientX"), args.GetPropertyAsDouble("clientY")), |
|||
new Vector(-(args.GetPropertyAsDouble("deltaX") / 50), -(args.GetPropertyAsDouble("deltaY") / 50)), GetModifiers(args)); |
|||
} |
|||
|
|||
private static RawInputModifiers GetModifiers(JSObject e) |
|||
{ |
|||
var modifiers = RawInputModifiers.None; |
|||
|
|||
if (e.GetPropertyAsBoolean("ctrlKey")) |
|||
modifiers |= RawInputModifiers.Control; |
|||
if (e.GetPropertyAsBoolean("altKey")) |
|||
modifiers |= RawInputModifiers.Alt; |
|||
if (e.GetPropertyAsBoolean("shiftKey")) |
|||
modifiers |= RawInputModifiers.Shift; |
|||
if (e.GetPropertyAsBoolean("metaKey")) |
|||
modifiers |= RawInputModifiers.Meta; |
|||
|
|||
var buttons = e.GetPropertyAsInt32("buttons"); |
|||
if ((buttons & 1L) == 1) |
|||
modifiers |= RawInputModifiers.LeftMouseButton; |
|||
|
|||
if ((buttons & 2L) == 2) |
|||
modifiers |= e.GetPropertyAsString("type") == "pen" ? RawInputModifiers.PenBarrelButton : RawInputModifiers.RightMouseButton; |
|||
|
|||
if ((buttons & 4L) == 4) |
|||
modifiers |= RawInputModifiers.MiddleMouseButton; |
|||
|
|||
if ((buttons & 8L) == 8) |
|||
modifiers |= RawInputModifiers.XButton1MouseButton; |
|||
|
|||
if ((buttons & 16L) == 16) |
|||
modifiers |= RawInputModifiers.XButton2MouseButton; |
|||
|
|||
if ((buttons & 32L) == 32) |
|||
modifiers |= RawInputModifiers.PenEraser; |
|||
|
|||
return modifiers; |
|||
} |
|||
|
|||
private bool OnKeyDown (string code, string key, int modifier) |
|||
{ |
|||
return _topLevelImpl.RawKeyboardEvent(RawKeyEventType.KeyDown, code, key, (RawInputModifiers)modifier); |
|||
} |
|||
|
|||
private bool OnKeyUp(string code, string key, int modifier) |
|||
{ |
|||
return _topLevelImpl.RawKeyboardEvent(RawKeyEventType.KeyUp, code, key, (RawInputModifiers)modifier); |
|||
} |
|||
|
|||
private bool OnTextInput (string type, string? data) |
|||
{ |
|||
if(data == null || IsComposing) |
|||
{ |
|||
return false; |
|||
} |
|||
|
|||
return _topLevelImpl.RawTextEvent(data); |
|||
} |
|||
|
|||
private bool OnCompositionStart (JSObject args) |
|||
{ |
|||
if (_client == null) |
|||
return false; |
|||
|
|||
_client.SetPreeditText(null); |
|||
IsComposing = true; |
|||
|
|||
return false; |
|||
} |
|||
|
|||
private bool OnCompositionUpdate(JSObject args) |
|||
{ |
|||
if (_client == null) |
|||
return false; |
|||
|
|||
_client.SetPreeditText(args.GetPropertyAsString("data")); |
|||
|
|||
return false; |
|||
} |
|||
|
|||
private bool OnCompositionEnd(JSObject args) |
|||
{ |
|||
if (_client == null) |
|||
return false; |
|||
|
|||
IsComposing = false; |
|||
_client.SetPreeditText(null); |
|||
_topLevelImpl.RawTextEvent(args.GetPropertyAsString("data")!); |
|||
|
|||
return false; |
|||
} |
|||
|
|||
private void OnRenderFrame() |
|||
{ |
|||
if (_useGL && (_jsGlInfo == null)) |
|||
{ |
|||
Console.WriteLine("nothing to render"); |
|||
return; |
|||
} |
|||
if (_canvasSize.Width <= 0 || _canvasSize.Height <= 0 || _dpi <= 0) |
|||
{ |
|||
Console.WriteLine("nothing to render"); |
|||
return; |
|||
} |
|||
|
|||
ManualTriggerRenderTimer.Instance.RaiseTick(); |
|||
} |
|||
|
|||
public Control? Content |
|||
{ |
|||
get => (Control)_topLevel.Content!; |
|||
set => _topLevel.Content = value; |
|||
} |
|||
|
|||
public bool IsComposing { get; private set; } |
|||
|
|||
internal INativeControlHostImpl GetNativeControlHostImpl() |
|||
{ |
|||
return new BrowserNativeControlHost(_nativeControlsContainer); |
|||
} |
|||
|
|||
private void ForceBlit() |
|||
{ |
|||
// Note: this is technically a hack, but it's a kinda unique use case when
|
|||
// we want to blit the previous frame
|
|||
// renderer doesn't have much control over the render target
|
|||
// we render on the UI thread
|
|||
// We also don't want to have it as a meaningful public API.
|
|||
// Therefore we have InternalsVisibleTo hack here.
|
|||
|
|||
if (_topLevel.Renderer is CompositingRenderer dr) |
|||
{ |
|||
dr.CompositionTarget.ImmediateUIThreadRender(); |
|||
} |
|||
} |
|||
|
|||
private void OnDpiChanged(double oldDpi, double newDpi) |
|||
{ |
|||
if (Math.Abs(_dpi - newDpi) > 0.0001) |
|||
{ |
|||
_dpi = newDpi; |
|||
|
|||
CanvasHelper.SetCanvasSize(_canvas, (int)(_canvasSize.Width * _dpi), (int)(_canvasSize.Height * _dpi)); |
|||
|
|||
_topLevelImpl.SetClientSize(_canvasSize, _dpi); |
|||
|
|||
ForceBlit(); |
|||
} |
|||
} |
|||
|
|||
private void OnSizeChanged(int height, int width) |
|||
{ |
|||
var newSize = new Size(height, width); |
|||
|
|||
if (_canvasSize != newSize) |
|||
{ |
|||
_canvasSize = newSize; |
|||
|
|||
CanvasHelper.SetCanvasSize(_canvas, (int)(_canvasSize.Width * _dpi), (int)(_canvasSize.Height * _dpi)); |
|||
|
|||
_topLevelImpl.SetClientSize(_canvasSize, _dpi); |
|||
|
|||
ForceBlit(); |
|||
} |
|||
} |
|||
|
|||
private void HideIme() |
|||
{ |
|||
InputHelper.HideElement(_inputElement); |
|||
InputHelper.FocusElement(_containerElement); |
|||
} |
|||
|
|||
public void SetClient(ITextInputMethodClient? client) |
|||
{ |
|||
Console.WriteLine("Set Client"); |
|||
if (_client != null) |
|||
{ |
|||
_client.SurroundingTextChanged -= SurroundingTextChanged; |
|||
} |
|||
|
|||
if (client != null) |
|||
{ |
|||
client.SurroundingTextChanged += SurroundingTextChanged; |
|||
} |
|||
|
|||
InputHelper.ClearInputElement(_inputElement); |
|||
|
|||
_client = client; |
|||
|
|||
if (_client != null) |
|||
{ |
|||
InputHelper.ShowElement(_inputElement); |
|||
InputHelper.FocusElement(_inputElement); |
|||
|
|||
var surroundingText = _client.SurroundingText; |
|||
|
|||
InputHelper.SetSurroundingText(_inputElement, surroundingText.Text, surroundingText.AnchorOffset, surroundingText.CursorOffset); |
|||
|
|||
Console.WriteLine("Shown, focused and surrounded."); |
|||
} |
|||
else |
|||
{ |
|||
HideIme(); |
|||
} |
|||
} |
|||
|
|||
private void SurroundingTextChanged(object? sender, EventArgs e) |
|||
{ |
|||
if (_client != null) |
|||
{ |
|||
var surroundingText = _client.SurroundingText; |
|||
|
|||
InputHelper.SetSurroundingText(_inputElement, surroundingText.Text, surroundingText.AnchorOffset, surroundingText.CursorOffset); |
|||
} |
|||
} |
|||
|
|||
public void SetCursorRect(Rect rect) |
|||
{ |
|||
InputHelper.FocusElement(_inputElement); |
|||
InputHelper.SetBounds(_inputElement, (int)rect.X, (int)rect.Y, (int)rect.Width, (int)rect.Height, _client?.SurroundingText.CursorOffset ?? 0); |
|||
InputHelper.FocusElement(_inputElement); |
|||
} |
|||
|
|||
public void SetOptions(TextInputOptions options) |
|||
{ |
|||
} |
|||
|
|||
public void Reset() |
|||
{ |
|||
InputHelper.ClearInputElement(_inputElement); |
|||
InputHelper.SetSurroundingText(_inputElement, "", 0, 0); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,136 @@ |
|||
using System; |
|||
using System.Diagnostics.CodeAnalysis; |
|||
using System.Runtime.InteropServices.JavaScript; |
|||
|
|||
using Avalonia.Controls.Platform; |
|||
using Avalonia.Platform; |
|||
using Avalonia.Web.Interop; |
|||
|
|||
namespace Avalonia.Web |
|||
{ |
|||
internal class BrowserNativeControlHost : INativeControlHostImpl |
|||
{ |
|||
private readonly JSObject _hostElement; |
|||
|
|||
public BrowserNativeControlHost(JSObject element) |
|||
{ |
|||
_hostElement = element; |
|||
} |
|||
|
|||
public INativeControlHostDestroyableControlHandle CreateDefaultChild(IPlatformHandle parent) |
|||
{ |
|||
var element = NativeControlHostHelper.CreateDefaultChild(null); |
|||
return new JSObjectControlHandle(element); |
|||
} |
|||
|
|||
public INativeControlHostControlTopLevelAttachment CreateNewAttachment(Func<IPlatformHandle, IPlatformHandle> create) |
|||
{ |
|||
Attachment? a = null; |
|||
try |
|||
{ |
|||
var child = create(new JSObjectControlHandle(_hostElement)); |
|||
var attachmenetReference = NativeControlHostHelper.CreateAttachment(); |
|||
// It has to be assigned to the variable before property setter is called so we dispose it on exception
|
|||
#pragma warning disable IDE0017 // Simplify object initialization
|
|||
a = new Attachment(attachmenetReference, child); |
|||
#pragma warning restore IDE0017 // Simplify object initialization
|
|||
a.AttachedTo = this; |
|||
return a; |
|||
} |
|||
catch |
|||
{ |
|||
a?.Dispose(); |
|||
throw; |
|||
} |
|||
} |
|||
|
|||
public INativeControlHostControlTopLevelAttachment CreateNewAttachment(IPlatformHandle handle) |
|||
{ |
|||
var attachmenetReference = NativeControlHostHelper.CreateAttachment(); |
|||
var a = new Attachment(attachmenetReference, handle); |
|||
a.AttachedTo = this; |
|||
return a; |
|||
} |
|||
|
|||
public bool IsCompatibleWith(IPlatformHandle handle) => handle is JSObjectControlHandle; |
|||
|
|||
private class Attachment : INativeControlHostControlTopLevelAttachment |
|||
{ |
|||
private const string InitializeWithChildHandleSymbol = "InitializeWithChildHandle"; |
|||
private const string AttachToSymbol = "AttachTo"; |
|||
private const string ShowInBoundsSymbol = "ShowInBounds"; |
|||
private const string HideWithSizeSymbol = "HideWithSize"; |
|||
private const string ReleaseChildSymbol = "ReleaseChild"; |
|||
|
|||
private JSObject? _native; |
|||
private BrowserNativeControlHost? _attachedTo; |
|||
|
|||
public Attachment(JSObject native, IPlatformHandle handle) |
|||
{ |
|||
_native = native; |
|||
NativeControlHostHelper.InitializeWithChildHandle(_native, ((JSObjectControlHandle)handle).Object); |
|||
} |
|||
|
|||
public void Dispose() |
|||
{ |
|||
if (_native != null) |
|||
{ |
|||
NativeControlHostHelper.ReleaseChild(_native); |
|||
_native.Dispose(); |
|||
_native = null; |
|||
} |
|||
} |
|||
|
|||
public INativeControlHostImpl? AttachedTo |
|||
{ |
|||
get => _attachedTo!; |
|||
set |
|||
{ |
|||
CheckDisposed(); |
|||
|
|||
var host = (BrowserNativeControlHost?)value; |
|||
if (host == null) |
|||
{ |
|||
NativeControlHostHelper.AttachTo(_native, null); |
|||
} |
|||
else |
|||
{ |
|||
NativeControlHostHelper.AttachTo(_native, host._hostElement); |
|||
} |
|||
_attachedTo = host; |
|||
} |
|||
} |
|||
|
|||
public bool IsCompatibleWith(INativeControlHostImpl host) => host is BrowserNativeControlHost; |
|||
|
|||
public void HideWithSize(Size size) |
|||
{ |
|||
CheckDisposed(); |
|||
if (_attachedTo == null) |
|||
return; |
|||
|
|||
NativeControlHostHelper.HideWithSize(_native, Math.Max(1, size.Width), Math.Max(1, size.Height)); |
|||
} |
|||
|
|||
public void ShowInBounds(Rect bounds) |
|||
{ |
|||
CheckDisposed(); |
|||
|
|||
if (_attachedTo == null) |
|||
throw new InvalidOperationException("Native control isn't attached to a toplevel"); |
|||
|
|||
bounds = new Rect(bounds.X, bounds.Y, Math.Max(1, bounds.Width), |
|||
Math.Max(1, bounds.Height)); |
|||
|
|||
NativeControlHostHelper.ShowInBounds(_native, bounds.X, bounds.Y, bounds.Width, bounds.Height); |
|||
} |
|||
|
|||
[MemberNotNull(nameof(_native))] |
|||
private void CheckDisposed() |
|||
{ |
|||
if (_native == null) |
|||
throw new ObjectDisposedException(nameof(Attachment)); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,41 @@ |
|||
using System.Runtime.InteropServices.JavaScript; |
|||
using System; |
|||
using Avalonia.Controls; |
|||
using Avalonia.Controls.ApplicationLifetimes; |
|||
using Avalonia.Media; |
|||
using Avalonia.Web.Skia; |
|||
|
|||
namespace Avalonia.Web |
|||
{ |
|||
[System.Runtime.Versioning.SupportedOSPlatform("browser")] // gets rid of callsite warnings
|
|||
public class BrowserSingleViewLifetime : ISingleViewApplicationLifetime |
|||
{ |
|||
public AvaloniaView? View; |
|||
|
|||
public Control? MainView |
|||
{ |
|||
get => View!.Content; |
|||
set => View!.Content = value; |
|||
} |
|||
} |
|||
|
|||
public static partial class WebAppBuilder |
|||
{ |
|||
public static T SetupBrowserApp<T>( |
|||
this T builder, string mainDivId) |
|||
where T : AppBuilderBase<T>, new() |
|||
{ |
|||
var lifetime = new BrowserSingleViewLifetime(); |
|||
|
|||
return builder |
|||
.UseWindowingSubsystem(BrowserWindowingPlatform.Register) |
|||
.UseSkia() |
|||
.With(new SkiaOptions { CustomGpuFactory = () => new BrowserSkiaGpu() }) |
|||
.AfterSetup(b => |
|||
{ |
|||
lifetime.View = new AvaloniaView(mainDivId); |
|||
}) |
|||
.SetupWithLifetime(lifetime); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,226 @@ |
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Diagnostics; |
|||
using System.Linq; |
|||
using Avalonia.Controls; |
|||
using Avalonia.Controls.Platform; |
|||
using Avalonia.Input; |
|||
using Avalonia.Input.Raw; |
|||
using Avalonia.Input.TextInput; |
|||
using Avalonia.Platform; |
|||
using Avalonia.Platform.Storage; |
|||
using Avalonia.Rendering; |
|||
using Avalonia.Rendering.Composition; |
|||
using Avalonia.Web.Skia; |
|||
using Avalonia.Web.Storage; |
|||
|
|||
namespace Avalonia.Web |
|||
{ |
|||
[System.Runtime.Versioning.SupportedOSPlatform("browser")] // gets rid of callsite warnings
|
|||
internal class BrowserTopLevelImpl : ITopLevelImplWithTextInputMethod, ITopLevelImplWithNativeControlHost, ITopLevelImplWithStorageProvider |
|||
{ |
|||
private Size _clientSize; |
|||
private IInputRoot? _inputRoot; |
|||
private readonly Stopwatch _sw = Stopwatch.StartNew(); |
|||
private readonly AvaloniaView _avaloniaView; |
|||
private readonly TouchDevice _touchDevice; |
|||
private readonly PenDevice _penDevice; |
|||
private string _currentCursor = CssCursor.Default; |
|||
|
|||
public BrowserTopLevelImpl(AvaloniaView avaloniaView) |
|||
{ |
|||
Surfaces = Enumerable.Empty<object>(); |
|||
_avaloniaView = avaloniaView; |
|||
TransparencyLevel = WindowTransparencyLevel.None; |
|||
AcrylicCompensationLevels = new AcrylicPlatformCompensationLevels(1, 1, 1); |
|||
_touchDevice = new TouchDevice(); |
|||
_penDevice = new PenDevice(); |
|||
NativeControlHost = _avaloniaView.GetNativeControlHostImpl(); |
|||
} |
|||
|
|||
public ulong Timestamp => (ulong)_sw.ElapsedMilliseconds; |
|||
|
|||
public void SetClientSize(Size newSize, double dpi) |
|||
{ |
|||
if (Math.Abs(RenderScaling - dpi) > 0.0001) |
|||
{ |
|||
if (Surfaces.FirstOrDefault() is BrowserSkiaSurface surface) |
|||
{ |
|||
surface.Scaling = dpi; |
|||
} |
|||
|
|||
ScalingChanged?.Invoke(dpi); |
|||
} |
|||
|
|||
if (newSize != _clientSize) |
|||
{ |
|||
_clientSize = newSize; |
|||
|
|||
if (Surfaces.FirstOrDefault() is BrowserSkiaSurface surface) |
|||
{ |
|||
surface.Size = new PixelSize((int)newSize.Width, (int)newSize.Height); |
|||
} |
|||
|
|||
Resized?.Invoke(newSize, PlatformResizeReason.User); |
|||
} |
|||
} |
|||
|
|||
public bool RawPointerEvent( |
|||
RawPointerEventType eventType, string pointerType, |
|||
RawPointerPoint p, RawInputModifiers modifiers, long touchPointId) |
|||
{ |
|||
if (_inputRoot is { } |
|||
&& Input is { } input) |
|||
{ |
|||
var device = GetPointerDevice(pointerType); |
|||
var args = device is TouchDevice ? |
|||
new RawTouchEventArgs(device, Timestamp, _inputRoot, eventType, p, modifiers, touchPointId) : |
|||
new RawPointerEventArgs(device, Timestamp, _inputRoot, eventType, p, modifiers) |
|||
{ |
|||
RawPointerId = touchPointId |
|||
}; |
|||
|
|||
input.Invoke(args); |
|||
|
|||
return args.Handled; |
|||
} |
|||
|
|||
return false; |
|||
} |
|||
|
|||
private IPointerDevice GetPointerDevice(string pointerType) |
|||
{ |
|||
return pointerType switch |
|||
{ |
|||
"touch" => _touchDevice, |
|||
"pen" => _penDevice, |
|||
_ => MouseDevice |
|||
}; |
|||
} |
|||
|
|||
public bool RawMouseWheelEvent(Point p, Vector v, RawInputModifiers modifiers) |
|||
{ |
|||
if (_inputRoot is { }) |
|||
{ |
|||
var args = new RawMouseWheelEventArgs(MouseDevice, Timestamp, _inputRoot, p, v, modifiers); |
|||
|
|||
Input?.Invoke(args); |
|||
|
|||
return args.Handled; |
|||
} |
|||
|
|||
return false; |
|||
} |
|||
|
|||
public bool RawKeyboardEvent(RawKeyEventType type, string code, string key, RawInputModifiers modifiers) |
|||
{ |
|||
if (Keycodes.KeyCodes.TryGetValue(code, out var avkey)) |
|||
{ |
|||
if (_inputRoot is { }) |
|||
{ |
|||
var args = new RawKeyEventArgs(KeyboardDevice, Timestamp, _inputRoot, type, avkey, modifiers); |
|||
|
|||
Input?.Invoke(args); |
|||
|
|||
return args.Handled; |
|||
} |
|||
} |
|||
else if (Keycodes.KeyCodes.TryGetValue(key, out avkey)) |
|||
{ |
|||
if (_inputRoot is { }) |
|||
{ |
|||
var args = new RawKeyEventArgs(KeyboardDevice, Timestamp, _inputRoot, type, avkey, modifiers); |
|||
|
|||
Input?.Invoke(args); |
|||
|
|||
return args.Handled; |
|||
} |
|||
} |
|||
|
|||
return false; |
|||
} |
|||
|
|||
public bool RawTextEvent(string text) |
|||
{ |
|||
if (_inputRoot is { }) |
|||
{ |
|||
var args = new RawTextInputEventArgs(KeyboardDevice, Timestamp, _inputRoot, text); |
|||
Input?.Invoke(args); |
|||
|
|||
return args.Handled; |
|||
} |
|||
|
|||
return false; |
|||
} |
|||
|
|||
public void Dispose() |
|||
{ |
|||
|
|||
} |
|||
|
|||
public IRenderer CreateRenderer(IRenderRoot root) |
|||
{ |
|||
var loop = AvaloniaLocator.Current.GetRequiredService<IRenderLoop>(); |
|||
return new CompositingRenderer(root, new Compositor(loop, null)); |
|||
} |
|||
|
|||
public void Invalidate(Rect rect) |
|||
{ |
|||
//Console.WriteLine("invalidate rect called");
|
|||
} |
|||
|
|||
public void SetInputRoot(IInputRoot inputRoot) |
|||
{ |
|||
_inputRoot = inputRoot; |
|||
} |
|||
|
|||
public Point PointToClient(PixelPoint point) => new Point(point.X, point.Y); |
|||
|
|||
public PixelPoint PointToScreen(Point point) => new PixelPoint((int)point.X, (int)point.Y); |
|||
|
|||
public void SetCursor(ICursorImpl? cursor) |
|||
{ |
|||
var val = (cursor as CssCursor)?.Value ?? CssCursor.Default; |
|||
if (_currentCursor != val) |
|||
{ |
|||
SetCssCursor?.Invoke(val); |
|||
_currentCursor = val; |
|||
} |
|||
} |
|||
|
|||
public IPopupImpl? CreatePopup() |
|||
{ |
|||
return null; |
|||
} |
|||
|
|||
public void SetTransparencyLevelHint(WindowTransparencyLevel transparencyLevel) |
|||
{ |
|||
|
|||
} |
|||
|
|||
public Size ClientSize => _clientSize; |
|||
public Size? FrameSize => null; |
|||
public double RenderScaling => (Surfaces.FirstOrDefault() as BrowserSkiaSurface)?.Scaling ?? 1; |
|||
|
|||
public IEnumerable<object> Surfaces { get; set; } |
|||
|
|||
public Action<string>? SetCssCursor { get; set; } |
|||
public Action<RawInputEventArgs>? Input { get; set; } |
|||
public Action<Rect>? Paint { get; set; } |
|||
public Action<Size, PlatformResizeReason>? Resized { get; set; } |
|||
public Action<double>? ScalingChanged { get; set; } |
|||
public Action<WindowTransparencyLevel>? TransparencyLevelChanged { get; set; } |
|||
public Action? Closed { get; set; } |
|||
public Action? LostFocus { get; set; } |
|||
public IMouseDevice MouseDevice { get; } = new MouseDevice(); |
|||
|
|||
public IKeyboardDevice KeyboardDevice { get; } = BrowserWindowingPlatform.Keyboard; |
|||
public WindowTransparencyLevel TransparencyLevel { get; } |
|||
public AcrylicPlatformCompensationLevels AcrylicCompensationLevels { get; } |
|||
|
|||
public ITextInputMethodImpl TextInputMethod => _avaloniaView; |
|||
|
|||
public INativeControlHostImpl? NativeControlHost { get; } |
|||
public IStorageProvider StorageProvider { get; } = new BrowserStorageProvider(); |
|||
} |
|||
} |
|||
@ -0,0 +1,29 @@ |
|||
using System; |
|||
using System.Threading.Tasks; |
|||
using Avalonia.Input; |
|||
using Avalonia.Input.Platform; |
|||
using Avalonia.Web.Interop; |
|||
|
|||
namespace Avalonia.Web |
|||
{ |
|||
internal class ClipboardImpl : IClipboard |
|||
{ |
|||
public Task<string> GetTextAsync() |
|||
{ |
|||
return InputHelper.ReadClipboardTextAsync(); |
|||
} |
|||
|
|||
public Task SetTextAsync(string text) |
|||
{ |
|||
return InputHelper.WriteClipboardTextAsync(text); |
|||
} |
|||
|
|||
public async Task ClearAsync() => await SetTextAsync(""); |
|||
|
|||
public Task SetDataObjectAsync(IDataObject data) => Task.CompletedTask; |
|||
|
|||
public Task<string[]> GetFormatsAsync() => Task.FromResult(Array.Empty<string>()); |
|||
|
|||
public Task<object> GetDataAsync(string format) => Task.FromResult<object>(new()); |
|||
} |
|||
} |
|||
@ -0,0 +1,95 @@ |
|||
using System; |
|||
using System.IO; |
|||
using Avalonia.Input; |
|||
using Avalonia.Platform; |
|||
|
|||
namespace Avalonia.Web |
|||
{ |
|||
public class CssCursor : ICursorImpl |
|||
{ |
|||
public const string Default = "default"; |
|||
public string? Value { get; set; } |
|||
|
|||
public CssCursor(StandardCursorType type) |
|||
{ |
|||
Value = ToKeyword(type); |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Create a cursor from base64 image
|
|||
/// </summary>
|
|||
public CssCursor(string base64, string format, PixelPoint hotspot, StandardCursorType fallback) |
|||
{ |
|||
Value = $"url(\"data:image/{format};base64,{base64}\") {hotspot.X} {hotspot.Y}, {ToKeyword(fallback)}"; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Create a cursor from url to *.cur file.
|
|||
/// </summary>
|
|||
public CssCursor(string url, StandardCursorType fallback) |
|||
{ |
|||
Value = $"url('{url}'), {ToKeyword(fallback)}"; |
|||
} |
|||
|
|||
/// <summary>
|
|||
/// Create a cursor from png/svg and hotspot position
|
|||
/// </summary>
|
|||
public CssCursor(string url, PixelPoint hotSpot, StandardCursorType fallback) |
|||
{ |
|||
Value = $"url('{url}') {hotSpot.X} {hotSpot.Y}, {ToKeyword(fallback)}"; |
|||
} |
|||
|
|||
private static string ToKeyword(StandardCursorType type) => type switch |
|||
{ |
|||
StandardCursorType.Hand => "pointer", |
|||
StandardCursorType.Cross => "crosshair", |
|||
StandardCursorType.Help => "help", |
|||
StandardCursorType.Ibeam => "text", |
|||
StandardCursorType.No => "not-allowed", |
|||
StandardCursorType.None => "none", |
|||
StandardCursorType.Wait => "progress", |
|||
StandardCursorType.AppStarting => "wait", |
|||
|
|||
StandardCursorType.DragMove => "move", |
|||
StandardCursorType.DragCopy => "copy", |
|||
StandardCursorType.DragLink => "alias", |
|||
|
|||
StandardCursorType.UpArrow => "default",/*not found matching one*/ |
|||
StandardCursorType.SizeWestEast => "ew-resize", |
|||
StandardCursorType.SizeNorthSouth => "ns-resize", |
|||
StandardCursorType.SizeAll => "move", |
|||
|
|||
StandardCursorType.TopSide => "n-resize", |
|||
StandardCursorType.BottomSide => "s-resize", |
|||
StandardCursorType.LeftSide => "w-resize", |
|||
StandardCursorType.RightSide => "e-resize", |
|||
StandardCursorType.TopLeftCorner => "nw-resize", |
|||
StandardCursorType.TopRightCorner => "ne-resize", |
|||
StandardCursorType.BottomLeftCorner => "sw-resize", |
|||
StandardCursorType.BottomRightCorner => "se-resize", |
|||
|
|||
_ => Default, |
|||
}; |
|||
|
|||
public void Dispose() {} |
|||
} |
|||
|
|||
internal class CssCursorFactory : ICursorFactory |
|||
{ |
|||
public ICursorImpl CreateCursor(IBitmapImpl cursor, PixelPoint hotSpot) |
|||
{ |
|||
using var imageStream = new MemoryStream(); |
|||
cursor.Save(imageStream); |
|||
|
|||
//not memory optimized because CryptoStream with ToBase64Transform is not supported in the browser.
|
|||
var base64String = Convert.ToBase64String(imageStream.ToArray()); |
|||
return new CssCursor(base64String, "png", hotSpot, StandardCursorType.Arrow); |
|||
} |
|||
|
|||
ICursorImpl ICursorFactory.GetCursor(StandardCursorType cursorType) |
|||
{ |
|||
return new CssCursor(cursorType); |
|||
} |
|||
} |
|||
} |
|||
|
|||
@ -0,0 +1,43 @@ |
|||
using System; |
|||
using System.Runtime.InteropServices; |
|||
using System.Runtime.InteropServices.JavaScript; |
|||
|
|||
namespace Avalonia.Web.Interop; |
|||
|
|||
internal record GLInfo(int ContextId, uint FboId, int Stencils, int Samples, int Depth); |
|||
|
|||
[System.Runtime.Versioning.SupportedOSPlatform("browser")] // gets rid of callsite warnings
|
|||
internal static partial class CanvasHelper |
|||
{ |
|||
|
|||
[DllImport("libSkiaSharp", CallingConvention = CallingConvention.Cdecl)] |
|||
static extern JSObject InterceptGLObject(); |
|||
|
|||
public static GLInfo InitialiseGL(JSObject canvas, Action renderFrameCallback) |
|||
{ |
|||
InterceptGLObject(); |
|||
|
|||
var info = InitGL(canvas, canvas.GetPropertyAsString("id")!, renderFrameCallback); |
|||
|
|||
var glInfo = new GLInfo( |
|||
info.GetPropertyAsInt32("context"), |
|||
(uint)info.GetPropertyAsInt32("fboId"), |
|||
info.GetPropertyAsInt32("stencil"), |
|||
info.GetPropertyAsInt32("sample"), |
|||
info.GetPropertyAsInt32("depth")); |
|||
|
|||
return glInfo; |
|||
} |
|||
|
|||
[JSImport("Canvas.requestAnimationFrame", "avalonia.ts")] |
|||
public static partial void RequestAnimationFrame(JSObject canvas, bool renderLoop); |
|||
|
|||
[JSImport("Canvas.setCanvasSize", "avalonia.ts")] |
|||
public static partial void SetCanvasSize(JSObject canvas, int height, int width); |
|||
|
|||
[JSImport("Canvas.initGL", "avalonia.ts")] |
|||
private static partial JSObject InitGL( |
|||
JSObject canvas, |
|||
string canvasId, |
|||
[JSMarshalAs<JSType.Function>] Action renderFrameCallback); |
|||
} |
|||
@ -0,0 +1,28 @@ |
|||
using System; |
|||
using System.Runtime.InteropServices.JavaScript; |
|||
|
|||
namespace Avalonia.Web.Interop; |
|||
|
|||
internal static partial class DomHelper |
|||
{ |
|||
[JSImport("globalThis.document.getElementById")] |
|||
internal static partial JSObject? GetElementById(string id); |
|||
|
|||
[JSImport("AvaloniaDOM.createAvaloniaHost", "avalonia.ts")] |
|||
public static partial JSObject CreateAvaloniaHost(JSObject element); |
|||
|
|||
[JSImport("AvaloniaDOM.addClass", "avalonia.ts")] |
|||
public static partial void AddCssClass(JSObject element, string className); |
|||
|
|||
[JSImport("SizeWatcher.observe", "avalonia.ts")] |
|||
public static partial JSObject ObserveSize( |
|||
JSObject canvas, |
|||
string canvasId, |
|||
[JSMarshalAs<JSType.Function<JSType.Number, JSType.Number>>] |
|||
Action<int, int> onSizeChanged); |
|||
|
|||
[JSImport("DpiWatcher.start", "avalonia.ts")] |
|||
public static partial double ObserveDpi( |
|||
[JSMarshalAs<JSType.Function<JSType.Number, JSType.Number>>] |
|||
Action<double, double> onDpiChanged); |
|||
} |
|||
@ -0,0 +1,78 @@ |
|||
using System; |
|||
using System.Runtime.InteropServices.JavaScript; |
|||
using System.Threading.Tasks; |
|||
|
|||
namespace Avalonia.Web.Interop; |
|||
|
|||
internal static partial class InputHelper |
|||
{ |
|||
[JSImport("InputHelper.subscribeKeyEvents", "avalonia.ts")] |
|||
public static partial void SubscribeKeyEvents( |
|||
JSObject htmlElement, |
|||
[JSMarshalAs<JSType.Function<JSType.String, JSType.String, JSType.Number, JSType.Boolean>>] |
|||
Func<string, string, int, bool> keyDown, |
|||
[JSMarshalAs<JSType.Function<JSType.String, JSType.String, JSType.Number, JSType.Boolean>>] |
|||
Func<string, string, int, bool> keyUp); |
|||
|
|||
[JSImport("InputHelper.subscribeTextEvents", "avalonia.ts")] |
|||
public static partial void SubscribeTextEvents( |
|||
JSObject htmlElement, |
|||
[JSMarshalAs<JSType.Function<JSType.String, JSType.String, JSType.Boolean>>] |
|||
Func<string, string?, bool> onInput, |
|||
[JSMarshalAs<JSType.Function<JSType.Object, JSType.Boolean>>] |
|||
Func<JSObject, bool> onCompositionStart, |
|||
[JSMarshalAs<JSType.Function<JSType.Object, JSType.Boolean>>] |
|||
Func<JSObject, bool> onCompositionUpdate, |
|||
[JSMarshalAs<JSType.Function<JSType.Object, JSType.Boolean>>] |
|||
Func<JSObject, bool> onCompositionEnd); |
|||
|
|||
[JSImport("InputHelper.subscribePointerEvents", "avalonia.ts")] |
|||
public static partial void SubscribePointerEvents( |
|||
JSObject htmlElement, |
|||
[JSMarshalAs<JSType.Function<JSType.Object, JSType.Boolean>>] |
|||
Func<JSObject, bool> pointerMove, |
|||
[JSMarshalAs<JSType.Function<JSType.Object, JSType.Boolean>>] |
|||
Func<JSObject, bool> pointerDown, |
|||
[JSMarshalAs<JSType.Function<JSType.Object, JSType.Boolean>>] |
|||
Func<JSObject, bool> pointerUp, |
|||
[JSMarshalAs<JSType.Function<JSType.Object, JSType.Boolean>>] |
|||
Func<JSObject, bool> wheel); |
|||
|
|||
|
|||
[JSImport("InputHelper.subscribeInputEvents", "avalonia.ts")] |
|||
public static partial void SubscribeInputEvents( |
|||
JSObject htmlElement, |
|||
[JSMarshalAs<JSType.Function<JSType.String, JSType.Boolean>>] |
|||
Func<string, bool> input); |
|||
|
|||
|
|||
[JSImport("InputHelper.clearInput", "avalonia.ts")] |
|||
public static partial void ClearInputElement(JSObject htmlElement); |
|||
|
|||
[JSImport("InputHelper.isInputElement", "avalonia.ts")] |
|||
public static partial void IsInputElement(JSObject htmlElement); |
|||
|
|||
[JSImport("InputHelper.focusElement", "avalonia.ts")] |
|||
public static partial void FocusElement(JSObject htmlElement); |
|||
|
|||
[JSImport("InputHelper.setCursor", "avalonia.ts")] |
|||
public static partial void SetCursor(JSObject htmlElement, string kind); |
|||
|
|||
[JSImport("InputHelper.hide", "avalonia.ts")] |
|||
public static partial void HideElement(JSObject htmlElement); |
|||
|
|||
[JSImport("InputHelper.show", "avalonia.ts")] |
|||
public static partial void ShowElement(JSObject htmlElement); |
|||
|
|||
[JSImport("InputHelper.setSurroundingText", "avalonia.ts")] |
|||
public static partial void SetSurroundingText(JSObject htmlElement, string text, int start, int end); |
|||
|
|||
[JSImport("InputHelper.setBounds", "avalonia.ts")] |
|||
public static partial void SetBounds(JSObject htmlElement, int x, int y, int width, int height, int caret); |
|||
|
|||
[JSImport("globalThis.navigator.clipboard.readText")] |
|||
public static partial Task<string> ReadClipboardTextAsync(); |
|||
|
|||
[JSImport("globalThis.navigator.clipboard.writeText")] |
|||
public static partial Task WriteClipboardTextAsync(string text); |
|||
} |
|||
@ -0,0 +1,28 @@ |
|||
using System; |
|||
using System.Runtime.InteropServices.JavaScript; |
|||
|
|||
namespace Avalonia.Web.Interop; |
|||
|
|||
internal static partial class NativeControlHostHelper |
|||
{ |
|||
[JSImport("NativeControlHost.createDefaultChild", "avalonia.ts")] |
|||
internal static partial JSObject CreateDefaultChild(JSObject? parent); |
|||
|
|||
[JSImport("NativeControlHost.createAttachment", "avalonia.ts")] |
|||
internal static partial JSObject CreateAttachment(); |
|||
|
|||
[JSImport("NativeControlHost.initializeWithChildHandle", "avalonia.ts")] |
|||
internal static partial void InitializeWithChildHandle(JSObject element, JSObject child); |
|||
|
|||
[JSImport("NativeControlHost.attachTo", "avalonia.ts")] |
|||
internal static partial void AttachTo(JSObject element, JSObject? host); |
|||
|
|||
[JSImport("NativeControlHost.showInBounds", "avalonia.ts")] |
|||
internal static partial void ShowInBounds(JSObject element, double x, double y, double width, double height); |
|||
|
|||
[JSImport("NativeControlHost.hideWithSize", "avalonia.ts")] |
|||
internal static partial void HideWithSize(JSObject element, double width, double height); |
|||
|
|||
[JSImport("NativeControlHost.releaseChild", "avalonia.ts")] |
|||
internal static partial void ReleaseChild(JSObject element); |
|||
} |
|||
@ -0,0 +1,55 @@ |
|||
using System.Runtime.InteropServices.JavaScript; |
|||
using System.Threading.Tasks; |
|||
|
|||
namespace Avalonia.Web.Interop; |
|||
|
|||
internal static partial class StorageHelper |
|||
{ |
|||
[JSImport("Caniuse.canShowOpenFilePicker", "avalonia.ts")] |
|||
public static partial bool CanShowOpenFilePicker(); |
|||
|
|||
[JSImport("Caniuse.canShowSaveFilePicker", "avalonia.ts")] |
|||
public static partial bool CanShowSaveFilePicker(); |
|||
|
|||
[JSImport("Caniuse.canShowDirectoryPicker", "avalonia.ts")] |
|||
public static partial bool CanShowDirectoryPicker(); |
|||
|
|||
[JSImport("StorageProvider.selectFolderDialog", "storage.ts")] |
|||
public static partial Task<JSObject?> SelectFolderDialog(JSObject? startIn); |
|||
|
|||
[JSImport("StorageProvider.openFileDialog", "storage.ts")] |
|||
public static partial Task<JSObject?> OpenFileDialog(JSObject? startIn, bool multiple, |
|||
[JSMarshalAs<JSType.Array<JSType.Any>>] object[]? types, bool excludeAcceptAllOption); |
|||
|
|||
[JSImport("StorageProvider.saveFileDialog", "storage.ts")] |
|||
public static partial Task<JSObject?> SaveFileDialog(JSObject? startIn, string? suggestedName, |
|||
[JSMarshalAs<JSType.Array<JSType.Any>>] object[]? types, bool excludeAcceptAllOption); |
|||
|
|||
[JSImport("StorageProvider.openBookmark", "storage.ts")] |
|||
public static partial Task<JSObject?> OpenBookmark(string key); |
|||
|
|||
[JSImport("StorageItem.saveBookmark", "storage.ts")] |
|||
public static partial Task<string?> SaveBookmark(JSObject item); |
|||
|
|||
[JSImport("StorageItem.deleteBookmark", "storage.ts")] |
|||
public static partial Task DeleteBookmark(JSObject item); |
|||
|
|||
[JSImport("StorageItem.getProperties", "storage.ts")] |
|||
public static partial Task<JSObject?> GetProperties(JSObject item); |
|||
|
|||
[JSImport("StorageItem.openWrite", "storage.ts")] |
|||
public static partial Task<JSObject> OpenWrite(JSObject item); |
|||
|
|||
[JSImport("StorageItem.openRead", "storage.ts")] |
|||
public static partial Task<JSObject> OpenRead(JSObject item); |
|||
|
|||
[JSImport("StorageItem.getItems", "storage.ts")] |
|||
[return: JSMarshalAs<JSType.Promise<JSType.Object>>] |
|||
public static partial Task<JSObject> GetItems(JSObject item); |
|||
|
|||
[JSImport("StorageItems.itemsArray", "storage.ts")] |
|||
public static partial JSObject[] ItemsArray(JSObject item); |
|||
|
|||
[JSImport("StorageProvider.createAcceptType", "storage.ts")] |
|||
public static partial JSObject CreateAcceptType(string description, string[] mimeTypes); |
|||
} |
|||
@ -0,0 +1,40 @@ |
|||
using System; |
|||
using System.Runtime.InteropServices.JavaScript; |
|||
using System.Threading.Tasks; |
|||
|
|||
namespace Avalonia.Web.Storage; |
|||
|
|||
/// <summary>
|
|||
/// Set of FileSystemWritableFileStream and Blob methods.
|
|||
/// </summary>
|
|||
internal static partial class StreamHelper |
|||
{ |
|||
[JSImport("StreamHelper.seek", "avalonia.ts")] |
|||
public static partial void Seek(JSObject stream, [JSMarshalAs<JSType.Number>] long position); |
|||
|
|||
[JSImport("StreamHelper.truncate", "avalonia.ts")] |
|||
public static partial void Truncate(JSObject stream, [JSMarshalAs<JSType.Number>] long size); |
|||
|
|||
[JSImport("StreamHelper.write", "avalonia.ts")] |
|||
public static partial Task WriteAsync(JSObject stream, [JSMarshalAs<JSType.MemoryView>] ArraySegment<byte> data); |
|||
|
|||
[JSImport("StreamHelper.close", "avalonia.ts")] |
|||
public static partial Task CloseAsync(JSObject stream); |
|||
|
|||
[JSImport("StreamHelper.byteLength", "avalonia.ts")] |
|||
[return: JSMarshalAs<JSType.Number>] |
|||
public static partial long ByteLength(JSObject stream); |
|||
|
|||
[JSImport("StreamHelper.sliceArrayBuffer", "avalonia.ts")] |
|||
private static partial Task<JSObject> SliceToArrayBuffer(JSObject stream, [JSMarshalAs<JSType.Number>] long offset, int count); |
|||
|
|||
[JSImport("StreamHelper.toMemoryView", "avalonia.ts")] |
|||
[return: JSMarshalAs<JSType.Array<JSType.Number>>] |
|||
private static partial byte[] ArrayBufferToMemoryView(JSObject stream); |
|||
|
|||
public static async Task<byte[]> SliceAsync(JSObject stream, long offset, int count) |
|||
{ |
|||
using var buffer = await SliceToArrayBuffer(stream, offset, count); |
|||
return ArrayBufferToMemoryView(buffer); |
|||
} |
|||
} |
|||
@ -0,0 +1,30 @@ |
|||
using System; |
|||
using System.Runtime.InteropServices.JavaScript; |
|||
|
|||
using Avalonia.Controls.Platform; |
|||
|
|||
namespace Avalonia.Web; |
|||
|
|||
public class JSObjectControlHandle : INativeControlHostDestroyableControlHandle |
|||
{ |
|||
internal const string ElementReferenceDescriptor = "JSObject"; |
|||
|
|||
public JSObjectControlHandle(JSObject reference) |
|||
{ |
|||
Object = reference; |
|||
} |
|||
|
|||
public JSObject Object { get; } |
|||
|
|||
public IntPtr Handle => throw new NotSupportedException(); |
|||
|
|||
public string? HandleDescriptor => ElementReferenceDescriptor; |
|||
|
|||
public void Destroy() |
|||
{ |
|||
if (Object is JSObject inProcess && !inProcess.IsDisposed) |
|||
{ |
|||
inProcess.Dispose(); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,129 @@ |
|||
using System.Collections.Generic; |
|||
|
|||
using Avalonia.Input; |
|||
|
|||
namespace Avalonia.Web |
|||
{ |
|||
internal static class Keycodes |
|||
{ |
|||
public static Dictionary<string, Key> KeyCodes = new() |
|||
{ |
|||
{ "Escape", Key.Escape }, |
|||
{ "Digit1", Key.D1 }, |
|||
{ "Digit2", Key.D2 }, |
|||
{ "Digit3", Key.D3 }, |
|||
{ "Digit4", Key.D4 }, |
|||
{ "Digit5", Key.D5 }, |
|||
{ "Digit6", Key.D6 }, |
|||
{ "Digit7", Key.D7 }, |
|||
{ "Digit8", Key.D8 }, |
|||
{ "Digit9", Key.D9 }, |
|||
{ "Digit0", Key.D0 }, |
|||
{ "Minus", Key.OemMinus }, |
|||
//{ "Equal" , Key. },
|
|||
{ "Backspace", Key.Back }, |
|||
{ "Tab", Key.Tab }, |
|||
{ "KeyQ", Key.Q }, |
|||
{ "KeyW", Key.W }, |
|||
{ "KeyE", Key.E }, |
|||
{ "KeyR", Key.R }, |
|||
{ "KeyT", Key.T }, |
|||
{ "KeyY", Key.Y }, |
|||
{ "KeyU", Key.U }, |
|||
{ "KeyI", Key.I }, |
|||
{ "KeyO", Key.O }, |
|||
{ "KeyP", Key.P }, |
|||
{ "BracketLeft", Key.OemOpenBrackets }, |
|||
{ "BracketRight", Key.OemCloseBrackets }, |
|||
{ "Enter", Key.Enter }, |
|||
{ "ControlLeft", Key.LeftCtrl }, |
|||
{ "KeyA", Key.A }, |
|||
{ "KeyS", Key.S }, |
|||
{ "KeyD", Key.D }, |
|||
{ "KeyF", Key.F }, |
|||
{ "KeyG", Key.G }, |
|||
{ "KeyH", Key.H }, |
|||
{ "KeyJ", Key.J }, |
|||
{ "KeyK", Key.K }, |
|||
{ "KeyL", Key.L }, |
|||
{ "Semicolon", Key.OemSemicolon }, |
|||
{ "Quote", Key.OemQuotes }, |
|||
//{ "Backquote" , Key. },
|
|||
{ "ShiftLeft", Key.LeftShift }, |
|||
{ "Backslash", Key.OemBackslash }, |
|||
{ "KeyZ", Key.Z }, |
|||
{ "KeyX", Key.X }, |
|||
{ "KeyC", Key.C }, |
|||
{ "KeyV", Key.V }, |
|||
{ "KeyB", Key.B }, |
|||
{ "KeyN", Key.N }, |
|||
{ "KeyM", Key.M }, |
|||
{ "Comma", Key.OemComma }, |
|||
{ "Period", Key.OemPeriod }, |
|||
//{ "Slash" , Key. },
|
|||
{ "ShiftRight", Key.RightShift }, |
|||
{ "NumpadMultiply", Key.Multiply }, |
|||
{ "AltLeft", Key.LeftAlt }, |
|||
{ "Space", Key.Space }, |
|||
{ "CapsLock", Key.CapsLock }, |
|||
{ "F1", Key.F1 }, |
|||
{ "F2", Key.F2 }, |
|||
{ "F3", Key.F3 }, |
|||
{ "F4", Key.F4 }, |
|||
{ "F5", Key.F5 }, |
|||
{ "F6", Key.F6 }, |
|||
{ "F7", Key.F7 }, |
|||
{ "F8", Key.F8 }, |
|||
{ "F9", Key.F9 }, |
|||
{ "F10", Key.F10 }, |
|||
{ "NumLock", Key.NumLock }, |
|||
{ "ScrollLock", Key.Scroll }, |
|||
{ "Numpad7", Key.NumPad7 }, |
|||
{ "Numpad8", Key.NumPad8 }, |
|||
{ "Numpad9", Key.NumPad9 }, |
|||
{ "NumpadSubtract", Key.Subtract }, |
|||
{ "Numpad4", Key.NumPad4 }, |
|||
{ "Numpad5", Key.NumPad5 }, |
|||
{ "Numpad6", Key.NumPad6 }, |
|||
{ "NumpadAdd", Key.Add }, |
|||
{ "Numpad1", Key.NumPad1 }, |
|||
{ "Numpad2", Key.NumPad2 }, |
|||
{ "Numpad3", Key.NumPad3 }, |
|||
{ "Numpad0", Key.NumPad0 }, |
|||
{ "NumpadDecimal", Key.Decimal }, |
|||
{ "Unidentified", Key.NoName }, |
|||
//{ "IntlBackslash" , Key.bac },
|
|||
{ "F11", Key.F11 }, |
|||
{ "F12", Key.F12 }, |
|||
//{ "IntlRo" , Key.Ro },
|
|||
//{ "Unidentified" , Key. },
|
|||
{ "Convert", Key.ImeConvert }, |
|||
{ "KanaMode", Key.KanaMode }, |
|||
{ "NonConvert", Key.ImeNonConvert }, |
|||
//{ "Unidentified" , Key. },
|
|||
{ "NumpadEnter", Key.Enter }, |
|||
{ "ControlRight", Key.RightCtrl }, |
|||
{ "NumpadDivide", Key.Divide }, |
|||
{ "PrintScreen", Key.PrintScreen }, |
|||
{ "AltRight", Key.RightAlt }, |
|||
//{ "Unidentified" , Key. },
|
|||
{ "Home", Key.Home }, |
|||
{ "ArrowUp", Key.Up }, |
|||
{ "PageUp", Key.PageUp }, |
|||
{ "ArrowLeft", Key.Left }, |
|||
{ "ArrowRight", Key.Right }, |
|||
{ "End", Key.End }, |
|||
{ "ArrowDown", Key.Down }, |
|||
{ "PageDown", Key.PageDown }, |
|||
{ "Insert", Key.Insert }, |
|||
{ "Delete", Key.Delete }, |
|||
//{ "Unidentified" , Key. },
|
|||
{ "AudioVolumeMute", Key.VolumeMute }, |
|||
{ "AudioVolumeDown", Key.VolumeDown }, |
|||
{ "AudioVolumeUp", Key.VolumeUp }, |
|||
//{ "NumpadEqual" , Key. },
|
|||
{ "Pause", Key.Pause }, |
|||
{ "NumpadComma", Key.OemComma } |
|||
}; |
|||
} |
|||
} |
|||
@ -0,0 +1,18 @@ |
|||
using System; |
|||
using System.Diagnostics; |
|||
using Avalonia.Rendering; |
|||
|
|||
namespace Avalonia.Web |
|||
{ |
|||
public class ManualTriggerRenderTimer : IRenderTimer |
|||
{ |
|||
private static readonly Stopwatch s_sw = Stopwatch.StartNew(); |
|||
|
|||
public static ManualTriggerRenderTimer Instance { get; } = new(); |
|||
|
|||
public void RaiseTick() => Tick?.Invoke(s_sw.Elapsed); |
|||
|
|||
public event Action<TimeSpan>? Tick; |
|||
public bool RunsInBackground => false; |
|||
} |
|||
} |
|||
@ -0,0 +1,26 @@ |
|||
using System.Collections.Generic; |
|||
using Avalonia.Skia; |
|||
|
|||
namespace Avalonia.Web.Skia |
|||
{ |
|||
public class BrowserSkiaGpu : ISkiaGpu |
|||
{ |
|||
public ISkiaGpuRenderTarget? TryCreateRenderTarget(IEnumerable<object> surfaces) |
|||
{ |
|||
foreach (var surface in surfaces) |
|||
{ |
|||
if (surface is BrowserSkiaSurface browserSkiaSurface) |
|||
{ |
|||
return new BrowserSkiaGpuRenderTarget(browserSkiaSurface); |
|||
} |
|||
} |
|||
|
|||
return null; |
|||
} |
|||
|
|||
public ISkiaSurface? TryCreateSurface(PixelSize size, ISkiaGpuRenderSession session) |
|||
{ |
|||
return null; |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,36 @@ |
|||
using Avalonia.Skia; |
|||
using SkiaSharp; |
|||
|
|||
namespace Avalonia.Web.Skia |
|||
{ |
|||
internal class BrowserSkiaGpuRenderSession : ISkiaGpuRenderSession |
|||
{ |
|||
private readonly SKSurface _surface; |
|||
|
|||
public BrowserSkiaGpuRenderSession(BrowserSkiaSurface browserSkiaSurface, GRBackendRenderTarget renderTarget) |
|||
{ |
|||
_surface = SKSurface.Create(browserSkiaSurface.Context, renderTarget, browserSkiaSurface.Origin, browserSkiaSurface.ColorType); |
|||
|
|||
GrContext = browserSkiaSurface.Context; |
|||
|
|||
ScaleFactor = browserSkiaSurface.Scaling; |
|||
|
|||
SurfaceOrigin = browserSkiaSurface.Origin; |
|||
} |
|||
|
|||
public void Dispose() |
|||
{ |
|||
_surface.Flush(); |
|||
|
|||
_surface.Dispose(); |
|||
} |
|||
|
|||
public GRContext GrContext { get; } |
|||
|
|||
public SKSurface SkSurface => _surface; |
|||
|
|||
public double ScaleFactor { get; } |
|||
|
|||
public GRSurfaceOrigin SurfaceOrigin { get; } |
|||
} |
|||
} |
|||
@ -0,0 +1,39 @@ |
|||
using Avalonia.Skia; |
|||
using SkiaSharp; |
|||
|
|||
namespace Avalonia.Web.Skia |
|||
{ |
|||
internal class BrowserSkiaGpuRenderTarget : ISkiaGpuRenderTarget |
|||
{ |
|||
private readonly GRBackendRenderTarget _renderTarget; |
|||
private readonly BrowserSkiaSurface _browserSkiaSurface; |
|||
private readonly PixelSize _size; |
|||
|
|||
public BrowserSkiaGpuRenderTarget(BrowserSkiaSurface browserSkiaSurface) |
|||
{ |
|||
_size = browserSkiaSurface.Size; |
|||
|
|||
var glFbInfo = new GRGlFramebufferInfo(browserSkiaSurface.GlInfo.FboId, browserSkiaSurface.ColorType.ToGlSizedFormat()); |
|||
{ |
|||
_browserSkiaSurface = browserSkiaSurface; |
|||
_renderTarget = new GRBackendRenderTarget( |
|||
(int)(browserSkiaSurface.Size.Width * browserSkiaSurface.Scaling), |
|||
(int)(browserSkiaSurface.Size.Height * browserSkiaSurface.Scaling), |
|||
browserSkiaSurface.GlInfo.Samples, |
|||
browserSkiaSurface.GlInfo.Stencils, glFbInfo); |
|||
} |
|||
} |
|||
|
|||
public void Dispose() |
|||
{ |
|||
_renderTarget.Dispose(); |
|||
} |
|||
|
|||
public ISkiaGpuRenderSession BeginRenderingSession() |
|||
{ |
|||
return new BrowserSkiaGpuRenderSession(_browserSkiaSurface, _renderTarget); |
|||
} |
|||
|
|||
public bool IsCorrupted => _browserSkiaSurface.Size != _size; |
|||
} |
|||
} |
|||
@ -0,0 +1,88 @@ |
|||
using System; |
|||
using System.Runtime.InteropServices; |
|||
using Avalonia.Controls.Platform.Surfaces; |
|||
using Avalonia.Platform; |
|||
using Avalonia.Skia; |
|||
using SkiaSharp; |
|||
|
|||
namespace Avalonia.Web.Skia |
|||
{ |
|||
internal class BrowserSkiaRasterSurface : IBrowserSkiaSurface, IFramebufferPlatformSurface, IDisposable |
|||
{ |
|||
public SKColorType ColorType { get; set; } |
|||
|
|||
public PixelSize Size { get; set; } |
|||
|
|||
public double Scaling { get; set; } |
|||
|
|||
private FramebufferData? _fbData; |
|||
private readonly Action<IntPtr, SKSizeI> _blitCallback; |
|||
private readonly Action _onDisposeAction; |
|||
|
|||
public BrowserSkiaRasterSurface( |
|||
SKColorType colorType, PixelSize size, double scaling, Action<IntPtr, SKSizeI> blitCallback) |
|||
{ |
|||
ColorType = colorType; |
|||
Size = size; |
|||
Scaling = scaling; |
|||
_blitCallback = blitCallback; |
|||
_onDisposeAction = Blit; |
|||
} |
|||
|
|||
public void Dispose() |
|||
{ |
|||
_fbData?.Dispose(); |
|||
_fbData = null; |
|||
} |
|||
|
|||
public ILockedFramebuffer Lock() |
|||
{ |
|||
var bytesPerPixel = 4; // TODO: derive from ColorType
|
|||
var dpi = Scaling * 96.0; |
|||
var width = (int)(Size.Width * Scaling); |
|||
var height = (int)(Size.Height * Scaling); |
|||
|
|||
if (_fbData is null || _fbData?.Size.Width != width || _fbData?.Size.Height != height) |
|||
{ |
|||
_fbData?.Dispose(); |
|||
_fbData = new FramebufferData(width, height, bytesPerPixel); |
|||
} |
|||
|
|||
var pixelFormat = ColorType.ToPixelFormat(); |
|||
var data = _fbData.Value; |
|||
return new LockedFramebuffer( |
|||
data.Address, data.Size, data.RowBytes, |
|||
new Vector(dpi, dpi), pixelFormat, _onDisposeAction); |
|||
} |
|||
|
|||
private void Blit() |
|||
{ |
|||
if (_fbData != null) |
|||
{ |
|||
var data = _fbData.Value; |
|||
_blitCallback(data.Address, new SKSizeI(data.Size.Width, data.Size.Height)); |
|||
} |
|||
} |
|||
|
|||
private readonly struct FramebufferData |
|||
{ |
|||
public PixelSize Size { get; } |
|||
|
|||
public int RowBytes { get; } |
|||
|
|||
public IntPtr Address { get; } |
|||
|
|||
public FramebufferData(int width, int height, int bytesPerPixel) |
|||
{ |
|||
Size = new PixelSize(width, height); |
|||
RowBytes = width * bytesPerPixel; |
|||
Address = Marshal.AllocHGlobal(width * height * bytesPerPixel); |
|||
} |
|||
|
|||
public void Dispose() |
|||
{ |
|||
Marshal.FreeHGlobal(Address); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,30 @@ |
|||
using Avalonia.Web.Interop; |
|||
using SkiaSharp; |
|||
|
|||
namespace Avalonia.Web.Skia |
|||
{ |
|||
internal class BrowserSkiaSurface : IBrowserSkiaSurface |
|||
{ |
|||
public BrowserSkiaSurface(GRContext context, GLInfo glInfo, SKColorType colorType, PixelSize size, double scaling, GRSurfaceOrigin origin) |
|||
{ |
|||
Context = context; |
|||
GlInfo = glInfo; |
|||
ColorType = colorType; |
|||
Size = size; |
|||
Scaling = scaling; |
|||
Origin = origin; |
|||
} |
|||
|
|||
public SKColorType ColorType { get; set; } |
|||
|
|||
public PixelSize Size { get; set; } |
|||
|
|||
public GRContext Context { get; set; } |
|||
|
|||
public GRSurfaceOrigin Origin { get; set; } |
|||
|
|||
public double Scaling { get; set; } |
|||
|
|||
public GLInfo GlInfo { get; set; } |
|||
} |
|||
} |
|||
@ -0,0 +1,9 @@ |
|||
namespace Avalonia.Web.Skia |
|||
{ |
|||
internal interface IBrowserSkiaSurface |
|||
{ |
|||
public PixelSize Size { get; set; } |
|||
|
|||
public double Scaling { get; set; } |
|||
} |
|||
} |
|||
@ -0,0 +1,88 @@ |
|||
using System; |
|||
using System.IO; |
|||
using System.Runtime.InteropServices.JavaScript; |
|||
using System.Threading; |
|||
using System.Threading.Tasks; |
|||
|
|||
namespace Avalonia.Web.Storage; |
|||
|
|||
[System.Runtime.Versioning.SupportedOSPlatform("browser")] |
|||
internal class BlobReadableStream : Stream |
|||
{ |
|||
private JSObject? _jSReference; |
|||
private long _position; |
|||
private readonly long _length; |
|||
|
|||
public BlobReadableStream(JSObject jsStreamReference) |
|||
{ |
|||
_jSReference = jsStreamReference; |
|||
_position = 0; |
|||
_length = StreamHelper.ByteLength(JSReference); |
|||
} |
|||
|
|||
private JSObject JSReference => _jSReference ?? throw new ObjectDisposedException(nameof(WriteableStream)); |
|||
|
|||
public override bool CanRead => true; |
|||
|
|||
public override bool CanSeek => false; |
|||
|
|||
public override bool CanWrite => false; |
|||
|
|||
public override long Length => _length; |
|||
|
|||
public override long Position |
|||
{ |
|||
get => _position; |
|||
set => throw new NotSupportedException(); |
|||
} |
|||
|
|||
public override void Flush() { } |
|||
|
|||
public override long Seek(long offset, SeekOrigin origin) |
|||
{ |
|||
return _position = origin switch |
|||
{ |
|||
SeekOrigin.Current => _position + offset, |
|||
SeekOrigin.End => _length + offset, |
|||
_ => offset |
|||
}; |
|||
} |
|||
|
|||
public override void SetLength(long value) |
|||
=> throw new NotSupportedException(); |
|||
|
|||
public override void Write(byte[] buffer, int offset, int count) |
|||
=> throw new NotSupportedException(); |
|||
|
|||
public override int Read(byte[] buffer, int offset, int count) |
|||
{ |
|||
throw new InvalidOperationException("Browser supports only ReadAsync"); |
|||
} |
|||
|
|||
public override async Task<int> ReadAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) |
|||
=> await ReadAsync(buffer.AsMemory(offset, count), cancellationToken); |
|||
|
|||
public override async ValueTask<int> ReadAsync(Memory<byte> buffer, CancellationToken cancellationToken = default) |
|||
{ |
|||
var numBytesToRead = (int)Math.Min(buffer.Length, Length - _position); |
|||
var bytesRead = await StreamHelper.SliceAsync(JSReference, _position, numBytesToRead); |
|||
if (bytesRead.Length != numBytesToRead) |
|||
{ |
|||
throw new EndOfStreamException("Failed to read the requested number of bytes from the stream."); |
|||
} |
|||
|
|||
_position += bytesRead.Length; |
|||
bytesRead.CopyTo(buffer); |
|||
|
|||
return bytesRead.Length; |
|||
} |
|||
|
|||
protected override void Dispose(bool disposing) |
|||
{ |
|||
if (_jSReference is { } jsReference) |
|||
{ |
|||
_jSReference = null; |
|||
jsReference.Dispose(); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,257 @@ |
|||
using System; |
|||
using System.Collections.Generic; |
|||
using System.Diagnostics.CodeAnalysis; |
|||
using System.IO; |
|||
using System.Linq; |
|||
using System.Runtime.InteropServices.JavaScript; |
|||
using System.Runtime.Versioning; |
|||
using System.Threading.Tasks; |
|||
|
|||
using Avalonia.Platform.Storage; |
|||
using Avalonia.Web.Interop; |
|||
|
|||
namespace Avalonia.Web.Storage; |
|||
|
|||
internal record FilePickerAcceptType(string Description, IReadOnlyDictionary<string, IReadOnlyList<string>> Accept); |
|||
|
|||
[SupportedOSPlatform("browser")] |
|||
internal class BrowserStorageProvider : IStorageProvider |
|||
{ |
|||
internal const string PickerCancelMessage = "The user aborted a request"; |
|||
internal const string NoPermissionsMessage = "Permissions denied"; |
|||
|
|||
private readonly Lazy<Task<JSObject>> _lazyModule = new(() => JSHost.ImportAsync("storage.ts", "./storage.js")); |
|||
|
|||
public bool CanOpen => StorageHelper.CanShowOpenFilePicker(); |
|||
public bool CanSave => StorageHelper.CanShowSaveFilePicker(); |
|||
public bool CanPickFolder => StorageHelper.CanShowDirectoryPicker(); |
|||
|
|||
public async Task<IReadOnlyList<IStorageFile>> OpenFilePickerAsync(FilePickerOpenOptions options) |
|||
{ |
|||
_ = await _lazyModule.Value; |
|||
var startIn = (options.SuggestedStartLocation as JSStorageItem)?.FileHandle; |
|||
|
|||
var (types, exludeAll) = ConvertFileTypes(options.FileTypeFilter); |
|||
|
|||
try |
|||
{ |
|||
using var items = await StorageHelper.OpenFileDialog(startIn, options.AllowMultiple, types, exludeAll); |
|||
if (items is null) |
|||
{ |
|||
return Array.Empty<IStorageFile>(); |
|||
} |
|||
|
|||
var itemsArray = StorageHelper.ItemsArray(items); |
|||
return itemsArray.Select(item => new JSStorageFile(item)).ToArray(); |
|||
} |
|||
catch (JSException ex) when (ex.Message.Contains(PickerCancelMessage, StringComparison.Ordinal)) |
|||
{ |
|||
return Array.Empty<IStorageFile>(); |
|||
} |
|||
finally |
|||
{ |
|||
if (types is not null) |
|||
{ |
|||
foreach (var type in types) |
|||
{ |
|||
type.Dispose(); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
public async Task<IStorageFile?> SaveFilePickerAsync(FilePickerSaveOptions options) |
|||
{ |
|||
_ = await _lazyModule.Value; |
|||
var startIn = (options.SuggestedStartLocation as JSStorageItem)?.FileHandle; |
|||
|
|||
var (types, exludeAll) = ConvertFileTypes(options.FileTypeChoices); |
|||
|
|||
try |
|||
{ |
|||
var item = await StorageHelper.SaveFileDialog(startIn, options.SuggestedFileName, types, exludeAll); |
|||
return item is not null ? new JSStorageFile(item) : null; |
|||
} |
|||
catch (JSException ex) when (ex.Message.Contains(PickerCancelMessage, StringComparison.Ordinal)) |
|||
{ |
|||
return null; |
|||
} |
|||
finally |
|||
{ |
|||
if (types is not null) |
|||
{ |
|||
foreach (var type in types) |
|||
{ |
|||
type.Dispose(); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
|
|||
public async Task<IReadOnlyList<IStorageFolder>> OpenFolderPickerAsync(FolderPickerOpenOptions options) |
|||
{ |
|||
_ = await _lazyModule.Value; |
|||
var startIn = (options.SuggestedStartLocation as JSStorageItem)?.FileHandle; |
|||
|
|||
try |
|||
{ |
|||
var item = await StorageHelper.SelectFolderDialog(startIn); |
|||
return item is not null ? new[] { new JSStorageFolder(item) } : Array.Empty<IStorageFolder>(); |
|||
} |
|||
catch (JSException ex) when (ex.Message.Contains(PickerCancelMessage, StringComparison.Ordinal)) |
|||
{ |
|||
return Array.Empty<IStorageFolder>(); |
|||
} |
|||
} |
|||
|
|||
public async Task<IStorageBookmarkFile?> OpenFileBookmarkAsync(string bookmark) |
|||
{ |
|||
_ = await _lazyModule.Value; |
|||
var item = await StorageHelper.OpenBookmark(bookmark); |
|||
return item is not null ? new JSStorageFile(item) : null; |
|||
} |
|||
|
|||
public async Task<IStorageBookmarkFolder?> OpenFolderBookmarkAsync(string bookmark) |
|||
{ |
|||
_ = await _lazyModule.Value; |
|||
var item = await StorageHelper.OpenBookmark(bookmark); |
|||
return item is not null ? new JSStorageFolder(item) : null; |
|||
} |
|||
|
|||
private static (JSObject[]? types, bool excludeAllOption) ConvertFileTypes(IEnumerable<FilePickerFileType>? input) |
|||
{ |
|||
var types = input? |
|||
.Where(t => t.MimeTypes?.Any() == true && t != FilePickerFileTypes.All) |
|||
.Select(t => StorageHelper.CreateAcceptType(t.Name, t.MimeTypes!.ToArray())) |
|||
.ToArray(); |
|||
if (types?.Length == 0) |
|||
{ |
|||
types = null; |
|||
} |
|||
|
|||
var inlcudeAll = input?.Contains(FilePickerFileTypes.All) == true || types is null; |
|||
|
|||
return (types, !inlcudeAll); |
|||
} |
|||
} |
|||
|
|||
internal abstract class JSStorageItem : IStorageBookmarkItem |
|||
{ |
|||
internal JSObject? _fileHandle; |
|||
|
|||
protected JSStorageItem(JSObject fileHandle) |
|||
{ |
|||
_fileHandle = fileHandle ?? throw new ArgumentNullException(nameof(fileHandle)); |
|||
} |
|||
|
|||
internal JSObject FileHandle => _fileHandle ?? throw new ObjectDisposedException(nameof(JSStorageItem)); |
|||
|
|||
public string Name => FileHandle.GetPropertyAsString("name") ?? string.Empty; |
|||
|
|||
public bool TryGetUri([NotNullWhen(true)] out Uri? uri) |
|||
{ |
|||
uri = new Uri(Name, UriKind.Relative); |
|||
return false; |
|||
} |
|||
|
|||
public async Task<StorageItemProperties> GetBasicPropertiesAsync() |
|||
{ |
|||
using var properties = await StorageHelper.GetProperties(FileHandle); |
|||
var size = (long?)properties?.GetPropertyAsDouble("Size"); |
|||
var lastModified = (long?)properties?.GetPropertyAsDouble("LastModified"); |
|||
|
|||
return new StorageItemProperties( |
|||
(ulong?)size, |
|||
dateCreated: null, |
|||
dateModified: lastModified > 0 ? DateTimeOffset.FromUnixTimeMilliseconds(lastModified.Value) : null); |
|||
} |
|||
|
|||
public bool CanBookmark => true; |
|||
|
|||
public Task<string?> SaveBookmarkAsync() |
|||
{ |
|||
return StorageHelper.SaveBookmark(FileHandle); |
|||
} |
|||
|
|||
public Task<IStorageFolder?> GetParentAsync() |
|||
{ |
|||
return Task.FromResult<IStorageFolder?>(null); |
|||
} |
|||
|
|||
public Task ReleaseBookmarkAsync() |
|||
{ |
|||
return StorageHelper.DeleteBookmark(FileHandle); |
|||
} |
|||
|
|||
public void Dispose() |
|||
{ |
|||
_fileHandle?.Dispose(); |
|||
_fileHandle = null; |
|||
} |
|||
} |
|||
|
|||
internal class JSStorageFile : JSStorageItem, IStorageBookmarkFile |
|||
{ |
|||
public JSStorageFile(JSObject fileHandle) : base(fileHandle) |
|||
{ |
|||
} |
|||
|
|||
public bool CanOpenRead => true; |
|||
public async Task<Stream> OpenReadAsync() |
|||
{ |
|||
try |
|||
{ |
|||
var blob = await StorageHelper.OpenRead(FileHandle); |
|||
return new BlobReadableStream(blob); |
|||
} |
|||
catch (JSException ex) when (ex.Message == BrowserStorageProvider.NoPermissionsMessage) |
|||
{ |
|||
throw new UnauthorizedAccessException("User denied permissions to open the file", ex); |
|||
} |
|||
} |
|||
|
|||
public bool CanOpenWrite => true; |
|||
public async Task<Stream> OpenWriteAsync() |
|||
{ |
|||
try |
|||
{ |
|||
using var properties = await StorageHelper.GetProperties(FileHandle); |
|||
var streamWriter = await StorageHelper.OpenWrite(FileHandle); |
|||
var size = (long?)properties?.GetPropertyAsDouble("Size") ?? 0; |
|||
|
|||
return new WriteableStream(streamWriter, size); |
|||
} |
|||
catch (JSException ex) when (ex.Message == BrowserStorageProvider.NoPermissionsMessage) |
|||
{ |
|||
throw new UnauthorizedAccessException("User denied permissions to open the file", ex); |
|||
} |
|||
} |
|||
} |
|||
|
|||
internal class JSStorageFolder : JSStorageItem, IStorageBookmarkFolder |
|||
{ |
|||
public JSStorageFolder(JSObject fileHandle) : base(fileHandle) |
|||
{ |
|||
} |
|||
|
|||
public async Task<IReadOnlyList<IStorageItem>> GetItemsAsync() |
|||
{ |
|||
using var items = await StorageHelper.GetItems(FileHandle); |
|||
if (items is null) |
|||
{ |
|||
return Array.Empty<IStorageItem>(); |
|||
} |
|||
|
|||
var itemsArray = StorageHelper.ItemsArray(items); |
|||
|
|||
return itemsArray |
|||
.Select(reference => reference.GetPropertyAsString("kind") switch |
|||
{ |
|||
"directory" => (IStorageItem)new JSStorageFolder(reference), |
|||
"file" => new JSStorageFile(reference), |
|||
_ => null |
|||
}) |
|||
.Where(i => i is not null) |
|||
.ToArray()!; |
|||
} |
|||
} |
|||
@ -0,0 +1,124 @@ |
|||
using System; |
|||
using System.IO; |
|||
using System.Runtime.InteropServices.JavaScript; |
|||
using System.Threading; |
|||
using System.Threading.Tasks; |
|||
|
|||
namespace Avalonia.Web.Storage; |
|||
|
|||
[System.Runtime.Versioning.SupportedOSPlatform("browser")] |
|||
// Loose wrapper implementaion of a stream on top of FileAPI FileSystemWritableFileStream
|
|||
internal sealed class WriteableStream : Stream |
|||
{ |
|||
private JSObject? _jSReference; |
|||
|
|||
// Unfortunatelly we can't read current length/position, so we need to keep it C#-side only.
|
|||
private long _length, _position; |
|||
|
|||
internal WriteableStream(JSObject jSReference, long initialLength) |
|||
{ |
|||
_jSReference = jSReference; |
|||
_length = initialLength; |
|||
} |
|||
|
|||
private JSObject JSReference => _jSReference ?? throw new ObjectDisposedException(nameof(WriteableStream)); |
|||
|
|||
public override bool CanRead => false; |
|||
|
|||
public override bool CanSeek => true; |
|||
|
|||
public override bool CanWrite => true; |
|||
|
|||
public override long Length => _length; |
|||
|
|||
public override long Position |
|||
{ |
|||
get => _position; |
|||
set => Seek(_position, SeekOrigin.Begin); |
|||
} |
|||
|
|||
public override void Flush() |
|||
{ |
|||
// no-op
|
|||
} |
|||
|
|||
public override int Read(byte[] buffer, int offset, int count) |
|||
{ |
|||
throw new NotSupportedException(); |
|||
} |
|||
|
|||
public override long Seek(long offset, SeekOrigin origin) |
|||
{ |
|||
var position = origin switch |
|||
{ |
|||
SeekOrigin.Current => _position + offset, |
|||
SeekOrigin.End => _length + offset, |
|||
_ => offset |
|||
}; |
|||
StreamHelper.Seek(JSReference, position); |
|||
return position; |
|||
} |
|||
|
|||
public override void SetLength(long value) |
|||
{ |
|||
_length = value; |
|||
|
|||
// See https://docs.w3cub.com/dom/filesystemwritablefilestream/truncate
|
|||
// If the offset is smaller than the size, it remains unchanged. If the offset is larger than size, the offset is set to that size
|
|||
if (_position > _length) |
|||
{ |
|||
_position = _length; |
|||
} |
|||
|
|||
StreamHelper.Truncate(JSReference, value); |
|||
} |
|||
|
|||
public override void Write(byte[] buffer, int offset, int count) |
|||
{ |
|||
throw new InvalidOperationException("Browser supports only WriteAsync"); |
|||
} |
|||
|
|||
public override ValueTask WriteAsync(ReadOnlyMemory<byte> buffer, CancellationToken cancellationToken = default) |
|||
{ |
|||
return new ValueTask(WriteAsyncInternal(buffer.ToArray(), cancellationToken)); |
|||
} |
|||
|
|||
private Task WriteAsyncInternal(byte[] buffer, CancellationToken _) |
|||
{ |
|||
_position += buffer.Length; |
|||
|
|||
return StreamHelper.WriteAsync(JSReference, buffer); |
|||
} |
|||
|
|||
protected override void Dispose(bool disposing) |
|||
{ |
|||
if (_jSReference is { } jsReference) |
|||
{ |
|||
_jSReference = null; |
|||
try |
|||
{ |
|||
_ = StreamHelper.CloseAsync(jsReference); |
|||
} |
|||
finally |
|||
{ |
|||
jsReference.Dispose(); |
|||
} |
|||
} |
|||
} |
|||
|
|||
public override async ValueTask DisposeAsync() |
|||
{ |
|||
if (_jSReference is { } jsReference) |
|||
{ |
|||
_jSReference = null; |
|||
try |
|||
{ |
|||
await StreamHelper.CloseAsync(jsReference); |
|||
} |
|||
finally |
|||
{ |
|||
jsReference.Dispose(); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,68 @@ |
|||
using System; |
|||
using Avalonia.Controls.Embedding; |
|||
using Avalonia.Media; |
|||
using Avalonia.Platform; |
|||
using Avalonia.Rendering.SceneGraph; |
|||
|
|||
namespace Avalonia.Web |
|||
{ |
|||
internal class WebEmbeddableControlRoot : EmbeddableControlRoot |
|||
{ |
|||
class SplashScreenCloseCustomDrawingOperation : ICustomDrawOperation |
|||
{ |
|||
private bool _hasRendered; |
|||
private Action _onFirstRender; |
|||
|
|||
public SplashScreenCloseCustomDrawingOperation(Action onFirstRender) |
|||
{ |
|||
_onFirstRender = onFirstRender; |
|||
} |
|||
|
|||
public Rect Bounds => Rect.Empty; |
|||
|
|||
public bool HasRendered => _hasRendered; |
|||
|
|||
public void Dispose() |
|||
{ |
|||
|
|||
} |
|||
|
|||
public bool Equals(ICustomDrawOperation? other) |
|||
{ |
|||
return false; |
|||
} |
|||
|
|||
public bool HitTest(Point p) |
|||
{ |
|||
return false; |
|||
} |
|||
|
|||
public void Render(IDrawingContextImpl context) |
|||
{ |
|||
_hasRendered = true; |
|||
_onFirstRender(); |
|||
} |
|||
} |
|||
|
|||
public WebEmbeddableControlRoot(ITopLevelImpl impl, Action onFirstRender) : base(impl) |
|||
{ |
|||
_splashCloseOp = new SplashScreenCloseCustomDrawingOperation(() => |
|||
{ |
|||
_splashCloseOp = null; |
|||
onFirstRender(); |
|||
}); |
|||
} |
|||
|
|||
private SplashScreenCloseCustomDrawingOperation? _splashCloseOp; |
|||
|
|||
public override void Render(DrawingContext context) |
|||
{ |
|||
base.Render(context); |
|||
|
|||
if (_splashCloseOp != null) |
|||
{ |
|||
context.Custom(_splashCloseOp); |
|||
} |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,48 @@ |
|||
using System.Collections.Generic; |
|||
using System.IO; |
|||
using Avalonia.Platform; |
|||
|
|||
#nullable enable |
|||
|
|||
namespace Avalonia.Web |
|||
{ |
|||
internal class IconLoaderStub : IPlatformIconLoader |
|||
{ |
|||
private class IconStub : IWindowIconImpl |
|||
{ |
|||
public void Save(Stream outputStream) |
|||
{ |
|||
|
|||
} |
|||
} |
|||
|
|||
public IWindowIconImpl LoadIcon(string fileName) => new IconStub(); |
|||
|
|||
public IWindowIconImpl LoadIcon(Stream stream) => new IconStub(); |
|||
|
|||
public IWindowIconImpl LoadIcon(IBitmapImpl bitmap) => new IconStub(); |
|||
} |
|||
|
|||
internal class ScreenStub : IScreenImpl |
|||
{ |
|||
public int ScreenCount => 1; |
|||
|
|||
public IReadOnlyList<Screen> AllScreens { get; } = |
|||
new[] { new Screen(96, new PixelRect(0, 0, 4000, 4000), new PixelRect(0, 0, 4000, 4000), true) }; |
|||
|
|||
public Screen? ScreenFromPoint(PixelPoint point) |
|||
{ |
|||
return ScreenHelper.ScreenFromPoint(point, AllScreens); |
|||
} |
|||
|
|||
public Screen? ScreenFromRect(PixelRect rect) |
|||
{ |
|||
return ScreenHelper.ScreenFromRect(rect, AllScreens); |
|||
} |
|||
|
|||
public Screen? ScreenFromWindow(IWindowBaseImpl window) |
|||
{ |
|||
return ScreenHelper.ScreenFromWindow(window, AllScreens); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,105 @@ |
|||
using System; |
|||
using System.Threading; |
|||
using Avalonia.Input; |
|||
using Avalonia.Input.Platform; |
|||
using Avalonia.Platform; |
|||
using Avalonia.Rendering; |
|||
using Avalonia.Threading; |
|||
|
|||
namespace Avalonia.Web |
|||
{ |
|||
public class BrowserWindowingPlatform : IWindowingPlatform, IPlatformSettings, IPlatformThreadingInterface |
|||
{ |
|||
private bool _signaled; |
|||
private static KeyboardDevice? s_keyboard; |
|||
|
|||
public IWindowImpl CreateWindow() => throw new NotSupportedException(); |
|||
|
|||
IWindowImpl IWindowingPlatform.CreateEmbeddableWindow() |
|||
{ |
|||
throw new NotImplementedException(); |
|||
} |
|||
|
|||
public ITrayIconImpl? CreateTrayIcon() |
|||
{ |
|||
return null; |
|||
} |
|||
|
|||
public static KeyboardDevice Keyboard => s_keyboard ?? |
|||
throw new InvalidOperationException("BrowserWindowingPlatform not registered."); |
|||
|
|||
public static void Register() |
|||
{ |
|||
var instance = new BrowserWindowingPlatform(); |
|||
s_keyboard = new KeyboardDevice(); |
|||
AvaloniaLocator.CurrentMutable |
|||
.Bind<IClipboard>().ToSingleton<ClipboardImpl>() |
|||
.Bind<ICursorFactory>().ToSingleton<CssCursorFactory>() |
|||
.Bind<IKeyboardDevice>().ToConstant(s_keyboard) |
|||
.Bind<IPlatformSettings>().ToConstant(instance) |
|||
.Bind<IPlatformThreadingInterface>().ToConstant(instance) |
|||
.Bind<IRenderLoop>().ToConstant(new RenderLoop()) |
|||
.Bind<IRenderTimer>().ToConstant(ManualTriggerRenderTimer.Instance) |
|||
.Bind<IWindowingPlatform>().ToConstant(instance) |
|||
.Bind<IPlatformIconLoader>().ToSingleton<IconLoaderStub>() |
|||
.Bind<PlatformHotkeyConfiguration>().ToSingleton<PlatformHotkeyConfiguration>(); |
|||
} |
|||
|
|||
public Size DoubleClickSize { get; } = new Size(2, 2); |
|||
|
|||
public TimeSpan DoubleClickTime { get; } = TimeSpan.FromMilliseconds(500); |
|||
|
|||
public Size TouchDoubleClickSize => new Size(16, 16); |
|||
|
|||
public TimeSpan TouchDoubleClickTime => DoubleClickTime; |
|||
public void RunLoop(CancellationToken cancellationToken) |
|||
{ |
|||
throw new NotSupportedException(); |
|||
} |
|||
|
|||
public IDisposable StartTimer(DispatcherPriority priority, TimeSpan interval, Action tick) |
|||
{ |
|||
return GetRuntimePlatform() |
|||
.StartSystemTimer(interval, () => |
|||
{ |
|||
Dispatcher.UIThread.RunJobs(priority); |
|||
tick(); |
|||
}); |
|||
} |
|||
|
|||
public void Signal(DispatcherPriority priority) |
|||
{ |
|||
if (_signaled) |
|||
return; |
|||
|
|||
_signaled = true; |
|||
|
|||
IDisposable? disp = null; |
|||
|
|||
disp = GetRuntimePlatform() |
|||
.StartSystemTimer(TimeSpan.FromMilliseconds(1), |
|||
() => |
|||
{ |
|||
_signaled = false; |
|||
disp?.Dispose(); |
|||
|
|||
Signaled?.Invoke(null); |
|||
}); |
|||
} |
|||
|
|||
public bool CurrentThreadIsLoopThread |
|||
{ |
|||
get |
|||
{ |
|||
return true; // Browser is single threaded.
|
|||
} |
|||
} |
|||
|
|||
public event Action<DispatcherPriority?>? Signaled; |
|||
|
|||
private static IRuntimePlatform GetRuntimePlatform() |
|||
{ |
|||
return AvaloniaLocator.Current.GetRequiredService<IRuntimePlatform>(); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,13 @@ |
|||
var LibraryExample = { |
|||
// Internal functions
|
|||
$EXAMPLE: { |
|||
internal_func: function () { |
|||
} |
|||
}, |
|||
InterceptGLObject: function () { |
|||
globalThis.AvaloniaGL = GL |
|||
} |
|||
} |
|||
|
|||
autoAddDeps(LibraryExample, '$EXAMPLE') |
|||
mergeInto(LibraryManager.library, LibraryExample) |
|||
@ -0,0 +1,47 @@ |
|||
{ |
|||
"env": { |
|||
"browser": true, |
|||
"es6": true |
|||
}, |
|||
"extends": "standard-with-typescript", |
|||
"overrides": [], |
|||
"parserOptions": { |
|||
"ecmaVersion": "latest", |
|||
"sourceType": "module", |
|||
"project": [ |
|||
"tsconfig.json" |
|||
] |
|||
}, |
|||
"rules": { |
|||
"indent": [ |
|||
"warn", |
|||
4 |
|||
], |
|||
"@typescript-eslint/indent": [ |
|||
"warn", |
|||
4 |
|||
], |
|||
"quotes": ["warn", "double"], |
|||
"semi": ["error", "always"], |
|||
"@typescript-eslint/quotes": ["warn", "double"], |
|||
"@typescript-eslint/explicit-function-return-type": "off", |
|||
"@typescript-eslint/no-extraneous-class": "off", |
|||
"@typescript-eslint/strict-boolean-expressions": "off", |
|||
"@typescript-eslint/space-before-function-paren": "off", |
|||
"@typescript-eslint/semi": ["error", "always"], |
|||
"@typescript-eslint/member-delimiter-style": [ |
|||
"error", |
|||
{ |
|||
"multiline": { |
|||
"delimiter": "semi", |
|||
"requireLast": true |
|||
}, |
|||
"singleline": { |
|||
"delimiter": "semi", |
|||
"requireLast": false |
|||
} |
|||
} |
|||
] |
|||
}, |
|||
"ignorePatterns": ["types/*"] |
|||
} |
|||
@ -0,0 +1,16 @@ |
|||
require("esbuild").build({ |
|||
entryPoints: [ |
|||
"./modules/avalonia.ts", |
|||
"./modules/storage.ts" |
|||
], |
|||
outdir: "../wwwroot", |
|||
bundle: true, |
|||
minify: false, |
|||
format: "esm", |
|||
target: "es2016", |
|||
platform: "browser", |
|||
sourcemap: "linked", |
|||
loader: { ".ts": "ts" } |
|||
}) |
|||
.then(() => console.log("⚡ Done")) |
|||
.catch(() => process.exit(1)); |
|||
@ -0,0 +1,20 @@ |
|||
import { RuntimeAPI } from "../types/dotnet"; |
|||
import { SizeWatcher, DpiWatcher, Canvas } from "./avalonia/canvas"; |
|||
import { InputHelper } from "./avalonia/input"; |
|||
import { AvaloniaDOM } from "./avalonia/dom"; |
|||
import { Caniuse } from "./avalonia/caniuse"; |
|||
import { StreamHelper } from "./avalonia/stream"; |
|||
import { NativeControlHost } from "./avalonia/nativeControlHost"; |
|||
|
|||
export async function createAvaloniaRuntime(api: RuntimeAPI): Promise<void> { |
|||
api.setModuleImports("avalonia.ts", { |
|||
Caniuse, |
|||
Canvas, |
|||
InputHelper, |
|||
SizeWatcher, |
|||
DpiWatcher, |
|||
AvaloniaDOM, |
|||
StreamHelper, |
|||
NativeControlHost |
|||
}); |
|||
} |
|||
@ -0,0 +1,13 @@ |
|||
export class Caniuse { |
|||
public static canShowOpenFilePicker(): boolean { |
|||
return typeof window.showOpenFilePicker !== "undefined"; |
|||
} |
|||
|
|||
public static canShowSaveFilePicker(): boolean { |
|||
return typeof window.showSaveFilePicker !== "undefined"; |
|||
} |
|||
|
|||
public static canShowDirectoryPicker(): boolean { |
|||
return typeof window.showDirectoryPicker !== "undefined"; |
|||
} |
|||
} |
|||
@ -0,0 +1,303 @@ |
|||
interface SKGLViewInfo { |
|||
context: WebGLRenderingContext | WebGL2RenderingContext | undefined; |
|||
fboId: number; |
|||
stencil: number; |
|||
sample: number; |
|||
depth: number; |
|||
} |
|||
|
|||
type CanvasElement = { |
|||
Canvas: Canvas | undefined; |
|||
} & HTMLCanvasElement; |
|||
|
|||
export class Canvas { |
|||
static elements: Map<string, HTMLCanvasElement>; |
|||
|
|||
htmlCanvas: HTMLCanvasElement; |
|||
glInfo?: SKGLViewInfo; |
|||
renderFrameCallback: () => void; |
|||
renderLoopEnabled: boolean = false; |
|||
renderLoopRequest: number = 0; |
|||
newWidth?: number; |
|||
newHeight?: number; |
|||
|
|||
public static initGL(element: HTMLCanvasElement, elementId: string, renderFrameCallback: () => void): SKGLViewInfo | null { |
|||
const view = Canvas.init(true, element, elementId, renderFrameCallback); |
|||
if (!view || !view.glInfo) { |
|||
return null; |
|||
} |
|||
|
|||
return view.glInfo; |
|||
} |
|||
|
|||
static init(useGL: boolean, element: HTMLCanvasElement, elementId: string, renderFrameCallback: () => void): Canvas | null { |
|||
const htmlCanvas = element as CanvasElement; |
|||
if (!htmlCanvas) { |
|||
console.error("No canvas element was provided."); |
|||
return null; |
|||
} |
|||
|
|||
if (!Canvas.elements) { |
|||
Canvas.elements = new Map<string, HTMLCanvasElement>(); |
|||
} |
|||
Canvas.elements.set(elementId, element); |
|||
|
|||
const view = new Canvas(useGL, element, renderFrameCallback); |
|||
|
|||
htmlCanvas.Canvas = view; |
|||
|
|||
return view; |
|||
} |
|||
|
|||
public constructor(useGL: boolean, element: HTMLCanvasElement, renderFrameCallback: () => void) { |
|||
this.htmlCanvas = element; |
|||
this.renderFrameCallback = renderFrameCallback; |
|||
|
|||
if (useGL) { |
|||
const ctx = Canvas.createWebGLContext(element); |
|||
if (!ctx) { |
|||
console.error("Failed to create WebGL context"); |
|||
return; |
|||
} |
|||
|
|||
const GL = (globalThis as any).AvaloniaGL; |
|||
|
|||
// make current
|
|||
GL.makeContextCurrent(ctx); |
|||
|
|||
const GLctx = GL.currentContext.GLctx as WebGLRenderingContext; |
|||
|
|||
// read values
|
|||
const fbo = GLctx.getParameter(GLctx.FRAMEBUFFER_BINDING); |
|||
|
|||
this.glInfo = { |
|||
context: ctx, |
|||
fboId: fbo ? fbo.id : 0, |
|||
stencil: GLctx.getParameter(GLctx.STENCIL_BITS), |
|||
sample: 0, // TODO: GLctx.getParameter(GLctx.SAMPLES)
|
|||
depth: GLctx.getParameter(GLctx.DEPTH_BITS) |
|||
}; |
|||
} |
|||
} |
|||
|
|||
public setEnableRenderLoop(enable: boolean): void { |
|||
this.renderLoopEnabled = enable; |
|||
|
|||
// either start the new frame or cancel the existing one
|
|||
if (enable) { |
|||
// console.info(`Enabling render loop with callback ${this.renderFrameCallback._id}...`);
|
|||
this.requestAnimationFrame(); |
|||
} else if (this.renderLoopRequest !== 0) { |
|||
window.cancelAnimationFrame(this.renderLoopRequest); |
|||
this.renderLoopRequest = 0; |
|||
} |
|||
} |
|||
|
|||
public requestAnimationFrame(renderLoop?: boolean): void { |
|||
// optionally update the render loop
|
|||
if (renderLoop !== undefined && this.renderLoopEnabled !== renderLoop) { |
|||
this.setEnableRenderLoop(renderLoop); |
|||
} |
|||
|
|||
// skip because we have a render loop
|
|||
if (this.renderLoopRequest !== 0) { |
|||
return; |
|||
} |
|||
|
|||
// add the draw to the next frame
|
|||
this.renderLoopRequest = window.requestAnimationFrame(() => { |
|||
if (this.glInfo) { |
|||
const GL = (globalThis as any).AvaloniaGL; |
|||
// make current
|
|||
GL.makeContextCurrent(this.glInfo.context); |
|||
} |
|||
|
|||
if (this.htmlCanvas.width !== this.newWidth) { |
|||
this.htmlCanvas.width = this.newWidth ?? 0; |
|||
} |
|||
|
|||
if (this.htmlCanvas.height !== this.newHeight) { |
|||
this.htmlCanvas.height = this.newHeight ?? 0; |
|||
} |
|||
|
|||
this.renderFrameCallback(); |
|||
this.renderLoopRequest = 0; |
|||
|
|||
// we may want to draw the next frame
|
|||
if (this.renderLoopEnabled) { |
|||
this.requestAnimationFrame(); |
|||
} |
|||
}); |
|||
} |
|||
|
|||
public setCanvasSize(width: number, height: number): void { |
|||
this.newWidth = width; |
|||
this.newHeight = height; |
|||
|
|||
if (this.htmlCanvas.width !== this.newWidth) { |
|||
this.htmlCanvas.width = this.newWidth; |
|||
} |
|||
|
|||
if (this.htmlCanvas.height !== this.newHeight) { |
|||
this.htmlCanvas.height = this.newHeight; |
|||
} |
|||
|
|||
if (this.glInfo) { |
|||
const GL = (globalThis as any).AvaloniaGL; |
|||
// make current
|
|||
GL.makeContextCurrent(this.glInfo.context); |
|||
} |
|||
} |
|||
|
|||
public static setCanvasSize(element: HTMLCanvasElement, width: number, height: number): void { |
|||
const htmlCanvas = element as CanvasElement; |
|||
if (!htmlCanvas || !htmlCanvas.Canvas) { |
|||
return; |
|||
} |
|||
|
|||
htmlCanvas.Canvas.setCanvasSize(width, height); |
|||
} |
|||
|
|||
public static requestAnimationFrame(element: HTMLCanvasElement, renderLoop?: boolean): void { |
|||
const htmlCanvas = element as CanvasElement; |
|||
if (!htmlCanvas || !htmlCanvas.Canvas) { |
|||
return; |
|||
} |
|||
|
|||
htmlCanvas.Canvas.requestAnimationFrame(renderLoop); |
|||
} |
|||
|
|||
static createWebGLContext(htmlCanvas: HTMLCanvasElement): WebGLRenderingContext | WebGL2RenderingContext { |
|||
const contextAttributes = { |
|||
alpha: 1, |
|||
depth: 1, |
|||
stencil: 8, |
|||
antialias: 0, |
|||
premultipliedAlpha: 1, |
|||
preserveDrawingBuffer: 0, |
|||
preferLowPowerToHighPerformance: 0, |
|||
failIfMajorPerformanceCaveat: 0, |
|||
majorVersion: 2, |
|||
minorVersion: 0, |
|||
enableExtensionsByDefault: 1, |
|||
explicitSwapControl: 0, |
|||
renderViaOffscreenBackBuffer: 1 |
|||
}; |
|||
|
|||
const GL = (globalThis as any).AvaloniaGL; |
|||
|
|||
let ctx: WebGLRenderingContext = GL.createContext(htmlCanvas, contextAttributes); |
|||
|
|||
if (!ctx && contextAttributes.majorVersion > 1) { |
|||
console.warn("Falling back to WebGL 1.0"); |
|||
contextAttributes.majorVersion = 1; |
|||
contextAttributes.minorVersion = 0; |
|||
ctx = GL.createContext(htmlCanvas, contextAttributes); |
|||
} |
|||
|
|||
return ctx; |
|||
} |
|||
} |
|||
|
|||
type SizeWatcherElement = { |
|||
SizeWatcher: SizeWatcherInstance; |
|||
} & HTMLElement; |
|||
|
|||
interface SizeWatcherInstance { |
|||
callback: (width: number, height: number) => void; |
|||
} |
|||
|
|||
export class SizeWatcher { |
|||
static observer: ResizeObserver; |
|||
static elements: Map<string, HTMLElement>; |
|||
|
|||
public static observe(element: HTMLElement, elementId: string, callback: (width: number, height: number) => void): void { |
|||
if (!element || !callback) { |
|||
return; |
|||
} |
|||
|
|||
SizeWatcher.init(); |
|||
|
|||
const watcherElement = element as SizeWatcherElement; |
|||
watcherElement.SizeWatcher = { |
|||
callback |
|||
}; |
|||
|
|||
SizeWatcher.elements.set(elementId, element); |
|||
SizeWatcher.observer.observe(element); |
|||
|
|||
SizeWatcher.invoke(element); |
|||
} |
|||
|
|||
public static unobserve(elementId: string): void { |
|||
if (!elementId || !SizeWatcher.observer) { |
|||
return; |
|||
} |
|||
|
|||
const element = SizeWatcher.elements.get(elementId); |
|||
if (element) { |
|||
SizeWatcher.elements.delete(elementId); |
|||
SizeWatcher.observer.unobserve(element); |
|||
} |
|||
} |
|||
|
|||
static init(): void { |
|||
if (SizeWatcher.observer) { |
|||
return; |
|||
} |
|||
|
|||
SizeWatcher.elements = new Map<string, HTMLElement>(); |
|||
SizeWatcher.observer = new ResizeObserver((entries) => { |
|||
for (const entry of entries) { |
|||
SizeWatcher.invoke(entry.target); |
|||
} |
|||
}); |
|||
} |
|||
|
|||
static invoke(element: Element): void { |
|||
const watcherElement = element as SizeWatcherElement; |
|||
const instance = watcherElement.SizeWatcher; |
|||
|
|||
if (!instance || !instance.callback) { |
|||
return; |
|||
} |
|||
|
|||
return instance.callback(element.clientWidth, element.clientHeight); |
|||
} |
|||
} |
|||
|
|||
export class DpiWatcher { |
|||
static lastDpi: number; |
|||
static timerId: number; |
|||
static callback: (old: number, newdpi: number) => void; |
|||
|
|||
public static getDpi(): number { |
|||
return window.devicePixelRatio; |
|||
} |
|||
|
|||
public static start(callback: (old: number, newdpi: number) => void): number { |
|||
DpiWatcher.lastDpi = window.devicePixelRatio; |
|||
DpiWatcher.timerId = window.setInterval(DpiWatcher.update, 1000); |
|||
DpiWatcher.callback = callback; |
|||
|
|||
return DpiWatcher.lastDpi; |
|||
} |
|||
|
|||
public static stop(): void { |
|||
window.clearInterval(DpiWatcher.timerId); |
|||
} |
|||
|
|||
static update(): void { |
|||
if (!DpiWatcher.callback) { |
|||
return; |
|||
} |
|||
|
|||
const currentDpi = window.devicePixelRatio; |
|||
const lastDpi = DpiWatcher.lastDpi; |
|||
DpiWatcher.lastDpi = currentDpi; |
|||
|
|||
if (Math.abs(lastDpi - currentDpi) > 0.001) { |
|||
DpiWatcher.callback(lastDpi, currentDpi); |
|||
} |
|||
} |
|||
} |
|||
@ -0,0 +1,149 @@ |
|||
// Based on https://github.com/component/textarea-caret-position/blob/master/index.js
|
|||
export class CaretHelper { |
|||
public static getCaretCoordinates( |
|||
element: HTMLInputElement | HTMLTextAreaElement, |
|||
position: number, |
|||
options?: { debug: boolean } |
|||
) { |
|||
if (!isBrowser) { |
|||
throw new Error( |
|||
"textarea-caret-position#getCaretCoordinates should only be called in a browser" |
|||
); |
|||
} |
|||
|
|||
const debug = options?.debug ?? false; |
|||
if (debug) { |
|||
const el = document.querySelector( |
|||
"#input-textarea-caret-position-mirror-div" |
|||
); |
|||
if (el) el.parentNode?.removeChild(el); |
|||
} |
|||
|
|||
// The mirror div will replicate the textarea's style
|
|||
const div = document.createElement("div"); |
|||
div.id = "input-textarea-caret-position-mirror-div"; |
|||
document.body.appendChild(div); |
|||
|
|||
const style = div.style; |
|||
const computed = window.getComputedStyle |
|||
? window.getComputedStyle(element) |
|||
: ((element as any).currentStyle as CSSStyleDeclaration); // currentStyle for IE < 9
|
|||
const isInput = element.nodeName === "INPUT"; |
|||
|
|||
// Default textarea styles
|
|||
style.whiteSpace = "pre-wrap"; |
|||
if (!isInput) style.wordWrap = "break-word"; // only for textarea-s
|
|||
|
|||
// Position off-screen
|
|||
style.position = "absolute"; // required to return coordinates properly
|
|||
if (!debug) style.visibility = "hidden"; // not 'display: none' because we want rendering
|
|||
|
|||
// Transfer the element's properties to the div
|
|||
properties.forEach((prop: string) => { |
|||
if (isInput && prop === "lineHeight") { |
|||
// Special case for <input>s because text is rendered centered and line height may be != height
|
|||
if (computed.boxSizing === "border-box") { |
|||
const height = parseInt(computed.height); |
|||
const outerHeight = |
|||
parseInt(computed.paddingTop) + |
|||
parseInt(computed.paddingBottom) + |
|||
parseInt(computed.borderTopWidth) + |
|||
parseInt(computed.borderBottomWidth); |
|||
const targetHeight = outerHeight + parseInt(computed.lineHeight); |
|||
if (height > targetHeight) { |
|||
style.lineHeight = `${height - outerHeight}px`; |
|||
} else if (height === targetHeight) { |
|||
style.lineHeight = computed.lineHeight; |
|||
} else { |
|||
style.lineHeight = "0"; |
|||
} |
|||
} else { |
|||
style.lineHeight = computed.height; |
|||
} |
|||
} else { |
|||
(style as any)[prop] = (computed as any)[prop]; |
|||
} |
|||
}); |
|||
|
|||
if (isFirefox) { |
|||
// Firefox lies about the overflow property for textareas: https://bugzilla.mozilla.org/show_bug.cgi?id=984275
|
|||
if (element.scrollHeight > parseInt(computed.height)) { |
|||
style.overflowY = "scroll"; |
|||
} |
|||
} else { |
|||
style.overflow = "hidden"; // for Chrome to not render a scrollbar; IE keeps overflowY = 'scroll'
|
|||
} |
|||
|
|||
div.textContent = element.value.substring(0, position); |
|||
// The second special handling for input type="text" vs textarea:
|
|||
// spaces need to be replaced with non-breaking spaces - http://stackoverflow.com/a/13402035/1269037
|
|||
if (isInput) div.textContent = div.textContent.replace(/\s/g, "\u00a0"); |
|||
|
|||
const span = document.createElement("span"); |
|||
// Wrapping must be replicated *exactly*, including when a long word gets
|
|||
// onto the next line, with whitespace at the end of the line before (#7).
|
|||
// The *only* reliable way to do that is to copy the *entire* rest of the
|
|||
// textarea's content into the <span> created at the caret position.
|
|||
// For inputs, just '.' would be enough, but no need to bother.
|
|||
span.textContent = element.value.substring(position) || "."; // || because a completely empty faux span doesn't render at all
|
|||
div.appendChild(span); |
|||
|
|||
const coordinates = { |
|||
top: span.offsetTop + parseInt(computed.borderTopWidth), |
|||
left: span.offsetLeft + parseInt(computed.borderLeftWidth), |
|||
height: parseInt(computed.lineHeight) |
|||
}; |
|||
|
|||
if (debug) { |
|||
span.style.backgroundColor = "#aaa"; |
|||
} else { |
|||
document.body.removeChild(div); |
|||
} |
|||
|
|||
return coordinates; |
|||
} |
|||
} |
|||
|
|||
const properties = [ |
|||
"direction", // RTL support
|
|||
"boxSizing", |
|||
"width", // on Chrome and IE, exclude the scrollbar, so the mirror div wraps exactly as the textarea does
|
|||
"height", |
|||
"overflowX", |
|||
"overflowY", // copy the scrollbar for IE
|
|||
|
|||
"borderTopWidth", |
|||
"borderRightWidth", |
|||
"borderBottomWidth", |
|||
"borderLeftWidth", |
|||
"borderStyle", |
|||
|
|||
"paddingTop", |
|||
"paddingRight", |
|||
"paddingBottom", |
|||
"paddingLeft", |
|||
|
|||
// https://developer.mozilla.org/en-US/docs/Web/CSS/font
|
|||
"fontStyle", |
|||
"fontVariant", |
|||
"fontWeight", |
|||
"fontStretch", |
|||
"fontSize", |
|||
"fontSizeAdjust", |
|||
"lineHeight", |
|||
"fontFamily", |
|||
|
|||
"textAlign", |
|||
"textTransform", |
|||
"textIndent", |
|||
"textDecoration", // might not make a difference, but better be safe
|
|||
|
|||
"letterSpacing", |
|||
"wordSpacing", |
|||
|
|||
"tabSize", |
|||
"MozTabSize" |
|||
]; |
|||
|
|||
const isBrowser = typeof window !== "undefined"; |
|||
const isFirefox = isBrowser && (window as any).mozInnerScreenX != null; |
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue