diff --git a/.gitmodules b/.gitmodules index 10c780c09f..9dbc50ef61 100644 --- a/.gitmodules +++ b/.gitmodules @@ -3,4 +3,4 @@ url = https://github.com/kekekeks/Numerge.git [submodule "src/Markup/Avalonia.Markup.Xaml/XamlIl/xamlil.github"] path = src/Markup/Avalonia.Markup.Xaml/XamlIl/xamlil.github - url = https://github.com/kekekeks/XamlIl.git + url = https://github.com/kekekeks/XamlX.git diff --git a/nukebuild/Build.cs b/nukebuild/Build.cs index 890967ae4f..fe877dc49c 100644 --- a/nukebuild/Build.cs +++ b/nukebuild/Build.cs @@ -268,6 +268,8 @@ partial class Build : NukeBuild .DependsOn(CreateIntermediateNugetPackages) .Executes(() => { + BuildTasksPatcher.PatchBuildTasksInPackage(Parameters.NugetIntermediateRoot / "Avalonia.Build.Tasks." + + Parameters.Version + ".nupkg"); var config = Numerge.MergeConfiguration.LoadFile(RootDirectory / "nukebuild" / "numerge.config"); EnsureCleanDirectory(Parameters.NugetRoot); if(!Numerge.NugetPackageMerger.Merge(Parameters.NugetIntermediateRoot, Parameters.NugetRoot, config, diff --git a/nukebuild/BuildTasksPatcher.cs b/nukebuild/BuildTasksPatcher.cs new file mode 100644 index 0000000000..44f01da669 --- /dev/null +++ b/nukebuild/BuildTasksPatcher.cs @@ -0,0 +1,76 @@ +using System; +using System.IO; +using System.IO.Compression; +using System.Linq; +using ILRepacking; +using Mono.Cecil; + +public class BuildTasksPatcher +{ + public static void PatchBuildTasksInPackage(string packagePath) + { + using (var archive = new ZipArchive(File.Open(packagePath, FileMode.Open, FileAccess.ReadWrite), + ZipArchiveMode.Update)) + { + + foreach (var entry in archive.Entries.ToList()) + { + if (entry.Name == "Avalonia.Build.Tasks.dll") + { + var temp = Path.Combine(Path.GetTempPath(), Guid.NewGuid() + ".dll"); + var output = temp + ".output"; + var patched = new MemoryStream(); + try + { + entry.ExtractToFile(temp, true); + var repack = new ILRepacking.ILRepack(new RepackOptions() + { + Internalize = true, + InputAssemblies = new[] + { + temp, typeof(Mono.Cecil.AssemblyDefinition).Assembly.GetModules()[0] + .FullyQualifiedName + }, + SearchDirectories = new string[0], + OutputFile = output + }); + repack.Repack(); + + + // 'hurr-durr assembly with the same name is already loaded' prevention + using (var asm = AssemblyDefinition.ReadAssembly(output, + new ReaderParameters { ReadWrite = true, InMemory = true, })) + { + asm.Name = new AssemblyNameDefinition( + "Avalonia.Build.Tasks." + + Guid.NewGuid().ToString().Replace("-", ""), + new Version(0, 0, 0)); + asm.Write(patched); + patched.Position = 0; + } + } + finally + { + try + { + if (File.Exists(temp)) + File.Delete(temp); + if (File.Exists(output)) + File.Delete(output); + } + catch + { + //ignore + } + } + + var fn = entry.FullName; + entry.Delete(); + var newEntry = archive.CreateEntry(fn, CompressionLevel.Optimal); + using (var s = newEntry.Open()) + patched.CopyTo(s); + } + } + } + } +} \ No newline at end of file diff --git a/nukebuild/_build.csproj b/nukebuild/_build.csproj index 584c36d033..4c64d4ff93 100644 --- a/nukebuild/_build.csproj +++ b/nukebuild/_build.csproj @@ -14,6 +14,9 @@ + + + diff --git a/samples/ControlCatalog/Pages/TextBlockPage.xaml b/samples/ControlCatalog/Pages/TextBlockPage.xaml index f73ef9b4fb..4b8edcf98c 100644 --- a/samples/ControlCatalog/Pages/TextBlockPage.xaml +++ b/samples/ControlCatalog/Pages/TextBlockPage.xaml @@ -64,51 +64,42 @@ - - - - - - - - - - - - + StrokeThicknessUnit="Pixel" + StrokeThickness="2"> + + + + + + + + - - - - - - - - - - - - + StrokeThicknessUnit="Pixel" + StrokeThickness="1"> + + + + + + + + - - - - - - - - - - - - + StrokeThicknessUnit="Pixel" + StrokeThickness="2"> + + + + + + + + diff --git a/samples/interop/NativeEmbedSample/NativeEmbedSample.csproj b/samples/interop/NativeEmbedSample/NativeEmbedSample.csproj index c623ae68b5..cc831ef8ae 100644 --- a/samples/interop/NativeEmbedSample/NativeEmbedSample.csproj +++ b/samples/interop/NativeEmbedSample/NativeEmbedSample.csproj @@ -10,6 +10,7 @@ + diff --git a/src/Avalonia.Base/Data/Core/PropertyAccessorNode.cs b/src/Avalonia.Base/Data/Core/PropertyAccessorNode.cs index e621512ded..d5e835cabd 100644 --- a/src/Avalonia.Base/Data/Core/PropertyAccessorNode.cs +++ b/src/Avalonia.Base/Data/Core/PropertyAccessorNode.cs @@ -89,6 +89,7 @@ namespace Avalonia.Data.Core return x; } } + return null; } protected override void StopListeningCore() diff --git a/src/Avalonia.Build.Tasks/Avalonia.Build.Tasks.csproj b/src/Avalonia.Build.Tasks/Avalonia.Build.Tasks.csproj index d0be33d332..7117fd51a2 100644 --- a/src/Avalonia.Build.Tasks/Avalonia.Build.Tasks.csproj +++ b/src/Avalonia.Build.Tasks/Avalonia.Build.Tasks.csproj @@ -5,7 +5,7 @@ exe false tools - $(DefineConstants);BUILDTASK;XAMLIL_CECIL_INTERNAL;XAMLIL_INTERNAL + $(DefineConstants);BUILDTASK;XAMLX_CECIL_INTERNAL;XAMLX_INTERNAL true NU1605 @@ -21,10 +21,10 @@ XamlIlExtensions/%(RecursiveDir)%(FileName)%(Extension) - + XamlIl/%(RecursiveDir)%(FileName)%(Extension) - + XamlIl.Cecil/%(RecursiveDir)%(FileName)%(Extension) @@ -58,27 +58,8 @@ Markup/%(RecursiveDir)%(FileName)%(Extension) - + - - - - - - $(MSBuildThisFileDirectory)bin\$(Configuration)\$(TargetFramework) - - - - - - - - - - - - - diff --git a/src/Avalonia.Build.Tasks/XamlCompilerTaskExecutor.Helpers.cs b/src/Avalonia.Build.Tasks/XamlCompilerTaskExecutor.Helpers.cs index f94f10f792..5a2c74e16f 100644 --- a/src/Avalonia.Build.Tasks/XamlCompilerTaskExecutor.Helpers.cs +++ b/src/Avalonia.Build.Tasks/XamlCompilerTaskExecutor.Helpers.cs @@ -5,7 +5,7 @@ using Avalonia.Utilities; using Mono.Cecil; using Mono.Cecil.Cil; using Mono.Collections.Generic; -using XamlIl.TypeSystem; +using XamlX.TypeSystem; namespace Avalonia.Build.Tasks { diff --git a/src/Avalonia.Build.Tasks/XamlCompilerTaskExecutor.cs b/src/Avalonia.Build.Tasks/XamlCompilerTaskExecutor.cs index 886cc1e917..c1cc0e7bf0 100644 --- a/src/Avalonia.Build.Tasks/XamlCompilerTaskExecutor.cs +++ b/src/Avalonia.Build.Tasks/XamlCompilerTaskExecutor.cs @@ -7,17 +7,18 @@ using System.Text; using Avalonia.Markup.Xaml.XamlIl.CompilerExtensions; using Microsoft.Build.Framework; using Mono.Cecil; -using XamlIl.TypeSystem; using Avalonia.Utilities; using Mono.Cecil.Cil; using Mono.Cecil.Rocks; -using XamlIl; -using XamlIl.Ast; -using XamlIl.Parsers; -using XamlIl.Transform; +using XamlX; +using XamlX.Ast; +using XamlX.Parsers; +using XamlX.Transform; +using XamlX.TypeSystem; using FieldAttributes = Mono.Cecil.FieldAttributes; using MethodAttributes = Mono.Cecil.MethodAttributes; using TypeAttributes = Mono.Cecil.TypeAttributes; +using XamlX.IL; namespace Avalonia.Build.Tasks { @@ -58,11 +59,11 @@ namespace Avalonia.Build.Tasks TypeAttributes.Class, asm.MainModule.TypeSystem.Object); asm.MainModule.Types.Add(indexerAccessorClosure); - var xamlLanguage = AvaloniaXamlIlLanguage.Configure(typeSystem); + var (xamlLanguage , emitConfig) = AvaloniaXamlIlLanguage.Configure(typeSystem); var compilerConfig = new AvaloniaXamlIlCompilerConfiguration(typeSystem, typeSystem.TargetAssembly, xamlLanguage, - XamlIlXmlnsMappings.Resolve(typeSystem, xamlLanguage), + XamlXmlnsMappings.Resolve(typeSystem, xamlLanguage), AvaloniaXamlIlLanguage.CustomValueConverter, new XamlIlClrPropertyInfoEmitter(typeSystem.CreateTypeBuilder(clrPropertiesDef)), new XamlIlPropertyInfoAccessorFactoryEmitter(typeSystem.CreateTypeBuilder(indexerAccessorClosure))); @@ -72,10 +73,10 @@ namespace Avalonia.Build.Tasks TypeAttributes.Class, asm.MainModule.TypeSystem.Object); asm.MainModule.Types.Add(contextDef); - var contextClass = XamlIlContextDefinition.GenerateContextClass(typeSystem.CreateTypeBuilder(contextDef), typeSystem, - xamlLanguage); + var contextClass = XamlILContextDefinition.GenerateContextClass(typeSystem.CreateTypeBuilder(contextDef), typeSystem, + xamlLanguage, emitConfig); - var compiler = new AvaloniaXamlIlCompiler(compilerConfig, contextClass) { EnableIlVerification = verifyIl }; + var compiler = new AvaloniaXamlIlCompiler(compilerConfig, emitConfig, contextClass) { EnableIlVerification = verifyIl }; var editorBrowsableAttribute = typeSystem .GetTypeReference(typeSystem.FindType("System.ComponentModel.EditorBrowsableAttribute")) @@ -135,35 +136,35 @@ namespace Avalonia.Build.Tasks // StreamReader is needed here to handle BOM var xaml = new StreamReader(new MemoryStream(res.FileContents)).ReadToEnd(); - var parsed = XDocumentXamlIlParser.Parse(xaml); + var parsed = XDocumentXamlParser.Parse(xaml); - var initialRoot = (XamlIlAstObjectNode)parsed.Root; + var initialRoot = (XamlAstObjectNode)parsed.Root; - var precompileDirective = initialRoot.Children.OfType() + var precompileDirective = initialRoot.Children.OfType() .FirstOrDefault(d => d.Namespace == XamlNamespaces.Xaml2006 && d.Name == "Precompile"); if (precompileDirective != null) { - var precompileText = (precompileDirective.Values[0] as XamlIlAstTextNode)?.Text.Trim() + var precompileText = (precompileDirective.Values[0] as XamlAstTextNode)?.Text.Trim() .ToLowerInvariant(); if (precompileText == "false") continue; if (precompileText != "true") - throw new XamlIlParseException("Invalid value for x:Precompile", precompileDirective); + throw new XamlParseException("Invalid value for x:Precompile", precompileDirective); } - var classDirective = initialRoot.Children.OfType() + var classDirective = initialRoot.Children.OfType() .FirstOrDefault(d => d.Namespace == XamlNamespaces.Xaml2006 && d.Name == "Class"); - IXamlIlType classType = null; + IXamlType classType = null; if (classDirective != null) { - if (classDirective.Values.Count != 1 || !(classDirective.Values[0] is XamlIlAstTextNode tn)) - throw new XamlIlParseException("x:Class should have a string value", classDirective); + if (classDirective.Values.Count != 1 || !(classDirective.Values[0] is XamlAstTextNode tn)) + throw new XamlParseException("x:Class should have a string value", classDirective); classType = typeSystem.TargetAssembly.FindType(tn.Text); if (classType == null) - throw new XamlIlParseException($"Unable to find type `{tn.Text}`", classDirective); + throw new XamlParseException($"Unable to find type `{tn.Text}`", classDirective); compiler.OverrideRootType(parsed, - new XamlIlAstClrTypeReference(classDirective, classType, false)); + new XamlAstClrTypeReference(classDirective, classType, false)); initialRoot.Children.Remove(classDirective); } @@ -332,7 +333,7 @@ namespace Avalonia.Build.Tasks catch (Exception e) { int lineNumber = 0, linePosition = 0; - if (e is XamlIlParseException xe) + if (e is XamlParseException xe) { lineNumber = xe.LineNumber; linePosition = xe.LinePosition; diff --git a/src/Avalonia.Controls/ComboBox.cs b/src/Avalonia.Controls/ComboBox.cs index 6557346b1f..75a0e41e7b 100644 --- a/src/Avalonia.Controls/ComboBox.cs +++ b/src/Avalonia.Controls/ComboBox.cs @@ -7,6 +7,7 @@ using Avalonia.Controls.Shapes; using Avalonia.Controls.Templates; using Avalonia.Input; using Avalonia.Interactivity; +using Avalonia.Layout; using Avalonia.LogicalTree; using Avalonia.Media; using Avalonia.VisualTree; @@ -63,6 +64,18 @@ namespace Avalonia.Controls public static readonly StyledProperty PlaceholderForegroundProperty = AvaloniaProperty.Register(nameof(PlaceholderForeground)); + /// + /// Defines the property. + /// + public static readonly StyledProperty HorizontalContentAlignmentProperty = + ContentControl.HorizontalContentAlignmentProperty.AddOwner(); + + /// + /// Defines the property. + /// + public static readonly StyledProperty VerticalContentAlignmentProperty = + ContentControl.VerticalContentAlignmentProperty.AddOwner(); + private bool _isDropDownOpen; private Popup _popup; private object _selectionBoxItem; @@ -133,6 +146,24 @@ namespace Avalonia.Controls set { SetValue(VirtualizationModeProperty, value); } } + /// + /// Gets or sets the horizontal alignment of the content within the control. + /// + public HorizontalAlignment HorizontalContentAlignment + { + get { return GetValue(HorizontalContentAlignmentProperty); } + set { SetValue(HorizontalContentAlignmentProperty, value); } + } + + /// + /// Gets or sets the vertical alignment of the content within the control. + /// + public VerticalAlignment VerticalContentAlignment + { + get { return GetValue(VerticalContentAlignmentProperty); } + set { SetValue(VerticalContentAlignmentProperty, value); } + } + /// protected override IItemContainerGenerator CreateItemContainerGenerator() { diff --git a/src/Avalonia.Controls/Presenters/ContentPresenter.cs b/src/Avalonia.Controls/Presenters/ContentPresenter.cs index f75184c686..c4571505ba 100644 --- a/src/Avalonia.Controls/Presenters/ContentPresenter.cs +++ b/src/Avalonia.Controls/Presenters/ContentPresenter.cs @@ -95,6 +95,7 @@ namespace Avalonia.Controls.Presenters static ContentPresenter() { AffectsRender(BackgroundProperty, BorderBrushProperty, BorderThicknessProperty, CornerRadiusProperty); + AffectsArrange(HorizontalContentAlignmentProperty, VerticalContentAlignmentProperty); AffectsMeasure(BorderThicknessProperty, PaddingProperty); ContentProperty.Changed.AddClassHandler((x, e) => x.ContentChanged(e)); ContentTemplateProperty.Changed.AddClassHandler((x, e) => x.ContentChanged(e)); diff --git a/src/Avalonia.Controls/Primitives/AccessText.cs b/src/Avalonia.Controls/Primitives/AccessText.cs index 4208a2f2f7..dd33023e38 100644 --- a/src/Avalonia.Controls/Primitives/AccessText.cs +++ b/src/Avalonia.Controls/Primitives/AccessText.cs @@ -110,7 +110,7 @@ namespace Avalonia.Controls.Primitives foreach (var textLine in TextLayout.TextLines) { - if (textLine.Text.End < textPosition) + if (textLine.TextRange.End < textPosition) { currentY += textLine.LineMetrics.Size.Height; @@ -121,21 +121,22 @@ namespace Avalonia.Controls.Primitives foreach (var textRun in textLine.TextRuns) { - if (!(textRun is ShapedTextRun shapedRun)) + if (!(textRun is ShapedTextCharacters shapedTextCharacters)) { continue; } - if (shapedRun.GlyphRun.Characters.End < textPosition) + if (shapedTextCharacters.GlyphRun.Characters.End < textPosition) { - currentX += shapedRun.GlyphRun.Bounds.Width; + currentX += shapedTextCharacters.GlyphRun.Bounds.Width; continue; } - var characterHit = shapedRun.GlyphRun.FindNearestCharacterHit(textPosition, out var width); + var characterHit = + shapedTextCharacters.GlyphRun.FindNearestCharacterHit(textPosition, out var width); - var distance = shapedRun.GlyphRun.GetDistanceFromCharacterHit(characterHit); + var distance = shapedTextCharacters.GlyphRun.GetDistanceFromCharacterHit(characterHit); currentX += distance - width; @@ -144,7 +145,7 @@ namespace Avalonia.Controls.Primitives width = 0.0; } - return new Rect(currentX, currentY, width, shapedRun.GlyphRun.Bounds.Height); + return new Rect(currentX, currentY, width, shapedTextCharacters.GlyphRun.Bounds.Height); } } diff --git a/src/Avalonia.Controls/TextBlock.cs b/src/Avalonia.Controls/TextBlock.cs index 13bc4ed124..2361ea9011 100644 --- a/src/Avalonia.Controls/TextBlock.cs +++ b/src/Avalonia.Controls/TextBlock.cs @@ -70,6 +70,15 @@ namespace Avalonia.Controls Brushes.Black, inherits: true); + /// + /// Defines the property. + /// + public static readonly StyledProperty LineHeightProperty = + AvaloniaProperty.Register( + nameof(LineHeight), + double.NaN, + validate: IsValidLineHeight); + /// /// Defines the property. /// @@ -122,19 +131,19 @@ namespace Avalonia.Controls { ClipToBoundsProperty.OverrideDefaultValue(true); - AffectsRender(BackgroundProperty, ForegroundProperty, + AffectsRender(BackgroundProperty, ForegroundProperty, TextAlignmentProperty, TextDecorationsProperty); - AffectsMeasure(FontSizeProperty, FontWeightProperty, - FontStyleProperty, TextWrappingProperty, FontFamilyProperty, - TextTrimmingProperty, TextProperty, PaddingProperty); + AffectsMeasure(FontSizeProperty, FontWeightProperty, + FontStyleProperty, TextWrappingProperty, FontFamilyProperty, + TextTrimmingProperty, TextProperty, PaddingProperty, LineHeightProperty, MaxLinesProperty); Observable.Merge(TextProperty.Changed, ForegroundProperty.Changed, TextAlignmentProperty.Changed, TextWrappingProperty.Changed, TextTrimmingProperty.Changed, FontSizeProperty.Changed, FontStyleProperty.Changed, FontWeightProperty.Changed, FontFamilyProperty.Changed, TextDecorationsProperty.Changed, - PaddingProperty.Changed + PaddingProperty.Changed, MaxLinesProperty.Changed, LineHeightProperty.Changed ).AddClassHandler((x, _) => x.InvalidateTextLayout()); } @@ -230,6 +239,15 @@ namespace Avalonia.Controls set { SetValue(ForegroundProperty, value); } } + /// + /// Gets or sets the height of each line of content. + /// + public double LineHeight + { + get => GetValue(LineHeightProperty); + set => SetValue(LineHeightProperty, value); + } + /// /// Gets or sets the maximum number of text lines. /// @@ -395,7 +413,7 @@ namespace Avalonia.Controls var padding = Padding; - TextLayout?.Draw(context.PlatformImpl, new Point(padding.Left, padding.Top)); + TextLayout?.Draw(context, new Point(padding.Left, padding.Top)); } /// @@ -422,7 +440,8 @@ namespace Avalonia.Controls TextDecorations, constraint.Width, constraint.Height, - MaxLines); + maxLines: MaxLines, + lineHeight: LineHeight); } /// @@ -471,5 +490,7 @@ namespace Avalonia.Controls } private static bool IsValidMaxLines(int maxLines) => maxLines >= 0; + + private static bool IsValidLineHeight(double lineHeight) => double.IsNaN(lineHeight) || lineHeight > 0; } } diff --git a/src/Avalonia.Desktop/AppBuilderDesktopExtensions.cs b/src/Avalonia.Desktop/AppBuilderDesktopExtensions.cs index 36f762d625..7c4a489328 100644 --- a/src/Avalonia.Desktop/AppBuilderDesktopExtensions.cs +++ b/src/Avalonia.Desktop/AppBuilderDesktopExtensions.cs @@ -46,10 +46,6 @@ namespace Avalonia where TAppBuilder : AppBuilderBase, new() => builder.UseX11(); - static void LoadDirect2D1(TAppBuilder builder) - where TAppBuilder : AppBuilderBase, new() - => builder.UseDirect2D1(); - static void LoadSkia(TAppBuilder builder) where TAppBuilder : AppBuilderBase, new() => builder.UseSkia(); diff --git a/src/Avalonia.Desktop/Avalonia.Desktop.csproj b/src/Avalonia.Desktop/Avalonia.Desktop.csproj index f45b0c54e3..72b7b5c1e7 100644 --- a/src/Avalonia.Desktop/Avalonia.Desktop.csproj +++ b/src/Avalonia.Desktop/Avalonia.Desktop.csproj @@ -5,8 +5,7 @@ - - + diff --git a/src/Avalonia.Themes.Default/ComboBox.xaml b/src/Avalonia.Themes.Default/ComboBox.xaml index 95bd9550a5..ae5b902ae8 100644 --- a/src/Avalonia.Themes.Default/ComboBox.xaml +++ b/src/Avalonia.Themes.Default/ComboBox.xaml @@ -1,10 +1,29 @@ + + + + + Item 1 + Item 2 + + + Item 1 + Item 2 + + + + - + + + - + - + - + - - - + - + - + + + + + + + diff --git a/src/Avalonia.Themes.Fluent/ComboBoxItem.xaml b/src/Avalonia.Themes.Fluent/ComboBoxItem.xaml index c26dec3d34..66ccea99b5 100644 --- a/src/Avalonia.Themes.Fluent/ComboBoxItem.xaml +++ b/src/Avalonia.Themes.Fluent/ComboBoxItem.xaml @@ -1,17 +1,19 @@ - - + + Item 1 - Item 2 - - - - Item 1 - Item 2 - - + Item 2 long + Item 3 + Item 4 + + @@ -19,12 +21,11 @@ - - + Padding="{TemplateBinding Padding}" /> + + + + + + + + - + - diff --git a/src/Avalonia.Visuals/Media/FontManager.cs b/src/Avalonia.Visuals/Media/FontManager.cs index f9410afe6a..bc979c15ee 100644 --- a/src/Avalonia.Visuals/Media/FontManager.cs +++ b/src/Avalonia.Visuals/Media/FontManager.cs @@ -100,7 +100,7 @@ namespace Avalonia.Media return typeface; } - typeface = new Typeface(fontFamily, fontWeight, fontStyle); + typeface = new Typeface(fontFamily, fontStyle, fontWeight); if (_typefaceCache.TryAdd(key, typeface)) { @@ -143,7 +143,7 @@ namespace Avalonia.Media } var matchedTypeface = PlatformImpl.TryMatchCharacter(codepoint, fontWeight, fontStyle, fontFamily, culture, out var key) ? - _typefaceCache.GetOrAdd(key, new Typeface(key.FamilyName, key.Weight, key.Style)) : + _typefaceCache.GetOrAdd(key, new Typeface(key.FamilyName, key.Style, key.Weight)) : null; return matchedTypeface; diff --git a/src/Avalonia.Visuals/Media/GlyphRun.cs b/src/Avalonia.Visuals/Media/GlyphRun.cs index 29c9d93560..a32a3e1b6c 100644 --- a/src/Avalonia.Visuals/Media/GlyphRun.cs +++ b/src/Avalonia.Visuals/Media/GlyphRun.cs @@ -1,7 +1,7 @@ using System; using System.Collections.Generic; using Avalonia.Platform; -using Avalonia.Utility; +using Avalonia.Utilities; namespace Avalonia.Media { @@ -205,13 +205,16 @@ namespace Avalonia.Media var glyphIndex = FindGlyphIndex(characterHit.FirstCharacterIndex); - var currentCluster = _glyphClusters[glyphIndex]; - - if (characterHit.TrailingLength > 0) + if (!GlyphClusters.IsEmpty) { - while (glyphIndex < _glyphClusters.Length && _glyphClusters[glyphIndex] == currentCluster) + var currentCluster = GlyphClusters[glyphIndex]; + + if (characterHit.TrailingLength > 0) { - glyphIndex++; + while (glyphIndex < GlyphClusters.Length && GlyphClusters[glyphIndex] == currentCluster) + { + glyphIndex++; + } } } @@ -302,7 +305,7 @@ namespace Avalonia.Media } } - var characterHit = FindNearestCharacterHit(GlyphClusters[index], out var width); + var characterHit = FindNearestCharacterHit(GlyphClusters.IsEmpty ? index : GlyphClusters[index], out var width); var offset = GetDistanceFromCharacterHit(new CharacterHit(characterHit.FirstCharacterIndex)); @@ -370,26 +373,31 @@ namespace Avalonia.Media /// public int FindGlyphIndex(int characterIndex) { + if (GlyphClusters.IsEmpty) + { + return characterIndex; + } + if (IsLeftToRight) { - if (characterIndex < _glyphClusters[0]) + if (characterIndex < GlyphClusters[0]) { return 0; } - if (characterIndex > _glyphClusters[_glyphClusters.Length - 1]) + if (characterIndex > GlyphClusters[GlyphClusters.Length - 1]) { return _glyphClusters.End; } } else { - if (characterIndex < _glyphClusters[_glyphClusters.Length - 1]) + if (characterIndex < GlyphClusters[GlyphClusters.Length - 1]) { return _glyphClusters.End; } - if (characterIndex > _glyphClusters[0]) + if (characterIndex > GlyphClusters[0]) { return 0; } @@ -397,7 +405,7 @@ namespace Avalonia.Media var comparer = IsLeftToRight ? s_ascendingComparer : s_descendingComparer; - var clusters = _glyphClusters.Buffer.Span; + var clusters = GlyphClusters.Buffer.Span; // Find the start of the cluster at the character index. var start = clusters.BinarySearch((ushort)characterIndex, comparer); @@ -418,9 +426,19 @@ namespace Avalonia.Media } } - while (start > 0 && clusters[start - 1] == clusters[start]) + if (IsLeftToRight) { - start--; + while (start > 0 && clusters[start - 1] == clusters[start]) + { + start--; + } + } + else + { + while (start + 1 < clusters.Length && clusters[start + 1] == clusters[start]) + { + start++; + } } return start; @@ -440,34 +458,74 @@ namespace Avalonia.Media var start = FindGlyphIndex(index); - var currentCluster = _glyphClusters[start]; + if (GlyphClusters.IsEmpty) + { + width = GetGlyphWidth(index); + + return new CharacterHit(start, 1); + } - var trailingLength = 0; + var cluster = GlyphClusters[start]; - while (start < _glyphClusters.Length && _glyphClusters[start] == currentCluster) + var nextCluster = cluster; + + var currentIndex = start; + + while (nextCluster == cluster) { - if (GlyphAdvances.IsEmpty) + width += GetGlyphWidth(currentIndex); + + if (IsLeftToRight) { - var glyph = GlyphIndices[start]; + currentIndex++; - width += GlyphTypeface.GetGlyphAdvance(glyph) * Scale; + if (currentIndex == GlyphClusters.Length) + { + break; + } } else { - width += GlyphAdvances[start]; + currentIndex--; + + if (currentIndex < 0) + { + break; + } } - trailingLength++; - start++; + nextCluster = GlyphClusters[currentIndex]; + } + + int trailingLength; + + if (nextCluster == cluster) + { + trailingLength = Characters.Start + Characters.Length - cluster; + } + else + { + trailingLength = nextCluster - cluster; } - if (start == _glyphClusters.Length && - currentCluster + trailingLength != Characters.Start + Characters.Length) + return new CharacterHit(cluster, trailingLength); + } + + /// + /// Gets a glyph's width. + /// + /// The glyph index. + /// The glyph's width. + private double GetGlyphWidth(int index) + { + if (GlyphAdvances.IsEmpty) { - trailingLength = Characters.Start + Characters.Length - currentCluster; + var glyph = GlyphIndices[index]; + + return GlyphTypeface.GetGlyphAdvance(glyph) * Scale; } - return new CharacterHit(currentCluster, trailingLength); + return GlyphAdvances[index]; } /// diff --git a/src/Avalonia.Visuals/Media/TextDecoration.cs b/src/Avalonia.Visuals/Media/TextDecoration.cs index a83555946b..681fc5d499 100644 --- a/src/Avalonia.Visuals/Media/TextDecoration.cs +++ b/src/Avalonia.Visuals/Media/TextDecoration.cs @@ -1,4 +1,5 @@ -using Avalonia.Media.Immutable; +using Avalonia.Collections; +using Avalonia.Media.TextFormatting; namespace Avalonia.Media { @@ -14,28 +15,52 @@ namespace Avalonia.Media AvaloniaProperty.Register(nameof(Location)); /// - /// Defines the property. + /// Defines the property. /// - public static readonly StyledProperty PenProperty = - AvaloniaProperty.Register(nameof(Pen)); + public static readonly StyledProperty StrokeProperty = + AvaloniaProperty.Register(nameof(Stroke)); /// - /// Defines the property. + /// Defines the property. /// - public static readonly StyledProperty PenThicknessUnitProperty = - AvaloniaProperty.Register(nameof(PenThicknessUnit)); + public static readonly StyledProperty StrokeThicknessUnitProperty = + AvaloniaProperty.Register(nameof(StrokeThicknessUnit)); /// - /// Defines the property. + /// Defines the property. /// - public static readonly StyledProperty PenOffsetProperty = - AvaloniaProperty.Register(nameof(PenOffset)); + public static readonly StyledProperty> StrokeDashArrayProperty = + AvaloniaProperty.Register>(nameof(StrokeDashArray)); /// - /// Defines the property. + /// Defines the property. /// - public static readonly StyledProperty PenOffsetUnitProperty = - AvaloniaProperty.Register(nameof(PenOffsetUnit)); + public static readonly StyledProperty StrokeDashOffsetProperty = + AvaloniaProperty.Register(nameof(StrokeDashOffset)); + + /// + /// Defines the property. + /// + public static readonly StyledProperty StrokeThicknessProperty = + AvaloniaProperty.Register(nameof(StrokeThickness), 1); + + /// + /// Defines the property. + /// + public static readonly StyledProperty StrokeLineCapProperty = + AvaloniaProperty.Register(nameof(StrokeLineCap)); + + /// + /// Defines the property. + /// + public static readonly StyledProperty StrokeOffsetProperty = + AvaloniaProperty.Register(nameof(StrokeOffset)); + + /// + /// Defines the property. + /// + public static readonly StyledProperty StrokeOffsetUnitProperty = + AvaloniaProperty.Register(nameof(StrokeOffsetUnit)); /// /// Gets or sets the location. @@ -50,54 +75,139 @@ namespace Avalonia.Media } /// - /// Gets or sets the pen. + /// Gets or sets the that specifies how the is painted. /// - /// - /// The pen. - /// - public IPen Pen + public IBrush Stroke + { + get { return GetValue(StrokeProperty); } + set { SetValue(StrokeProperty, value); } + } + + /// + /// Gets the units in which the thickness of the is expressed. + /// + public TextDecorationUnit StrokeThicknessUnit + { + get => GetValue(StrokeThicknessUnitProperty); + set => SetValue(StrokeThicknessUnitProperty, value); + } + + /// + /// Gets or sets a collection of values that indicate the pattern of dashes and gaps + /// that is used to draw the . + /// + public AvaloniaList StrokeDashArray + { + get { return GetValue(StrokeDashArrayProperty); } + set { SetValue(StrokeDashArrayProperty, value); } + } + + /// + /// Gets or sets a value that specifies the distance within the dash pattern where a dash begins. + /// + public double StrokeDashOffset + { + get { return GetValue(StrokeDashOffsetProperty); } + set { SetValue(StrokeDashOffsetProperty, value); } + } + + /// + /// Gets or sets the thickness of the . + /// + public double StrokeThickness { - get => GetValue(PenProperty); - set => SetValue(PenProperty, value); + get { return GetValue(StrokeThicknessProperty); } + set { SetValue(StrokeThicknessProperty, value); } } /// - /// Gets the units in which the Thickness of the text decoration's is expressed. + /// Gets or sets a enumeration value that describes the shape at the ends of a line. /// - public TextDecorationUnit PenThicknessUnit + public PenLineCap StrokeLineCap { - get => GetValue(PenThicknessUnitProperty); - set => SetValue(PenThicknessUnitProperty, value); + get { return GetValue(StrokeLineCapProperty); } + set { SetValue(StrokeLineCapProperty, value); } } /// - /// Gets or sets the pen offset. + /// The stroke's offset. /// /// /// The pen offset. /// - public double PenOffset + public double StrokeOffset { - get => GetValue(PenOffsetProperty); - set => SetValue(PenOffsetProperty, value); + get => GetValue(StrokeOffsetProperty); + set => SetValue(StrokeOffsetProperty, value); } /// - /// Gets the units in which the value is expressed. + /// Gets the units in which the value is expressed. /// - public TextDecorationUnit PenOffsetUnit + public TextDecorationUnit StrokeOffsetUnit { - get => GetValue(PenOffsetUnitProperty); - set => SetValue(PenOffsetUnitProperty, value); + get => GetValue(StrokeOffsetUnitProperty); + set => SetValue(StrokeOffsetUnitProperty, value); } /// - /// Creates an immutable clone of the . + /// Draws the at given origin. /// - /// The immutable clone. - public ImmutableTextDecoration ToImmutable() + /// The drawing context. + /// The shaped characters that are decorated. + /// The origin. + internal void Draw(DrawingContext drawingContext, ShapedTextCharacters shapedTextCharacters, Point origin) { - return new ImmutableTextDecoration(Location, Pen?.ToImmutable(), PenThicknessUnit, PenOffset, PenOffsetUnit); + var fontRenderingEmSize = shapedTextCharacters.Properties.FontRenderingEmSize; + var fontMetrics = shapedTextCharacters.FontMetrics; + var thickness = StrokeThickness; + + switch (StrokeThicknessUnit) + { + case TextDecorationUnit.FontRecommended: + switch (Location) + { + case TextDecorationLocation.Underline: + thickness = fontMetrics.UnderlineThickness; + break; + case TextDecorationLocation.Strikethrough: + thickness = fontMetrics.StrikethroughThickness; + break; + } + + break; + case TextDecorationUnit.FontRenderingEmSize: + thickness = fontRenderingEmSize * thickness; + break; + } + + switch (Location) + { + case TextDecorationLocation.Overline: + origin += new Point(0, fontMetrics.Ascent); + break; + case TextDecorationLocation.Strikethrough: + origin += new Point(0, -fontMetrics.StrikethroughPosition); + break; + case TextDecorationLocation.Underline: + origin += new Point(0, -fontMetrics.UnderlinePosition); + break; + } + + switch (StrokeOffsetUnit) + { + case TextDecorationUnit.FontRenderingEmSize: + origin += new Point(0, StrokeOffset * fontRenderingEmSize); + break; + case TextDecorationUnit.Pixel: + origin += new Point(0, StrokeOffset); + break; + } + + var pen = new Pen(Stroke ?? shapedTextCharacters.Properties.ForegroundBrush, thickness, + new DashStyle(StrokeDashArray, StrokeDashOffset), StrokeLineCap); + + drawingContext.DrawLine(pen, origin, origin + new Point(shapedTextCharacters.Bounds.Width, 0)); } } } diff --git a/src/Avalonia.Visuals/Media/TextDecorationCollection.cs b/src/Avalonia.Visuals/Media/TextDecorationCollection.cs index 21e2e2484c..2dced2252e 100644 --- a/src/Avalonia.Visuals/Media/TextDecorationCollection.cs +++ b/src/Avalonia.Visuals/Media/TextDecorationCollection.cs @@ -1,7 +1,6 @@ using System; using System.Collections.Generic; using Avalonia.Collections; -using Avalonia.Media.Immutable; using Avalonia.Utilities; namespace Avalonia.Media @@ -11,22 +10,6 @@ namespace Avalonia.Media /// public class TextDecorationCollection : AvaloniaList { - /// - /// Creates an immutable clone of the . - /// - /// The immutable clone. - public ImmutableTextDecoration[] ToImmutable() - { - var immutable = new ImmutableTextDecoration[Count]; - - for (var i = 0; i < Count; i++) - { - immutable[i] = this[i].ToImmutable(); - } - - return immutable; - } - /// /// Parses a string. /// diff --git a/src/Avalonia.Visuals/Media/TextDecorationUnit.cs b/src/Avalonia.Visuals/Media/TextDecorationUnit.cs index dde425bb94..a61983e8d5 100644 --- a/src/Avalonia.Visuals/Media/TextDecorationUnit.cs +++ b/src/Avalonia.Visuals/Media/TextDecorationUnit.cs @@ -1,7 +1,7 @@ namespace Avalonia.Media { /// - /// Specifies the unit type of either a or a thickness value. + /// Specifies the unit type of either a or a value. /// public enum TextDecorationUnit { diff --git a/src/Avalonia.Visuals/Media/TextFormatting/DrawableTextRun.cs b/src/Avalonia.Visuals/Media/TextFormatting/DrawableTextRun.cs index 4903342cea..56790cc0db 100644 --- a/src/Avalonia.Visuals/Media/TextFormatting/DrawableTextRun.cs +++ b/src/Avalonia.Visuals/Media/TextFormatting/DrawableTextRun.cs @@ -1,6 +1,4 @@ -using Avalonia.Platform; - -namespace Avalonia.Media.TextFormatting +namespace Avalonia.Media.TextFormatting { /// /// A text run that supports drawing content. @@ -17,6 +15,6 @@ namespace Avalonia.Media.TextFormatting /// /// The drawing context. /// The origin. - public abstract void Draw(IDrawingContextImpl drawingContext, Point origin); + public abstract void Draw(DrawingContext drawingContext, Point origin); } } diff --git a/src/Avalonia.Visuals/Media/TextFormatting/GenericTextParagraphProperties.cs b/src/Avalonia.Visuals/Media/TextFormatting/GenericTextParagraphProperties.cs new file mode 100644 index 0000000000..c4302aecec --- /dev/null +++ b/src/Avalonia.Visuals/Media/TextFormatting/GenericTextParagraphProperties.cs @@ -0,0 +1,69 @@ +namespace Avalonia.Media.TextFormatting +{ + public class GenericTextParagraphProperties : TextParagraphProperties + { + private TextAlignment _textAlignment; + private TextWrapping _textWrapping; + private TextTrimming _textTrimming; + private double _lineHeight; + + public GenericTextParagraphProperties( + TextRunProperties defaultTextRunProperties, + TextAlignment textAlignment = TextAlignment.Left, + TextWrapping textWrapping = TextWrapping.WrapWithOverflow, + TextTrimming textTrimming = TextTrimming.None, + double lineHeight = 0) + { + DefaultTextRunProperties = defaultTextRunProperties; + + _textAlignment = textAlignment; + + _textWrapping = textWrapping; + + _textTrimming = textTrimming; + + _lineHeight = lineHeight; + } + + public override TextRunProperties DefaultTextRunProperties { get; } + + public override TextAlignment TextAlignment => _textAlignment; + + public override TextWrapping TextWrapping => _textWrapping; + + public override TextTrimming TextTrimming => _textTrimming; + + public override double LineHeight => _lineHeight; + + /// + /// Set text alignment + /// + internal void SetTextAlignment(TextAlignment textAlignment) + { + _textAlignment = textAlignment; + } + + /// + /// Set text wrap + /// + internal void SetTextWrapping(TextWrapping textWrapping) + { + _textWrapping = textWrapping; + } + /// + /// Set text trimming + /// + internal void SetTextTrimming(TextTrimming textTrimming) + { + _textTrimming = textTrimming; + } + + /// + /// Set line height + /// + internal void SetLineHeight(double lineHeight) + { + _lineHeight = lineHeight; + } + } +} diff --git a/src/Avalonia.Visuals/Media/TextFormatting/GenericTextRunProperties.cs b/src/Avalonia.Visuals/Media/TextFormatting/GenericTextRunProperties.cs new file mode 100644 index 0000000000..3db3589498 --- /dev/null +++ b/src/Avalonia.Visuals/Media/TextFormatting/GenericTextRunProperties.cs @@ -0,0 +1,40 @@ +using System.Globalization; + +namespace Avalonia.Media.TextFormatting +{ + /// + /// Generic implementation of TextRunProperties + /// + public class GenericTextRunProperties : TextRunProperties + { + public GenericTextRunProperties(Typeface typeface, double fontRenderingEmSize = 12, + TextDecorationCollection textDecorations = null, IBrush foregroundBrush = null, IBrush backgroundBrush = null, + CultureInfo cultureInfo = null) + { + Typeface = typeface; + FontRenderingEmSize = fontRenderingEmSize; + TextDecorations = textDecorations; + ForegroundBrush = foregroundBrush; + BackgroundBrush = backgroundBrush; + CultureInfo = cultureInfo; + } + + /// + public override Typeface Typeface { get; } + + /// + public override double FontRenderingEmSize { get; } + + /// + public override TextDecorationCollection TextDecorations { get; } + + /// + public override IBrush ForegroundBrush { get; } + + /// + public override IBrush BackgroundBrush { get; } + + /// + public override CultureInfo CultureInfo { get; } + } +} diff --git a/src/Avalonia.Visuals/Media/TextFormatting/ShapeableTextCharacters.cs b/src/Avalonia.Visuals/Media/TextFormatting/ShapeableTextCharacters.cs new file mode 100644 index 0000000000..0c6c722941 --- /dev/null +++ b/src/Avalonia.Visuals/Media/TextFormatting/ShapeableTextCharacters.cs @@ -0,0 +1,23 @@ +using Avalonia.Utilities; + +namespace Avalonia.Media.TextFormatting +{ + /// + /// A group of characters that can be shaped. + /// + public sealed class ShapeableTextCharacters : TextRun + { + public ShapeableTextCharacters(ReadOnlySlice text, TextRunProperties properties) + { + TextSourceLength = text.Length; + Text = text; + Properties = properties; + } + + public override int TextSourceLength { get; } + + public override ReadOnlySlice Text { get; } + + public override TextRunProperties Properties { get; } + } +} diff --git a/src/Avalonia.Visuals/Media/TextFormatting/ShapedTextCharacters.cs b/src/Avalonia.Visuals/Media/TextFormatting/ShapedTextCharacters.cs new file mode 100644 index 0000000000..2e7e7aceb1 --- /dev/null +++ b/src/Avalonia.Visuals/Media/TextFormatting/ShapedTextCharacters.cs @@ -0,0 +1,164 @@ +using Avalonia.Media.TextFormatting.Unicode; +using Avalonia.Utilities; + +namespace Avalonia.Media.TextFormatting +{ + /// + /// A text run that holds shaped characters. + /// + public sealed class ShapedTextCharacters : DrawableTextRun + { + public ShapedTextCharacters(GlyphRun glyphRun, TextRunProperties properties) + { + Text = glyphRun.Characters; + Properties = properties; + TextSourceLength = Text.Length; + FontMetrics = new FontMetrics(Properties.Typeface, Properties.FontRenderingEmSize); + GlyphRun = glyphRun; + } + + /// + public override ReadOnlySlice Text { get; } + + /// + public override TextRunProperties Properties { get; } + + /// + public override int TextSourceLength { get; } + + /// + public override Rect Bounds => GlyphRun.Bounds; + + /// + /// Gets the font metrics. + /// + /// + /// The font metrics. + /// + public FontMetrics FontMetrics { get; } + + /// + /// Gets the glyph run. + /// + /// + /// The glyphs. + /// + public GlyphRun GlyphRun { get; } + + /// + public override void Draw(DrawingContext drawingContext, Point origin) + { + if (GlyphRun.GlyphIndices.Length == 0) + { + return; + } + + if (Properties.Typeface == null) + { + return; + } + + if (Properties.ForegroundBrush == null) + { + return; + } + + if (Properties.BackgroundBrush != null) + { + drawingContext.DrawRectangle(Properties.BackgroundBrush, null, + new Rect(origin.X, origin.Y + FontMetrics.Ascent, Bounds.Width, Bounds.Height)); + } + + drawingContext.DrawGlyphRun(Properties.ForegroundBrush, GlyphRun, origin); + + if (Properties.TextDecorations == null) + { + return; + } + + foreach (var textDecoration in Properties.TextDecorations) + { + textDecoration.Draw(drawingContext, this, origin); + } + } + + /// + /// Splits the at specified length. + /// + /// The length. + /// The split result. + public SplitTextCharactersResult Split(int length) + { + var glyphCount = 0; + + var firstCharacters = GlyphRun.Characters.Take(length); + + var codepointEnumerator = new CodepointEnumerator(firstCharacters); + + while (codepointEnumerator.MoveNext()) + { + glyphCount++; + } + + if (GlyphRun.Characters.Length == length) + { + return new SplitTextCharactersResult(this, null); + } + + if (GlyphRun.GlyphIndices.Length == glyphCount) + { + return new SplitTextCharactersResult(this, null); + } + + var firstGlyphRun = new GlyphRun( + Properties.Typeface.GlyphTypeface, + Properties.FontRenderingEmSize, + GlyphRun.GlyphIndices.Take(glyphCount), + GlyphRun.GlyphAdvances.Take(glyphCount), + GlyphRun.GlyphOffsets.Take(glyphCount), + GlyphRun.Characters.Take(length), + GlyphRun.GlyphClusters.Take(glyphCount)); + + var firstTextRun = new ShapedTextCharacters(firstGlyphRun, Properties); + + var secondGlyphRun = new GlyphRun( + Properties.Typeface.GlyphTypeface, + Properties.FontRenderingEmSize, + GlyphRun.GlyphIndices.Skip(glyphCount), + GlyphRun.GlyphAdvances.Skip(glyphCount), + GlyphRun.GlyphOffsets.Skip(glyphCount), + GlyphRun.Characters.Skip(length), + GlyphRun.GlyphClusters.Skip(glyphCount)); + + var secondTextRun = new ShapedTextCharacters(secondGlyphRun, Properties); + + return new SplitTextCharactersResult(firstTextRun, secondTextRun); + } + + public readonly struct SplitTextCharactersResult + { + public SplitTextCharactersResult(ShapedTextCharacters first, ShapedTextCharacters second) + { + First = first; + + Second = second; + } + + /// + /// Gets the first text run. + /// + /// + /// The first text run. + /// + public ShapedTextCharacters First { get; } + + /// + /// Gets the second text run. + /// + /// + /// The second text run. + /// + public ShapedTextCharacters Second { get; } + } + } +} diff --git a/src/Avalonia.Visuals/Media/TextFormatting/ShapedTextRun.cs b/src/Avalonia.Visuals/Media/TextFormatting/ShapedTextRun.cs deleted file mode 100644 index 00f9b918cb..0000000000 --- a/src/Avalonia.Visuals/Media/TextFormatting/ShapedTextRun.cs +++ /dev/null @@ -1,212 +0,0 @@ -using Avalonia.Media.Immutable; -using Avalonia.Media.TextFormatting.Unicode; -using Avalonia.Platform; -using Avalonia.Utility; - -namespace Avalonia.Media.TextFormatting -{ - /// - /// A text run that holds a shaped glyph run. - /// - public sealed class ShapedTextRun : DrawableTextRun - { - public ShapedTextRun(ReadOnlySlice text, TextStyle style) : this( - TextShaper.Current.ShapeText(text, style.TextFormat), style) - { - } - - public ShapedTextRun(GlyphRun glyphRun, TextStyle style) - { - Text = glyphRun.Characters; - Style = style; - GlyphRun = glyphRun; - } - - /// - public override Rect Bounds => GlyphRun.Bounds; - - /// - /// Gets the glyph run. - /// - /// - /// The glyphs. - /// - public GlyphRun GlyphRun { get; } - - /// - public override void Draw(IDrawingContextImpl drawingContext, Point origin) - { - if (GlyphRun.GlyphIndices.Length == 0) - { - return; - } - - if (Style.TextFormat.Typeface == null) - { - return; - } - - if (Style.Foreground == null) - { - return; - } - - drawingContext.DrawGlyphRun(Style.Foreground, GlyphRun, origin); - - if (Style.TextDecorations == null) - { - return; - } - - foreach (var textDecoration in Style.TextDecorations) - { - DrawTextDecoration(drawingContext, textDecoration, origin); - } - } - - /// - /// Draws the at given origin. - /// - /// The drawing context. - /// The text decoration. - /// The origin. - private void DrawTextDecoration(IDrawingContextImpl drawingContext, ImmutableTextDecoration textDecoration, Point origin) - { - var textFormat = Style.TextFormat; - - var fontMetrics = Style.TextFormat.FontMetrics; - - var thickness = textDecoration.Pen?.Thickness ?? 1.0; - - switch (textDecoration.PenThicknessUnit) - { - case TextDecorationUnit.FontRecommended: - switch (textDecoration.Location) - { - case TextDecorationLocation.Underline: - thickness = fontMetrics.UnderlineThickness; - break; - case TextDecorationLocation.Strikethrough: - thickness = fontMetrics.StrikethroughThickness; - break; - } - break; - case TextDecorationUnit.FontRenderingEmSize: - thickness = textFormat.FontRenderingEmSize * thickness; - break; - } - - switch (textDecoration.Location) - { - case TextDecorationLocation.Overline: - origin += new Point(0, textFormat.FontMetrics.Ascent); - break; - case TextDecorationLocation.Strikethrough: - origin += new Point(0, -textFormat.FontMetrics.StrikethroughPosition); - break; - case TextDecorationLocation.Underline: - origin += new Point(0, -textFormat.FontMetrics.UnderlinePosition); - break; - } - - switch (textDecoration.PenOffsetUnit) - { - case TextDecorationUnit.FontRenderingEmSize: - origin += new Point(0, textDecoration.PenOffset * textFormat.FontRenderingEmSize); - break; - case TextDecorationUnit.Pixel: - origin += new Point(0, textDecoration.PenOffset); - break; - } - - var pen = new ImmutablePen( - textDecoration.Pen?.Brush ?? Style.Foreground.ToImmutable(), - thickness, - textDecoration.Pen?.DashStyle?.ToImmutable(), - textDecoration.Pen?.LineCap ?? default, - textDecoration.Pen?.LineJoin ?? PenLineJoin.Miter, - textDecoration.Pen?.MiterLimit ?? 10.0); - - drawingContext.DrawLine(pen, origin, origin + new Point(GlyphRun.Bounds.Width, 0)); - } - - /// - /// Splits the at specified length. - /// - /// The length. - /// The split result. - public SplitTextCharactersResult Split(int length) - { - var glyphCount = 0; - - var firstCharacters = GlyphRun.Characters.Take(length); - - var codepointEnumerator = new CodepointEnumerator(firstCharacters); - - while (codepointEnumerator.MoveNext()) - { - glyphCount++; - } - - if (GlyphRun.Characters.Length == length) - { - return new SplitTextCharactersResult(this, null); - } - - if (GlyphRun.GlyphIndices.Length == glyphCount) - { - return new SplitTextCharactersResult(this, null); - } - - var firstGlyphRun = new GlyphRun( - Style.TextFormat.Typeface.GlyphTypeface, - Style.TextFormat.FontRenderingEmSize, - GlyphRun.GlyphIndices.Take(glyphCount), - GlyphRun.GlyphAdvances.Take(glyphCount), - GlyphRun.GlyphOffsets.Take(glyphCount), - GlyphRun.Characters.Take(length), - GlyphRun.GlyphClusters.Take(length)); - - var firstTextRun = new ShapedTextRun(firstGlyphRun, Style); - - var secondGlyphRun = new GlyphRun( - Style.TextFormat.Typeface.GlyphTypeface, - Style.TextFormat.FontRenderingEmSize, - GlyphRun.GlyphIndices.Skip(glyphCount), - GlyphRun.GlyphAdvances.Skip(glyphCount), - GlyphRun.GlyphOffsets.Skip(glyphCount), - GlyphRun.Characters.Skip(length), - GlyphRun.GlyphClusters.Skip(length)); - - var secondTextRun = new ShapedTextRun(secondGlyphRun, Style); - - return new SplitTextCharactersResult(firstTextRun, secondTextRun); - } - - public readonly struct SplitTextCharactersResult - { - public SplitTextCharactersResult(ShapedTextRun first, ShapedTextRun second) - { - First = first; - - Second = second; - } - - /// - /// Gets the first text run. - /// - /// - /// The first text run. - /// - public ShapedTextRun First { get; } - - /// - /// Gets the second text run. - /// - /// - /// The second text run. - /// - public ShapedTextRun Second { get; } - } - } -} diff --git a/src/Avalonia.Visuals/Media/TextFormatting/SimpleTextFormatter.cs b/src/Avalonia.Visuals/Media/TextFormatting/SimpleTextFormatter.cs deleted file mode 100644 index f84e45d4c6..0000000000 --- a/src/Avalonia.Visuals/Media/TextFormatting/SimpleTextFormatter.cs +++ /dev/null @@ -1,395 +0,0 @@ -using System; -using System.Collections.Generic; -using Avalonia.Media.TextFormatting.Unicode; -using Avalonia.Platform; -using Avalonia.Utility; - -namespace Avalonia.Media.TextFormatting -{ - internal class SimpleTextFormatter : TextFormatter - { - private static readonly ReadOnlySlice s_ellipsis = new ReadOnlySlice(new[] { '\u2026' }); - - /// - public override TextLine FormatLine(ITextSource textSource, int firstTextSourceIndex, double paragraphWidth, - TextParagraphProperties paragraphProperties) - { - var textTrimming = paragraphProperties.TextTrimming; - var textWrapping = paragraphProperties.TextWrapping; - TextLine textLine; - - var textRuns = FormatTextRuns(textSource, firstTextSourceIndex, out var textPointer); - - if (textTrimming != TextTrimming.None) - { - textLine = PerformTextTrimming(textPointer, textRuns, paragraphWidth, paragraphProperties); - } - else - { - if (textWrapping == TextWrapping.Wrap) - { - textLine = PerformTextWrapping(textPointer, textRuns, paragraphWidth, paragraphProperties); - } - else - { - var textLineMetrics = - TextLineMetrics.Create(textRuns, paragraphWidth, paragraphProperties.TextAlignment); - - textLine = new SimpleTextLine(textPointer, textRuns, textLineMetrics); - } - } - - return textLine; - } - - /// - /// Formats text runs with optional text style overrides. - /// - /// The text source. - /// The first text source index. - /// The text pointer that covers the formatted text runs. - /// - /// The formatted text runs. - /// - private List FormatTextRuns(ITextSource textSource, int firstTextSourceIndex, out TextPointer textPointer) - { - var start = -1; - var length = 0; - - var textRuns = new List(); - - while (true) - { - var textRun = textSource.GetTextRun(firstTextSourceIndex + length); - - if (start == -1) - { - start = textRun.Text.Start; - } - - if (textRun is TextEndOfLine) - { - break; - } - - switch (textRun) - { - case TextCharacters textCharacters: - - var runText = textCharacters.Text; - - while (!runText.IsEmpty) - { - var shapableTextStyleRun = CreateShapableTextStyleRun(runText, textRun.Style); - - var shapedRun = new ShapedTextRun(runText.Take(shapableTextStyleRun.TextPointer.Length), - shapableTextStyleRun.Style); - - textRuns.Add(shapedRun); - - runText = runText.Skip(shapedRun.Text.Length); - } - - break; - default: - throw new NotSupportedException("Run type not supported by the formatter."); - } - - length += textRun.Text.Length; - } - - textPointer = new TextPointer(start, length); - - return textRuns; - } - - /// - /// Performs text trimming and returns a trimmed line. - /// - /// A value that specifies the width of the paragraph that the line fills. - /// A value that represents paragraph properties, - /// such as TextWrapping, TextAlignment, or TextStyle. - /// The text runs to perform the trimming on. - /// The text that was used to construct the text runs. - /// - private static TextLine PerformTextTrimming(TextPointer text, IReadOnlyList textRuns, - double paragraphWidth, TextParagraphProperties paragraphProperties) - { - var textTrimming = paragraphProperties.TextTrimming; - var availableWidth = paragraphWidth; - var currentWidth = 0.0; - var runIndex = 0; - - while (runIndex < textRuns.Count) - { - var currentRun = textRuns[runIndex]; - - currentWidth += currentRun.GlyphRun.Bounds.Width; - - if (currentWidth > availableWidth) - { - var ellipsisRun = CreateEllipsisRun(currentRun.Style); - - var measuredLength = MeasureText(currentRun, availableWidth - ellipsisRun.GlyphRun.Bounds.Width); - - if (textTrimming == TextTrimming.WordEllipsis) - { - if (measuredLength < text.End) - { - var currentBreakPosition = 0; - - var lineBreaker = new LineBreakEnumerator(currentRun.Text); - - while (currentBreakPosition < measuredLength && lineBreaker.MoveNext()) - { - var nextBreakPosition = lineBreaker.Current.PositionWrap; - - if (nextBreakPosition == 0) - { - break; - } - - if (nextBreakPosition > measuredLength) - { - break; - } - - currentBreakPosition = nextBreakPosition; - } - - measuredLength = currentBreakPosition; - } - } - - var splitResult = SplitTextRuns(textRuns, measuredLength); - - var trimmedRuns = new List(splitResult.First.Count + 1); - - trimmedRuns.AddRange(splitResult.First); - - trimmedRuns.Add(ellipsisRun); - - var textLineMetrics = - TextLineMetrics.Create(trimmedRuns, paragraphWidth, paragraphProperties.TextAlignment); - - return new SimpleTextLine(text.Take(measuredLength), trimmedRuns, textLineMetrics); - } - - availableWidth -= currentRun.GlyphRun.Bounds.Width; - - runIndex++; - } - - return new SimpleTextLine(text, textRuns, - TextLineMetrics.Create(textRuns, paragraphWidth, paragraphProperties.TextAlignment)); - } - - /// - /// Performs text wrapping returns a list of text lines. - /// - /// The text paragraph properties. - /// The text run'S. - /// The text to analyze for break opportunities. - /// - /// - private static TextLine PerformTextWrapping(TextPointer text, IReadOnlyList textRuns, - double paragraphWidth, TextParagraphProperties paragraphProperties) - { - var availableWidth = paragraphWidth; - var currentWidth = 0.0; - var runIndex = 0; - var length = 0; - - while (runIndex < textRuns.Count) - { - var currentRun = textRuns[runIndex]; - - if (currentWidth + currentRun.GlyphRun.Bounds.Width > availableWidth) - { - var measuredLength = MeasureText(currentRun, paragraphWidth - currentWidth); - - if (measuredLength < currentRun.Text.Length) - { - var currentBreakPosition = -1; - - var lineBreaker = new LineBreakEnumerator(currentRun.Text); - - while (currentBreakPosition < measuredLength && lineBreaker.MoveNext()) - { - var nextBreakPosition = lineBreaker.Current.PositionWrap; - - if (nextBreakPosition == 0) - { - break; - } - - if (nextBreakPosition > measuredLength) - { - break; - } - - currentBreakPosition = nextBreakPosition; - } - - if (currentBreakPosition != -1) - { - measuredLength = currentBreakPosition; - } - } - - length += measuredLength; - - var splitResult = SplitTextRuns(textRuns, length); - - var textLineMetrics = - TextLineMetrics.Create(splitResult.First, paragraphWidth, paragraphProperties.TextAlignment); - - return new SimpleTextLine(text.Take(length), splitResult.First, textLineMetrics); - } - - currentWidth += currentRun.GlyphRun.Bounds.Width; - - length += currentRun.GlyphRun.Characters.Length; - - runIndex++; - } - - return new SimpleTextLine(text, textRuns, - TextLineMetrics.Create(textRuns, paragraphWidth, paragraphProperties.TextAlignment)); - } - - /// - /// Measures the number of characters that fits into available width. - /// - /// The text run. - /// The available width. - /// - private static int MeasureText(ShapedTextRun textRun, double availableWidth) - { - var glyphRun = textRun.GlyphRun; - - var characterHit = glyphRun.GetCharacterHitFromDistance(availableWidth, out _); - - return characterHit.FirstCharacterIndex + characterHit.TrailingLength - textRun.Text.Start; - } - - /// - /// Creates an ellipsis. - /// - /// The text style. - /// - private static ShapedTextRun CreateEllipsisRun(TextStyle textStyle) - { - var formatterImpl = AvaloniaLocator.Current.GetService(); - - var glyphRun = formatterImpl.ShapeText(s_ellipsis, textStyle.TextFormat); - - return new ShapedTextRun(glyphRun, textStyle); - } - - private readonly struct SplitTextRunsResult - { - public SplitTextRunsResult(IReadOnlyList first, IReadOnlyList second) - { - First = first; - - Second = second; - } - - /// - /// Gets the first text runs. - /// - /// - /// The first text runs. - /// - public IReadOnlyList First { get; } - - /// - /// Gets the second text runs. - /// - /// - /// The second text runs. - /// - public IReadOnlyList Second { get; } - } - - /// - /// Split a sequence of runs into two segments at specified length. - /// - /// The text run's. - /// The length to split at. - /// - private static SplitTextRunsResult SplitTextRuns(IReadOnlyList textRuns, int length) - { - var currentLength = 0; - - for (var i = 0; i < textRuns.Count; i++) - { - var currentRun = textRuns[i]; - - if (currentLength + currentRun.GlyphRun.Characters.Length < length) - { - currentLength += currentRun.GlyphRun.Characters.Length; - continue; - } - - var firstCount = currentRun.GlyphRun.Characters.Length >= 1 ? i + 1 : i; - - var first = new ShapedTextRun[firstCount]; - - if (firstCount > 1) - { - for (var j = 0; j < i; j++) - { - first[j] = textRuns[j]; - } - } - - var secondCount = textRuns.Count - firstCount; - - if (currentLength + currentRun.GlyphRun.Characters.Length == length) - { - var second = new ShapedTextRun[secondCount]; - - var offset = currentRun.GlyphRun.Characters.Length > 1 ? 1 : 0; - - if (secondCount > 0) - { - for (var j = 0; j < secondCount; j++) - { - second[j] = textRuns[i + j + offset]; - } - } - - first[i] = currentRun; - - return new SplitTextRunsResult(first, second); - } - else - { - secondCount++; - - var second = new ShapedTextRun[secondCount]; - - if (secondCount > 0) - { - for (var j = 1; j < secondCount; j++) - { - second[j] = textRuns[i + j]; - } - } - - var split = currentRun.Split(length - currentLength); - - first[i] = split.First; - - second[0] = split.Second; - - return new SplitTextRunsResult(first, second); - } - } - - return new SplitTextRunsResult(textRuns, null); - } - } -} diff --git a/src/Avalonia.Visuals/Media/TextFormatting/SimpleTextLine.cs b/src/Avalonia.Visuals/Media/TextFormatting/SimpleTextLine.cs deleted file mode 100644 index 11d241bc34..0000000000 --- a/src/Avalonia.Visuals/Media/TextFormatting/SimpleTextLine.cs +++ /dev/null @@ -1,259 +0,0 @@ -using System; -using System.Collections.Generic; -using Avalonia.Platform; - -namespace Avalonia.Media.TextFormatting -{ - internal class SimpleTextLine : TextLine - { - private readonly IReadOnlyList _textRuns; - - public SimpleTextLine(TextPointer textPointer, IReadOnlyList textRuns, TextLineMetrics lineMetrics) - { - Text = textPointer; - _textRuns = textRuns; - LineMetrics = lineMetrics; - } - - /// - public override TextPointer Text { get; } - - /// - public override IReadOnlyList TextRuns => _textRuns; - - /// - public override TextLineMetrics LineMetrics { get; } - - /// - public override void Draw(IDrawingContextImpl drawingContext, Point origin) - { - var currentX = origin.X; - - foreach (var textRun in _textRuns) - { - var baselineOrigin = new Point(currentX + LineMetrics.BaselineOrigin.X, - origin.Y + LineMetrics.BaselineOrigin.Y); - - textRun.Draw(drawingContext, baselineOrigin); - - currentX += textRun.Bounds.Width; - } - } - - /// - public override CharacterHit GetCharacterHitFromDistance(double distance) - { - if (distance < 0) - { - // hit happens before the line, return the first position - return new CharacterHit(Text.Start); - } - - // process hit that happens within the line - var characterHit = new CharacterHit(); - - foreach (var run in _textRuns) - { - characterHit = run.GlyphRun.GetCharacterHitFromDistance(distance, out _); - - if (distance <= run.Bounds.Width) - { - break; - } - - distance -= run.Bounds.Width; - } - - return characterHit; - } - - /// - public override double GetDistanceFromCharacterHit(CharacterHit characterHit) - { - return DistanceFromCodepointIndex(characterHit.FirstCharacterIndex + (characterHit.TrailingLength != 0 ? 1 : 0)); - } - - /// - public override CharacterHit GetNextCaretCharacterHit(CharacterHit characterHit) - { - int nextVisibleCp; - bool navigableCpFound; - - if (characterHit.TrailingLength == 0) - { - navigableCpFound = FindNextCodepointIndex(characterHit.FirstCharacterIndex, out nextVisibleCp); - - if (navigableCpFound) - { - // Move from leading to trailing edge - return new CharacterHit(nextVisibleCp, 1); - } - } - - navigableCpFound = FindNextCodepointIndex(characterHit.FirstCharacterIndex + 1, out nextVisibleCp); - - if (navigableCpFound) - { - // Move from trailing edge of current character to trailing edge of next - return new CharacterHit(nextVisibleCp, 1); - } - - // Can't move, we're after the last character - return characterHit; - } - - /// - public override CharacterHit GetPreviousCaretCharacterHit(CharacterHit characterHit) - { - int previousCodepointIndex; - bool codepointIndexFound; - - var cpHit = characterHit.FirstCharacterIndex; - var trailingHit = characterHit.TrailingLength != 0; - - // Input can be right after the end of the current line. Snap it to be at the end of the line. - if (cpHit >= Text.Start + Text.Length) - { - cpHit = Text.Start + Text.Length - 1; - - trailingHit = true; - } - - if (trailingHit) - { - codepointIndexFound = FindPreviousCodepointIndex(cpHit, out previousCodepointIndex); - - if (codepointIndexFound) - { - // Move from trailing to leading edge - return new CharacterHit(previousCodepointIndex, 0); - } - } - - codepointIndexFound = FindPreviousCodepointIndex(cpHit - 1, out previousCodepointIndex); - - if (codepointIndexFound) - { - // Move from leading edge of current character to leading edge of previous - return new CharacterHit(previousCodepointIndex, 0); - } - - // Can't move, we're before the first character - return characterHit; - } - - /// - public override CharacterHit GetBackspaceCaretCharacterHit(CharacterHit characterHit) - { - // same operation as move-to-previous - return GetPreviousCaretCharacterHit(characterHit); - } - - /// - /// Get distance from line start to the specified codepoint index - /// - private double DistanceFromCodepointIndex(int codepointIndex) - { - var currentDistance = 0.0; - - foreach (var textRun in _textRuns) - { - if (codepointIndex > textRun.Text.End) - { - currentDistance += textRun.Bounds.Width; - - continue; - } - - return currentDistance + textRun.GlyphRun.GetDistanceFromCharacterHit(new CharacterHit(codepointIndex)); - } - - return currentDistance; - } - - /// - /// Search forward from the given codepoint index (inclusive) to find the next navigable codepoint index. - /// Return true if one such codepoint index is found, false otherwise. - /// - private bool FindNextCodepointIndex(int codepointIndex, out int nextCodepointIndex) - { - nextCodepointIndex = codepointIndex; - - if (codepointIndex >= Text.Start + Text.Length) - { - return false; // Cannot go forward anymore - } - - GetRunIndexAtCodepointIndex(codepointIndex, out var runIndex, out var cpRunStart); - - while (runIndex < TextRuns.Count) - { - // When navigating forward, only the trailing edge of visible content is - // navigable. - if (runIndex < TextRuns.Count) - { - nextCodepointIndex = Math.Max(cpRunStart, codepointIndex); - return true; - } - - cpRunStart += TextRuns[runIndex++].Text.Length; - } - - return false; - } - - /// - /// Search backward from the given codepoint index (inclusive) to find the previous navigable codepoint index. - /// Return true if one such codepoint is found, false otherwise. - /// - private bool FindPreviousCodepointIndex(int codepointIndex, out int previousCodepointIndex) - { - previousCodepointIndex = codepointIndex; - - if (codepointIndex < Text.Start) - { - return false; // Cannot go backward anymore. - } - - // Position the cpRunEnd at the end of the span that contains the given cp - GetRunIndexAtCodepointIndex(codepointIndex, out var runIndex, out var codepointIndexAtRunEnd); - - codepointIndexAtRunEnd += TextRuns[runIndex].Text.End; - - while (runIndex >= 0) - { - // Visible content has caret stops at its leading edge. - if (runIndex + 1 < TextRuns.Count) - { - previousCodepointIndex = Math.Min(codepointIndexAtRunEnd, codepointIndex); - return true; - } - - // Newline sequence has caret stops at its leading edge. - if (runIndex == TextRuns.Count) - { - // Get the cp index at the beginning of the newline sequence. - previousCodepointIndex = codepointIndexAtRunEnd - TextRuns[runIndex].Text.Length + 1; - return true; - } - - codepointIndexAtRunEnd -= TextRuns[runIndex--].Text.Length; - } - - return false; - } - - private void GetRunIndexAtCodepointIndex(int codepointIndex, out int runIndex, out int codepointIndexAtRunStart) - { - codepointIndexAtRunStart = Text.Start; - runIndex = 0; - - // Find the span that contains the given cp - while (runIndex < TextRuns.Count && - codepointIndexAtRunStart + TextRuns[runIndex].Text.Length <= codepointIndex) - { - codepointIndexAtRunStart += TextRuns[runIndex++].Text.Length; - } - } - } -} diff --git a/src/Avalonia.Visuals/Media/TextFormatting/TextCharacters.cs b/src/Avalonia.Visuals/Media/TextFormatting/TextCharacters.cs index d9b27958ab..b35882fc0e 100644 --- a/src/Avalonia.Visuals/Media/TextFormatting/TextCharacters.cs +++ b/src/Avalonia.Visuals/Media/TextFormatting/TextCharacters.cs @@ -1,4 +1,6 @@ -using Avalonia.Utility; +using System.Collections.Generic; +using Avalonia.Media.TextFormatting.Unicode; +using Avalonia.Utilities; namespace Avalonia.Media.TextFormatting { @@ -7,15 +9,182 @@ namespace Avalonia.Media.TextFormatting /// public class TextCharacters : TextRun { - protected TextCharacters() + public TextCharacters(ReadOnlySlice text, TextRunProperties properties) { - + TextSourceLength = text.Length; + Text = text; + Properties = properties; } - public TextCharacters(ReadOnlySlice text, TextStyle style) + /// + public override int TextSourceLength { get; } + + /// + public override ReadOnlySlice Text { get; } + + /// + public override TextRunProperties Properties { get; } + + /// + /// Gets a list of . + /// + /// The shapeable text characters. + internal IList GetShapeableCharacters() { - Text = text; - Style = style; + var shapeableCharacters = new List(2); + + var runText = Text; + + while (!runText.IsEmpty) + { + var shapeableRun = CreateShapeableRun(runText, Properties); + + shapeableCharacters.Add(shapeableRun); + + runText = runText.Skip(shapeableRun.Text.Length); + } + + return shapeableCharacters; + } + + /// + /// Creates a shapeable text run with unique properties. + /// + /// The text to create text runs from. + /// The default text run properties. + /// A list of shapeable text runs. + private ShapeableTextCharacters CreateShapeableRun(ReadOnlySlice text, TextRunProperties defaultProperties) + { + var defaultTypeface = defaultProperties.Typeface; + + var currentTypeface = defaultTypeface; + + if (TryGetRunProperties(text, currentTypeface, defaultTypeface, out var count)) + { + return new ShapeableTextCharacters(text.Take(count), + new GenericTextRunProperties(currentTypeface, defaultProperties.FontRenderingEmSize, + defaultProperties.TextDecorations, defaultProperties.ForegroundBrush)); + + } + + var codepoint = Codepoint.ReadAt(text, count, out _); + + //ToDo: Fix FontFamily fallback + currentTypeface = + FontManager.Current.MatchCharacter(codepoint, defaultTypeface.Weight, defaultTypeface.Style, defaultTypeface.FontFamily); + + if (currentTypeface != null && TryGetRunProperties(text, currentTypeface, defaultTypeface, out count)) + { + //Fallback found + return new ShapeableTextCharacters(text.Take(count), + new GenericTextRunProperties(currentTypeface, defaultProperties.FontRenderingEmSize, + defaultProperties.TextDecorations, defaultProperties.ForegroundBrush)); + } + + // no fallback found + currentTypeface = defaultTypeface; + + var glyphTypeface = currentTypeface.GlyphTypeface; + + var enumerator = new GraphemeEnumerator(text); + + while (enumerator.MoveNext()) + { + var grapheme = enumerator.Current; + + if (!grapheme.FirstCodepoint.IsWhiteSpace && glyphTypeface.TryGetGlyph(grapheme.FirstCodepoint, out _)) + { + break; + } + + count += grapheme.Text.Length; + } + + return new ShapeableTextCharacters(text.Take(count), + new GenericTextRunProperties(currentTypeface, defaultProperties.FontRenderingEmSize, + defaultProperties.TextDecorations, defaultProperties.ForegroundBrush)); + } + + /// + /// Tries to get run properties. + /// + /// + /// + /// The typeface that is used to find matching characters. + /// + /// + protected bool TryGetRunProperties(ReadOnlySlice text, Typeface typeface, Typeface defaultTypeface, + out int count) + { + if (text.Length == 0) + { + count = 0; + return false; + } + + var isFallback = typeface != defaultTypeface; + + count = 0; + var script = Script.Common; + //var direction = BiDiClass.LeftToRight; + + var font = typeface.GlyphTypeface; + var defaultFont = defaultTypeface.GlyphTypeface; + + var enumerator = new GraphemeEnumerator(text); + + while (enumerator.MoveNext()) + { + var grapheme = enumerator.Current; + + var currentScript = grapheme.FirstCodepoint.Script; + + //var currentDirection = grapheme.FirstCodepoint.BiDiClass; + + //// ToDo: Implement BiDi algorithm + //if (currentScript.HorizontalDirection != direction) + //{ + // if (!UnicodeUtility.IsWhiteSpace(grapheme.FirstCodepoint)) + // { + // break; + // } + //} + + if (currentScript != script) + { + if (currentScript != Script.Inherited && currentScript != Script.Common) + { + if (script == Script.Inherited || script == Script.Common) + { + script = currentScript; + } + else + { + break; + } + } + } + + if (isFallback) + { + if (defaultFont.TryGetGlyph(grapheme.FirstCodepoint, out _)) + { + break; + } + } + + if (!font.TryGetGlyph(grapheme.FirstCodepoint, out _)) + { + if (!grapheme.FirstCodepoint.IsWhiteSpace) + { + break; + } + } + + count += grapheme.Text.Length; + } + + return count > 0; } } } diff --git a/src/Avalonia.Visuals/Media/TextFormatting/TextFormat.cs b/src/Avalonia.Visuals/Media/TextFormatting/TextFormat.cs deleted file mode 100644 index 18dd6c7c10..0000000000 --- a/src/Avalonia.Visuals/Media/TextFormatting/TextFormat.cs +++ /dev/null @@ -1,71 +0,0 @@ -using System; - -namespace Avalonia.Media.TextFormatting -{ - /// - /// Unique text formatting properties that are used by the . - /// - public readonly struct TextFormat : IEquatable - { - public TextFormat(Typeface typeface, double fontRenderingEmSize) - { - Typeface = typeface; - FontRenderingEmSize = fontRenderingEmSize; - FontMetrics = new FontMetrics(typeface, fontRenderingEmSize); - } - - /// - /// Gets the typeface. - /// - /// - /// The typeface. - /// - public Typeface Typeface { get; } - - /// - /// Gets the font rendering em size. - /// - /// - /// The em rendering size of the font. - /// - public double FontRenderingEmSize { get; } - - /// - /// Gets the font metrics. - /// - /// - /// The metrics of the font. - /// - public FontMetrics FontMetrics { get; } - - public static bool operator ==(TextFormat self, TextFormat other) - { - return self.Equals(other); - } - - public static bool operator !=(TextFormat self, TextFormat other) - { - return !(self == other); - } - - public bool Equals(TextFormat other) - { - return Typeface.Equals(other.Typeface) && FontRenderingEmSize.Equals(other.FontRenderingEmSize); - } - - public override bool Equals(object obj) - { - return obj is TextFormat other && Equals(other); - } - - public override int GetHashCode() - { - unchecked - { - var hashCode = (Typeface != null ? Typeface.GetHashCode() : 0); - hashCode = (hashCode * 397) ^ FontRenderingEmSize.GetHashCode(); - return hashCode; - } - } - } -} diff --git a/src/Avalonia.Visuals/Media/TextFormatting/TextFormatter.cs b/src/Avalonia.Visuals/Media/TextFormatting/TextFormatter.cs index 7da39dc5dc..e4c898e2b8 100644 --- a/src/Avalonia.Visuals/Media/TextFormatting/TextFormatter.cs +++ b/src/Avalonia.Visuals/Media/TextFormatting/TextFormatter.cs @@ -1,5 +1,4 @@ using Avalonia.Media.TextFormatting.Unicode; -using Avalonia.Utility; namespace Avalonia.Media.TextFormatting { @@ -22,7 +21,7 @@ namespace Avalonia.Media.TextFormatting return current; } - current = new SimpleTextFormatter(); + current = new TextFormatterImpl(); AvaloniaLocator.CurrentMutable.Bind().ToConstant(current); @@ -38,149 +37,10 @@ namespace Avalonia.Media.TextFormatting /// A value that specifies the width of the paragraph that the line fills. /// A value that represents paragraph properties, /// such as TextWrapping, TextAlignment, or TextStyle. + /// A value that specifies the text formatter state, + /// in terms of where the previous line in the paragraph was broken by the text formatting process. /// The formatted line. public abstract TextLine FormatLine(ITextSource textSource, int firstTextSourceIndex, double paragraphWidth, - TextParagraphProperties paragraphProperties); - - /// - /// Creates a text style run with unique properties. - /// - /// The text to create text runs from. - /// - /// A list of text runs. - protected TextStyleRun CreateShapableTextStyleRun(ReadOnlySlice text, TextStyle defaultStyle) - { - var defaultTypeface = defaultStyle.TextFormat.Typeface; - - var currentTypeface = defaultTypeface; - - if (TryGetRunProperties(text, currentTypeface, defaultTypeface, out var count)) - { - return new TextStyleRun(new TextPointer(text.Start, count), new TextStyle(currentTypeface, - defaultStyle.TextFormat.FontRenderingEmSize, - defaultStyle.Foreground, defaultStyle.TextDecorations)); - - } - - var codepoint = Codepoint.ReadAt(text, count, out _); - - //ToDo: Fix FontFamily fallback - currentTypeface = - FontManager.Current.MatchCharacter(codepoint, defaultTypeface.Weight, defaultTypeface.Style, defaultStyle.TextFormat.Typeface.FontFamily); - - if (currentTypeface != null && TryGetRunProperties(text, currentTypeface, defaultTypeface, out count)) - { - //Fallback found - return new TextStyleRun(new TextPointer(text.Start, count), new TextStyle(currentTypeface, - defaultStyle.TextFormat.FontRenderingEmSize, - defaultStyle.Foreground, defaultStyle.TextDecorations)); - - } - - // no fallback found - currentTypeface = defaultTypeface; - - var glyphTypeface = currentTypeface.GlyphTypeface; - - var enumerator = new GraphemeEnumerator(text); - - while (enumerator.MoveNext()) - { - var grapheme = enumerator.Current; - - if (!grapheme.FirstCodepoint.IsWhiteSpace && glyphTypeface.TryGetGlyph(grapheme.FirstCodepoint, out _)) - { - break; - } - - count += grapheme.Text.Length; - } - - return new TextStyleRun(new TextPointer(text.Start, count), - new TextStyle(currentTypeface, defaultStyle.TextFormat.FontRenderingEmSize, - defaultStyle.Foreground, defaultStyle.TextDecorations)); - } - - /// - /// Tries to get run properties. - /// - /// - /// - /// The typeface that is used to find matching characters. - /// - /// - protected bool TryGetRunProperties(ReadOnlySlice text, Typeface typeface, Typeface defaultTypeface, - out int count) - { - if (text.Length == 0) - { - count = 0; - return false; - } - - var isFallback = typeface != defaultTypeface; - - count = 0; - var script = Script.Common; - //var direction = BiDiClass.LeftToRight; - - var font = typeface.GlyphTypeface; - var defaultFont = defaultTypeface.GlyphTypeface; - - var enumerator = new GraphemeEnumerator(text); - - while (enumerator.MoveNext()) - { - var grapheme = enumerator.Current; - - var currentScript = grapheme.FirstCodepoint.Script; - - //var currentDirection = grapheme.FirstCodepoint.BiDiClass; - - //// ToDo: Implement BiDi algorithm - //if (currentScript.HorizontalDirection != direction) - //{ - // if (!UnicodeUtility.IsWhiteSpace(grapheme.FirstCodepoint)) - // { - // break; - // } - //} - - if (currentScript != script) - { - if (currentScript != Script.Inherited && currentScript != Script.Common) - { - if (script == Script.Inherited || script == Script.Common) - { - script = currentScript; - } - else - { - break; - } - } - } - - if (isFallback) - { - if (defaultFont.TryGetGlyph(grapheme.FirstCodepoint, out _)) - { - break; - } - } - - if (!font.TryGetGlyph(grapheme.FirstCodepoint, out _)) - { - if (!grapheme.FirstCodepoint.IsWhiteSpace) - { - break; - } - } - - count += grapheme.Text.Length; - } - - return count > 0; - } + TextParagraphProperties paragraphProperties, TextLineBreak previousLineBreak = null); } } diff --git a/src/Avalonia.Visuals/Media/TextFormatting/TextFormatterImpl.cs b/src/Avalonia.Visuals/Media/TextFormatting/TextFormatterImpl.cs new file mode 100644 index 0000000000..793707d0b2 --- /dev/null +++ b/src/Avalonia.Visuals/Media/TextFormatting/TextFormatterImpl.cs @@ -0,0 +1,544 @@ +using System.Collections.Generic; +using Avalonia.Media.TextFormatting.Unicode; +using Avalonia.Platform; +using Avalonia.Utilities; + +namespace Avalonia.Media.TextFormatting +{ + internal class TextFormatterImpl : TextFormatter + { + private static readonly ReadOnlySlice s_ellipsis = new ReadOnlySlice(new[] { '\u2026' }); + + /// + public override TextLine FormatLine(ITextSource textSource, int firstTextSourceIndex, double paragraphWidth, + TextParagraphProperties paragraphProperties, TextLineBreak previousLineBreak = null) + { + var textTrimming = paragraphProperties.TextTrimming; + var textWrapping = paragraphProperties.TextWrapping; + TextLine textLine = null; + + var textRuns = FetchTextRuns(textSource, firstTextSourceIndex, previousLineBreak, out var nextLineBreak); + + var textRange = GetTextRange(textRuns); + + if (textTrimming != TextTrimming.None) + { + textLine = PerformTextTrimming(textRuns, textRange, paragraphWidth, paragraphProperties); + } + else + { + switch (textWrapping) + { + case TextWrapping.NoWrap: + { + var textLineMetrics = + TextLineMetrics.Create(textRuns, textRange, paragraphWidth, paragraphProperties); + + textLine = new TextLineImpl(textRuns, textLineMetrics, nextLineBreak); + break; + } + case TextWrapping.WrapWithOverflow: + case TextWrapping.Wrap: + { + textLine = PerformTextWrapping(textRuns, textRange, paragraphWidth, paragraphProperties); + break; + } + } + } + + return textLine; + } + + /// + /// Fetches text runs. + /// + /// The text source. + /// The first text source index. + /// Previous line break. Can be null. + /// Next line break. Can be null. + /// + /// The formatted text runs. + /// + private static IReadOnlyList FetchTextRuns(ITextSource textSource, + int firstTextSourceIndex, TextLineBreak previousLineBreak, out TextLineBreak nextLineBreak) + { + nextLineBreak = default; + + var currentLength = 0; + + var textRuns = new List(); + + if (previousLineBreak != null) + { + foreach (var shapedCharacters in previousLineBreak.RemainingCharacters) + { + textRuns.Add(shapedCharacters); + + if (TryGetLineBreak(shapedCharacters, out var runLineBreak)) + { + var splitResult = SplitTextRuns(textRuns, currentLength + runLineBreak.PositionWrap); + + nextLineBreak = new TextLineBreak(splitResult.Second); + + return splitResult.First; + } + + currentLength += shapedCharacters.Text.Length; + } + } + + firstTextSourceIndex += currentLength; + + var textRunEnumerator = new TextRunEnumerator(textSource, firstTextSourceIndex); + + while (textRunEnumerator.MoveNext()) + { + var textRun = textRunEnumerator.Current; + + switch (textRun) + { + case TextCharacters textCharacters: + { + var shapeableRuns = textCharacters.GetShapeableCharacters(); + + foreach (var run in shapeableRuns) + { + var glyphRun = TextShaper.Current.ShapeText(run.Text, run.Properties.Typeface, + run.Properties.FontRenderingEmSize, run.Properties.CultureInfo); + + var shapedCharacters = new ShapedTextCharacters(glyphRun, textRun.Properties); + + textRuns.Add(shapedCharacters); + } + + break; + } + } + + if (TryGetLineBreak(textRun, out var runLineBreak)) + { + var splitResult = SplitTextRuns(textRuns, currentLength + runLineBreak.PositionWrap); + + nextLineBreak = new TextLineBreak(splitResult.Second); + + return splitResult.First; + } + + currentLength += textRun.Text.Length; + } + + return textRuns; + } + + private static bool TryGetLineBreak(TextRun textRun, out LineBreak lineBreak) + { + lineBreak = default; + + if (textRun.Text.IsEmpty) + { + return false; + } + + var lineBreakEnumerator = new LineBreakEnumerator(textRun.Text); + + while (lineBreakEnumerator.MoveNext()) + { + if (!lineBreakEnumerator.Current.Required) + { + continue; + } + + lineBreak = lineBreakEnumerator.Current; + + if (lineBreak.PositionWrap >= textRun.Text.Length) + { + return true; + } + + //The line breaker isn't treating \n\r as a pair so we have to fix that here. + if (textRun.Text[lineBreak.PositionMeasure] == '\n' + && textRun.Text[lineBreak.PositionWrap] == '\r') + { + lineBreak = new LineBreak(lineBreak.PositionMeasure, lineBreak.PositionWrap + 1, + lineBreak.Required); + } + + return true; + } + + return false; + } + + /// + /// Performs text trimming and returns a trimmed line. + /// + /// The text runs to perform the trimming on. + /// The text range that is covered by the text runs. + /// A value that specifies the width of the paragraph that the line fills. + /// A value that represents paragraph properties, + /// such as TextWrapping, TextAlignment, or TextStyle. + /// + private static TextLine PerformTextTrimming(IReadOnlyList textRuns, TextRange textRange, + double paragraphWidth, TextParagraphProperties paragraphProperties) + { + var textTrimming = paragraphProperties.TextTrimming; + var availableWidth = paragraphWidth; + var currentWidth = 0.0; + var runIndex = 0; + + while (runIndex < textRuns.Count) + { + var currentRun = textRuns[runIndex]; + + currentWidth += currentRun.GlyphRun.Bounds.Width; + + if (currentWidth > availableWidth) + { + var ellipsisRun = CreateEllipsisRun(currentRun.Properties); + + var measuredLength = MeasureText(currentRun, availableWidth - ellipsisRun.GlyphRun.Bounds.Width); + + if (textTrimming == TextTrimming.WordEllipsis) + { + if (measuredLength < textRange.End) + { + var currentBreakPosition = 0; + + var lineBreaker = new LineBreakEnumerator(currentRun.Text); + + while (currentBreakPosition < measuredLength && lineBreaker.MoveNext()) + { + var nextBreakPosition = lineBreaker.Current.PositionWrap; + + if (nextBreakPosition == 0) + { + break; + } + + if (nextBreakPosition > measuredLength) + { + break; + } + + currentBreakPosition = nextBreakPosition; + } + + measuredLength = currentBreakPosition; + } + } + + var splitResult = SplitTextRuns(textRuns, measuredLength); + + var trimmedRuns = new List(splitResult.First.Count + 1); + + trimmedRuns.AddRange(splitResult.First); + + trimmedRuns.Add(ellipsisRun); + + var textLineMetrics = + TextLineMetrics.Create(trimmedRuns, textRange, paragraphWidth, paragraphProperties); + + return new TextLineImpl(trimmedRuns, textLineMetrics); + } + + availableWidth -= currentRun.GlyphRun.Bounds.Width; + + runIndex++; + } + + return new TextLineImpl(textRuns, + TextLineMetrics.Create(textRuns, textRange, paragraphWidth, paragraphProperties)); + } + + /// + /// Performs text wrapping returns a list of text lines. + /// + /// The text run's. + /// The text range that is covered by the text runs. + /// The paragraph width. + /// The text paragraph properties. + /// The wrapped text line. + private static TextLine PerformTextWrapping(IReadOnlyList textRuns, TextRange textRange, + double paragraphWidth, TextParagraphProperties paragraphProperties) + { + var availableWidth = paragraphWidth; + var currentWidth = 0.0; + var runIndex = 0; + var length = 0; + + while (runIndex < textRuns.Count) + { + var currentRun = textRuns[runIndex]; + + if (currentWidth + currentRun.GlyphRun.Bounds.Width > availableWidth) + { + var measuredLength = MeasureText(currentRun, paragraphWidth - currentWidth); + + if (measuredLength < currentRun.Text.Length) + { + if (paragraphProperties.TextWrapping == TextWrapping.WrapWithOverflow) + { + var lineBreaker = new LineBreakEnumerator(currentRun.Text.Skip(measuredLength)); + + if (lineBreaker.MoveNext()) + { + measuredLength += lineBreaker.Current.PositionWrap; + } + else + { + measuredLength = currentRun.Text.Length; + } + } + else + { + var currentBreakPosition = -1; + + var lineBreaker = new LineBreakEnumerator(currentRun.Text); + + while (currentBreakPosition < measuredLength && lineBreaker.MoveNext()) + { + var nextBreakPosition = lineBreaker.Current.PositionWrap; + + if (nextBreakPosition == 0) + { + break; + } + + if (nextBreakPosition > measuredLength) + { + break; + } + + currentBreakPosition = nextBreakPosition; + } + + if (currentBreakPosition != -1) + { + measuredLength = currentBreakPosition; + } + + } + } + + length += measuredLength; + + var splitResult = SplitTextRuns(textRuns, length); + + var textLineMetrics = TextLineMetrics.Create(splitResult.First, + new TextRange(textRange.Start, length), paragraphWidth, paragraphProperties); + + var lineBreak = splitResult.Second != null && splitResult.Second.Count > 0 ? + new TextLineBreak(splitResult.Second) : + null; + + return new TextLineImpl(splitResult.First, textLineMetrics, lineBreak); + } + + currentWidth += currentRun.GlyphRun.Bounds.Width; + + length += currentRun.GlyphRun.Characters.Length; + + runIndex++; + } + + return new TextLineImpl(textRuns, + TextLineMetrics.Create(textRuns, textRange, paragraphWidth, paragraphProperties)); + } + + /// + /// Measures the number of characters that fits into available width. + /// + /// The text run. + /// The available width. + /// + private static int MeasureText(ShapedTextCharacters textCharacters, double availableWidth) + { + var glyphRun = textCharacters.GlyphRun; + + var characterHit = glyphRun.GetCharacterHitFromDistance(availableWidth, out _); + + return characterHit.FirstCharacterIndex + characterHit.TrailingLength - textCharacters.Text.Start; + } + + /// + /// Creates an ellipsis. + /// + /// The text run properties. + /// + private static ShapedTextCharacters CreateEllipsisRun(TextRunProperties properties) + { + var formatterImpl = AvaloniaLocator.Current.GetService(); + + var glyphRun = formatterImpl.ShapeText(s_ellipsis, properties.Typeface, properties.FontRenderingEmSize, + properties.CultureInfo); + + return new ShapedTextCharacters(glyphRun, properties); + } + + /// + /// Gets the text range that is covered by the text runs. + /// + /// The text runs. + /// The text range that is covered by the text runs. + private static TextRange GetTextRange(IReadOnlyList textRuns) + { + if (textRuns is null || textRuns.Count == 0) + { + return new TextRange(); + } + + var firstTextRun = textRuns[0]; + + if (textRuns.Count == 1) + { + return new TextRange(firstTextRun.Text.Start, firstTextRun.Text.Length); + } + + var start = firstTextRun.Text.Start; + + var end = textRuns[textRuns.Count - 1].Text.End + 1; + + return new TextRange(start, end - start); + } + + /// + /// Split a sequence of runs into two segments at specified length. + /// + /// The text run's. + /// The length to split at. + /// The split text runs. + private static SplitTextRunsResult SplitTextRuns(IReadOnlyList textRuns, int length) + { + var currentLength = 0; + + for (var i = 0; i < textRuns.Count; i++) + { + var currentRun = textRuns[i]; + + if (currentLength + currentRun.GlyphRun.Characters.Length < length) + { + currentLength += currentRun.GlyphRun.Characters.Length; + continue; + } + + var firstCount = currentRun.GlyphRun.Characters.Length >= 1 ? i + 1 : i; + + var first = new ShapedTextCharacters[firstCount]; + + if (firstCount > 1) + { + for (var j = 0; j < i; j++) + { + first[j] = textRuns[j]; + } + } + + var secondCount = textRuns.Count - firstCount; + + if (currentLength + currentRun.GlyphRun.Characters.Length == length) + { + var second = new ShapedTextCharacters[secondCount]; + + var offset = currentRun.GlyphRun.Characters.Length > 1 ? 1 : 0; + + if (secondCount > 0) + { + for (var j = 0; j < secondCount; j++) + { + second[j] = textRuns[i + j + offset]; + } + } + + first[i] = currentRun; + + return new SplitTextRunsResult(first, second); + } + else + { + secondCount++; + + var second = new ShapedTextCharacters[secondCount]; + + if (secondCount > 0) + { + for (var j = 1; j < secondCount; j++) + { + second[j] = textRuns[i + j]; + } + } + + var split = currentRun.Split(length - currentLength); + + first[i] = split.First; + + second[0] = split.Second; + + return new SplitTextRunsResult(first, second); + } + } + + return new SplitTextRunsResult(textRuns, null); + } + + private readonly struct SplitTextRunsResult + { + public SplitTextRunsResult(IReadOnlyList first, IReadOnlyList second) + { + First = first; + + Second = second; + } + + /// + /// Gets the first text runs. + /// + /// + /// The first text runs. + /// + public IReadOnlyList First { get; } + + /// + /// Gets the second text runs. + /// + /// + /// The second text runs. + /// + public IReadOnlyList Second { get; } + } + + private struct TextRunEnumerator + { + private readonly ITextSource _textSource; + private int _pos; + + public TextRunEnumerator(ITextSource textSource, int firstTextSourceIndex) + { + _textSource = textSource; + _pos = firstTextSourceIndex; + Current = null; + } + + // ReSharper disable once MemberHidesStaticFromOuterClass + public TextRun Current { get; private set; } + + public bool MoveNext() + { + Current = _textSource.GetTextRun(_pos); + + if (Current is null) + { + return false; + } + + if (Current.TextSourceLength == 0) + { + return false; + } + + _pos += Current.TextSourceLength; + + return !(Current is TextEndOfLine); + } + } + } +} diff --git a/src/Avalonia.Visuals/Media/TextFormatting/TextLayout.cs b/src/Avalonia.Visuals/Media/TextFormatting/TextLayout.cs index 0292398782..2e2e4a8c68 100644 --- a/src/Avalonia.Visuals/Media/TextFormatting/TextLayout.cs +++ b/src/Avalonia.Visuals/Media/TextFormatting/TextLayout.cs @@ -1,11 +1,9 @@ using System; using System.Collections.Generic; using System.Linq; -using Avalonia.Media.Immutable; using Avalonia.Media.TextFormatting.Unicode; -using Avalonia.Platform; using Avalonia.Utilities; -using Avalonia.Utility; +using Avalonia.Platform; namespace Avalonia.Media.TextFormatting { @@ -14,11 +12,11 @@ namespace Avalonia.Media.TextFormatting /// public class TextLayout { - private static readonly ReadOnlySlice s_empty = new ReadOnlySlice(new[] { '\u200B' }); + private static readonly char[] s_empty = { '\u200B' }; private readonly ReadOnlySlice _text; private readonly TextParagraphProperties _paragraphProperties; - private readonly IReadOnlyList _textStyleOverrides; + private readonly IReadOnlyList> _textStyleOverrides; /// /// Initializes a new instance of the class. @@ -33,6 +31,7 @@ namespace Avalonia.Media.TextFormatting /// The text decorations. /// The maximum width. /// The maximum height. + /// The height of each line of text. /// The maximum number of text lines. /// The text style overrides. public TextLayout( @@ -46,18 +45,22 @@ namespace Avalonia.Media.TextFormatting TextDecorationCollection textDecorations = null, double maxWidth = double.PositiveInfinity, double maxHeight = double.PositiveInfinity, + double lineHeight = double.NaN, int maxLines = 0, - IReadOnlyList textStyleOverrides = null) + IReadOnlyList> textStyleOverrides = null) { _text = string.IsNullOrEmpty(text) ? new ReadOnlySlice() : new ReadOnlySlice(text.AsMemory()); _paragraphProperties = - CreateTextParagraphProperties(typeface, fontSize, foreground, textAlignment, textWrapping, textTrimming, textDecorations?.ToImmutable()); + CreateTextParagraphProperties(typeface, fontSize, foreground, textAlignment, textWrapping, textTrimming, + textDecorations, lineHeight); _textStyleOverrides = textStyleOverrides; + LineHeight = lineHeight; + MaxWidth = maxWidth; MaxHeight = maxHeight; @@ -67,22 +70,29 @@ namespace Avalonia.Media.TextFormatting UpdateLayout(); } + /// + /// Gets or sets the height of each line of text. + /// + /// + /// A value of NaN (equivalent to an attribute value of "Auto") indicates that the line height + /// is determined automatically from the current font characteristics. The default is NaN. + /// + public double LineHeight { get; } + /// /// Gets the maximum width. /// public double MaxWidth { get; } - /// /// Gets the maximum height. /// public double MaxHeight { get; } - /// /// Gets the maximum number of text lines. /// - public double MaxLines { get; } + public int MaxLines { get; } /// /// Gets the text lines. @@ -105,7 +115,7 @@ namespace Avalonia.Media.TextFormatting /// /// The drawing context. /// The origin. - public void Draw(IDrawingContextImpl context, Point origin) + public void Draw(DrawingContext context, Point origin) { if (!TextLines.Any()) { @@ -132,14 +142,16 @@ namespace Avalonia.Media.TextFormatting /// The text wrapping. /// The text trimming. /// The text decorations. + /// The height of each line of text. /// private static TextParagraphProperties CreateTextParagraphProperties(Typeface typeface, double fontSize, IBrush foreground, TextAlignment textAlignment, TextWrapping textWrapping, TextTrimming textTrimming, - ImmutableTextDecoration[] textDecorations) + TextDecorationCollection textDecorations, double lineHeight) { - var textRunStyle = new TextStyle(typeface, fontSize, foreground, textDecorations); + var textRunStyle = new GenericTextRunProperties(typeface, fontSize, textDecorations, foreground); - return new TextParagraphProperties(textRunStyle, textAlignment, textWrapping, textTrimming); + return new GenericTextParagraphProperties(textRunStyle, textAlignment, textWrapping, textTrimming, + lineHeight); } /// @@ -170,14 +182,15 @@ namespace Avalonia.Media.TextFormatting /// The empty text line. private TextLine CreateEmptyTextLine(int startingIndex) { - var textFormat = _paragraphProperties.DefaultTextStyle.TextFormat; + var properties = _paragraphProperties.DefaultTextRunProperties; - var glyphRun = TextShaper.Current.ShapeText(s_empty, textFormat); + var glyphRun = TextShaper.Current.ShapeText(new ReadOnlySlice(s_empty, startingIndex, 1), + properties.Typeface, properties.FontRenderingEmSize, properties.CultureInfo); - var textRuns = new[] { new ShapedTextRun(glyphRun, _paragraphProperties.DefaultTextStyle) }; + var textRuns = new[] { new ShapedTextCharacters(glyphRun, _paragraphProperties.DefaultTextRunProperties) }; - return new SimpleTextLine(new TextPointer(startingIndex, 0), textRuns, - TextLineMetrics.Create(textRuns, MaxWidth, _paragraphProperties.TextAlignment)); + return new TextLineImpl(textRuns, + TextLineMetrics.Create(textRuns, new TextRange(startingIndex, 1), MaxWidth, _paragraphProperties)); } /// @@ -199,77 +212,38 @@ namespace Avalonia.Media.TextFormatting double left = 0.0, right = 0.0, bottom = 0.0; - var lineBreaker = new LineBreakEnumerator(_text); - var currentPosition = 0; + var textSource = new FormattedTextSource(_text, + _paragraphProperties.DefaultTextRunProperties, _textStyleOverrides); + + TextLineBreak previousLineBreak = null; + while (currentPosition < _text.Length && (MaxLines == 0 || textLines.Count < MaxLines)) { - int length; + var textLine = TextFormatter.Current.FormatLine(textSource, currentPosition, MaxWidth, + _paragraphProperties, previousLineBreak); - if (lineBreaker.MoveNext()) - { - if (!lineBreaker.Current.Required) - { - continue; - } + previousLineBreak = textLine.LineBreak; - length = lineBreaker.Current.PositionWrap - currentPosition; + textLines.Add(textLine); - if (currentPosition + length < _text.Length) - { - //The line breaker isn't treating \n\r as a pair so we have to fix that here. - if (_text[lineBreaker.Current.PositionMeasure] == '\n' - && _text[lineBreaker.Current.PositionWrap] == '\r') - { - length++; - } - } - } - else + UpdateBounds(textLine, ref left, ref right, ref bottom); + + if (!double.IsPositiveInfinity(MaxHeight) && bottom > MaxHeight) { - length = _text.Length - currentPosition; + break; } - var remainingLength = length; + currentPosition += textLine.TextRange.Length; - while (remainingLength > 0 && (MaxLines == 0 || textLines.Count < MaxLines)) + if (currentPosition != _text.Length || textLine.LineBreak == null) { - var textSlice = _text.AsSlice(currentPosition, remainingLength); - - var textSource = new FormattedTextSource(textSlice, _paragraphProperties.DefaultTextStyle, _textStyleOverrides); - - var textLine = TextFormatter.Current.FormatLine(textSource, 0, MaxWidth, _paragraphProperties); - - UpdateBounds(textLine, ref left, ref right, ref bottom); - - textLines.Add(textLine); - - if (!double.IsPositiveInfinity(MaxHeight) && bottom + textLine.LineMetrics.Size.Height > MaxHeight) - { - currentPosition = _text.Length; - break; - } - - if (_paragraphProperties.TextTrimming != TextTrimming.None) - { - currentPosition += remainingLength; - - break; - } - - remainingLength -= textLine.Text.Length; - - currentPosition += textLine.Text.Length; + continue; } - } - if (lineBreaker.Current.Required && currentPosition == _text.Length) - { var emptyTextLine = CreateEmptyTextLine(currentPosition); - UpdateBounds(emptyTextLine, ref left, ref right, ref bottom); - textLines.Add(emptyTextLine); } @@ -279,22 +253,27 @@ namespace Avalonia.Media.TextFormatting } } - private struct FormattedTextSource : ITextSource + private readonly struct FormattedTextSource : ITextSource { private readonly ReadOnlySlice _text; - private readonly TextStyle _defaultStyle; - private readonly IReadOnlyList _textStyleOverrides; + private readonly TextRunProperties _defaultProperties; + private readonly IReadOnlyList> _textModifier; - public FormattedTextSource(ReadOnlySlice text, TextStyle defaultStyle, - IReadOnlyList textStyleOverrides) + public FormattedTextSource(ReadOnlySlice text, TextRunProperties defaultProperties, + IReadOnlyList> textModifier) { _text = text; - _defaultStyle = defaultStyle; - _textStyleOverrides = textStyleOverrides; + _defaultProperties = defaultProperties; + _textModifier = textModifier; } public TextRun GetTextRun(int textSourceIndex) { + if (textSourceIndex > _text.End) + { + return new TextEndOfLine(); + } + var runText = _text.Skip(textSourceIndex); if (runText.IsEmpty) @@ -302,30 +281,29 @@ namespace Avalonia.Media.TextFormatting return new TextEndOfLine(); } - var textStyleRun = CreateTextStyleRunWithOverride(runText, _defaultStyle, _textStyleOverrides); + var textStyleRun = CreateTextStyleRun(runText, _defaultProperties, _textModifier); - return new TextCharacters(runText.Take(textStyleRun.TextPointer.Length), textStyleRun.Style); + return new TextCharacters(runText.Take(textStyleRun.Length), textStyleRun.Value); } /// - /// Creates a text style run that has overrides applied. Only overrides with equal TextStyle. - /// If optimizeForShaping is true Foreground is ignored. + /// Creates a span of text run properties that has modifier applied. /// - /// The text to create the run for. - /// The default text style for segments that don't have an override. - /// The text style overrides. + /// The text to create the properties for. + /// The default text properties. + /// The text properties modifier. /// /// The created text style run. /// - private static TextStyleRun CreateTextStyleRunWithOverride(ReadOnlySlice text, - TextStyle defaultTextStyle, IReadOnlyList textStyleOverrides) + private static ValueSpan CreateTextStyleRun(ReadOnlySlice text, + TextRunProperties defaultProperties, IReadOnlyList> textModifier) { - if(textStyleOverrides == null || textStyleOverrides.Count == 0) + if (textModifier == null || textModifier.Count == 0) { - return new TextStyleRun(new TextPointer(text.Start, text.Length), defaultTextStyle); + return new ValueSpan(text.Start, text.Length, defaultProperties); } - var currentTextStyle = defaultTextStyle; + var currentProperties = defaultProperties; var hasOverride = false; @@ -333,35 +311,34 @@ namespace Avalonia.Media.TextFormatting var length = 0; - for (; i < textStyleOverrides.Count; i++) + for (; i < textModifier.Count; i++) { - var styleOverride = textStyleOverrides[i]; + var propertiesOverride = textModifier[i]; - var textPointer = styleOverride.TextPointer; + var textRange = new TextRange(propertiesOverride.Start, propertiesOverride.Length); - if (textPointer.End < text.Start) + if (textRange.End < text.Start) { continue; } - if (textPointer.Start > text.End) + if (textRange.Start > text.End) { length = text.Length; break; } - if (textPointer.Start > text.Start) + if (textRange.Start > text.Start) { - if (styleOverride.Style.TextFormat != currentTextStyle.TextFormat || - !currentTextStyle.Foreground.Equals(styleOverride.Style.Foreground)) + if (propertiesOverride.Value != currentProperties) { - length = Math.Min(Math.Abs(textPointer.Start - text.Start), text.Length); + length = Math.Min(Math.Abs(textRange.Start - text.Start), text.Length); break; } } - length += Math.Min(text.Length - length, textPointer.Length); + length += Math.Min(text.Length - length, textRange.Length); if (hasOverride) { @@ -370,13 +347,12 @@ namespace Avalonia.Media.TextFormatting hasOverride = true; - currentTextStyle = styleOverride.Style; + currentProperties = propertiesOverride.Value; } - if (length < text.Length && i == textStyleOverrides.Count) + if (length < text.Length && i == textModifier.Count) { - if (currentTextStyle.Foreground.Equals(defaultTextStyle.Foreground) && - currentTextStyle.TextFormat == defaultTextStyle.TextFormat) + if (currentProperties == defaultProperties) { length = text.Length; } @@ -387,7 +363,7 @@ namespace Avalonia.Media.TextFormatting text = text.Take(length); } - return new TextStyleRun(new TextPointer(text.Start, length), currentTextStyle); + return new ValueSpan(text.Start, length, currentProperties); } } } diff --git a/src/Avalonia.Visuals/Media/TextFormatting/TextLine.cs b/src/Avalonia.Visuals/Media/TextFormatting/TextLine.cs index a0f7b44882..c3b7dfc77a 100644 --- a/src/Avalonia.Visuals/Media/TextFormatting/TextLine.cs +++ b/src/Avalonia.Visuals/Media/TextFormatting/TextLine.cs @@ -1,5 +1,4 @@ using System.Collections.Generic; -using Avalonia.Platform; namespace Avalonia.Media.TextFormatting { @@ -9,12 +8,12 @@ namespace Avalonia.Media.TextFormatting public abstract class TextLine { /// - /// Gets the text. + /// Gets the text range that is covered by the line. /// /// - /// The text pointer. + /// The text range that is covered by the line. /// - public abstract TextPointer Text { get; } + public abstract TextRange TextRange { get; } /// /// Gets the text runs. @@ -32,12 +31,20 @@ namespace Avalonia.Media.TextFormatting /// public abstract TextLineMetrics LineMetrics { get; } + /// + /// Gets the state of the line when broken by line breaking process. + /// + /// + /// A value that represents the line break. + /// + public abstract TextLineBreak LineBreak { get; } + /// /// Draws the at the given origin. /// /// The drawing context. /// The origin. - public abstract void Draw(IDrawingContextImpl drawingContext, Point origin); + public abstract void Draw(DrawingContext drawingContext, Point origin); /// /// Client to get the character hit corresponding to the specified diff --git a/src/Avalonia.Visuals/Media/TextFormatting/TextLineBreak.cs b/src/Avalonia.Visuals/Media/TextFormatting/TextLineBreak.cs new file mode 100644 index 0000000000..c24454cb76 --- /dev/null +++ b/src/Avalonia.Visuals/Media/TextFormatting/TextLineBreak.cs @@ -0,0 +1,17 @@ +using System.Collections.Generic; + +namespace Avalonia.Media.TextFormatting +{ + public class TextLineBreak + { + public TextLineBreak(IReadOnlyList remainingCharacters) + { + RemainingCharacters = remainingCharacters; + } + + /// + /// Get the remaining shaped characters that were split up by the during the formatting process. + /// + public IReadOnlyList RemainingCharacters { get; } + } +} diff --git a/src/Avalonia.Visuals/Media/TextFormatting/TextLineImpl.cs b/src/Avalonia.Visuals/Media/TextFormatting/TextLineImpl.cs new file mode 100644 index 0000000000..cf00399b8a --- /dev/null +++ b/src/Avalonia.Visuals/Media/TextFormatting/TextLineImpl.cs @@ -0,0 +1,235 @@ +using System.Collections.Generic; + +namespace Avalonia.Media.TextFormatting +{ + internal class TextLineImpl : TextLine + { + private readonly IReadOnlyList _textRuns; + + public TextLineImpl(IReadOnlyList textRuns, TextLineMetrics lineMetrics, + TextLineBreak lineBreak = null) + { + _textRuns = textRuns; + LineMetrics = lineMetrics; + LineBreak = lineBreak; + } + + /// + public override TextRange TextRange => LineMetrics.TextRange; + + /// + public override IReadOnlyList TextRuns => _textRuns; + + /// + public override TextLineMetrics LineMetrics { get; } + + /// + public override TextLineBreak LineBreak { get; } + + /// + public override void Draw(DrawingContext drawingContext, Point origin) + { + var currentX = origin.X; + + foreach (var textRun in _textRuns) + { + var baselineOrigin = new Point(currentX + LineMetrics.BaselineOrigin.X, + origin.Y + LineMetrics.BaselineOrigin.Y); + + textRun.Draw(drawingContext, baselineOrigin); + + currentX += textRun.Bounds.Width; + } + } + + /// + public override CharacterHit GetCharacterHitFromDistance(double distance) + { + if (distance < 0) + { + // hit happens before the line, return the first position + return new CharacterHit(TextRange.Start); + } + + // process hit that happens within the line + var characterHit = new CharacterHit(); + + foreach (var run in _textRuns) + { + characterHit = run.GlyphRun.GetCharacterHitFromDistance(distance, out _); + + if (distance <= run.Bounds.Width) + { + break; + } + + distance -= run.Bounds.Width; + } + + return characterHit; + } + + /// + public override double GetDistanceFromCharacterHit(CharacterHit characterHit) + { + return DistanceFromCodepointIndex(characterHit.FirstCharacterIndex + (characterHit.TrailingLength != 0 ? 1 : 0)); + } + + /// + public override CharacterHit GetNextCaretCharacterHit(CharacterHit characterHit) + { + if (TryFindNextCharacterHit(characterHit, out var nextCharacterHit)) + { + return nextCharacterHit; + } + + return new CharacterHit(TextRange.End); // Can't move, we're after the last character + } + + /// + public override CharacterHit GetPreviousCaretCharacterHit(CharacterHit characterHit) + { + if (TryFindPreviousCharacterHit(characterHit, out var previousCharacterHit)) + { + return previousCharacterHit; + } + + return new CharacterHit(TextRange.Start); // Can't move, we're before the first character + } + + /// + public override CharacterHit GetBackspaceCaretCharacterHit(CharacterHit characterHit) + { + // same operation as move-to-previous + return GetPreviousCaretCharacterHit(characterHit); + } + + /// + /// Get distance from line start to the specified codepoint index. + /// + private double DistanceFromCodepointIndex(int codepointIndex) + { + var currentDistance = 0.0; + + foreach (var textRun in _textRuns) + { + if (codepointIndex > textRun.Text.End) + { + currentDistance += textRun.Bounds.Width; + + continue; + } + + return currentDistance + textRun.GlyphRun.GetDistanceFromCharacterHit(new CharacterHit(codepointIndex)); + } + + return currentDistance; + } + + /// + /// Tries to find the next character hit. + /// + /// The current character hit. + /// The next character hit. + /// + private bool TryFindNextCharacterHit(CharacterHit characterHit, out CharacterHit nextCharacterHit) + { + nextCharacterHit = characterHit; + + var codepointIndex = characterHit.FirstCharacterIndex + characterHit.TrailingLength; + + if (codepointIndex >= TextRange.Start + TextRange.Length) + { + return false; // Cannot go forward anymore + } + + var runIndex = GetRunIndexAtCodepointIndex(codepointIndex); + + while (runIndex < TextRuns.Count) + { + var run = _textRuns[runIndex]; + + nextCharacterHit = run.GlyphRun.FindNearestCharacterHit(characterHit.FirstCharacterIndex + characterHit.TrailingLength, out _); + + if (codepointIndex <= nextCharacterHit.FirstCharacterIndex + nextCharacterHit.TrailingLength) + { + return true; + } + + runIndex++; + } + + return false; + } + + /// + /// Tries to find the previous character hit. + /// + /// The current character hit. + /// The previous character hit. + /// + private bool TryFindPreviousCharacterHit(CharacterHit characterHit, out CharacterHit previousCharacterHit) + { + previousCharacterHit = characterHit; + + var codepointIndex = characterHit.FirstCharacterIndex + characterHit.TrailingLength; + + if (codepointIndex < TextRange.Start) + { + return false; // Cannot go backward anymore. + } + + var runIndex = GetRunIndexAtCodepointIndex(codepointIndex); + + while (runIndex >= 0) + { + var run = _textRuns[runIndex]; + + previousCharacterHit = run.GlyphRun.FindNearestCharacterHit(characterHit.FirstCharacterIndex - 1, out _); + + if (previousCharacterHit.FirstCharacterIndex < codepointIndex) + { + return true; + } + + runIndex--; + } + + return false; + } + + /// + /// Gets the run index of the specified codepoint index. + /// + /// The codepoint index. + /// The text run index. + private int GetRunIndexAtCodepointIndex(int codepointIndex) + { + if (codepointIndex >= TextRange.End) + { + return _textRuns.Count - 1; + } + + if (codepointIndex <= 0) + { + return 0; + } + + var runIndex = 0; + + while (runIndex < _textRuns.Count) + { + var run = _textRuns[runIndex]; + + if (run.Text.End > codepointIndex) + { + return runIndex; + } + + runIndex++; + } + + return runIndex; + } + } +} diff --git a/src/Avalonia.Visuals/Media/TextFormatting/TextLineMetrics.cs b/src/Avalonia.Visuals/Media/TextFormatting/TextLineMetrics.cs index 096305c09c..d47cc0c394 100644 --- a/src/Avalonia.Visuals/Media/TextFormatting/TextLineMetrics.cs +++ b/src/Avalonia.Visuals/Media/TextFormatting/TextLineMetrics.cs @@ -1,4 +1,5 @@ using System.Collections.Generic; +using Avalonia.Utilities; namespace Avalonia.Media.TextFormatting { @@ -8,38 +9,20 @@ namespace Avalonia.Media.TextFormatting /// public readonly struct TextLineMetrics { - public TextLineMetrics(double width, double xOrigin, double ascent, double descent, double lineGap) + public TextLineMetrics(Size size, Point baselineOrigin, TextRange textRange) { - Ascent = ascent; - Descent = descent; - LineGap = lineGap; - Size = new Size(width, descent - ascent + lineGap); - BaselineOrigin = new Point(xOrigin, -ascent); + Size = size; + BaselineOrigin = baselineOrigin; + TextRange = textRange; } /// - /// Gets the overall recommended distance above the baseline. + /// Gets the text range that is covered by the text line. /// /// - /// The ascent. + /// The text range that is covered by the text line. /// - public double Ascent { get; } - - /// - /// Gets the overall recommended distance under the baseline. - /// - /// - /// The descent. - /// - public double Descent { get; } - - /// - /// Gets the overall recommended additional space between two lines of text. - /// - /// - /// The leading. - /// - public double LineGap { get; } + public TextRange TextRange { get; } /// /// Gets the size of the text line. @@ -61,10 +44,12 @@ namespace Avalonia.Media.TextFormatting /// Creates the text line metrics. /// /// The text runs. + /// The text range that is covered by the text line. /// The paragraph width. - /// The text alignment. + /// The text alignment. /// - public static TextLineMetrics Create(IEnumerable textRuns, double paragraphWidth, TextAlignment textAlignment) + public static TextLineMetrics Create(IEnumerable textRuns, TextRange textRange, double paragraphWidth, + TextParagraphProperties paragraphProperties) { var lineWidth = 0.0; var ascent = 0.0; @@ -73,31 +58,39 @@ namespace Avalonia.Media.TextFormatting foreach (var textRun in textRuns) { - var shapedRun = (ShapedTextRun)textRun; + var shapedRun = (ShapedTextCharacters)textRun; - lineWidth += shapedRun.Bounds.Width; + var fontMetrics = + new FontMetrics(shapedRun.Properties.Typeface, shapedRun.Properties.FontRenderingEmSize); - var textFormat = textRun.Style.TextFormat; + lineWidth += shapedRun.Bounds.Width; - if (ascent > textRun.Style.TextFormat.FontMetrics.Ascent) + if (ascent > fontMetrics.Ascent) { - ascent = textFormat.FontMetrics.Ascent; + ascent = fontMetrics.Ascent; } - if (descent < textFormat.FontMetrics.Descent) + if (descent < fontMetrics.Descent) { - descent = textFormat.FontMetrics.Descent; + descent = fontMetrics.Descent; } - if (lineGap < textFormat.FontMetrics.LineGap) + if (lineGap < fontMetrics.LineGap) { - lineGap = textFormat.FontMetrics.LineGap; + lineGap = fontMetrics.LineGap; } } - var xOrigin = TextLine.GetParagraphOffsetX(lineWidth, paragraphWidth, textAlignment); + var xOrigin = TextLine.GetParagraphOffsetX(lineWidth, paragraphWidth, paragraphProperties.TextAlignment); + + var baselineOrigin = new Point(xOrigin, -ascent); + + var size = new Size(lineWidth, + double.IsNaN(paragraphProperties.LineHeight) || MathUtilities.IsZero(paragraphProperties.LineHeight) ? + descent - ascent + lineGap : + paragraphProperties.LineHeight); - return new TextLineMetrics(lineWidth, xOrigin, ascent, descent, lineGap); + return new TextLineMetrics(size, baselineOrigin, textRange); } } } diff --git a/src/Avalonia.Visuals/Media/TextFormatting/TextParagraphProperties.cs b/src/Avalonia.Visuals/Media/TextFormatting/TextParagraphProperties.cs index 1368f1777a..39eb695404 100644 --- a/src/Avalonia.Visuals/Media/TextFormatting/TextParagraphProperties.cs +++ b/src/Avalonia.Visuals/Media/TextFormatting/TextParagraphProperties.cs @@ -3,38 +3,37 @@ /// /// Provides a set of properties that are used during the paragraph layout. /// - public readonly struct TextParagraphProperties + public abstract class TextParagraphProperties { - public TextParagraphProperties( - TextStyle defaultTextStyle, - TextAlignment textAlignment = TextAlignment.Left, - TextWrapping textWrapping = TextWrapping.NoWrap, - TextTrimming textTrimming = TextTrimming.None) - { - DefaultTextStyle = defaultTextStyle; - TextAlignment = textAlignment; - TextWrapping = textWrapping; - TextTrimming = textTrimming; - } + /// + /// Gets the text alignment. + /// + public abstract TextAlignment TextAlignment { get; } /// /// Gets the default text style. /// - public TextStyle DefaultTextStyle { get; } + public abstract TextRunProperties DefaultTextRunProperties { get; } /// - /// Gets the text alignment. + /// If not null, text decorations to apply to all runs in the line. This is in addition + /// to any text decorations specified by the TextRunProperties for individual text runs. /// - public TextAlignment TextAlignment { get; } + public virtual TextDecorationCollection TextDecorations => null; /// /// Gets the text wrapping. /// - public TextWrapping TextWrapping { get; } + public abstract TextWrapping TextWrapping { get; } /// /// Gets the text trimming. /// - public TextTrimming TextTrimming { get; } + public abstract TextTrimming TextTrimming { get; } + + /// + /// Paragraph's line height + /// + public abstract double LineHeight { get; } } } diff --git a/src/Avalonia.Visuals/Media/TextFormatting/TextPointer.cs b/src/Avalonia.Visuals/Media/TextFormatting/TextRange.cs similarity index 73% rename from src/Avalonia.Visuals/Media/TextFormatting/TextPointer.cs rename to src/Avalonia.Visuals/Media/TextFormatting/TextRange.cs index 65d5c04b4c..1177c758f4 100644 --- a/src/Avalonia.Visuals/Media/TextFormatting/TextPointer.cs +++ b/src/Avalonia.Visuals/Media/TextFormatting/TextRange.cs @@ -5,9 +5,9 @@ namespace Avalonia.Media.TextFormatting /// /// References a portion of a text buffer. /// - public readonly struct TextPointer + public readonly struct TextRange { - public TextPointer(int start, int length) + public TextRange(int start, int length) { Start = start; Length = length; @@ -41,30 +41,30 @@ namespace Avalonia.Media.TextFormatting /// Returns a specified number of contiguous elements from the start of the slice. /// /// The number of elements to return. - /// A that contains the specified number of elements from the start of this slice. - public TextPointer Take(int length) + /// A that contains the specified number of elements from the start of this slice. + public TextRange Take(int length) { if (length > Length) { throw new ArgumentOutOfRangeException(nameof(length)); } - return new TextPointer(Start, length); + return new TextRange(Start, length); } /// /// Bypasses a specified number of elements in the slice and then returns the remaining elements. /// /// The number of elements to skip before returning the remaining elements. - /// A that contains the elements that occur after the specified index in this slice. - public TextPointer Skip(int length) + /// A that contains the elements that occur after the specified index in this slice. + public TextRange Skip(int length) { if (length > Length) { throw new ArgumentOutOfRangeException(nameof(length)); } - return new TextPointer(Start + length, Length - length); + return new TextRange(Start + length, Length - length); } } } diff --git a/src/Avalonia.Visuals/Media/TextFormatting/TextRun.cs b/src/Avalonia.Visuals/Media/TextFormatting/TextRun.cs index 28b83333b9..c15a771755 100644 --- a/src/Avalonia.Visuals/Media/TextFormatting/TextRun.cs +++ b/src/Avalonia.Visuals/Media/TextFormatting/TextRun.cs @@ -1,5 +1,5 @@ using System.Diagnostics; -using Avalonia.Utility; +using Avalonia.Utilities; namespace Avalonia.Media.TextFormatting { @@ -9,15 +9,22 @@ namespace Avalonia.Media.TextFormatting [DebuggerTypeProxy(typeof(TextRunDebuggerProxy))] public abstract class TextRun { + public static readonly int DefaultTextSourceLength = 1; + + /// + /// Gets the text source length. + /// + public virtual int TextSourceLength => DefaultTextSourceLength; + /// /// Gets the text run's text. /// - public ReadOnlySlice Text { get; protected set; } + public virtual ReadOnlySlice Text => default; /// - /// Gets the text run's style. + /// A set of properties shared by every characters in the run /// - public TextStyle Style { get; protected set; } + public virtual TextRunProperties Properties => null; private class TextRunDebuggerProxy { @@ -42,7 +49,7 @@ namespace Avalonia.Media.TextFormatting } } - public TextStyle Style => _textRun.Style; + public TextRunProperties Properties => _textRun.Properties; } } } diff --git a/src/Avalonia.Visuals/Media/TextFormatting/TextRunProperties.cs b/src/Avalonia.Visuals/Media/TextFormatting/TextRunProperties.cs new file mode 100644 index 0000000000..bbcdfe2d8e --- /dev/null +++ b/src/Avalonia.Visuals/Media/TextFormatting/TextRunProperties.cs @@ -0,0 +1,90 @@ +using System; +using System.Globalization; + +namespace Avalonia.Media.TextFormatting +{ + /// + /// Properties that can change from one run to the next, such as typeface or foreground brush. + /// + /// + /// The client provides a concrete implementation of this abstract run properties class. This + /// allows client to implement their run properties the way that fits with their run formatting + /// store. + /// + public abstract class TextRunProperties : IEquatable + { + /// + /// Run typeface + /// + public abstract Typeface Typeface { get; } + + /// + /// Em size of font used to format and display text + /// + public abstract double FontRenderingEmSize { get; } + + /// + /// Run TextDecorations. + /// + public abstract TextDecorationCollection TextDecorations { get; } + + /// + /// Brush used to fill text. + /// + public abstract IBrush ForegroundBrush { get; } + + /// + /// Brush used to paint background of run. + /// + public abstract IBrush BackgroundBrush { get; } + + /// + /// Run text culture. + /// + public abstract CultureInfo CultureInfo { get; } + + public bool Equals(TextRunProperties other) + { + if (ReferenceEquals(null, other)) + return false; + if (ReferenceEquals(this, other)) + return true; + + return Typeface.Equals(other.Typeface) && + FontRenderingEmSize.Equals(other.FontRenderingEmSize) + && Equals(TextDecorations, other.TextDecorations) && + Equals(ForegroundBrush, other.ForegroundBrush) && + Equals(BackgroundBrush, other.BackgroundBrush) && + Equals(CultureInfo, other.CultureInfo); + } + + public override bool Equals(object obj) + { + return ReferenceEquals(this, obj) || obj is TextRunProperties other && Equals(other); + } + + public override int GetHashCode() + { + unchecked + { + var hashCode = (Typeface != null ? Typeface.GetHashCode() : 0); + hashCode = (hashCode * 397) ^ FontRenderingEmSize.GetHashCode(); + hashCode = (hashCode * 397) ^ (TextDecorations != null ? TextDecorations.GetHashCode() : 0); + hashCode = (hashCode * 397) ^ (ForegroundBrush != null ? ForegroundBrush.GetHashCode() : 0); + hashCode = (hashCode * 397) ^ (BackgroundBrush != null ? BackgroundBrush.GetHashCode() : 0); + hashCode = (hashCode * 397) ^ (CultureInfo != null ? CultureInfo.GetHashCode() : 0); + return hashCode; + } + } + + public static bool operator ==(TextRunProperties left, TextRunProperties right) + { + return Equals(left, right); + } + + public static bool operator !=(TextRunProperties left, TextRunProperties right) + { + return !Equals(left, right); + } + } +} diff --git a/src/Avalonia.Visuals/Media/TextFormatting/TextShaper.cs b/src/Avalonia.Visuals/Media/TextFormatting/TextShaper.cs index eb3a4129bc..a02ace408f 100644 --- a/src/Avalonia.Visuals/Media/TextFormatting/TextShaper.cs +++ b/src/Avalonia.Visuals/Media/TextFormatting/TextShaper.cs @@ -1,6 +1,7 @@ using System; +using System.Globalization; using Avalonia.Platform; -using Avalonia.Utility; +using Avalonia.Utilities; namespace Avalonia.Media.TextFormatting { @@ -44,9 +45,10 @@ namespace Avalonia.Media.TextFormatting } /// - public GlyphRun ShapeText(ReadOnlySlice text, TextFormat textFormat) + public GlyphRun ShapeText(ReadOnlySlice text, Typeface typeface, double fontRenderingEmSize, + CultureInfo culture) { - return _platformImpl.ShapeText(text, textFormat); + return _platformImpl.ShapeText(text, typeface, fontRenderingEmSize, culture); } } } diff --git a/src/Avalonia.Visuals/Media/TextFormatting/TextStyle.cs b/src/Avalonia.Visuals/Media/TextFormatting/TextStyle.cs deleted file mode 100644 index cf52c3ca17..0000000000 --- a/src/Avalonia.Visuals/Media/TextFormatting/TextStyle.cs +++ /dev/null @@ -1,39 +0,0 @@ -using Avalonia.Media.Immutable; - -namespace Avalonia.Media.TextFormatting -{ - /// - /// Unique text formatting properties that effect the styling of a text. - /// - public readonly struct TextStyle - { - public TextStyle(Typeface typeface, double fontRenderingEmSize = 12, IBrush foreground = null, - ImmutableTextDecoration[] textDecorations = null) - : this(new TextFormat(typeface, fontRenderingEmSize), foreground, textDecorations) - { - } - - public TextStyle(TextFormat textFormat, IBrush foreground = null, - ImmutableTextDecoration[] textDecorations = null) - { - TextFormat = textFormat; - Foreground = foreground; - TextDecorations = textDecorations; - } - - /// - /// Gets the text format. - /// - public TextFormat TextFormat { get; } - - /// - /// Gets the foreground. - /// - public IBrush Foreground { get; } - - /// - /// Gets the text decorations. - /// - public ImmutableTextDecoration[] TextDecorations { get; } - } -} diff --git a/src/Avalonia.Visuals/Media/TextFormatting/TextStyleRun.cs b/src/Avalonia.Visuals/Media/TextFormatting/TextStyleRun.cs deleted file mode 100644 index 55f8999182..0000000000 --- a/src/Avalonia.Visuals/Media/TextFormatting/TextStyleRun.cs +++ /dev/null @@ -1,24 +0,0 @@ -namespace Avalonia.Media.TextFormatting -{ - /// - /// Represents a text run's style and is used during the layout process of the . - /// - public readonly struct TextStyleRun - { - public TextStyleRun(TextPointer textPointer, TextStyle style) - { - TextPointer = textPointer; - Style = style; - } - - /// - /// Gets the text pointer. - /// - public TextPointer TextPointer { get; } - - /// - /// Gets the text style. - /// - public TextStyle Style { get; } - } -} diff --git a/src/Avalonia.Visuals/Media/TextFormatting/Unicode/Codepoint.cs b/src/Avalonia.Visuals/Media/TextFormatting/Unicode/Codepoint.cs index 94171b7324..20fe345d93 100644 --- a/src/Avalonia.Visuals/Media/TextFormatting/Unicode/Codepoint.cs +++ b/src/Avalonia.Visuals/Media/TextFormatting/Unicode/Codepoint.cs @@ -1,4 +1,4 @@ -using Avalonia.Utility; +using Avalonia.Utilities; namespace Avalonia.Media.TextFormatting.Unicode { diff --git a/src/Avalonia.Visuals/Media/TextFormatting/Unicode/CodepointEnumerator.cs b/src/Avalonia.Visuals/Media/TextFormatting/Unicode/CodepointEnumerator.cs index 2ff4952cab..9e1f748ebb 100644 --- a/src/Avalonia.Visuals/Media/TextFormatting/Unicode/CodepointEnumerator.cs +++ b/src/Avalonia.Visuals/Media/TextFormatting/Unicode/CodepointEnumerator.cs @@ -1,4 +1,4 @@ -using Avalonia.Utility; +using Avalonia.Utilities; namespace Avalonia.Media.TextFormatting.Unicode { diff --git a/src/Avalonia.Visuals/Media/TextFormatting/Unicode/Grapheme.cs b/src/Avalonia.Visuals/Media/TextFormatting/Unicode/Grapheme.cs index a6791b4a53..f268340eb9 100644 --- a/src/Avalonia.Visuals/Media/TextFormatting/Unicode/Grapheme.cs +++ b/src/Avalonia.Visuals/Media/TextFormatting/Unicode/Grapheme.cs @@ -1,4 +1,4 @@ -using Avalonia.Utility; +using Avalonia.Utilities; namespace Avalonia.Media.TextFormatting.Unicode { diff --git a/src/Avalonia.Visuals/Media/TextFormatting/Unicode/GraphemeEnumerator.cs b/src/Avalonia.Visuals/Media/TextFormatting/Unicode/GraphemeEnumerator.cs index fd7831dfe6..1e4ac8fe0f 100644 --- a/src/Avalonia.Visuals/Media/TextFormatting/Unicode/GraphemeEnumerator.cs +++ b/src/Avalonia.Visuals/Media/TextFormatting/Unicode/GraphemeEnumerator.cs @@ -4,7 +4,7 @@ // Licensed to The Avalonia Project under MIT License, courtesy of The .NET Foundation. using System.Runtime.InteropServices; -using Avalonia.Utility; +using Avalonia.Utilities; namespace Avalonia.Media.TextFormatting.Unicode { diff --git a/src/Avalonia.Visuals/Media/TextFormatting/Unicode/LineBreakEnumerator.cs b/src/Avalonia.Visuals/Media/TextFormatting/Unicode/LineBreakEnumerator.cs index 25a32bb1a3..26f7721128 100644 --- a/src/Avalonia.Visuals/Media/TextFormatting/Unicode/LineBreakEnumerator.cs +++ b/src/Avalonia.Visuals/Media/TextFormatting/Unicode/LineBreakEnumerator.cs @@ -16,7 +16,7 @@ // Ported from: https://github.com/foliojs/linebreak // Copied from: https://github.com/toptensoftware/RichTextKit -using Avalonia.Utility; +using Avalonia.Utilities; namespace Avalonia.Media.TextFormatting.Unicode { diff --git a/src/Avalonia.Visuals/Media/TextWrapping.cs b/src/Avalonia.Visuals/Media/TextWrapping.cs index 56df3670bd..d649bda23f 100644 --- a/src/Avalonia.Visuals/Media/TextWrapping.cs +++ b/src/Avalonia.Visuals/Media/TextWrapping.cs @@ -5,6 +5,13 @@ namespace Avalonia.Media /// public enum TextWrapping { + /// + /// Line-breaking occurs if the line overflows the available block width. + /// However, a line may overflow the block width if the line breaking algorithm + /// cannot determine a break opportunity, as in the case of a very long word. + /// + WrapWithOverflow, + /// /// Text should not wrap. /// @@ -15,4 +22,4 @@ namespace Avalonia.Media /// Wrap } -} \ No newline at end of file +} diff --git a/src/Avalonia.Visuals/Media/Typeface.cs b/src/Avalonia.Visuals/Media/Typeface.cs index 7618598a3f..677e930804 100644 --- a/src/Avalonia.Visuals/Media/Typeface.cs +++ b/src/Avalonia.Visuals/Media/Typeface.cs @@ -16,11 +16,11 @@ namespace Avalonia.Media /// Initializes a new instance of the class. /// /// The font family. - /// The font weight. /// The font style. + /// The font weight. public Typeface([NotNull]FontFamily fontFamily, - FontWeight weight = FontWeight.Normal, - FontStyle style = FontStyle.Normal) + FontStyle style = FontStyle.Normal, + FontWeight weight = FontWeight.Normal) { if (weight <= 0) { @@ -39,9 +39,9 @@ namespace Avalonia.Media /// The font style. /// The font weight. public Typeface(string fontFamilyName, - FontWeight weight = FontWeight.Normal, - FontStyle style = FontStyle.Normal) - : this(new FontFamily(fontFamilyName), weight, style) + FontStyle style = FontStyle.Normal, + FontWeight weight = FontWeight.Normal) + : this(new FontFamily(fontFamilyName), style, weight) { } diff --git a/src/Avalonia.Visuals/Platform/ITextShaperImpl.cs b/src/Avalonia.Visuals/Platform/ITextShaperImpl.cs index 4d770a6c6e..d915da2603 100644 --- a/src/Avalonia.Visuals/Platform/ITextShaperImpl.cs +++ b/src/Avalonia.Visuals/Platform/ITextShaperImpl.cs @@ -1,6 +1,6 @@ -using Avalonia.Media; -using Avalonia.Media.TextFormatting; -using Avalonia.Utility; +using System.Globalization; +using Avalonia.Media; +using Avalonia.Utilities; namespace Avalonia.Platform { @@ -13,8 +13,10 @@ namespace Avalonia.Platform /// Shapes the specified region within the text and returns a resulting glyph run. /// /// The text. - /// The text format. + /// The typeface. + /// The font rendering em size. + /// The culture. /// A shaped glyph run. - GlyphRun ShapeText(ReadOnlySlice text, TextFormat textFormat); + GlyphRun ShapeText(ReadOnlySlice text, Typeface typeface, double fontRenderingEmSize, CultureInfo culture); } } diff --git a/src/Avalonia.Visuals/Utility/ReadOnlySlice.cs b/src/Avalonia.Visuals/Utilities/ReadOnlySlice.cs similarity index 98% rename from src/Avalonia.Visuals/Utility/ReadOnlySlice.cs rename to src/Avalonia.Visuals/Utilities/ReadOnlySlice.cs index ff2b3b9363..5feaa88e26 100644 --- a/src/Avalonia.Visuals/Utility/ReadOnlySlice.cs +++ b/src/Avalonia.Visuals/Utilities/ReadOnlySlice.cs @@ -2,9 +2,8 @@ using System.Collections; using System.Collections.Generic; using System.Diagnostics; -using Avalonia.Utilities; -namespace Avalonia.Utility +namespace Avalonia.Utilities { /// /// ReadOnlySlice enables the ability to work with a sequence within a region of memory and retains the position in within that region. @@ -47,7 +46,7 @@ namespace Avalonia.Utility public int Length { get; } /// - /// Gets a value that indicates whether this instance of is Empty. + /// Gets a value that indicates whether this instance of is Empty. /// public bool IsEmpty => Length == 0; diff --git a/src/Avalonia.Visuals/Utilities/ValueSpan.cs b/src/Avalonia.Visuals/Utilities/ValueSpan.cs new file mode 100644 index 0000000000..7a10d865ef --- /dev/null +++ b/src/Avalonia.Visuals/Utilities/ValueSpan.cs @@ -0,0 +1,30 @@ +namespace Avalonia.Utilities +{ + /// + /// Pairing of value and positions sharing that value. + /// + public readonly struct ValueSpan + { + public ValueSpan(int start, int length, T value) + { + Start = start; + Length = length; + Value = value; + } + + /// + /// Get's the start of the span. + /// + public int Start { get; } + + /// + /// Get's the length of the span. + /// + public int Length { get; } + + /// + /// Get's the value of the span. + /// + public T Value { get; } + } +} diff --git a/src/Markup/Avalonia.Markup.Xaml/Avalonia.Markup.Xaml.csproj b/src/Markup/Avalonia.Markup.Xaml/Avalonia.Markup.Xaml.csproj index 14687da6bc..da345835c8 100644 --- a/src/Markup/Avalonia.Markup.Xaml/Avalonia.Markup.Xaml.csproj +++ b/src/Markup/Avalonia.Markup.Xaml/Avalonia.Markup.Xaml.csproj @@ -1,7 +1,7 @@  netstandard2.0 - PCL;NETSTANDARD;NETSTANDARD2_0;HAS_TYPE_CONVERTER;HAS_CUSTOM_ATTRIBUTE_PROVIDER;XAMLIL_INTERNAL + PCL;NETSTANDARD;NETSTANDARD2_0;HAS_TYPE_CONVERTER;HAS_CUSTOM_ATTRIBUTE_PROVIDER;XAMLX_INTERNAL false $(DefineConstants);RUNTIME_XAML_CECIL False @@ -77,8 +77,8 @@ - - + + diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/AvaloniaXamlIlRuntimeCompiler.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/AvaloniaXamlIlRuntimeCompiler.cs index 949e2173a5..d9b4cd70da 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/AvaloniaXamlIlRuntimeCompiler.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/AvaloniaXamlIlRuntimeCompiler.cs @@ -10,12 +10,15 @@ using System.Runtime.InteropServices; using Avalonia.Markup.Xaml.XamlIl.CompilerExtensions; using Avalonia.Markup.Xaml.XamlIl.Runtime; using Avalonia.Platform; -using XamlIl.Transform; -using XamlIl.TypeSystem; +using XamlX.Transform; +using XamlX.TypeSystem; +using XamlX.IL; +using XamlX.Emit; #if RUNTIME_XAML_CECIL using TypeAttributes = Mono.Cecil.TypeAttributes; using Mono.Cecil; -using XamlIl.Ast; +using XamlX.Ast; +using XamlX.IL.Cecil; #endif namespace Avalonia.Markup.Xaml.XamlIl { @@ -24,9 +27,10 @@ namespace Avalonia.Markup.Xaml.XamlIl #if !RUNTIME_XAML_CECIL private static SreTypeSystem _sreTypeSystem; private static ModuleBuilder _sreBuilder; - private static IXamlIlType _sreContextType; - private static XamlIlLanguageTypeMappings _sreMappings; - private static XamlIlXmlnsMappings _sreXmlns; + private static IXamlType _sreContextType; + private static XamlLanguageTypeMappings _sreMappings; + private static XamlLanguageEmitMappings _sreEmitMappings; + private static XamlXmlnsMappings _sreXmlns; private static AssemblyBuilder _sreAsm; private static bool _sreCanSave; @@ -82,13 +86,14 @@ namespace Avalonia.Markup.Xaml.XamlIl } if (_sreMappings == null) - _sreMappings = AvaloniaXamlIlLanguage.Configure(_sreTypeSystem); + (_sreMappings, _sreEmitMappings) = AvaloniaXamlIlLanguage.Configure(_sreTypeSystem); if (_sreXmlns == null) - _sreXmlns = XamlIlXmlnsMappings.Resolve(_sreTypeSystem, _sreMappings); + _sreXmlns = XamlXmlnsMappings.Resolve(_sreTypeSystem, _sreMappings); if (_sreContextType == null) - _sreContextType = XamlIlContextDefinition.GenerateContextClass( + _sreContextType = XamlILContextDefinition.GenerateContextClass( _sreTypeSystem.CreateTypeBuilder( - _sreBuilder.DefineType("XamlIlContext")), _sreTypeSystem, _sreMappings); + _sreBuilder.DefineType("XamlIlContext")), _sreTypeSystem, _sreMappings, + _sreEmitMappings); } @@ -122,10 +127,11 @@ namespace Avalonia.Markup.Xaml.XamlIl _sreMappings, _sreXmlns, AvaloniaXamlIlLanguage.CustomValueConverter, new XamlIlClrPropertyInfoEmitter(_sreTypeSystem.CreateTypeBuilder(clrPropertyBuilder)), new XamlIlPropertyInfoAccessorFactoryEmitter(_sreTypeSystem.CreateTypeBuilder(indexerClosureType))), + _sreEmitMappings, _sreContextType) { EnableIlVerification = true }; - IXamlIlType overrideType = null; + IXamlType overrideType = null; if (rootInstance != null) { overrideType = _sreTypeSystem.GetType(rootInstance.GetType()); @@ -209,6 +215,7 @@ namespace Avalonia.Markup.Xaml.XamlIl private static string _cecilEmitDir; private static CecilTypeSystem _cecilTypeSystem; private static XamlIlLanguageTypeMappings _cecilMappings; + private static XamlLanguageEmitMappings _cecilEmitMappings; private static XamlIlXmlnsMappings _cecilXmlns; private static bool _cecilInitialized; @@ -221,7 +228,7 @@ namespace Avalonia.Markup.Xaml.XamlIl Directory.CreateDirectory(_cecilEmitDir); var refs = new[] {path}.Concat(File.ReadAllLines(path + ".refs")); _cecilTypeSystem = new CecilTypeSystem(refs); - _cecilMappings = AvaloniaXamlIlLanguage.Configure(_cecilTypeSystem); + (_cecilMappings, _cecilEmitMappings) = AvaloniaXamlIlLanguage.Configure(_cecilTypeSystem); _cecilXmlns = XamlIlXmlnsMappings.Resolve(_cecilTypeSystem, _cecilMappings); _cecilInitialized = true; } @@ -232,7 +239,7 @@ namespace Avalonia.Markup.Xaml.XamlIl if (uri == null) throw new InvalidOperationException("Please, go away"); InitializeCecil(); - IXamlIlType overrideType = null; + IXamlType overrideType = null; if (rootInstance != null) { overrideType = _cecilTypeSystem.GetType(rootInstance.GetType().FullName); @@ -267,6 +274,7 @@ namespace Avalonia.Markup.Xaml.XamlIl localAssembly == null ? null : _cecilTypeSystem.FindAssembly(localAssembly.GetName().Name), _cecilMappings, XamlIlXmlnsMappings.Resolve(_cecilTypeSystem, _cecilMappings), AvaloniaXamlIlLanguage.CustomValueConverter), + _cecilEmitMappings, _cecilTypeSystem.CreateTypeBuilder(contextDef)); compiler.ParseAndCompile(xaml, uri.ToString(), tb, overrideType); var asmPath = Path.Combine(_cecilEmitDir, safeUri + ".dll"); diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/AvaloniaXamlIlCompiler.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/AvaloniaXamlIlCompiler.cs index b126834e5b..f3b8559d45 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/AvaloniaXamlIlCompiler.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/AvaloniaXamlIlCompiler.cs @@ -1,30 +1,33 @@ using System.Collections.Generic; using System.Linq; using Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers; -using XamlIl; -using XamlIl.Ast; -using XamlIl.Parsers; -using XamlIl.Transform; -using XamlIl.Transform.Transformers; -using XamlIl.TypeSystem; +using XamlX; +using XamlX.Ast; +using XamlX.Emit; +using XamlX.IL; +using XamlX.Parsers; +using XamlX.Transform; +using XamlX.Transform.Transformers; +using XamlX.TypeSystem; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions { - class AvaloniaXamlIlCompiler : XamlIlCompiler + class AvaloniaXamlIlCompiler : XamlILCompiler { - private readonly XamlIlTransformerConfiguration _configuration; - private readonly IXamlIlType _contextType; + private readonly TransformerConfiguration _configuration; + private readonly IXamlType _contextType; private readonly AvaloniaXamlIlDesignPropertiesTransformer _designTransformer; private readonly AvaloniaBindingExtensionTransformer _bindingTransformer; - private AvaloniaXamlIlCompiler(AvaloniaXamlIlCompilerConfiguration configuration) : base(configuration, true) + private AvaloniaXamlIlCompiler(TransformerConfiguration configuration, XamlLanguageEmitMappings emitMappings) + : base(configuration, emitMappings, true) { _configuration = configuration; - void InsertAfter(params IXamlIlAstTransformer[] t) + void InsertAfter(params IXamlAstTransformer[] t) => Transformers.InsertRange(Transformers.FindIndex(x => x is T) + 1, t); - void InsertBefore(params IXamlIlAstTransformer[] t) + void InsertBefore(params IXamlAstTransformer[] t) => Transformers.InsertRange(Transformers.FindIndex(x => x is T), t); @@ -38,14 +41,14 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions // Targeted - InsertBefore( + InsertBefore( new AvaloniaXamlIlTransformInstanceAttachedProperties(), new AvaloniaXamlIlTransformSyntheticCompiledBindingMembers()); - InsertAfter(new AvaloniaXamlIlAvaloniaPropertyResolver()); + InsertAfter(new AvaloniaXamlIlAvaloniaPropertyResolver()); - InsertBefore( + InsertBefore( new AvaloniaXamlIlBindingPathParser(), new AvaloniaXamlIlSelectorTransformer(), new AvaloniaXamlIlControlTemplateTargetTypeMetadataTransformer(), @@ -56,8 +59,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions ); // After everything else - - InsertBefore( + InsertBefore( new AddNameScopeRegistration(), new AvaloniaXamlIlDataContextTypeTransformer(), new AvaloniaXamlIlBindingPathTransformer(), @@ -66,17 +68,22 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions Transformers.Add(new AvaloniaXamlIlMetadataRemover()); Transformers.Add(new AvaloniaXamlIlRootObjectScope()); - } - public AvaloniaXamlIlCompiler(AvaloniaXamlIlCompilerConfiguration configuration, - IXamlIlTypeBuilder contextTypeBuilder) : this(configuration) + Emitters.Add(new AvaloniaNameScopeRegistrationXamlIlNodeEmitter()); + Emitters.Add(new AvaloniaXamlIlRootObjectScope.Emitter()); + } + public AvaloniaXamlIlCompiler(TransformerConfiguration configuration, + XamlLanguageEmitMappings emitMappings, + IXamlTypeBuilder contextTypeBuilder) + : this(configuration, emitMappings) { _contextType = CreateContextType(contextTypeBuilder); } - public AvaloniaXamlIlCompiler(AvaloniaXamlIlCompilerConfiguration configuration, - IXamlIlType contextType) : this(configuration) + public AvaloniaXamlIlCompiler(TransformerConfiguration configuration, + XamlLanguageEmitMappings emitMappings, + IXamlType contextType) : this(configuration, emitMappings) { _contextType = contextType; } @@ -96,37 +103,35 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions set => _bindingTransformer.CompileBindingsByDefault = value; } - public void ParseAndCompile(string xaml, string baseUri, IFileSource fileSource, IXamlIlTypeBuilder tb, IXamlIlType overrideRootType) + public void ParseAndCompile(string xaml, string baseUri, IFileSource fileSource, IXamlTypeBuilder tb, IXamlType overrideRootType) { - var parsed = XDocumentXamlIlParser.Parse(xaml, new Dictionary + var parsed = XDocumentXamlParser.Parse(xaml, new Dictionary { {XamlNamespaces.Blend2008, XamlNamespaces.Blend2008} }); - var rootObject = (XamlIlAstObjectNode)parsed.Root; + var rootObject = (XamlAstObjectNode)parsed.Root; var classDirective = rootObject.Children - .OfType().FirstOrDefault(x => + .OfType().FirstOrDefault(x => x.Namespace == XamlNamespaces.Xaml2006 && x.Name == "Class"); var rootType = classDirective != null ? - new XamlIlAstClrTypeReference(classDirective, - _configuration.TypeSystem.GetType(((XamlIlAstTextNode)classDirective.Values[0]).Text), + new XamlAstClrTypeReference(classDirective, + _configuration.TypeSystem.GetType(((XamlAstTextNode)classDirective.Values[0]).Text), false) : - XamlIlTypeReferenceResolver.ResolveType(CreateTransformationContext(parsed, true), - (XamlIlAstXmlTypeReference)rootObject.Type, true); + TypeReferenceResolver.ResolveType(CreateTransformationContext(parsed, true), + (XamlAstXmlTypeReference)rootObject.Type, true); if (overrideRootType != null) { - - if (!rootType.Type.IsAssignableFrom(overrideRootType)) - throw new XamlIlLoadException( + throw new XamlX.XamlLoadException( $"Unable to substitute {rootType.Type.GetFqn()} with {overrideRootType.GetFqn()}", rootObject); - rootType = new XamlIlAstClrTypeReference(rootObject, overrideRootType, false); + rootType = new XamlAstClrTypeReference(rootObject, overrideRootType, false); } OverrideRootType(parsed, rootType); @@ -136,17 +141,17 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions } - public void OverrideRootType(XamlIlDocument doc, IXamlIlAstTypeReference newType) + public void OverrideRootType(XamlDocument doc, IXamlAstTypeReference newType) { - var root = (XamlIlAstObjectNode)doc.Root; + var root = (XamlAstObjectNode)doc.Root; var oldType = root.Type; if (oldType.Equals(newType)) return; root.Type = newType; - foreach (var child in root.Children.OfType()) + foreach (var child in root.Children.OfType()) { - if (child.Property is XamlIlAstNamePropertyReference prop) + if (child.Property is XamlAstNamePropertyReference prop) { if (prop.DeclaringType.Equals(oldType)) prop.DeclaringType = newType; diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/AvaloniaXamlIlCompilerConfiguration.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/AvaloniaXamlIlCompilerConfiguration.cs index 6235ef5d86..0c0dcb1634 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/AvaloniaXamlIlCompilerConfiguration.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/AvaloniaXamlIlCompilerConfiguration.cs @@ -1,18 +1,18 @@ -using XamlIl.Transform; -using XamlIl.TypeSystem; +using XamlX.Transform; +using XamlX.TypeSystem; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions { - class AvaloniaXamlIlCompilerConfiguration : XamlIlTransformerConfiguration + class AvaloniaXamlIlCompilerConfiguration : TransformerConfiguration { public XamlIlClrPropertyInfoEmitter ClrPropertyEmitter { get; } public XamlIlPropertyInfoAccessorFactoryEmitter AccessorFactoryEmitter { get; } - public AvaloniaXamlIlCompilerConfiguration(IXamlIlTypeSystem typeSystem, - IXamlIlAssembly defaultAssembly, - XamlIlLanguageTypeMappings typeMappings, - XamlIlXmlnsMappings xmlnsMappings, - XamlIlValueConverter customValueConverter, + public AvaloniaXamlIlCompilerConfiguration(IXamlTypeSystem typeSystem, + IXamlAssembly defaultAssembly, + XamlLanguageTypeMappings typeMappings, + XamlXmlnsMappings xmlnsMappings, + XamlValueConverter customValueConverter, XamlIlClrPropertyInfoEmitter clrPropertyEmitter, XamlIlPropertyInfoAccessorFactoryEmitter accessorFactoryEmitter) : base(typeSystem, defaultAssembly, typeMappings, xmlnsMappings, customValueConverter) diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/AvaloniaXamlIlLanguage.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/AvaloniaXamlIlLanguage.cs index c3f4c479dc..99ec3744bf 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/AvaloniaXamlIlLanguage.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/AvaloniaXamlIlLanguage.cs @@ -2,10 +2,12 @@ using System.Collections.Generic; using System.Globalization; using System.Linq; using Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers; -using XamlIl; -using XamlIl.Ast; -using XamlIl.Transform; -using XamlIl.TypeSystem; +using XamlX; +using XamlX.Ast; +using XamlX.Emit; +using XamlX.IL; +using XamlX.Transform; +using XamlX.TypeSystem; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions { @@ -17,12 +19,12 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions class AvaloniaXamlIlLanguage { - public static XamlIlLanguageTypeMappings Configure(IXamlIlTypeSystem typeSystem) + public static (XamlLanguageTypeMappings language, XamlLanguageEmitMappings emit) Configure(IXamlTypeSystem typeSystem) { var runtimeHelpers = typeSystem.GetType("Avalonia.Markup.Xaml.XamlIl.Runtime.XamlIlRuntimeHelpers"); var assignBindingAttribute = typeSystem.GetType("Avalonia.Data.AssignBindingAttribute"); var bindingType = typeSystem.GetType("Avalonia.Data.IBinding"); - var rv = new XamlIlLanguageTypeMappings(typeSystem) + var rv = new XamlLanguageTypeMappings(typeSystem) { SupportInitialize = typeSystem.GetType("System.ComponentModel.ISupportInitialize"), XmlnsAttributes = @@ -51,18 +53,22 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions }, InnerServiceProviderFactoryMethod = runtimeHelpers.FindMethod(m => m.Name == "CreateInnerServiceProviderV1"), - ProvideValueTargetPropertyEmitter = XamlIlAvaloniaPropertyHelper.EmitProvideValueTarget, }; rv.CustomAttributeResolver = new AttributeResolver(typeSystem, rv); - rv.ContextTypeBuilderCallback = (b, c) => EmitNameScopeField(rv, typeSystem, b, c); - return rv; + + var emit = new XamlLanguageEmitMappings + { + ProvideValueTargetPropertyEmitter = XamlIlAvaloniaPropertyHelper.EmitProvideValueTarget, + ContextTypeBuilderCallback = (b, c) => EmitNameScopeField(rv, typeSystem, b, c) + }; + return (rv, emit); } public const string ContextNameScopeFieldName = "AvaloniaNameScope"; - private static void EmitNameScopeField(XamlIlLanguageTypeMappings mappings, - IXamlIlTypeSystem typeSystem, - IXamlIlTypeBuilder typebuilder, IXamlIlEmitter constructor) + private static void EmitNameScopeField(XamlLanguageTypeMappings mappings, + IXamlTypeSystem typeSystem, + IXamlTypeBuilder typebuilder, IXamlILEmitter constructor) { var nameScopeType = typeSystem.FindType("Avalonia.Controls.INameScope"); @@ -78,23 +84,23 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions } - class AttributeResolver : IXamlIlCustomAttributeResolver + class AttributeResolver : IXamlCustomAttributeResolver { - private readonly IXamlIlType _typeConverterAttribute; + private readonly IXamlType _typeConverterAttribute; - private readonly List> _converters = - new List>(); + private readonly List> _converters = + new List>(); - private readonly IXamlIlType _avaloniaList; - private readonly IXamlIlType _avaloniaListConverter; + private readonly IXamlType _avaloniaList; + private readonly IXamlType _avaloniaListConverter; - public AttributeResolver(IXamlIlTypeSystem typeSystem, XamlIlLanguageTypeMappings mappings) + public AttributeResolver(IXamlTypeSystem typeSystem, XamlLanguageTypeMappings mappings) { _typeConverterAttribute = mappings.TypeConverterAttributes.First(); - void AddType(IXamlIlType type, IXamlIlType conv) - => _converters.Add(new KeyValuePair(type, conv)); + void AddType(IXamlType type, IXamlType conv) + => _converters.Add(new KeyValuePair(type, conv)); void Add(string type, string conv) => AddType(typeSystem.GetType(type), typeSystem.GetType(conv)); @@ -113,7 +119,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions _avaloniaListConverter = typeSystem.GetType("Avalonia.Collections.AvaloniaListConverter`1"); } - IXamlIlType LookupConverter(IXamlIlType type) + IXamlType LookupConverter(IXamlType type) { foreach(var p in _converters) if (p.Key.Equals(type)) @@ -123,15 +129,15 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions return null; } - class ConstructedAttribute : IXamlIlCustomAttribute + class ConstructedAttribute : IXamlCustomAttribute { - public bool Equals(IXamlIlCustomAttribute other) => false; + public bool Equals(IXamlCustomAttribute other) => false; - public IXamlIlType Type { get; } + public IXamlType Type { get; } public List Parameters { get; } public Dictionary Properties { get; } - public ConstructedAttribute(IXamlIlType type, List parameters, Dictionary properties) + public ConstructedAttribute(IXamlType type, List parameters, Dictionary properties) { Type = type; Parameters = parameters ?? new List(); @@ -139,7 +145,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions } } - public IXamlIlCustomAttribute GetCustomAttribute(IXamlIlType type, IXamlIlType attributeType) + public IXamlCustomAttribute GetCustomAttribute(IXamlType type, IXamlType attributeType) { if (attributeType.Equals(_typeConverterAttribute)) { @@ -151,25 +157,25 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions return null; } - public IXamlIlCustomAttribute GetCustomAttribute(IXamlIlProperty property, IXamlIlType attributeType) + public IXamlCustomAttribute GetCustomAttribute(IXamlProperty property, IXamlType attributeType) { return null; } } - public static bool CustomValueConverter(XamlIlAstTransformationContext context, - IXamlIlAstValueNode node, IXamlIlType type, out IXamlIlAstValueNode result) + public static bool CustomValueConverter(AstTransformationContext context, + IXamlAstValueNode node, IXamlType type, out IXamlAstValueNode result) { if (type.FullName == "System.TimeSpan" - && node is XamlIlAstTextNode tn + && node is XamlAstTextNode tn && !tn.Text.Contains(":")) { var seconds = double.Parse(tn.Text, CultureInfo.InvariantCulture); - result = new XamlIlStaticOrTargetedReturnMethodCallNode(tn, + result = new XamlStaticOrTargetedReturnMethodCallNode(tn, type.FindMethod("FromSeconds", type, false, context.Configuration.WellKnownTypes.Double), new[] { - new XamlIlConstantNode(tn, context.Configuration.WellKnownTypes.Double, seconds) + new XamlConstantNode(tn, context.Configuration.WellKnownTypes.Double, seconds) }); return true; } @@ -178,9 +184,9 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions { var scope = context.ParentNodes().OfType().FirstOrDefault(); if (scope == null) - throw new XamlIlLoadException("Unable to find the parent scope for AvaloniaProperty lookup", node); - if (!(node is XamlIlAstTextNode text)) - throw new XamlIlLoadException("Property should be a text node", node); + throw new XamlX.XamlLoadException("Unable to find the parent scope for AvaloniaProperty lookup", node); + if (!(node is XamlAstTextNode text)) + throw new XamlX.XamlLoadException("Property should be a text node", node); result = XamlIlAvaloniaPropertyHelper.CreateNode(context, text.Text, scope.TargetType, text); return true; } diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AddNameScopeRegistration.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AddNameScopeRegistration.cs index df88584e54..cb36851bab 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AddNameScopeRegistration.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AddNameScopeRegistration.cs @@ -1,35 +1,37 @@ using System; using System.Linq; -using XamlIl; -using XamlIl.Ast; -using XamlIl.Transform; -using XamlIl.TypeSystem; +using XamlX; +using XamlX.Ast; +using XamlX.Transform; +using XamlX.TypeSystem; +using XamlX.Emit; +using XamlX.IL; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers { - class AddNameScopeRegistration : IXamlIlAstTransformer + class AddNameScopeRegistration : IXamlAstTransformer { - public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node) + public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node) { - if (node is XamlIlPropertyAssignmentNode pa) + if (node is XamlPropertyAssignmentNode pa) { if (pa.Property.Name == "Name" && pa.Property.DeclaringType.FullName == "Avalonia.StyledElement") { - if (context.ParentNodes().FirstOrDefault() is XamlIlManipulationGroupNode mg + if (context.ParentNodes().FirstOrDefault() is XamlManipulationGroupNode mg && mg.Children.OfType().Any()) return node; - IXamlIlAstValueNode value = null; + IXamlAstValueNode value = null; for (var c = 0; c < pa.Values.Count; c++) if (pa.Values[c].Type.GetClrType().Equals(context.Configuration.WellKnownTypes.String)) { value = pa.Values[c]; - if (!(value is XamlIlAstTextNode)) + if (!(value is XamlAstTextNode)) { - var local = new XamlIlAstCompilerLocalNode(value); + var local = new XamlAstCompilerLocalNode(value); // Wrap original in local initialization - pa.Values[c] = new XamlIlAstLocalInitializationNodeEmitter(value, value, local); + pa.Values[c] = new XamlAstLocalInitializationNodeEmitter(value, value, local); // Use local value = local; } @@ -39,13 +41,13 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers if (value != null) { - var objectType = context.ParentNodes().OfType().FirstOrDefault()?.Type.GetClrType(); - return new XamlIlManipulationGroupNode(pa) + var objectType = context.ParentNodes().OfType().FirstOrDefault()?.Type.GetClrType(); + return new XamlManipulationGroupNode(pa) { Children = { pa, - new AvaloniaNameScopeRegistrationXamlIlNode(value, context.GetAvaloniaTypes(), objectType) + new AvaloniaNameScopeRegistrationXamlIlNode(value, objectType) } }; } @@ -61,52 +63,58 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers } } - class NestedScopeMetadataNode : XamlIlValueWithSideEffectNodeBase + class NestedScopeMetadataNode : XamlValueWithSideEffectNodeBase { - public NestedScopeMetadataNode(IXamlIlAstValueNode value) : base(value, value) + public NestedScopeMetadataNode(IXamlAstValueNode value) : base(value, value) { } } - class AvaloniaNameScopeRegistrationXamlIlNode : XamlIlAstNode, IXamlIlAstManipulationNode, IXamlIlAstEmitableNode + class AvaloniaNameScopeRegistrationXamlIlNode : XamlAstNode, IXamlAstManipulationNode { - private readonly AvaloniaXamlIlWellKnownTypes _types; - public IXamlIlAstValueNode Name { get; set; } - public IXamlIlType TargetType { get; } + public IXamlAstValueNode Name { get; set; } + public IXamlType TargetType { get; } - public AvaloniaNameScopeRegistrationXamlIlNode(IXamlIlAstValueNode name, AvaloniaXamlIlWellKnownTypes types, IXamlIlType targetType) : base(name) + public AvaloniaNameScopeRegistrationXamlIlNode(IXamlAstValueNode name, IXamlType targetType) : base(name) { - _types = types; TargetType = targetType; Name = name; } - public override void VisitChildren(IXamlIlAstVisitor visitor) - => Name = (IXamlIlAstValueNode)Name.Visit(visitor); + public override void VisitChildren(IXamlAstVisitor visitor) + => Name = (IXamlAstValueNode)Name.Visit(visitor); + } - public XamlIlNodeEmitResult Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + class AvaloniaNameScopeRegistrationXamlIlNodeEmitter : IXamlAstLocalsNodeEmitter + { + public XamlILNodeEmitResult Emit(IXamlAstNode node, XamlEmitContextWithLocals context, IXamlILEmitter codeGen) { - var scopeField = context.RuntimeContext.ContextType.Fields.First(f => - f.Name == AvaloniaXamlIlLanguage.ContextNameScopeFieldName); - - using (var targetLoc = context.GetLocal(context.Configuration.WellKnownTypes.Object)) + if (node is AvaloniaNameScopeRegistrationXamlIlNode registration) { - codeGen - // var target = {pop} - .Stloc(targetLoc.Local) - // _context.NameScope.Register(Name, target) - .Ldloc(context.ContextLocal) - .Ldfld(scopeField); - - context.Emit(Name, codeGen, Name.Type.GetClrType()); - - codeGen - .Ldloc(targetLoc.Local) - .EmitCall(_types.INameScopeRegister, true); - } + var scopeField = context.RuntimeContext.ContextType.Fields.First(f => + f.Name == AvaloniaXamlIlLanguage.ContextNameScopeFieldName); + + using (var targetLoc = context.GetLocalOfType(context.Configuration.WellKnownTypes.Object)) + { - return XamlIlNodeEmitResult.Void(1); + codeGen + // var target = {pop} + .Stloc(targetLoc.Local) + // _context.NameScope.Register(Name, target) + .Ldloc(context.ContextLocal) + .Ldfld(scopeField); + + context.Emit(registration.Name, codeGen, registration.Name.Type.GetClrType()); + + codeGen + .Ldloc(targetLoc.Local) + .EmitCall(context.GetAvaloniaTypes().INameScopeRegister, true); + } + + return XamlILNodeEmitResult.Void(1); + } + return default; } } } diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaBindingExtensionTransformer.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaBindingExtensionTransformer.cs index 23904a19fb..de2c0eab96 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaBindingExtensionTransformer.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaBindingExtensionTransformer.cs @@ -1,35 +1,38 @@ using System.Linq; -using XamlIl; -using XamlIl.Ast; -using XamlIl.Transform; +using XamlX; +using XamlX.Ast; +using XamlX.Transform; + + +using XamlParseException = XamlX.XamlParseException; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers { - class AvaloniaBindingExtensionTransformer : IXamlIlAstTransformer + class AvaloniaBindingExtensionTransformer : IXamlAstTransformer { public bool CompileBindingsByDefault { get; set; } - public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node) + public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node) { if (context.ParentNodes().FirstOrDefault() is AvaloniaXamlIlCompileBindingsNode) { return node; } - if (node is XamlIlAstObjectNode obj) + if (node is XamlAstObjectNode obj) { foreach (var item in obj.Children) { - if (item is XamlIlAstXmlDirective directive) + if (item is XamlAstXmlDirective directive) { if (directive.Namespace == XamlNamespaces.Xaml2006 && directive.Name == "CompileBindings" && directive.Values.Count == 1) { - if (!(directive.Values[0] is XamlIlAstTextNode text + if (!(directive.Values[0] is XamlAstTextNode text && bool.TryParse(text.Text, out var compileBindings))) { - throw new XamlIlParseException("The value of x:CompileBindings must be a literal boolean value.", directive.Values[0]); + throw new XamlParseException("The value of x:CompileBindings must be a literal boolean value.", directive.Values[0]); } obj.Children.Remove(directive); @@ -40,10 +43,9 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers } } - // Our code base expects XAML parser to prefer `FooExtension` to `Foo` even with `` syntax - // This is the legacy of Portable.Xaml, so we emulate that behavior here + // Convert the tag to either a CompiledBinding or ReflectionBinding tag. - if (node is XamlIlAstXmlTypeReference tref + if (node is XamlAstXmlTypeReference tref && tref.Name == "Binding" && tref.XmlNamespace == "https://github.com/avaloniaui") { @@ -60,9 +62,9 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers } } - internal class AvaloniaXamlIlCompileBindingsNode : XamlIlValueWithSideEffectNodeBase + internal class AvaloniaXamlIlCompileBindingsNode : XamlValueWithSideEffectNodeBase { - public AvaloniaXamlIlCompileBindingsNode(IXamlIlAstValueNode value, bool compileBindings) + public AvaloniaXamlIlCompileBindingsNode(IXamlAstValueNode value, bool compileBindings) : base(value, value) { CompileBindings = compileBindings; diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlAvaloniaPropertyResolver.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlAvaloniaPropertyResolver.cs index 74f5c29f6a..9219a39ddc 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlAvaloniaPropertyResolver.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlAvaloniaPropertyResolver.cs @@ -1,14 +1,14 @@ using System.Linq; -using XamlIl.Ast; -using XamlIl.Transform; +using XamlX.Ast; +using XamlX.Transform; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers { - class AvaloniaXamlIlAvaloniaPropertyResolver : IXamlIlAstTransformer + class AvaloniaXamlIlAvaloniaPropertyResolver : IXamlAstTransformer { - public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node) + public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node) { - if (node is XamlIlAstClrProperty prop) + if (node is XamlAstClrProperty prop) { var n = prop.Name + "Property"; var field = diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlBindingPathParser.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlBindingPathParser.cs index daf3f57936..7944d8b569 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlBindingPathParser.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlBindingPathParser.cs @@ -4,23 +4,25 @@ using System.Linq; using System.Text; using Avalonia.Markup.Parsers; using Avalonia.Utilities; -using XamlIl; -using XamlIl.Ast; -using XamlIl.Transform; -using XamlIl.Transform.Transformers; -using XamlIl.TypeSystem; +using XamlX; +using XamlX.Ast; +using XamlX.Transform; +using XamlX.Transform.Transformers; +using XamlX.TypeSystem; + +using XamlParseException = XamlX.XamlParseException; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers { - class AvaloniaXamlIlBindingPathParser : IXamlIlAstTransformer + class AvaloniaXamlIlBindingPathParser : IXamlAstTransformer { - public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node) + public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node) { - if (node is XamlIlAstObjectNode binding && binding.Type.GetClrType().Equals(context.GetAvaloniaTypes().CompiledBindingExtension)) + if (node is XamlAstObjectNode binding && binding.Type.GetClrType().Equals(context.GetAvaloniaTypes().CompiledBindingExtension)) { var convertedNode = ConvertLongFormPropertiesToBindingExpressionNode(context, binding); - if (binding.Arguments.Count > 0 && binding.Arguments[0] is XamlIlAstTextNode bindingPathText) + if (binding.Arguments.Count > 0 && binding.Arguments[0] is XamlAstTextNode bindingPathText) { var reader = new CharacterReader(bindingPathText.Text.AsSpan()); var (nodes, _) = BindingExpressionGrammar.Parse(ref reader); @@ -34,10 +36,10 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers } else { - var bindingPathAssignment = binding.Children.OfType() + var bindingPathAssignment = binding.Children.OfType() .FirstOrDefault(v => v.Property.GetClrProperty().Name == "Path"); - if (bindingPathAssignment != null && bindingPathAssignment.Values[0] is XamlIlAstTextNode pathValue) + if (bindingPathAssignment != null && bindingPathAssignment.Values[0] is XamlAstTextNode pathValue) { var reader = new CharacterReader(pathValue.Text.AsSpan()); var (nodes, _) = BindingExpressionGrammar.Parse(ref reader); @@ -56,12 +58,12 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers } private static BindingExpressionGrammar.INode ConvertLongFormPropertiesToBindingExpressionNode( - XamlIlAstTransformationContext context, - XamlIlAstObjectNode binding) + AstTransformationContext context, + XamlAstObjectNode binding) { BindingExpressionGrammar.INode convertedNode = null; - var syntheticCompiledBindingProperties = binding.Children.OfType() + var syntheticCompiledBindingProperties = binding.Children.OfType() .Where(v => v.Property is AvaloniaSyntheticCompiledBindingProperty) .ToList(); @@ -80,20 +82,20 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers v.Property is AvaloniaSyntheticCompiledBindingProperty prop && prop.Name == SyntheticCompiledBindingPropertyName.RelativeSource); - if (elementNameProperty?.Values[0] is XamlIlAstTextNode elementName) + if (elementNameProperty?.Values[0] is XamlAstTextNode elementName) { convertedNode = new BindingExpressionGrammar.NameNode { Name = elementName.Text }; } else if (elementNameProperty != null) { - throw new XamlIlParseException($"Invalid ElementName '{elementNameProperty.Values[0]}'.", elementNameProperty.Values[0]); + throw new XamlParseException($"Invalid ElementName '{elementNameProperty.Values[0]}'.", elementNameProperty.Values[0]); } if (sourceProperty?.Values[0] != null) { if (convertedNode != null) { - throw new XamlIlParseException("Only one of ElementName, Source, or RelativeSource specified as a binding source. Only one property is allowed.", binding); + throw new XamlParseException("Only one of ElementName, Source, or RelativeSource specified as a binding source. Only one property is allowed.", binding); } convertedNode = new RawSourceBindingExpressionNode(sourceProperty?.Values[0]); @@ -106,13 +108,13 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers { if (convertedNode != null) { - throw new XamlIlParseException("Only one of ElementName, Source, or RelativeSource specified as a binding source. Only one property is allowed.", binding); + throw new XamlParseException("Only one of ElementName, Source, or RelativeSource specified as a binding source. Only one property is allowed.", binding); } var mode = relativeSourceObject.Children - .OfType() + .OfType() .FirstOrDefault(x => x.Property.GetClrProperty().Name == "Mode") - ?.Values[0] is XamlIlAstTextNode modeAssignedValue ? modeAssignedValue.Text : null; + ?.Values[0] is XamlAstTextNode modeAssignedValue ? modeAssignedValue.Text : null; if (relativeSourceObject.Arguments.Count == 0 && mode == null) { mode = "FindAncestor"; @@ -121,46 +123,46 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers if (mode == "FindAncestor") { var ancestorLevel = relativeSourceObject.Children - .OfType() + .OfType() .FirstOrDefault(x => x.Property.GetClrProperty().Name == "FindAncestor") - ?.Values[0] is XamlIlAstTextNode ancestorLevelText ? int.Parse(ancestorLevelText.Text) - 1 : 0; + ?.Values[0] is XamlAstTextNode ancestorLevelText ? int.Parse(ancestorLevelText.Text) - 1 : 0; var treeType = relativeSourceObject.Children - .OfType() + .OfType() .FirstOrDefault(x => x.Property.GetClrProperty().Name == "Tree") - ?.Values[0] is XamlIlAstTextNode treeTypeValue ? treeTypeValue.Text : "Visual"; + ?.Values[0] is XamlAstTextNode treeTypeValue ? treeTypeValue.Text : "Visual"; var ancestorTypeName = relativeSourceObject.Children - .OfType() + .OfType() .FirstOrDefault(x => x.Property.GetClrProperty().Name == "AncestorType") - ?.Values[0] as XamlIlAstTextNode; + ?.Values[0] as XamlAstTextNode; - IXamlIlType ancestorType = null; + IXamlType ancestorType = null; if (ancestorTypeName is null) { if (treeType == "Visual") { - throw new XamlIlParseException("AncestorType must be set for RelativeSourceMode.FindAncestor when searching the visual tree.", relativeSourceObject); + throw new XamlParseException("AncestorType must be set for RelativeSourceMode.FindAncestor when searching the visual tree.", relativeSourceObject); } else if (treeType == "Logical") { var styledElementType = context.GetAvaloniaTypes().StyledElement; ancestorType = context .ParentNodes() - .OfType() + .OfType() .Where(x => styledElementType.IsAssignableFrom(x.Type.GetClrType())) .ElementAtOrDefault(ancestorLevel) ?.Type.GetClrType(); if (ancestorType is null) { - throw new XamlIlParseException("Unable to resolve implicit ancestor type based on XAML tree.", relativeSourceObject); + throw new XamlX.XamlParseException("Unable to resolve implicit ancestor type based on XAML tree.", relativeSourceObject); } } } else { - ancestorType = XamlIlTypeReferenceResolver.ResolveType( + ancestorType = TypeReferenceResolver.ResolveType( context, ancestorTypeName.Text, false, @@ -186,7 +188,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers } else { - throw new XamlIlParseException($"Unknown tree type '{treeType}'.", binding); + throw new XamlParseException($"Unknown tree type '{treeType}'.", binding); } } else if (mode == "DataContext") @@ -206,14 +208,14 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers if (parentType is null) { - throw new XamlIlParseException("A binding with a TemplatedParent RelativeSource has to be in a ControlTemplate.", binding); + throw new XamlParseException("A binding with a TemplatedParent RelativeSource has to be in a ControlTemplate.", binding); } convertedNode = new TemplatedParentBindingExpressionNode { Type = parentType }; } else { - throw new XamlIlParseException($"Unknown RelativeSource mode '{mode}'.", binding); + throw new XamlParseException($"Unknown RelativeSource mode '{mode}'.", binding); } } @@ -234,9 +236,9 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers } private static bool GetRelativeSourceObjectFromAssignment( - XamlIlAstTransformationContext context, - XamlIlAstXamlPropertyValueNode relativeSourceProperty, - out XamlIlAstObjectNode relativeSourceObject) + AstTransformationContext context, + XamlAstXamlPropertyValueNode relativeSourceProperty, + out XamlAstObjectNode relativeSourceObject) { relativeSourceObject = null; if (relativeSourceProperty is null) @@ -244,22 +246,22 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers return false; } - if (relativeSourceProperty.Values[0] is XamlIlMarkupExtensionNode me) + if (relativeSourceProperty.Values[0] is XamlMarkupExtensionNode me) { if (me.Type.GetClrType() != context.GetAvaloniaTypes().RelativeSource) { - throw new XamlIlParseException($"Expected an object of type 'Avalonia.Data.RelativeSource'. Found a object of type '{me.Type.GetClrType().GetFqn()}'", me); + throw new XamlParseException($"Expected an object of type 'Avalonia.Data.RelativeSource'. Found a object of type '{me.Type.GetClrType().GetFqn()}'", me); } - relativeSourceObject = (XamlIlAstObjectNode)me.Value; + relativeSourceObject = (XamlAstObjectNode)me.Value; return true; } - if (relativeSourceProperty.Values[0] is XamlIlAstObjectNode on) + if (relativeSourceProperty.Values[0] is XamlAstObjectNode on) { if (on.Type.GetClrType() != context.GetAvaloniaTypes().RelativeSource) { - throw new XamlIlParseException($"Expected an object of type 'Avalonia.Data.RelativeSource'. Found a object of type '{on.Type.GetClrType().GetFqn()}'", on); + throw new XamlParseException($"Expected an object of type 'Avalonia.Data.RelativeSource'. Found a object of type '{on.Type.GetClrType().GetFqn()}'", on); } relativeSourceObject = on; @@ -270,24 +272,24 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers } } - class ParsedBindingPathNode : XamlIlAstNode, IXamlIlAstValueNode + class ParsedBindingPathNode : XamlAstNode, IXamlAstValueNode { - public ParsedBindingPathNode(IXamlIlLineInfo lineInfo, IXamlIlType compiledBindingType, IList path) + public ParsedBindingPathNode(IXamlLineInfo lineInfo, IXamlType compiledBindingType, IList path) : base(lineInfo) { - Type = new XamlIlAstClrTypeReference(lineInfo, compiledBindingType, false); + Type = new XamlAstClrTypeReference(lineInfo, compiledBindingType, false); Path = path; } - public IXamlIlAstTypeReference Type { get; } + public IXamlAstTypeReference Type { get; } public IList Path { get; } - public override void VisitChildren(IXamlIlAstVisitor visitor) + public override void VisitChildren(IXamlAstVisitor visitor) { for (int i = 0; i < Path.Count; i++) { - if (Path[i] is IXamlIlAstNode ast) + if (Path[i] is IXamlAstNode ast) { Path[i] = (BindingExpressionGrammar.INode)ast.Visit(visitor); } @@ -297,34 +299,34 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers class VisualAncestorBindingExpressionNode : BindingExpressionGrammar.INode { - public IXamlIlType Type { get; set; } + public IXamlType Type { get; set; } public int Level { get; set; } } class LogicalAncestorBindingExpressionNode : BindingExpressionGrammar.INode { - public IXamlIlType Type { get; set; } + public IXamlType Type { get; set; } public int Level { get; set; } } class TemplatedParentBindingExpressionNode : BindingExpressionGrammar.INode { - public IXamlIlType Type { get; set; } + public IXamlType Type { get; set; } } - class RawSourceBindingExpressionNode : XamlIlAstNode, BindingExpressionGrammar.INode + class RawSourceBindingExpressionNode : XamlAstNode, BindingExpressionGrammar.INode { - public RawSourceBindingExpressionNode(IXamlIlAstValueNode rawSource) + public RawSourceBindingExpressionNode(IXamlAstValueNode rawSource) : base(rawSource) { RawSource = rawSource; } - public IXamlIlAstValueNode RawSource { get; private set; } + public IXamlAstValueNode RawSource { get; private set; } - public override void VisitChildren(IXamlIlAstVisitor visitor) + public override void VisitChildren(IXamlAstVisitor visitor) { - RawSource = (IXamlIlAstValueNode)RawSource.Visit(visitor); + RawSource = (IXamlAstValueNode)RawSource.Visit(visitor); } } } diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlBindingPathTransformer.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlBindingPathTransformer.cs index aa0fd82b0d..fc32084687 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlBindingPathTransformer.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlBindingPathTransformer.cs @@ -2,24 +2,24 @@ using System.Collections.Generic; using System.Linq; using System.Text; -using XamlIl; -using XamlIl.Ast; -using XamlIl.Transform; -using XamlIl.TypeSystem; +using XamlX; +using XamlX.Ast; +using XamlX.Transform; +using XamlX.TypeSystem; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers { - class AvaloniaXamlIlBindingPathTransformer : IXamlIlAstTransformer + class AvaloniaXamlIlBindingPathTransformer : IXamlAstTransformer { - public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node) + public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node) { - if (node is XamlIlAstObjectNode binding && binding.Type.GetClrType().Equals(context.GetAvaloniaTypes().CompiledBindingExtension)) + if (node is XamlAstConstructableObjectNode binding && binding.Type.GetClrType().Equals(context.GetAvaloniaTypes().CompiledBindingExtension)) { - IXamlIlType startType; + IXamlType startType; var parentDataContextNode = context.ParentNodes().OfType().FirstOrDefault(); if (parentDataContextNode is null) { - throw new XamlIlParseException("Cannot parse a compiled binding without an explicit x:DataType directive to give a starting data type for bindings.", binding); + throw new XamlX.XamlParseException("Cannot parse a compiled binding without an explicit x:DataType directive to give a starting data type for bindings.", binding); } startType = parentDataContextNode.DataContextType; diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlCompiledBindingsMetadataRemover.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlCompiledBindingsMetadataRemover.cs index 4a9e9fa3a7..70bd15ea12 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlCompiledBindingsMetadataRemover.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlCompiledBindingsMetadataRemover.cs @@ -1,12 +1,12 @@ using System.Linq; -using XamlIl.Ast; -using XamlIl.Transform; +using XamlX.Ast; +using XamlX.Transform; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers { - class AvaloniaXamlIlCompiledBindingsMetadataRemover : IXamlIlAstTransformer + class AvaloniaXamlIlCompiledBindingsMetadataRemover : IXamlAstTransformer { - public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node) + public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node) { while (true) { diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlConstructorServiceProviderTransformer.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlConstructorServiceProviderTransformer.cs index 7e8f296b44..35e2624ff9 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlConstructorServiceProviderTransformer.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlConstructorServiceProviderTransformer.cs @@ -1,15 +1,17 @@ using System.Linq; -using XamlIl.Ast; -using XamlIl.Transform; -using XamlIl.TypeSystem; +using XamlX.Ast; +using XamlX.Emit; +using XamlX.IL; +using XamlX.Transform; +using XamlX.TypeSystem; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers { - class AvaloniaXamlIlConstructorServiceProviderTransformer : IXamlIlAstTransformer + class AvaloniaXamlIlConstructorServiceProviderTransformer : IXamlAstTransformer { - public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node) + public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node) { - if (node is XamlIlAstObjectNode on && on.Arguments.Count == 0) + if (node is XamlAstObjectNode on && on.Arguments.Count == 0) { var ctors = on.Type.GetClrType().Constructors; if (!ctors.Any(c => c.IsPublic && !c.IsStatic && c.Parameters.Count == 0)) @@ -27,20 +29,20 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers return node; } - class InjectServiceProviderNode : XamlIlAstNode, IXamlIlAstValueNode,IXamlIlAstNodeNeedsParentStack, - IXamlIlAstEmitableNode + class InjectServiceProviderNode : XamlAstNode, IXamlAstValueNode,IXamlAstNodeNeedsParentStack, + IXamlAstEmitableNode { - public InjectServiceProviderNode(IXamlIlType type, IXamlIlLineInfo lineInfo) : base(lineInfo) + public InjectServiceProviderNode(IXamlType type, IXamlLineInfo lineInfo) : base(lineInfo) { - Type = new XamlIlAstClrTypeReference(lineInfo, type, false); + Type = new XamlAstClrTypeReference(lineInfo, type, false); } - public IXamlIlAstTypeReference Type { get; } + public IXamlAstTypeReference Type { get; } public bool NeedsParentStack => true; - public XamlIlNodeEmitResult Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public XamlILNodeEmitResult Emit(XamlEmitContext context, IXamlILEmitter codeGen) { codeGen.Ldloc(context.ContextLocal); - return XamlIlNodeEmitResult.Type(0, Type.GetClrType()); + return XamlILNodeEmitResult.Type(0, Type.GetClrType()); } } } diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlControlTemplateTargetTypeMetadataTransformer.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlControlTemplateTargetTypeMetadataTransformer.cs index 40386924c3..f95d086bf6 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlControlTemplateTargetTypeMetadataTransformer.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlControlTemplateTargetTypeMetadataTransformer.cs @@ -1,29 +1,29 @@ using System.Linq; -using XamlIl.Ast; -using XamlIl.Transform; -using XamlIl.TypeSystem; +using XamlX.Ast; +using XamlX.Transform; +using XamlX.TypeSystem; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers { - class AvaloniaXamlIlControlTemplateTargetTypeMetadataTransformer : IXamlIlAstTransformer + class AvaloniaXamlIlControlTemplateTargetTypeMetadataTransformer : IXamlAstTransformer { - public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node) + public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node) { - if (!(node is XamlIlAstObjectNode on + if (!(node is XamlAstObjectNode on && on.Type.GetClrType().FullName == "Avalonia.Markup.Xaml.Templates.ControlTemplate")) return node; - var tt = on.Children.OfType().FirstOrDefault(ch => + var tt = on.Children.OfType().FirstOrDefault(ch => ch.Property.GetClrProperty().Name == "TargetType"); if (context.ParentNodes().FirstOrDefault() is AvaloniaXamlIlTargetTypeMetadataNode) // Deja vu. I've just been in this place before return node; - IXamlIlAstTypeReference targetType; + IXamlAstTypeReference targetType; var templatableBaseType = context.Configuration.TypeSystem.GetType("Avalonia.Controls.Control"); - if ((tt?.Values.FirstOrDefault() is XamlIlTypeExtensionNode tn)) + if ((tt?.Values.FirstOrDefault() is XamlTypeExtensionNode tn)) { targetType = tn.Value; } @@ -33,11 +33,11 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers .FirstOrDefault(); if (parentScope?.ScopeType == AvaloniaXamlIlTargetTypeMetadataNode.ScopeTypes.Style) targetType = parentScope.TargetType; - else if (context.ParentNodes().Skip(1).FirstOrDefault() is XamlIlAstObjectNode directParentNode + else if (context.ParentNodes().Skip(1).FirstOrDefault() is XamlAstObjectNode directParentNode && templatableBaseType.IsAssignableFrom(directParentNode.Type.GetClrType())) targetType = directParentNode.Type; else - targetType = new XamlIlAstClrTypeReference(node, + targetType = new XamlAstClrTypeReference(node, templatableBaseType, false); } @@ -48,9 +48,9 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers } } - class AvaloniaXamlIlTargetTypeMetadataNode : XamlIlValueWithSideEffectNodeBase + class AvaloniaXamlIlTargetTypeMetadataNode : XamlValueWithSideEffectNodeBase { - public IXamlIlAstTypeReference TargetType { get; set; } + public IXamlAstTypeReference TargetType { get; set; } public ScopeTypes ScopeType { get; } public enum ScopeTypes @@ -60,7 +60,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers Transitions } - public AvaloniaXamlIlTargetTypeMetadataNode(IXamlIlAstValueNode value, IXamlIlAstTypeReference targetType, + public AvaloniaXamlIlTargetTypeMetadataNode(IXamlAstValueNode value, IXamlAstTypeReference targetType, ScopeTypes type) : base(value, value) { diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlDataContextTypeTransformer.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlDataContextTypeTransformer.cs index 6c7dbbb861..5a0d6bac8d 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlDataContextTypeTransformer.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlDataContextTypeTransformer.cs @@ -6,18 +6,18 @@ using System.Text; using Avalonia.Markup.Parsers; using Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers; using Avalonia.Utilities; -using XamlIl; -using XamlIl.Ast; -using XamlIl.Transform; -using XamlIl.Transform.Transformers; -using XamlIl.TypeSystem; +using XamlX; +using XamlX.Ast; +using XamlX.Transform; +using XamlX.Transform.Transformers; +using XamlX.TypeSystem; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers { - class AvaloniaXamlIlDataContextTypeTransformer : IXamlIlAstTransformer + class AvaloniaXamlIlDataContextTypeTransformer : IXamlAstTransformer { private const string AvaloniaNs = "https://github.com/avaloniaui"; - public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node) + public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node) { if (context.ParentNodes().FirstOrDefault() is AvaloniaXamlIlDataContextTypeMetadataNode) { @@ -25,7 +25,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers return node; } - if (node is XamlIlAstObjectNode on) + if (node is XamlAstConstructableObjectNode on) { AvaloniaXamlIlDataContextTypeMetadataNode inferredDataContextTypeNode = null; AvaloniaXamlIlDataContextTypeMetadataNode directiveDataContextTypeNode = null; @@ -34,7 +34,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers for (int i = 0; i < on.Children.Count; ++i) { var child = on.Children[i]; - if (child is XamlIlAstXmlDirective directive) + if (child is XamlAstXmlDirective directive) { if (directive.Namespace == XamlNamespaces.Xaml2006 && directive.Name == "DataType" @@ -42,29 +42,29 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers { on.Children.RemoveAt(i); i--; - if (directive.Values[0] is XamlIlAstTextNode text) + if (directive.Values[0] is XamlAstTextNode text) { directiveDataContextTypeNode = new AvaloniaXamlIlDataContextTypeMetadataNode(on, - XamlIlTypeReferenceResolver.ResolveType(context, text.Text, isMarkupExtension: false, text, strict: true).Type); + TypeReferenceResolver.ResolveType(context, text.Text, isMarkupExtension: false, text, strict: true).Type); } else { - throw new XamlIlParseException("x:DataType should be set to a type name.", directive.Values[0]); + throw new XamlX.XamlParseException("x:DataType should be set to a type name.", directive.Values[0]); } } } - else if (child is XamlIlPropertyAssignmentNode pa) + else if (child is XamlPropertyAssignmentNode pa) { if (pa.Property.Name == "DataContext" && pa.Property.DeclaringType.Equals(context.GetAvaloniaTypes().StyledElement) - && pa.Values[0] is XamlIlMarkupExtensionNode ext - && ext.Value is XamlIlAstObjectNode obj) + && pa.Values[0] is XamlMarkupExtensionNode ext + && ext.Value is XamlAstConstructableObjectNode obj) { inferredDataContextTypeNode = ParseDataContext(context, on, obj); } else if(isDataTemplate && pa.Property.Name == "DataType" - && pa.Values[0] is XamlIlTypeExtensionNode dataTypeNode) + && pa.Values[0] is XamlTypeExtensionNode dataTypeNode) { inferredDataContextTypeNode = new AvaloniaXamlIlDataContextTypeMetadataNode(on, dataTypeNode.Value.GetClrType()); } @@ -78,7 +78,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers if (isDataTemplate && inferredDataContextTypeNode is null) { // Infer data type from collection binding on a control that displays items. - var parentObject = context.ParentNodes().OfType().FirstOrDefault(); + var parentObject = context.ParentNodes().OfType().FirstOrDefault(); if (parentObject != null && context.GetAvaloniaTypes().IItemsPresenterHost.IsDirectlyAssignableFrom(parentObject.Type.GetClrType())) { inferredDataContextTypeNode = InferDataContextOfPresentedItem(context, on, parentObject); @@ -96,10 +96,10 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers return node; } - private static AvaloniaXamlIlDataContextTypeMetadataNode InferDataContextOfPresentedItem(XamlIlAstTransformationContext context, XamlIlAstObjectNode on, XamlIlAstObjectNode parentObject) + private static AvaloniaXamlIlDataContextTypeMetadataNode InferDataContextOfPresentedItem(AstTransformationContext context, XamlAstConstructableObjectNode on, XamlAstConstructableObjectNode parentObject) { var parentItemsValue = parentObject - .Children.OfType() + .Children.OfType() .FirstOrDefault(pa => pa.Property.Name == "Items") ?.Values[0]; if (parentItemsValue is null) @@ -109,11 +109,11 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers return new AvaloniaXamlIlUninferrableDataContextMetadataNode(on); } - IXamlIlType itemsCollectionType = null; + IXamlType itemsCollectionType = null; if (context.GetAvaloniaTypes().IBinding.IsAssignableFrom(parentItemsValue.Type.GetClrType())) { if (parentItemsValue.Type.GetClrType().Equals(context.GetAvaloniaTypes().CompiledBindingExtension) - && parentItemsValue is XamlIlMarkupExtensionNode ext && ext.Value is XamlIlAstObjectNode parentItemsBinding) + && parentItemsValue is XamlMarkupExtensionNode ext && ext.Value is XamlAstConstructableObjectNode parentItemsBinding) { var parentItemsDataContext = context.ParentNodes().SkipWhile(n => n != parentObject).OfType().FirstOrDefault(); if (parentItemsDataContext != null) @@ -141,7 +141,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers return new AvaloniaXamlIlUninferrableDataContextMetadataNode(on); } - private static AvaloniaXamlIlDataContextTypeMetadataNode ParseDataContext(XamlIlAstTransformationContext context, XamlIlAstObjectNode on, XamlIlAstObjectNode obj) + private static AvaloniaXamlIlDataContextTypeMetadataNode ParseDataContext(AstTransformationContext context, XamlAstConstructableObjectNode on, XamlAstConstructableObjectNode obj) { var bindingType = context.GetAvaloniaTypes().IBinding; if (!bindingType.IsAssignableFrom(obj.Type.GetClrType()) && !obj.Type.GetClrType().Equals(context.GetAvaloniaTypes().ReflectionBindingExtension)) @@ -150,11 +150,11 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers } else if (obj.Type.GetClrType().Equals(context.GetAvaloniaTypes().CompiledBindingExtension)) { - IXamlIlType startType; + IXamlType startType; var parentDataContextNode = context.ParentNodes().OfType().FirstOrDefault(); if (parentDataContextNode is null) { - throw new XamlIlParseException("Cannot parse a compiled binding without an explicit x:DataType directive to give a starting data type for bindings.", obj); + throw new XamlX.XamlParseException("Cannot parse a compiled binding without an explicit x:DataType directive to give a starting data type for bindings.", obj); } startType = parentDataContextNode.DataContextType; @@ -168,11 +168,11 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers } [DebuggerDisplay("DataType = {DataContextType}")] - class AvaloniaXamlIlDataContextTypeMetadataNode : XamlIlValueWithSideEffectNodeBase + class AvaloniaXamlIlDataContextTypeMetadataNode : XamlValueWithSideEffectNodeBase { - public virtual IXamlIlType DataContextType { get; } + public virtual IXamlType DataContextType { get; } - public AvaloniaXamlIlDataContextTypeMetadataNode(IXamlIlAstValueNode value, IXamlIlType targetType) + public AvaloniaXamlIlDataContextTypeMetadataNode(IXamlAstValueNode value, IXamlType targetType) : base(value, value) { DataContextType = targetType; @@ -182,11 +182,11 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers [DebuggerDisplay("DataType = Unknown")] class AvaloniaXamlIlUninferrableDataContextMetadataNode : AvaloniaXamlIlDataContextTypeMetadataNode { - public AvaloniaXamlIlUninferrableDataContextMetadataNode(IXamlIlAstValueNode value) + public AvaloniaXamlIlUninferrableDataContextMetadataNode(IXamlAstValueNode value) : base(value, null) { } - public override IXamlIlType DataContextType => throw new XamlIlTransformException("Unable to infer DataContext type for compiled bindings nested within this element.", Value); + public override IXamlType DataContextType => throw new XamlTransformException("Unable to infer DataContext type for compiled bindings nested within this element.", Value); } } diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlDesignPropertiesTransformer.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlDesignPropertiesTransformer.cs index 9cc4c5cf11..3096be522f 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlDesignPropertiesTransformer.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlDesignPropertiesTransformer.cs @@ -1,12 +1,12 @@ using System.Collections.Generic; using System.Linq; -using XamlIl; -using XamlIl.Ast; -using XamlIl.Transform; +using XamlX; +using XamlX.Ast; +using XamlX.Transform; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers { - class AvaloniaXamlIlDesignPropertiesTransformer : IXamlIlAstTransformer + class AvaloniaXamlIlDesignPropertiesTransformer : IXamlAstTransformer { public bool IsDesignMode { get; set; } @@ -17,14 +17,14 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers }; private const string AvaloniaNs = "https://github.com/avaloniaui"; - public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node) + public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node) { - if (node is XamlIlAstObjectNode on) + if (node is XamlAstObjectNode on) { for (var c=0; c() .FirstOrDefault(); if(parentScope == null) - throw new XamlIlParseException("No target type scope found for property path", text); + throw new XamlX.XamlParseException("No target type scope found for property path", text); if (parentScope.ScopeType != AvaloniaXamlIlTargetTypeMetadataNode.ScopeTypes.Style) - throw new XamlIlParseException("PropertyPath is currently only valid for styles", pv); + throw new XamlX.XamlParseException("PropertyPath is currently only valid for styles", pv); IEnumerable parsed; @@ -36,11 +38,11 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers } catch (Exception e) { - throw new XamlIlParseException("Unable to parse PropertyPath: " + e.Message, text); + throw new XamlX.XamlParseException("Unable to parse PropertyPath: " + e.Message, text); } var elements = new List(); - IXamlIlType currentType = parentScope.TargetType.GetClrType(); + IXamlType currentType = parentScope.TargetType.GetClrType(); var expectProperty = true; @@ -48,16 +50,16 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers var expectTraversal = false; var types = context.GetAvaloniaTypes(); - IXamlIlType GetType(string ns, string name) + IXamlType GetType(string ns, string name) { - return XamlIlTypeReferenceResolver.ResolveType(context, $"{ns}:{name}", false, + return TypeReferenceResolver.ResolveType(context, $"{ns}:{name}", false, text, true).GetClrType(); } void HandleProperty(string name, string typeNamespace, string typeName) { if(!expectProperty || currentType == null) - throw new XamlIlParseException("Unexpected property node", text); + throw new XamlX.XamlParseException("Unexpected property node", text); var propertySearchType = typeName != null ? GetType(typeNamespace, typeName) : currentType; @@ -78,7 +80,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers } if (prop == null) - throw new XamlIlParseException( + throw new XamlX.XamlParseException( $"Unable to resolve property {name} on type {propertySearchType.GetFqn()}", text); @@ -93,7 +95,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers if (ge is PropertyPathGrammar.ChildTraversalSyntax) { if (!expectTraversal) - throw new XamlIlParseException("Unexpected child traversal .", text); + throw new XamlX.XamlParseException("Unexpected child traversal .", text); elements.Add(new XamlIlChildTraversalPropertyPathElementNode()); expectTraversal = expectCast = false; expectProperty = true; @@ -101,7 +103,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers else if (ge is PropertyPathGrammar.EnsureTypeSyntax ets) { if(!expectCast) - throw new XamlIlParseException("Unexpected cast node", text); + throw new XamlX.XamlParseException("Unexpected cast node", text); currentType = GetType(ets.TypeNamespace, ets.TypeName); elements.Add(new XamlIlCastPropertyPathElementNode(currentType, true)); expectProperty = false; @@ -110,7 +112,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers else if (ge is PropertyPathGrammar.CastTypeSyntax cts) { if(!expectCast) - throw new XamlIlParseException("Unexpected cast node", text); + throw new XamlX.XamlParseException("Unexpected cast node", text); //TODO: Check if cast can be done currentType = GetType(cts.TypeNamespace, cts.TypeName); elements.Add(new XamlIlCastPropertyPathElementNode(currentType, false)); @@ -126,12 +128,12 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers HandleProperty(tqps.Name, tqps.TypeNamespace, tqps.TypeName); } else - throw new XamlIlParseException("Unexpected node " + ge, text); + throw new XamlX.XamlParseException("Unexpected node " + ge, text); } var propertyPathNode = new XamlIlPropertyPathNode(text, elements, types); if (propertyPathNode.Type == null) - throw new XamlIlParseException("Unexpected end of the property path", text); + throw new XamlX.XamlParseException("Unexpected end of the property path", text); pv.Values[0] = propertyPathNode; } @@ -140,49 +142,49 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers interface IXamlIlPropertyPathElementNode { - void Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen); - IXamlIlType Type { get; } + void Emit(XamlEmitContext context, IXamlILEmitter codeGen); + IXamlType Type { get; } } class XamlIlChildTraversalPropertyPathElementNode : IXamlIlPropertyPathElementNode { - public void Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public void Emit(XamlEmitContext context, IXamlILEmitter codeGen) => codeGen.EmitCall( context.GetAvaloniaTypes() .PropertyPathBuilder.FindMethod(m => m.Name == "ChildTraversal")); - public IXamlIlType Type => null; + public IXamlType Type => null; } class XamlIlAvaloniaPropertyPropertyPathElementNode : IXamlIlPropertyPathElementNode { - private readonly IXamlIlField _field; + private readonly IXamlField _field; - public XamlIlAvaloniaPropertyPropertyPathElementNode(IXamlIlField field, IXamlIlType propertyType) + public XamlIlAvaloniaPropertyPropertyPathElementNode(IXamlField field, IXamlType propertyType) { _field = field; Type = propertyType; } - public void Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public void Emit(XamlEmitContext context, IXamlILEmitter codeGen) => codeGen .Ldsfld(_field) .EmitCall(context.GetAvaloniaTypes() .PropertyPathBuilder.FindMethod(m => m.Name == "Property")); - public IXamlIlType Type { get; } + public IXamlType Type { get; } } class XamlIClrPropertyPathElementNode : IXamlIlPropertyPathElementNode { - private readonly IXamlIlProperty _property; + private readonly IXamlProperty _property; - public XamlIClrPropertyPathElementNode(IXamlIlProperty property) + public XamlIClrPropertyPathElementNode(IXamlProperty property) { _property = property; } - public void Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public void Emit(XamlEmitContext context, IXamlILEmitter codeGen) { context.Configuration.GetExtra() .Emit(context, codeGen, _property); @@ -191,21 +193,21 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers .PropertyPathBuilder.FindMethod(m => m.Name == "Property")); } - public IXamlIlType Type => _property.Getter?.ReturnType ?? _property.Setter?.Parameters[0]; + public IXamlType Type => _property.Getter?.ReturnType ?? _property.Setter?.Parameters[0]; } class XamlIlCastPropertyPathElementNode : IXamlIlPropertyPathElementNode { - private readonly IXamlIlType _type; + private readonly IXamlType _type; private readonly bool _ensureType; - public XamlIlCastPropertyPathElementNode(IXamlIlType type, bool ensureType) + public XamlIlCastPropertyPathElementNode(IXamlType type, bool ensureType) { _type = type; _ensureType = ensureType; } - public void Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public void Emit(XamlEmitContext context, IXamlILEmitter codeGen) { codeGen .Ldtype(_type) @@ -213,39 +215,39 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers .PropertyPathBuilder.FindMethod(m => m.Name == (_ensureType ? "EnsureType" : "Cast"))); } - public IXamlIlType Type => _type; + public IXamlType Type => _type; } - class XamlIlPropertyPathNode : XamlIlAstNode, IXamlIlPropertyPathNode, IXamlIlAstEmitableNode + class XamlIlPropertyPathNode : XamlAstNode, IXamlIlPropertyPathNode, IXamlAstEmitableNode { private readonly List _elements; private readonly AvaloniaXamlIlWellKnownTypes _types; - public XamlIlPropertyPathNode(IXamlIlLineInfo lineInfo, + public XamlIlPropertyPathNode(IXamlLineInfo lineInfo, List elements, AvaloniaXamlIlWellKnownTypes types) : base(lineInfo) { _elements = elements; _types = types; - Type = new XamlIlAstClrTypeReference(this, types.PropertyPath, false); + Type = new XamlAstClrTypeReference(this, types.PropertyPath, false); } - public IXamlIlAstTypeReference Type { get; } - public IXamlIlType PropertyType => _elements.LastOrDefault()?.Type; - public XamlIlNodeEmitResult Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public IXamlAstTypeReference Type { get; } + public IXamlType PropertyType => _elements.LastOrDefault()?.Type; + public XamlILNodeEmitResult Emit(XamlEmitContext context, IXamlILEmitter codeGen) { codeGen .Newobj(_types.PropertyPathBuilder.FindConstructor()); foreach(var e in _elements) e.Emit(context, codeGen); codeGen.EmitCall(_types.PropertyPathBuilder.FindMethod(m => m.Name == "Build")); - return XamlIlNodeEmitResult.Type(0, _types.PropertyPath); + return XamlILNodeEmitResult.Type(0, _types.PropertyPath); } } } - interface IXamlIlPropertyPathNode : IXamlIlAstValueNode + interface IXamlIlPropertyPathNode : IXamlAstValueNode { - IXamlIlType PropertyType { get; } + IXamlType PropertyType { get; } } } diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlRootObjectScopeTransformer.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlRootObjectScopeTransformer.cs index 25fd032c4f..0513c78a7a 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlRootObjectScopeTransformer.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlRootObjectScopeTransformer.cs @@ -1,20 +1,22 @@ using System; using System.Linq; -using XamlIl; -using XamlIl.Ast; -using XamlIl.Transform; -using XamlIl.TypeSystem; +using XamlX; +using XamlX.Ast; +using XamlX.Transform; +using XamlX.TypeSystem; +using XamlX.IL; +using XamlX.Emit; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers { - class AvaloniaXamlIlRootObjectScope : IXamlIlAstTransformer + class AvaloniaXamlIlRootObjectScope : IXamlAstTransformer { - public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node) + public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node) { if (!context.ParentNodes().Any() - && node is XamlIlValueWithManipulationNode mnode) + && node is XamlValueWithManipulationNode mnode) { - mnode.Manipulation = new XamlIlManipulationGroupNode(mnode, + mnode.Manipulation = new XamlManipulationGroupNode(mnode, new[] { mnode.Manipulation, @@ -23,41 +25,48 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers } return node; } - class HandleRootObjectScopeNode : XamlIlAstNode, IXamlIlAstManipulationNode, IXamlIlAstEmitableNode + class HandleRootObjectScopeNode : XamlAstNode, IXamlAstManipulationNode { private readonly AvaloniaXamlIlWellKnownTypes _types; - public HandleRootObjectScopeNode(IXamlIlLineInfo lineInfo, + public HandleRootObjectScopeNode(IXamlLineInfo lineInfo, AvaloniaXamlIlWellKnownTypes types) : base(lineInfo) { _types = types; } - - public XamlIlNodeEmitResult Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + } + internal class Emitter : IXamlILAstNodeEmitter + { + public XamlILNodeEmitResult Emit(IXamlAstNode node, XamlEmitContext context, IXamlILEmitter codeGen) { + if (!(node is HandleRootObjectScopeNode)) + { + return null; + } + var types = context.GetAvaloniaTypes(); + var next = codeGen.DefineLabel(); var scopeField = context.RuntimeContext.ContextType.Fields.First(f => f.Name == AvaloniaXamlIlLanguage.ContextNameScopeFieldName); - using (var local = codeGen.LocalsPool.GetLocal(_types.StyledElement)) + using (var local = codeGen.LocalsPool.GetLocal(types.StyledElement)) { codeGen - .Isinst(_types.StyledElement) + .Isinst(types.StyledElement) .Dup() .Stloc(local.Local) .Brfalse(next) .Ldloc(local.Local) .Ldloc(context.ContextLocal) .Ldfld(scopeField) - .EmitCall(_types.NameScopeSetNameScope, true) + .EmitCall(types.NameScopeSetNameScope, true) .MarkLabel(next) .Ldloc(context.ContextLocal) .Ldfld(scopeField) - .EmitCall(_types.INameScopeComplete, true); + .EmitCall(types.INameScopeComplete, true); } - return XamlIlNodeEmitResult.Void(1); + return XamlILNodeEmitResult.Void(1); } } - } } diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlSelectorTransformer.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlSelectorTransformer.cs index d5114244cf..b81d25d613 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlSelectorTransformer.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlSelectorTransformer.cs @@ -3,41 +3,45 @@ using System.Collections.Generic; using System.Globalization; using System.Linq; using Avalonia.Markup.Parsers; -using XamlIl; -using XamlIl.Ast; -using XamlIl.Transform; -using XamlIl.Transform.Transformers; -using XamlIl.TypeSystem; +using XamlX; +using XamlX.Ast; +using XamlX.Emit; +using XamlX.IL; +using XamlX.Transform; +using XamlX.Transform.Transformers; +using XamlX.TypeSystem; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers { - class AvaloniaXamlIlSelectorTransformer : IXamlIlAstTransformer + using XamlParseException = XamlX.XamlParseException; + using XamlLoadException = XamlX.XamlLoadException; + class AvaloniaXamlIlSelectorTransformer : IXamlAstTransformer { - public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node) + public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node) { - if (!(node is XamlIlAstObjectNode on && on.Type.GetClrType().FullName == "Avalonia.Styling.Style")) + if (!(node is XamlAstObjectNode on && on.Type.GetClrType().FullName == "Avalonia.Styling.Style")) return node; - var pn = on.Children.OfType() + var pn = on.Children.OfType() .FirstOrDefault(p => p.Property.GetClrProperty().Name == "Selector"); if (pn == null) return node; if (pn.Values.Count != 1) - throw new XamlIlParseException("Selector property should should have exactly one value", node); + throw new XamlParseException("Selector property should should have exactly one value", node); if (pn.Values[0] is XamlIlSelectorNode) //Deja vu. I've just been in this place before return node; - if (!(pn.Values[0] is XamlIlAstTextNode tn)) - throw new XamlIlParseException("Selector property should be a text node", node); + if (!(pn.Values[0] is XamlAstTextNode tn)) + throw new XamlParseException("Selector property should be a text node", node); var selectorType = pn.Property.GetClrProperty().Getter.ReturnType; var initialNode = new XamlIlSelectorInitialNode(node, selectorType); XamlIlSelectorNode Create(IEnumerable syntax, - Func typeResolver) + Func typeResolver) { XamlIlSelectorNode result = initialNode; XamlIlOrSelectorNode results = null; @@ -63,18 +67,18 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers var type = result?.TargetType; if (type == null) - throw new XamlIlParseException("Property selectors must be applied to a type.", node); + throw new XamlParseException("Property selectors must be applied to a type.", node); var targetProperty = type.GetAllProperties().FirstOrDefault(p => p.Name == property.Property); if (targetProperty == null) - throw new XamlIlParseException($"Cannot find '{property.Property}' on '{type}", node); + throw new XamlParseException($"Cannot find '{property.Property}' on '{type}", node); - if (!XamlIlTransformHelpers.TryGetCorrectlyTypedValue(context, - new XamlIlAstTextNode(node, property.Value, context.Configuration.WellKnownTypes.String), + if (!XamlTransformHelpers.TryGetCorrectlyTypedValue(context, + new XamlAstTextNode(node, property.Value, context.Configuration.WellKnownTypes.String), targetProperty.PropertyType, out var typedValue)) - throw new XamlIlParseException( + throw new XamlParseException( $"Cannot convert '{property.Value}' to '{targetProperty.PropertyType.GetFqn()}", node); @@ -100,7 +104,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers result = initialNode; break; default: - throw new XamlIlParseException($"Unsupported selector grammar '{i.GetType()}'.", node); + throw new XamlParseException($"Unsupported selector grammar '{i.GetType()}'.", node); } } @@ -119,15 +123,15 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers } catch (Exception e) { - throw new XamlIlParseException("Unable to parse selector: " + e.Message, node); + throw new XamlParseException("Unable to parse selector: " + e.Message, node); } var selector = Create(parsed, (p, n) - => XamlIlTypeReferenceResolver.ResolveType(context, $"{p}:{n}", true, node, true)); + => TypeReferenceResolver.ResolveType(context, $"{p}:{n}", true, node, true)); pn.Values[0] = selector; return new AvaloniaXamlIlTargetTypeMetadataNode(on, - new XamlIlAstClrTypeReference(selector, selector.TargetType, false), + new XamlAstClrTypeReference(selector, selector.TargetType, false), AvaloniaXamlIlTargetTypeMetadataNode.ScopeTypes.Style); } @@ -135,32 +139,32 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers - abstract class XamlIlSelectorNode : XamlIlAstNode, IXamlIlAstValueNode, IXamlIlAstEmitableNode + abstract class XamlIlSelectorNode : XamlAstNode, IXamlAstValueNode, IXamlAstEmitableNode { protected XamlIlSelectorNode Previous { get; } - public abstract IXamlIlType TargetType { get; } + public abstract IXamlType TargetType { get; } public XamlIlSelectorNode(XamlIlSelectorNode previous, - IXamlIlLineInfo info = null, - IXamlIlType selectorType = null) : base(info ?? previous) + IXamlLineInfo info = null, + IXamlType selectorType = null) : base(info ?? previous) { Previous = previous; - Type = selectorType == null ? previous.Type : new XamlIlAstClrTypeReference(this, selectorType, false); + Type = selectorType == null ? previous.Type : new XamlAstClrTypeReference(this, selectorType, false); } - public IXamlIlAstTypeReference Type { get; } + public IXamlAstTypeReference Type { get; } - public virtual XamlIlNodeEmitResult Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public virtual XamlILNodeEmitResult Emit(XamlEmitContext context, IXamlILEmitter codeGen) { if (Previous != null) context.Emit(Previous, codeGen, Type.GetClrType()); DoEmit(context, codeGen); - return XamlIlNodeEmitResult.Type(0, Type.GetClrType()); + return XamlILNodeEmitResult.Type(0, Type.GetClrType()); } - protected abstract void DoEmit(XamlIlEmitContext context, IXamlIlEmitter codeGen); + protected abstract void DoEmit(XamlEmitContext context, IXamlILEmitter codeGen); - protected void EmitCall(XamlIlEmitContext context, IXamlIlEmitter codeGen, Func method) + protected void EmitCall(XamlEmitContext context, IXamlILEmitter codeGen, Func method) { var selectors = context.Configuration.TypeSystem.GetType("Avalonia.Styling.Selectors"); var found = selectors.FindMethod(m => m.IsStatic && m.Parameters.Count > 0 && method(m)); @@ -170,27 +174,27 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers class XamlIlSelectorInitialNode : XamlIlSelectorNode { - public XamlIlSelectorInitialNode(IXamlIlLineInfo info, - IXamlIlType selectorType) : base(null, info, selectorType) + public XamlIlSelectorInitialNode(IXamlLineInfo info, + IXamlType selectorType) : base(null, info, selectorType) { } - public override IXamlIlType TargetType => null; - protected override void DoEmit(XamlIlEmitContext context, IXamlIlEmitter codeGen) => codeGen.Ldnull(); + public override IXamlType TargetType => null; + protected override void DoEmit(XamlEmitContext context, IXamlILEmitter codeGen) => codeGen.Ldnull(); } class XamlIlTypeSelector : XamlIlSelectorNode { public bool Concrete { get; } - public XamlIlTypeSelector(XamlIlSelectorNode previous, IXamlIlType type, bool concrete) : base(previous) + public XamlIlTypeSelector(XamlIlSelectorNode previous, IXamlType type, bool concrete) : base(previous) { TargetType = type; Concrete = concrete; } - public override IXamlIlType TargetType { get; } - protected override void DoEmit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public override IXamlType TargetType { get; } + protected override void DoEmit(XamlEmitContext context, IXamlILEmitter codeGen) { var name = Concrete ? "OfType" : "Is"; codeGen.Ldtype(TargetType); @@ -217,8 +221,8 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers } - public override IXamlIlType TargetType => Previous?.TargetType; - protected override void DoEmit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public override IXamlType TargetType => Previous?.TargetType; + protected override void DoEmit(XamlEmitContext context, IXamlILEmitter codeGen) { codeGen.Ldstr(String); var name = _type.ToString(); @@ -242,8 +246,8 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers _type = type; } - public override IXamlIlType TargetType => null; - protected override void DoEmit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public override IXamlType TargetType => null; + protected override void DoEmit(XamlEmitContext context, IXamlILEmitter codeGen) { var name = _type.ToString(); EmitCall(context, codeGen, @@ -260,8 +264,8 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers Argument = argument; } - public override IXamlIlType TargetType => Previous?.TargetType; - protected override void DoEmit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public override IXamlType TargetType => Previous?.TargetType; + protected override void DoEmit(XamlEmitContext context, IXamlILEmitter codeGen) { context.Emit(Argument, codeGen, Type.GetClrType()); EmitCall(context, codeGen, @@ -272,22 +276,22 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers class XamlIlPropertyEqualsSelector : XamlIlSelectorNode { public XamlIlPropertyEqualsSelector(XamlIlSelectorNode previous, - IXamlIlProperty property, - IXamlIlAstValueNode value) + IXamlProperty property, + IXamlAstValueNode value) : base(previous) { Property = property; Value = value; } - public IXamlIlProperty Property { get; set; } - public IXamlIlAstValueNode Value { get; set; } + public IXamlProperty Property { get; set; } + public IXamlAstValueNode Value { get; set; } - public override IXamlIlType TargetType => Previous?.TargetType; - protected override void DoEmit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public override IXamlType TargetType => Previous?.TargetType; + protected override void DoEmit(XamlEmitContext context, IXamlILEmitter codeGen) { if (!XamlIlAvaloniaPropertyHelper.Emit(context, codeGen, Property)) - throw new XamlIlLoadException( + throw new XamlLoadException( $"{Property.Name} of {(Property.Setter ?? Property.Getter).DeclaringType.GetFqn()} doesn't seem to be an AvaloniaProperty", this); context.Emit(Value, codeGen, context.Configuration.WellKnownTypes.Object); @@ -302,7 +306,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers class XamlIlOrSelectorNode : XamlIlSelectorNode { List _selectors = new List(); - public XamlIlOrSelectorNode(IXamlIlLineInfo info, IXamlIlType selectorType) : base(null, info, selectorType) + public XamlIlOrSelectorNode(IXamlLineInfo info, IXamlType selectorType) : base(null, info, selectorType) { } @@ -311,11 +315,11 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers _selectors.Add(node); } - public override IXamlIlType TargetType + public override IXamlType TargetType { get { - IXamlIlType result = null; + IXamlType result = null; foreach (var selector in _selectors) { @@ -340,10 +344,10 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers } } - protected override void DoEmit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + protected override void DoEmit(XamlEmitContext context, IXamlILEmitter codeGen) { if (_selectors.Count == 0) - throw new XamlIlLoadException("Invalid selector count", this); + throw new XamlLoadException("Invalid selector count", this); if (_selectors.Count == 1) { _selectors[0].Emit(context, codeGen); diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlSetterTransformer.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlSetterTransformer.cs index 468717f281..e816265422 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlSetterTransformer.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlSetterTransformer.cs @@ -2,74 +2,78 @@ using System; using System.Collections.Generic; using System.Linq; using Avalonia.Data.Core; -using XamlIl; -using XamlIl.Ast; -using XamlIl.Transform; -using XamlIl.Transform.Transformers; -using XamlIl.TypeSystem; +using XamlX; +using XamlX.Ast; +using XamlX.Emit; +using XamlX.IL; +using XamlX.Transform; +using XamlX.Transform.Transformers; +using XamlX.TypeSystem; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers { - class AvaloniaXamlIlSetterTransformer : IXamlIlAstTransformer + using XamlParseException = XamlX.XamlParseException; + using XamlLoadException = XamlX.XamlLoadException; + class AvaloniaXamlIlSetterTransformer : IXamlAstTransformer { - public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node) + public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node) { - if (!(node is XamlIlAstObjectNode on + if (!(node is XamlAstObjectNode on && on.Type.GetClrType().FullName == "Avalonia.Styling.Setter")) return node; - var parent = context.ParentNodes().OfType() + var parent = context.ParentNodes().OfType() .FirstOrDefault(p => p.Type.GetClrType().FullName == "Avalonia.Styling.Style"); if (parent == null) - throw new XamlIlParseException( + throw new XamlParseException( "Avalonia.Styling.Setter is only valid inside Avalonia.Styling.Style", node); - var selectorProperty = parent.Children.OfType() + var selectorProperty = parent.Children.OfType() .FirstOrDefault(p => p.Property.GetClrProperty().Name == "Selector"); if (selectorProperty == null) - throw new XamlIlParseException( + throw new XamlParseException( "Can not find parent Style Selector", node); var selector = selectorProperty.Values.FirstOrDefault() as XamlIlSelectorNode; if (selector?.TargetType == null) - throw new XamlIlParseException( + throw new XamlParseException( "Can not resolve parent Style Selector type", node); - IXamlIlType propType = null; - var property = @on.Children.OfType() + IXamlType propType = null; + var property = @on.Children.OfType() .FirstOrDefault(x => x.Property.GetClrProperty().Name == "Property"); if (property != null) { - var propertyName = property.Values.OfType().FirstOrDefault()?.Text; + var propertyName = property.Values.OfType().FirstOrDefault()?.Text; if (propertyName == null) - throw new XamlIlParseException("Setter.Property must be a string", node); + throw new XamlParseException("Setter.Property must be a string", node); var avaloniaPropertyNode = XamlIlAvaloniaPropertyHelper.CreateNode(context, propertyName, - new XamlIlAstClrTypeReference(selector, selector.TargetType, false), property.Values[0]); - property.Values = new List {avaloniaPropertyNode}; + new XamlAstClrTypeReference(selector, selector.TargetType, false), property.Values[0]); + property.Values = new List {avaloniaPropertyNode}; propType = avaloniaPropertyNode.AvaloniaPropertyType; } else { - var propertyPath = on.Children.OfType() + var propertyPath = on.Children.OfType() .FirstOrDefault(x => x.Property.GetClrProperty().Name == "PropertyPath"); if (propertyPath == null) - throw new XamlIlParseException("Setter without a property or property path is not valid", node); + throw new XamlX.XamlParseException("Setter without a property or property path is not valid", node); if (propertyPath.Values[0] is IXamlIlPropertyPathNode ppn && ppn.PropertyType != null) propType = ppn.PropertyType; else - throw new XamlIlParseException("Unable to get the property path property type", node); + throw new XamlX.XamlParseException("Unable to get the property path property type", node); } var valueProperty = on.Children - .OfType().FirstOrDefault(p => p.Property.GetClrProperty().Name == "Value"); - if (valueProperty?.Values?.Count == 1 && valueProperty.Values[0] is XamlIlAstTextNode) + .OfType().FirstOrDefault(p => p.Property.GetClrProperty().Name == "Value"); + if (valueProperty?.Values?.Count == 1 && valueProperty.Values[0] is XamlAstTextNode) { - if (!XamlIlTransformHelpers.TryGetCorrectlyTypedValue(context, valueProperty.Values[0], + if (!XamlTransformHelpers.TryGetCorrectlyTypedValue(context, valueProperty.Values[0], propType, out var converted)) - throw new XamlIlParseException( + throw new XamlParseException( $"Unable to convert property value to {propType.GetFqn()}", valueProperty.Values[0]); @@ -80,9 +84,9 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers return node; } - class SetterValueProperty : XamlIlAstClrProperty + class SetterValueProperty : XamlAstClrProperty { - public SetterValueProperty(IXamlIlLineInfo line, IXamlIlType setterType, IXamlIlType targetType, + public SetterValueProperty(IXamlLineInfo line, IXamlType setterType, IXamlType targetType, AvaloniaXamlIlWellKnownTypes types) : base(line, "Value", setterType, null) { @@ -93,21 +97,21 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers Setters.Add(new XamlIlDirectCallPropertySetter(method, targetType)); } - class XamlIlDirectCallPropertySetter : IXamlIlPropertySetter + class XamlIlDirectCallPropertySetter : IXamlPropertySetter, IXamlEmitablePropertySetter { - private readonly IXamlIlMethod _method; - private readonly IXamlIlType _type; - public IXamlIlType TargetType { get; } + private readonly IXamlMethod _method; + private readonly IXamlType _type; + public IXamlType TargetType { get; } public PropertySetterBinderParameters BinderParameters { get; } = new PropertySetterBinderParameters(); - public IReadOnlyList Parameters { get; } - public void Emit(IXamlIlEmitter codegen) + public IReadOnlyList Parameters { get; } + public void Emit(IXamlILEmitter codegen) { if (_type.IsValueType) codegen.Box(_type); codegen.EmitCall(_method, true); } - public XamlIlDirectCallPropertySetter(IXamlIlMethod method, IXamlIlType type) + public XamlIlDirectCallPropertySetter(IXamlMethod method, IXamlType type) { _method = method; _type = type; diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlTransformInstanceAttachedProperties.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlTransformInstanceAttachedProperties.cs index 548f0161d6..8e194e9385 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlTransformInstanceAttachedProperties.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlTransformInstanceAttachedProperties.cs @@ -1,20 +1,22 @@ using System.Collections.Generic; using System.Linq; -using XamlIl; -using XamlIl.Ast; -using XamlIl.Transform; -using XamlIl.TypeSystem; +using XamlX; +using XamlX.Ast; +using XamlX.Emit; +using XamlX.IL; +using XamlX.Transform; +using XamlX.TypeSystem; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers { - class AvaloniaXamlIlTransformInstanceAttachedProperties : IXamlIlAstTransformer + class AvaloniaXamlIlTransformInstanceAttachedProperties : IXamlAstTransformer { - public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node) + public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node) { - if (node is XamlIlAstNamePropertyReference prop - && prop.TargetType is XamlIlAstClrTypeReference targetRef - && prop.DeclaringType is XamlIlAstClrTypeReference declaringRef) + if (node is XamlAstNamePropertyReference prop + && prop.TargetType is XamlAstClrTypeReference targetRef + && prop.DeclaringType is XamlAstClrTypeReference declaringRef) { // Target and declared type aren't assignable but both inherit from AvaloniaObject var avaloniaObject = context.Configuration.TypeSystem.FindType("Avalonia.AvaloniaObject"); @@ -70,21 +72,21 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers return node; } - class AvaloniaAttachedInstanceProperty : XamlIlAstClrProperty, IXamlIlAvaloniaProperty + class AvaloniaAttachedInstanceProperty : XamlAstClrProperty, IXamlIlAvaloniaProperty { - private readonly XamlIlTransformerConfiguration _config; - private readonly IXamlIlType _declaringType; - private readonly IXamlIlType _avaloniaPropertyType; - private readonly IXamlIlType _avaloniaObject; - private readonly IXamlIlField _field; - - public AvaloniaAttachedInstanceProperty(XamlIlAstNamePropertyReference prop, - XamlIlTransformerConfiguration config, - IXamlIlType declaringType, - IXamlIlType type, - IXamlIlType avaloniaPropertyType, - IXamlIlType avaloniaObject, - IXamlIlField field) : base(prop, prop.Name, + private readonly TransformerConfiguration _config; + private readonly IXamlType _declaringType; + private readonly IXamlType _avaloniaPropertyType; + private readonly IXamlType _avaloniaObject; + private readonly IXamlField _field; + + public AvaloniaAttachedInstanceProperty(XamlAstNamePropertyReference prop, + TransformerConfiguration config, + IXamlType declaringType, + IXamlType type, + IXamlType avaloniaPropertyType, + IXamlType avaloniaObject, + IXamlField field) : base(prop, prop.Name, declaringType, null) @@ -104,11 +106,11 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers Getter = new GetterMethod(this); } - public IXamlIlType PropertyType { get; } + public IXamlType PropertyType { get; } - public IXamlIlField AvaloniaProperty => _field; + public IXamlField AvaloniaProperty => _field; - class SetterMethod : IXamlIlPropertySetter + class SetterMethod : IXamlPropertySetter, IXamlEmitablePropertySetter { private readonly AvaloniaAttachedInstanceProperty _parent; @@ -118,10 +120,10 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers Parameters = new[] {_parent._avaloniaObject, _parent.PropertyType}; } - public IXamlIlType TargetType => _parent.DeclaringType; + public IXamlType TargetType => _parent.DeclaringType; public PropertySetterBinderParameters BinderParameters { get; } = new PropertySetterBinderParameters(); - public IReadOnlyList Parameters { get; } - public void Emit(IXamlIlEmitter emitter) + public IReadOnlyList Parameters { get; } + public void Emit(IXamlILEmitter emitter) { var so = _parent._config.WellKnownTypes.Object; var method = _parent._avaloniaObject @@ -133,7 +135,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers && m.Parameters[2].IsEnum ); if (method == null) - throw new XamlIlTypeSystemException( + throw new XamlTypeSystemException( "Unable to find SetValue(AvaloniaProperty, object, BindingPriority) on AvaloniaObject"); using (var loc = emitter.LocalsPool.GetLocal(_parent.PropertyType)) emitter @@ -150,7 +152,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers } } - class GetterMethod : IXamlIlCustomEmitMethod + class GetterMethod : IXamlCustomEmitMethod { public GetterMethod(AvaloniaAttachedInstanceProperty parent) { @@ -163,16 +165,16 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers public bool IsPublic => true; public bool IsStatic => true; public string Name { get; protected set; } - public IXamlIlType DeclaringType { get; } - public IXamlIlMethod MakeGenericMethod(IReadOnlyList typeArguments) + public IXamlType DeclaringType { get; } + public IXamlMethod MakeGenericMethod(IReadOnlyList typeArguments) => throw new System.NotSupportedException(); - public bool Equals(IXamlIlMethod other) => + public bool Equals(IXamlMethod other) => other is GetterMethod m && m.Name == Name && m.DeclaringType.Equals(DeclaringType); - public IXamlIlType ReturnType => Parent.PropertyType; - public IReadOnlyList Parameters { get; } - public void EmitCall(IXamlIlEmitter emitter) + public IXamlType ReturnType => Parent.PropertyType; + public IReadOnlyList Parameters { get; } + public void EmitCall(IXamlILEmitter emitter) { var method = Parent._avaloniaObject .FindMethod(m => m.IsPublic && !m.IsStatic && m.Name == "GetValue" @@ -180,7 +182,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers m.Parameters.Count == 1 && m.Parameters[0].Equals(Parent._avaloniaPropertyType)); if (method == null) - throw new XamlIlTypeSystemException( + throw new XamlTypeSystemException( "Unable to find T GetValue(AvaloniaProperty) on AvaloniaObject"); emitter .Ldsfld(Parent._field) diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlTransformSyntheticCompiledBindingMembers.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlTransformSyntheticCompiledBindingMembers.cs index 8e8f628da3..154c6a235c 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlTransformSyntheticCompiledBindingMembers.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlTransformSyntheticCompiledBindingMembers.cs @@ -1,18 +1,18 @@ using System; using System.Collections.Generic; using System.Text; -using XamlIl; -using XamlIl.Ast; -using XamlIl.Transform; +using XamlX; +using XamlX.Ast; +using XamlX.Transform; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers { - class AvaloniaXamlIlTransformSyntheticCompiledBindingMembers : IXamlIlAstTransformer + class AvaloniaXamlIlTransformSyntheticCompiledBindingMembers : IXamlAstTransformer { - public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node) + public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node) { - if (node is XamlIlAstNamePropertyReference prop - && prop.TargetType is XamlIlAstClrTypeReference targetRef + if (node is XamlAstNamePropertyReference prop + && prop.TargetType is XamlAstClrTypeReference targetRef && targetRef.GetClrType().Equals(context.GetAvaloniaTypes().CompiledBindingExtension)) { if (prop.Name == "ElementName") @@ -43,12 +43,12 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers Source } - class AvaloniaSyntheticCompiledBindingProperty : XamlIlAstNode, IXamlIlAstPropertyReference + class AvaloniaSyntheticCompiledBindingProperty : XamlAstNode, IXamlAstPropertyReference { public SyntheticCompiledBindingPropertyName Name { get; } public AvaloniaSyntheticCompiledBindingProperty( - IXamlIlLineInfo lineInfo, + IXamlLineInfo lineInfo, SyntheticCompiledBindingPropertyName name) : base(lineInfo) { diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlTransitionsTypeMetadataTransformer.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlTransitionsTypeMetadataTransformer.cs index c4136f4824..4be2fc6f60 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlTransitionsTypeMetadataTransformer.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlTransitionsTypeMetadataTransformer.cs @@ -1,17 +1,17 @@ -using XamlIl.Ast; -using XamlIl.Transform; +using XamlX.Ast; +using XamlX.Transform; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers { - class AvaloniaXamlIlTransitionsTypeMetadataTransformer : IXamlIlAstTransformer + class AvaloniaXamlIlTransitionsTypeMetadataTransformer : IXamlAstTransformer { - public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node) + public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node) { - if (node is XamlIlAstObjectNode on) + if (node is XamlAstObjectNode on) { foreach (var ch in on.Children) { - if (ch is XamlIlAstXamlPropertyValueNode pn + if (ch is XamlAstXamlPropertyValueNode pn && pn.Property.GetClrProperty().Getter?.ReturnType.Equals(context.GetAvaloniaTypes().Transitions) == true) { for (var c = 0; c < pn.Values.Count; c++) diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlWellKnownTypes.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlWellKnownTypes.cs index 6f2861e2bf..bf1fb4a6fc 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlWellKnownTypes.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/AvaloniaXamlIlWellKnownTypes.cs @@ -1,47 +1,49 @@ -using XamlIl.Transform; -using XamlIl.TypeSystem; +using XamlX.Emit; +using XamlX.IL; +using XamlX.Transform; +using XamlX.TypeSystem; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers { class AvaloniaXamlIlWellKnownTypes { - public IXamlIlType AvaloniaObject { get; } - public IXamlIlType IAvaloniaObject { get; } - public IXamlIlType BindingPriority { get; } - public IXamlIlType AvaloniaObjectExtensions { get; } - public IXamlIlType AvaloniaProperty { get; } - public IXamlIlType AvaloniaPropertyT { get; } - public IXamlIlType IBinding { get; } - public IXamlIlMethod AvaloniaObjectBindMethod { get; } - public IXamlIlMethod AvaloniaObjectSetValueMethod { get; } - public IXamlIlType IDisposable { get; } - public XamlIlTypeWellKnownTypes XamlIlTypes { get; } - public XamlIlLanguageTypeMappings XamlIlMappings { get; } - public IXamlIlType Transitions { get; } - public IXamlIlType AssignBindingAttribute { get; } - public IXamlIlType UnsetValueType { get; } - public IXamlIlType StyledElement { get; } - public IXamlIlType NameScope { get; } - public IXamlIlMethod NameScopeSetNameScope { get; } - public IXamlIlType INameScope { get; } - public IXamlIlMethod INameScopeRegister { get; } - public IXamlIlMethod INameScopeComplete { get; } - public IXamlIlType IPropertyInfo { get; } - public IXamlIlType ClrPropertyInfo { get; } - public IXamlIlType PropertyPath { get; } - public IXamlIlType PropertyPathBuilder { get; } - public IXamlIlType IPropertyAccessor { get; } - public IXamlIlType PropertyInfoAccessorFactory { get; } - public IXamlIlType CompiledBindingPathBuilder { get; } - public IXamlIlType CompiledBindingPath { get; } - public IXamlIlType CompiledBindingExtension { get; } - public IXamlIlType DataTemplate { get; } - public IXamlIlType IItemsPresenterHost { get; } - public IXamlIlType ReflectionBindingExtension { get; } + public IXamlType AvaloniaObject { get; } + public IXamlType IAvaloniaObject { get; } + public IXamlType BindingPriority { get; } + public IXamlType AvaloniaObjectExtensions { get; } + public IXamlType AvaloniaProperty { get; } + public IXamlType AvaloniaPropertyT { get; } + public IXamlType IBinding { get; } + public IXamlMethod AvaloniaObjectBindMethod { get; } + public IXamlMethod AvaloniaObjectSetValueMethod { get; } + public IXamlType IDisposable { get; } + public XamlTypeWellKnownTypes XamlIlTypes { get; } + public XamlLanguageTypeMappings XamlIlMappings { get; } + public IXamlType Transitions { get; } + public IXamlType AssignBindingAttribute { get; } + public IXamlType UnsetValueType { get; } + public IXamlType StyledElement { get; } + public IXamlType NameScope { get; } + public IXamlMethod NameScopeSetNameScope { get; } + public IXamlType INameScope { get; } + public IXamlMethod INameScopeRegister { get; } + public IXamlMethod INameScopeComplete { get; } + public IXamlType IPropertyInfo { get; } + public IXamlType ClrPropertyInfo { get; } + public IXamlType PropertyPath { get; } + public IXamlType PropertyPathBuilder { get; } + public IXamlType IPropertyAccessor { get; } + public IXamlType PropertyInfoAccessorFactory { get; } + public IXamlType CompiledBindingPathBuilder { get; } + public IXamlType CompiledBindingPath { get; } + public IXamlType CompiledBindingExtension { get; } + public IXamlType DataTemplate { get; } + public IXamlType IItemsPresenterHost { get; } + public IXamlType ReflectionBindingExtension { get; } - public IXamlIlType RelativeSource { get; } + public IXamlType RelativeSource { get; } - public AvaloniaXamlIlWellKnownTypes(XamlIlTransformerConfiguration cfg) + public AvaloniaXamlIlWellKnownTypes(TransformerConfiguration cfg) { XamlIlTypes = cfg.WellKnownTypes; AvaloniaObject = cfg.TypeSystem.GetType("Avalonia.AvaloniaObject"); @@ -99,7 +101,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers static class AvaloniaXamlIlWellKnownTypesExtensions { - public static AvaloniaXamlIlWellKnownTypes GetAvaloniaTypes(this XamlIlAstTransformationContext ctx) + public static AvaloniaXamlIlWellKnownTypes GetAvaloniaTypes(this AstTransformationContext ctx) { if (ctx.TryGetItem(out var rv)) return rv; @@ -107,7 +109,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers return rv; } - public static AvaloniaXamlIlWellKnownTypes GetAvaloniaTypes(this XamlIlEmitContext ctx) + public static AvaloniaXamlIlWellKnownTypes GetAvaloniaTypes(this XamlEmitContext ctx) { if (ctx.TryGetItem(out var rv)) return rv; diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/IgnoredDirectivesTransformer.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/IgnoredDirectivesTransformer.cs index a79a4977ef..1f2508715e 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/IgnoredDirectivesTransformer.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/IgnoredDirectivesTransformer.cs @@ -1,17 +1,17 @@ using System.Linq; -using XamlIl; -using XamlIl.Ast; -using XamlIl.Transform; +using XamlX; +using XamlX.Ast; +using XamlX.Transform; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers { - class IgnoredDirectivesTransformer : IXamlIlAstTransformer + class IgnoredDirectivesTransformer : IXamlAstTransformer { - public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node) + public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node) { - if (node is XamlIlAstObjectNode no) + if (node is XamlAstObjectNode no) { - foreach (var d in no.Children.OfType().ToList()) + foreach (var d in no.Children.OfType().ToList()) { if (d.Namespace == XamlNamespaces.Xaml2006) { diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/XNameTransformer.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/XNameTransformer.cs index dd64ab542a..f4eb7cf5f9 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/XNameTransformer.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/Transformers/XNameTransformer.cs @@ -1,30 +1,29 @@ -using XamlIl; -using XamlIl.Ast; -using XamlIl.Transform; +using XamlX; +using XamlX.Ast; +using XamlX.Transform; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers { - class XNameTransformer : IXamlIlAstTransformer + class XNameTransformer : IXamlAstTransformer { - /// /// Converts x:Name directives to regular Name assignments /// /// - public IXamlIlAstNode Transform(XamlIlAstTransformationContext context, IXamlIlAstNode node) + public IXamlAstNode Transform(AstTransformationContext context, IXamlAstNode node) { - if (node is XamlIlAstObjectNode on) + if (node is XamlAstObjectNode on) { for (var c =0; c< on.Children.Count;c++) { var ch = on.Children[c]; - if (ch is XamlIlAstXmlDirective d + if (ch is XamlAstXmlDirective d && d.Namespace == XamlNamespaces.Xaml2006 && d.Name == "Name") - on.Children[c] = new XamlIlAstXamlPropertyValueNode(d, - new XamlIlAstNamePropertyReference(d, on.Type, "Name", on.Type), + on.Children[c] = new XamlAstXamlPropertyValueNode(d, + new XamlAstNamePropertyReference(d, on.Type, "Name", on.Type), d.Values); } } diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/XamlIlAvaloniaPropertyHelper.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/XamlIlAvaloniaPropertyHelper.cs index bc7c58bbb4..7f1b8caf0d 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/XamlIlAvaloniaPropertyHelper.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/XamlIlAvaloniaPropertyHelper.cs @@ -5,18 +5,23 @@ using System.Xml; using Avalonia.Markup.Xaml.Parsers; using Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers; using Avalonia.Utilities; -using XamlIl; -using XamlIl.Ast; -using XamlIl.Transform; -using XamlIl.Transform.Transformers; -using XamlIl.TypeSystem; +using XamlX; +using XamlX.Ast; +using XamlX.Transform; +using XamlX.Transform.Transformers; +using XamlX.TypeSystem; +using XamlX.Emit; +using XamlX.IL; + +using XamlIlEmitContext = XamlX.Emit.XamlEmitContext; +using IXamlIlAstEmitableNode = XamlX.Emit.IXamlAstEmitableNode; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions { class XamlIlAvaloniaPropertyHelper { - public static bool EmitProvideValueTarget(XamlIlEmitContext context, IXamlIlEmitter emitter, - XamlIlAstClrProperty property) + public static bool EmitProvideValueTarget(XamlIlEmitContext context, IXamlILEmitter emitter, + XamlAstClrProperty property) { if (Emit(context, emitter, property)) return true; @@ -29,7 +34,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions return true; } - public static bool Emit(XamlIlEmitContext context, IXamlIlEmitter emitter, XamlIlAstClrProperty property) + public static bool Emit(XamlIlEmitContext context, IXamlILEmitter emitter, XamlAstClrProperty property) { if (property is IXamlIlAvaloniaProperty ap) { @@ -46,7 +51,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions return true; } - public static bool Emit(XamlIlEmitContext context, IXamlIlEmitter emitter, IXamlIlProperty property) + public static bool Emit(XamlIlEmitContext context, IXamlILEmitter emitter, IXamlProperty property) { var type = (property.Getter ?? property.Setter).DeclaringType; var name = property.Name + "Property"; @@ -58,16 +63,16 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions return true; } - public static IXamlIlAvaloniaPropertyNode CreateNode(XamlIlAstTransformationContext context, - string propertyName, IXamlIlAstTypeReference selectorTypeReference, IXamlIlLineInfo lineInfo) + public static IXamlIlAvaloniaPropertyNode CreateNode(AstTransformationContext context, + string propertyName, IXamlAstTypeReference selectorTypeReference, IXamlLineInfo lineInfo) { - XamlIlAstNamePropertyReference forgedReference; + XamlAstNamePropertyReference forgedReference; var parser = new PropertyParser(); var parsedPropertyName = parser.Parse(new CharacterReader(propertyName.AsSpan())); if(parsedPropertyName.owner == null) - forgedReference = new XamlIlAstNamePropertyReference(lineInfo, selectorTypeReference, + forgedReference = new XamlAstNamePropertyReference(lineInfo, selectorTypeReference, propertyName, selectorTypeReference); else { @@ -76,27 +81,27 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions xmlOwner += ":"; xmlOwner += parsedPropertyName.owner; - var tref = XamlIlTypeReferenceResolver.ResolveType(context, xmlOwner, false, lineInfo, true); + var tref = TypeReferenceResolver.ResolveType(context, xmlOwner, false, lineInfo, true); var propertyFieldName = parsedPropertyName.name + "Property"; var found = tref.Type.GetAllFields() .FirstOrDefault(f => f.IsStatic && f.IsPublic && f.Name == propertyFieldName); if (found == null) - throw new XamlIlParseException( + throw new XamlX.XamlParseException( $"Unable to find {propertyFieldName} field on type {tref.Type.GetFullName()}", lineInfo); return new XamlIlAvaloniaPropertyFieldNode(context.GetAvaloniaTypes(), lineInfo, found); } var clrProperty = - ((XamlIlAstClrProperty)new XamlIlPropertyReferenceResolver().Transform(context, + ((XamlAstClrProperty)new PropertyReferenceResolver().Transform(context, forgedReference)); return new XamlIlAvaloniaPropertyNode(lineInfo, context.Configuration.TypeSystem.GetType("Avalonia.AvaloniaProperty"), clrProperty); } - public static IXamlIlType GetAvaloniaPropertyType(IXamlIlField field, - AvaloniaXamlIlWellKnownTypes types, IXamlIlLineInfo lineInfo) + public static IXamlType GetAvaloniaPropertyType(IXamlField field, + AvaloniaXamlIlWellKnownTypes types, IXamlLineInfo lineInfo) { var avaloniaPropertyType = field.FieldType; while (avaloniaPropertyType != null) @@ -109,47 +114,47 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions avaloniaPropertyType = avaloniaPropertyType.BaseType; } - throw new XamlIlParseException( + throw new XamlX.XamlParseException( $"{field.Name}'s type {field.FieldType} doesn't inherit from AvaloniaProperty, make sure to use typed properties", lineInfo); } } - interface IXamlIlAvaloniaPropertyNode : IXamlIlAstValueNode + interface IXamlIlAvaloniaPropertyNode : IXamlAstValueNode { - IXamlIlType AvaloniaPropertyType { get; } + IXamlType AvaloniaPropertyType { get; } } - class XamlIlAvaloniaPropertyNode : XamlIlAstNode, IXamlIlAstValueNode, IXamlIlAstEmitableNode, IXamlIlAvaloniaPropertyNode + class XamlIlAvaloniaPropertyNode : XamlAstNode, IXamlAstValueNode, IXamlIlAstEmitableNode, IXamlIlAvaloniaPropertyNode { - public XamlIlAvaloniaPropertyNode(IXamlIlLineInfo lineInfo, IXamlIlType type, XamlIlAstClrProperty property) : base(lineInfo) + public XamlIlAvaloniaPropertyNode(IXamlLineInfo lineInfo, IXamlType type, XamlAstClrProperty property) : base(lineInfo) { - Type = new XamlIlAstClrTypeReference(this, type, false); + Type = new XamlAstClrTypeReference(this, type, false); Property = property; AvaloniaPropertyType = Property.Getter?.ReturnType ?? Property.Setters.First().Parameters[0]; } - public XamlIlAstClrProperty Property { get; } + public XamlAstClrProperty Property { get; } - public IXamlIlAstTypeReference Type { get; } - public XamlIlNodeEmitResult Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public IXamlAstTypeReference Type { get; } + public XamlILNodeEmitResult Emit(XamlIlEmitContext context, IXamlILEmitter codeGen) { if (!XamlIlAvaloniaPropertyHelper.Emit(context, codeGen, Property)) - throw new XamlIlLoadException(Property.Name + " is not an AvaloniaProperty", this); - return XamlIlNodeEmitResult.Type(0, Type.GetClrType()); + throw new XamlX.XamlLoadException(Property.Name + " is not an AvaloniaProperty", this); + return XamlILNodeEmitResult.Type(0, Type.GetClrType()); } - public IXamlIlType AvaloniaPropertyType { get; } + public IXamlType AvaloniaPropertyType { get; } } - class XamlIlAvaloniaPropertyFieldNode : XamlIlAstNode, IXamlIlAstValueNode, IXamlIlAstEmitableNode, IXamlIlAvaloniaPropertyNode + class XamlIlAvaloniaPropertyFieldNode : XamlAstNode, IXamlAstValueNode, IXamlIlAstEmitableNode, IXamlIlAvaloniaPropertyNode { - private readonly IXamlIlField _field; + private readonly IXamlField _field; public XamlIlAvaloniaPropertyFieldNode(AvaloniaXamlIlWellKnownTypes types, - IXamlIlLineInfo lineInfo, IXamlIlField field) : base(lineInfo) + IXamlLineInfo lineInfo, IXamlField field) : base(lineInfo) { _field = field; AvaloniaPropertyType = XamlIlAvaloniaPropertyHelper.GetAvaloniaPropertyType(field, @@ -158,25 +163,25 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions - public IXamlIlAstTypeReference Type => new XamlIlAstClrTypeReference(this, _field.FieldType, false); - public XamlIlNodeEmitResult Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public IXamlAstTypeReference Type => new XamlAstClrTypeReference(this, _field.FieldType, false); + public XamlILNodeEmitResult Emit(XamlIlEmitContext context, IXamlILEmitter codeGen) { codeGen.Ldsfld(_field); - return XamlIlNodeEmitResult.Type(0, _field.FieldType); + return XamlILNodeEmitResult.Type(0, _field.FieldType); } - public IXamlIlType AvaloniaPropertyType { get; } + public IXamlType AvaloniaPropertyType { get; } } interface IXamlIlAvaloniaProperty { - IXamlIlField AvaloniaProperty { get; } + IXamlField AvaloniaProperty { get; } } - class XamlIlAvaloniaProperty : XamlIlAstClrProperty, IXamlIlAvaloniaProperty + class XamlIlAvaloniaProperty : XamlAstClrProperty, IXamlIlAvaloniaProperty { - public IXamlIlField AvaloniaProperty { get; } - public XamlIlAvaloniaProperty(XamlIlAstClrProperty original, IXamlIlField field, + public IXamlField AvaloniaProperty { get; } + public XamlIlAvaloniaProperty(XamlAstClrProperty original, IXamlField field, AvaloniaXamlIlWellKnownTypes types) :base(original, original.Name, original.DeclaringType, original.Getter, original.Setters) { @@ -188,41 +193,41 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions Setters.Insert(0, new UnsetValueSetter(types, original.DeclaringType, field)); } - abstract class AvaloniaPropertyCustomSetter : IXamlIlPropertySetter + abstract class AvaloniaPropertyCustomSetter : IXamlPropertySetter, IXamlEmitablePropertySetter { protected AvaloniaXamlIlWellKnownTypes Types; - protected IXamlIlField AvaloniaProperty; + protected IXamlField AvaloniaProperty; public AvaloniaPropertyCustomSetter(AvaloniaXamlIlWellKnownTypes types, - IXamlIlType declaringType, - IXamlIlField avaloniaProperty) + IXamlType declaringType, + IXamlField avaloniaProperty) { Types = types; AvaloniaProperty = avaloniaProperty; TargetType = declaringType; } - public IXamlIlType TargetType { get; } + public IXamlType TargetType { get; } public PropertySetterBinderParameters BinderParameters { get; } = new PropertySetterBinderParameters { AllowXNull = false }; - public IReadOnlyList Parameters { get; set; } - public abstract void Emit(IXamlIlEmitter codegen); + public IReadOnlyList Parameters { get; set; } + public abstract void Emit(IXamlILEmitter codegen); } class BindingSetter : AvaloniaPropertyCustomSetter { public BindingSetter(AvaloniaXamlIlWellKnownTypes types, - IXamlIlType declaringType, - IXamlIlField avaloniaProperty) : base(types, declaringType, avaloniaProperty) + IXamlType declaringType, + IXamlField avaloniaProperty) : base(types, declaringType, avaloniaProperty) { Parameters = new[] {types.IBinding}; } - public override void Emit(IXamlIlEmitter emitter) + public override void Emit(IXamlILEmitter emitter) { using (var bloc = emitter.LocalsPool.GetLocal(Types.IBinding)) emitter @@ -237,13 +242,13 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions class UnsetValueSetter : AvaloniaPropertyCustomSetter { - public UnsetValueSetter(AvaloniaXamlIlWellKnownTypes types, IXamlIlType declaringType, IXamlIlField avaloniaProperty) + public UnsetValueSetter(AvaloniaXamlIlWellKnownTypes types, IXamlType declaringType, IXamlField avaloniaProperty) : base(types, declaringType, avaloniaProperty) { Parameters = new[] {types.UnsetValueType}; } - public override void Emit(IXamlIlEmitter codegen) + public override void Emit(IXamlILEmitter codegen) { var unsetValue = Types.AvaloniaProperty.Fields.First(f => f.Name == "UnsetValue"); codegen diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/XamlIlBindingPathHelper.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/XamlIlBindingPathHelper.cs index 5d8c3bea7e..1f527e9569 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/XamlIlBindingPathHelper.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/XamlIlBindingPathHelper.cs @@ -5,20 +5,24 @@ using System.Linq; using System.Reflection.Emit; using Avalonia.Markup.Parsers; using Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers; -using XamlIl.Ast; -using XamlIl.Transform; -using XamlIl.Transform.Transformers; -using XamlIl.TypeSystem; -using XamlIl; +using XamlX.Ast; +using XamlX.Transform; +using XamlX.Transform.Transformers; +using XamlX.TypeSystem; +using XamlX; +using XamlX.Emit; +using XamlX.IL; using Avalonia.Utilities; +using XamlIlEmitContext = XamlX.Emit.XamlEmitContext; + namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions { static class XamlIlBindingPathHelper { - public static IXamlIlType UpdateCompiledBindingExtension(XamlIlAstTransformationContext context, XamlIlAstObjectNode binding, IXamlIlType startType) + public static IXamlType UpdateCompiledBindingExtension(AstTransformationContext context, XamlAstConstructableObjectNode binding, IXamlType startType) { - IXamlIlType bindingResultType = null; + IXamlType bindingResultType = null; if (binding.Arguments.Count > 0 && binding.Arguments[0] is ParsedBindingPathNode bindingPath) { var transformed = TransformBindingPath( @@ -32,7 +36,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions } else { - var bindingPathAssignment = binding.Children.OfType() + var bindingPathAssignment = binding.Children.OfType() .FirstOrDefault(v => v.Property.Name == "Path"); if (bindingPathAssignment is null) @@ -60,7 +64,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions return bindingResultType; } - private static IXamlIlBindingPathNode TransformBindingPath(XamlIlAstTransformationContext context, IXamlIlLineInfo lineInfo, IXamlIlType startType, IEnumerable bindingExpression) + private static IXamlIlBindingPathNode TransformBindingPath(AstTransformationContext context, IXamlLineInfo lineInfo, IXamlType startType, IEnumerable bindingExpression) { List transformNodes = new List(); List nodes = new List(); @@ -75,7 +79,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions transformNodes.Add(new XamlIlNotPathElementNode(context.Configuration.WellKnownTypes.Boolean)); break; case BindingExpressionGrammar.StreamNode _: - IXamlIlType observableType; + IXamlType observableType; if (targetType.GenericTypeDefinition?.Equals(context.Configuration.TypeSystem.FindType("System.IObservable`1")) == true) { observableType = targetType; @@ -104,7 +108,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions { break; } - throw new XamlIlParseException($"Compiled bindings do not support stream bindings for objects of type {targetType.FullName}.", lineInfo); + throw new XamlX.XamlParseException($"Compiled bindings do not support stream bindings for objects of type {targetType.FullName}.", lineInfo); case BindingExpressionGrammar.PropertyNameNode propName: var avaloniaPropertyFieldNameMaybe = propName.PropertyName + "Property"; var avaloniaPropertyFieldMaybe = targetType.GetAllFields().FirstOrDefault(f => @@ -121,7 +125,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions if (clrProperty is null) { - throw new XamlIlParseException($"Unable to resolve property of name '{propName.PropertyName}' on type '{targetType}'.", lineInfo); + throw new XamlX.XamlParseException($"Unable to resolve property of name '{propName.PropertyName}' on type '{targetType}'.", lineInfo); } nodes.Add(new XamlIlClrPropertyPathElementNode(clrProperty)); } @@ -134,7 +138,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions break; } - IXamlIlProperty property = null; + IXamlProperty property = null; for (var currentType = targetType; currentType != null; currentType = currentType.BaseType) { var defaultMemberAttribute = currentType.CustomAttributes.FirstOrDefault(x => x.Type.Namespace == "System.Reflection" && x.Type.Name == "DefaultMemberAttribute"); @@ -146,19 +150,19 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions }; if (property is null) { - throw new XamlIlParseException($"The type '${targetType}' does not have an indexer.", lineInfo); + throw new XamlX.XamlParseException($"The type '${targetType}' does not have an indexer.", lineInfo); } - IEnumerable parameters = property.IndexerParameters; + IEnumerable parameters = property.IndexerParameters; - List values = new List(); + List values = new List(); int currentParamIndex = 0; foreach (var param in parameters) { - var textNode = new XamlIlAstTextNode(lineInfo, indexer.Arguments[currentParamIndex], type: context.Configuration.WellKnownTypes.String); - if (!XamlIlTransformHelpers.TryGetCorrectlyTypedValue(context, textNode, + var textNode = new XamlAstTextNode(lineInfo, indexer.Arguments[currentParamIndex], type: context.Configuration.WellKnownTypes.String); + if (!XamlTransformHelpers.TryGetCorrectlyTypedValue(context, textNode, param, out var converted)) - throw new XamlIlParseException( + throw new XamlX.XamlParseException( $"Unable to convert indexer parameter value of '{indexer.Arguments[currentParamIndex]}' to {param.GetFqn()}", textNode); @@ -197,14 +201,14 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions var styledElementType = context.GetAvaloniaTypes().StyledElement; var ancestorType = context .ParentNodes() - .OfType() + .OfType() .Where(x => styledElementType.IsAssignableFrom(x.Type.GetClrType())) .ElementAtOrDefault(ancestor.Level) ?.Type.GetClrType(); if (ancestorType is null) { - throw new XamlIlParseException("Unable to resolve implicit ancestor type based on XAML tree.", lineInfo); + throw new XamlX.XamlParseException("Unable to resolve implicit ancestor type based on XAML tree.", lineInfo); } nodes.Add(new FindAncestorPathElementNode(ancestorType, ancestor.Level)); @@ -215,7 +219,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions } break; case BindingExpressionGrammar.NameNode elementName: - IXamlIlType elementType = null; + IXamlType elementType = null; foreach (var deferredContent in context.ParentNodes().OfType()) { elementType = ScopeRegistrationFinder.GetTargetType(deferredContent, elementName.Name); @@ -231,7 +235,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions if (elementType is null) { - throw new XamlIlParseException($"Unable to find element '{elementName.Name}' in the current namescope. Unable to use a compiled binding with a name binding if the name cannot be found at compile time.", lineInfo); + throw new XamlX.XamlParseException($"Unable to find element '{elementName.Name}' in the current namescope. Unable to use a compiled binding with a name binding if the name cannot be found at compile time.", lineInfo); } nodes.Add(new ElementNamePathElementNode(elementName.Name, elementType)); break; @@ -243,17 +247,17 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions return new XamlIlBindingPathNode(lineInfo, context.GetAvaloniaTypes().CompiledBindingPath, transformNodes, nodes); - IXamlIlType GetType(string ns, string name) + IXamlType GetType(string ns, string name) { - return XamlIlTypeReferenceResolver.ResolveType(context, $"{ns}:{name}", false, + return TypeReferenceResolver.ResolveType(context, $"{ns}:{name}", false, lineInfo, true).GetClrType(); } } - class ScopeRegistrationFinder : IXamlIlAstVisitor + class ScopeRegistrationFinder : IXamlAstVisitor { - private Stack _stack = new Stack(); - private Stack _childScopesStack = new Stack(); + private Stack _stack = new Stack(); + private Stack _childScopesStack = new Stack(); private ScopeRegistrationFinder(string name) { @@ -262,16 +266,16 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions string Name { get; } - IXamlIlType TargetType { get; set; } + IXamlType TargetType { get; set; } - public static IXamlIlType GetTargetType(IXamlIlAstNode namescopeRoot, string name) + public static IXamlType GetTargetType(IXamlAstNode namescopeRoot, string name) { var finder = new ScopeRegistrationFinder(name); namescopeRoot.Visit(finder); return finder.TargetType; } - void IXamlIlAstVisitor.Pop() + void IXamlAstVisitor.Pop() { var node = _stack.Pop(); if (_childScopesStack.Count > 0 && node == _childScopesStack.Peek()) @@ -280,7 +284,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions } } - void IXamlIlAstVisitor.Push(IXamlIlAstNode node) + void IXamlAstVisitor.Push(IXamlAstNode node) { _stack.Push(node); if (node is NestedScopeMetadataNode) @@ -289,11 +293,11 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions } } - IXamlIlAstNode IXamlIlAstVisitor.Visit(IXamlIlAstNode node) + IXamlAstNode IXamlAstVisitor.Visit(IXamlAstNode node) { if (_childScopesStack.Count == 0 && node is AvaloniaNameScopeRegistrationXamlIlNode registration) { - if (registration.Name is XamlIlAstTextNode text && text.Text == Name) + if (registration.Name is XamlAstTextNode text && text.Text == Name) { TargetType = registration.TargetType; } @@ -304,21 +308,21 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions interface IXamlIlBindingPathElementNode { - IXamlIlType Type { get; } + IXamlType Type { get; } - void Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen); + void Emit(XamlIlEmitContext context, IXamlILEmitter codeGen); } class XamlIlNotPathElementNode : IXamlIlBindingPathElementNode { - public XamlIlNotPathElementNode(IXamlIlType boolType) + public XamlIlNotPathElementNode(IXamlType boolType) { Type = boolType; } - public IXamlIlType Type { get; } + public IXamlType Type { get; } - public void Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public void Emit(XamlIlEmitContext context, IXamlILEmitter codeGen) { codeGen.EmitCall(context.GetAvaloniaTypes().CompiledBindingPathBuilder.FindMethod(m => m.Name == "Not")); } @@ -326,14 +330,14 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions class XamlIlStreamObservablePathElementNode : IXamlIlBindingPathElementNode { - public XamlIlStreamObservablePathElementNode(IXamlIlType type) + public XamlIlStreamObservablePathElementNode(IXamlType type) { Type = type; } - public IXamlIlType Type { get; } + public IXamlType Type { get; } - public void Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public void Emit(XamlIlEmitContext context, IXamlILEmitter codeGen) { codeGen.EmitCall(context.GetAvaloniaTypes().CompiledBindingPathBuilder.FindMethod(m => m.Name == "StreamObservable").MakeGenericMethod(new[] { Type })); } @@ -341,14 +345,14 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions class XamlIlStreamTaskPathElementNode : IXamlIlBindingPathElementNode { - public XamlIlStreamTaskPathElementNode(IXamlIlType type) + public XamlIlStreamTaskPathElementNode(IXamlType type) { Type = type; } - public IXamlIlType Type { get; } + public IXamlType Type { get; } - public void Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public void Emit(XamlIlEmitContext context, IXamlILEmitter codeGen) { codeGen.EmitCall(context.GetAvaloniaTypes().CompiledBindingPathBuilder.FindMethod(m => m.Name == "StreamTask").MakeGenericMethod(new[] { Type })); } @@ -356,14 +360,14 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions class SelfPathElementNode : IXamlIlBindingPathElementNode { - public SelfPathElementNode(IXamlIlType type) + public SelfPathElementNode(IXamlType type) { Type = type; } - public IXamlIlType Type { get; } + public IXamlType Type { get; } - public void Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public void Emit(XamlIlEmitContext context, IXamlILEmitter codeGen) { codeGen.EmitCall(context.GetAvaloniaTypes().CompiledBindingPathBuilder.FindMethod(m => m.Name == "Self")); } @@ -373,15 +377,15 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions { private readonly int _level; - public FindAncestorPathElementNode(IXamlIlType ancestorType, int level) + public FindAncestorPathElementNode(IXamlType ancestorType, int level) { Type = ancestorType; _level = level; } - public IXamlIlType Type { get; } + public IXamlType Type { get; } - public void Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public void Emit(XamlIlEmitContext context, IXamlILEmitter codeGen) { codeGen.Ldtype(Type) .Ldc_I4(_level) @@ -393,15 +397,15 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions { private readonly int _level; - public FindVisualAncestorPathElementNode(IXamlIlType ancestorType, int level) + public FindVisualAncestorPathElementNode(IXamlType ancestorType, int level) { Type = ancestorType; _level = level; } - public IXamlIlType Type { get; } + public IXamlType Type { get; } - public void Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public void Emit(XamlIlEmitContext context, IXamlILEmitter codeGen) { codeGen.Ldtype(Type) .Ldc_I4(_level) @@ -413,15 +417,15 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions { private readonly string _name; - public ElementNamePathElementNode(string name, IXamlIlType elementType) + public ElementNamePathElementNode(string name, IXamlType elementType) { _name = name; Type = elementType; } - public IXamlIlType Type { get; } + public IXamlType Type { get; } - public void Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public void Emit(XamlIlEmitContext context, IXamlILEmitter codeGen) { var scopeField = context.RuntimeContext.ContextType.Fields.First(f => f.Name == AvaloniaXamlIlLanguage.ContextNameScopeFieldName); @@ -436,15 +440,15 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions class XamlIlAvaloniaPropertyPropertyPathElementNode : IXamlIlBindingPathElementNode { - private readonly IXamlIlField _field; + private readonly IXamlField _field; - public XamlIlAvaloniaPropertyPropertyPathElementNode(IXamlIlField field, IXamlIlType propertyType) + public XamlIlAvaloniaPropertyPropertyPathElementNode(IXamlField field, IXamlType propertyType) { _field = field; Type = propertyType; } - public void Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public void Emit(XamlIlEmitContext context, IXamlILEmitter codeGen) { codeGen.Ldsfld(_field); context.Configuration.GetExtra() @@ -453,19 +457,19 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions .CompiledBindingPathBuilder.FindMethod(m => m.Name == "Property")); } - public IXamlIlType Type { get; } + public IXamlType Type { get; } } class XamlIlClrPropertyPathElementNode : IXamlIlBindingPathElementNode { - private readonly IXamlIlProperty _property; + private readonly IXamlProperty _property; - public XamlIlClrPropertyPathElementNode(IXamlIlProperty property) + public XamlIlClrPropertyPathElementNode(IXamlProperty property) { _property = property; } - public void Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public void Emit(XamlIlEmitContext context, IXamlILEmitter codeGen) { context.Configuration.GetExtra() .Emit(context, codeGen, _property); @@ -478,17 +482,17 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions .CompiledBindingPathBuilder.FindMethod(m => m.Name == "Property")); } - public IXamlIlType Type => _property.Getter?.ReturnType ?? _property.Setter?.Parameters[0]; + public IXamlType Type => _property.Getter?.ReturnType ?? _property.Setter?.Parameters[0]; } class XamlIlClrIndexerPathElementNode : IXamlIlBindingPathElementNode { - private readonly IXamlIlProperty _property; - private readonly List _values; + private readonly IXamlProperty _property; + private readonly List _values; private readonly string _indexerKey; private readonly bool _isNotifyingCollection; - public XamlIlClrIndexerPathElementNode(IXamlIlProperty property, List values, string indexerKey, bool isNotifyingCollection) + public XamlIlClrIndexerPathElementNode(IXamlProperty property, List values, string indexerKey, bool isNotifyingCollection) { _property = property; _values = values; @@ -496,7 +500,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions _isNotifyingCollection = isNotifyingCollection; } - public void Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public void Emit(XamlIlEmitContext context, IXamlILEmitter codeGen) { var intType = context.Configuration.TypeSystem.GetType("System.Int32"); context.Configuration.GetExtra() @@ -520,15 +524,15 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions .CompiledBindingPathBuilder.FindMethod(m => m.Name == "Property")); } - public IXamlIlType Type => _property.Getter?.ReturnType ?? _property.Setter?.Parameters[0]; + public IXamlType Type => _property.Getter?.ReturnType ?? _property.Setter?.Parameters[0]; } class XamlIlArrayIndexerPathElementNode : IXamlIlBindingPathElementNode { - private readonly IXamlIlType _arrayType; + private readonly IXamlType _arrayType; private readonly List _values; - public XamlIlArrayIndexerPathElementNode(IXamlIlType arrayType, IList values, IXamlIlLineInfo lineInfo) + public XamlIlArrayIndexerPathElementNode(IXamlType arrayType, IList values, IXamlLineInfo lineInfo) { _arrayType = arrayType; _values = new List(values.Count); @@ -536,13 +540,13 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions { if (!int.TryParse(item, out var index)) { - throw new XamlIlParseException($"Unable to convert '{item}' to an integer.", lineInfo.Line, lineInfo.Position); + throw new XamlX.XamlParseException($"Unable to convert '{item}' to an integer.", lineInfo.Line, lineInfo.Position); } _values.Add(index); } } - public void Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public void Emit(XamlIlEmitContext context, IXamlILEmitter codeGen) { var intType = context.Configuration.TypeSystem.GetType("System.Int32"); var indices = codeGen.DefineLocal(intType.MakeArrayType(1)); @@ -563,23 +567,23 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions .CompiledBindingPathBuilder.FindMethod(m => m.Name == "ArrayElement")); } - public IXamlIlType Type => _arrayType.ArrayElementType; + public IXamlType Type => _arrayType.ArrayElementType; } - class RawSourcePathElementNode : XamlIlAstNode, IXamlIlBindingPathElementNode + class RawSourcePathElementNode : XamlAstNode, IXamlIlBindingPathElementNode { - private readonly IXamlIlAstValueNode _rawSource; + private readonly IXamlAstValueNode _rawSource; - public RawSourcePathElementNode(IXamlIlAstValueNode rawSource) + public RawSourcePathElementNode(IXamlAstValueNode rawSource) :base(rawSource) { _rawSource = rawSource; } - public IXamlIlType Type => _rawSource.Type.GetClrType(); + public IXamlType Type => _rawSource.Type.GetClrType(); - public void Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public void Emit(XamlIlEmitContext context, IXamlILEmitter codeGen) { context.Emit(_rawSource, codeGen, Type); codeGen @@ -588,29 +592,29 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions } } - class XamlIlBindingPathNode : XamlIlAstNode, IXamlIlBindingPathNode, IXamlIlAstEmitableNode + class XamlIlBindingPathNode : XamlAstNode, IXamlIlBindingPathNode, IXamlAstEmitableNode { private readonly List _transformElements; private readonly List _elements; - public XamlIlBindingPathNode(IXamlIlLineInfo lineInfo, - IXamlIlType bindingPathType, + public XamlIlBindingPathNode(IXamlLineInfo lineInfo, + IXamlType bindingPathType, List transformElements, List elements) : base(lineInfo) { - Type = new XamlIlAstClrTypeReference(lineInfo, bindingPathType, false); + Type = new XamlAstClrTypeReference(lineInfo, bindingPathType, false); _transformElements = transformElements; _elements = elements; } - public IXamlIlType BindingResultType + public IXamlType BindingResultType => _transformElements.Count > 0 ? _transformElements[0].Type : _elements[_elements.Count - 1].Type; - public IXamlIlAstTypeReference Type { get; } + public IXamlAstTypeReference Type { get; } - public XamlIlNodeEmitResult Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public XamlILNodeEmitResult Emit(XamlIlEmitContext context, IXamlILEmitter codeGen) { var types = context.GetAvaloniaTypes(); codeGen.Newobj(types.CompiledBindingPathBuilder.FindConstructor()); @@ -626,21 +630,21 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions } codeGen.EmitCall(types.CompiledBindingPathBuilder.FindMethod(m => m.Name == "Build")); - return XamlIlNodeEmitResult.Type(0, types.CompiledBindingPath); + return XamlILNodeEmitResult.Type(0, types.CompiledBindingPath); } - public override void VisitChildren(IXamlIlAstVisitor visitor) + public override void VisitChildren(IXamlAstVisitor visitor) { for (int i = 0; i < _transformElements.Count; i++) { - if (_transformElements[i] is IXamlIlAstNode ast) + if (_transformElements[i] is IXamlAstNode ast) { _transformElements[i] = (IXamlIlBindingPathElementNode)ast.Visit(visitor); } } for (int i = 0; i < _elements.Count; i++) { - if (_elements[i] is IXamlIlAstNode ast) + if (_elements[i] is IXamlAstNode ast) { _elements[i] = (IXamlIlBindingPathElementNode)ast.Visit(visitor); } @@ -649,8 +653,8 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions } } - interface IXamlIlBindingPathNode : IXamlIlAstValueNode + interface IXamlIlBindingPathNode : IXamlAstValueNode { - IXamlIlType BindingResultType { get; } + IXamlType BindingResultType { get; } } } diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/XamlIlClrPropertyInfoHelper.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/XamlIlClrPropertyInfoHelper.cs index d2608df9e9..871a2a2045 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/XamlIlClrPropertyInfoHelper.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/XamlIlClrPropertyInfoHelper.cs @@ -2,25 +2,27 @@ using System; using System.Collections.Generic; using System.Linq; using Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers; -using XamlIl.Ast; -using XamlIl.Transform; -using XamlIl.TypeSystem; +using XamlX.Ast; +using XamlX.Transform; +using XamlX.TypeSystem; +using XamlX.IL; +using XamlX.Emit; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions { class XamlIlClrPropertyInfoEmitter { - private readonly IXamlIlTypeBuilder _builder; + private readonly IXamlTypeBuilder _builder; - private Dictionary> _fields - = new Dictionary>(); + private Dictionary> _fields + = new Dictionary>(); - public XamlIlClrPropertyInfoEmitter(IXamlIlTypeBuilder builder) + public XamlIlClrPropertyInfoEmitter(IXamlTypeBuilder builder) { _builder = builder; } - static string GetKey(IXamlIlProperty property, string indexerArgumentsKey) + static string GetKey(IXamlProperty property, string indexerArgumentsKey) { var baseKey = property.Getter.DeclaringType.GetFullName() + "." + property.Name; @@ -32,15 +34,15 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions return baseKey + $"[{indexerArgumentsKey}]"; } - public IXamlIlType Emit(XamlIlEmitContext context, IXamlIlEmitter codeGen, IXamlIlProperty property, IEnumerable indexerArguments = null, string indexerArgumentsKey = null) + public IXamlType Emit(XamlEmitContext context, IXamlILEmitter codeGen, IXamlProperty property, IEnumerable indexerArguments = null, string indexerArgumentsKey = null) { - indexerArguments = indexerArguments ?? Enumerable.Empty(); + indexerArguments = indexerArguments ?? Enumerable.Empty(); var types = context.GetAvaloniaTypes(); - IXamlIlMethod Get() + IXamlMethod Get() { var key = GetKey(property, indexerArgumentsKey); if (!_fields.TryGetValue(key, out var lst)) - _fields[key] = lst = new List<(IXamlIlProperty prop, IXamlIlMethod get)>(); + _fields[key] = lst = new List<(IXamlProperty prop, IXamlMethod get)>(); foreach (var cached in lst) { @@ -57,7 +59,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions var field = _builder.DefineField(types.IPropertyInfo, name + "!Field", false, true); - void Load(IXamlIlMethod m, IXamlIlEmitter cg) + void Load(IXamlMethod m, IXamlILEmitter cg) { cg .Ldarg_0(); @@ -105,7 +107,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions .Ret(); } - var get = _builder.DefineMethod(types.IPropertyInfo, Array.Empty(), + var get = _builder.DefineMethod(types.IPropertyInfo, Array.Empty(), name + "!Property", true, true, false); @@ -121,7 +123,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions .MarkLabel(cacheMiss) .Ldstr(property.Name); - void EmitFunc(IXamlIlEmitter emitter, IXamlIlMethod method, IXamlIlType del) + void EmitFunc(IXamlILEmitter emitter, IXamlMethod method, IXamlType del) { if (method == null) emitter.Ldnull(); diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/XamlIlPropertyInfoAccessorFactoryEmitter.cs b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/XamlIlPropertyInfoAccessorFactoryEmitter.cs index 42910581ff..d24a43a84f 100644 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/XamlIlPropertyInfoAccessorFactoryEmitter.cs +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/CompilerExtensions/XamlIlPropertyInfoAccessorFactoryEmitter.cs @@ -3,37 +3,41 @@ using System.Collections.Generic; using System.Linq; using System.Text; using Avalonia.Markup.Xaml.XamlIl.CompilerExtensions.Transformers; -using XamlIl.Ast; -using XamlIl.Transform; -using XamlIl.TypeSystem; +using XamlX.Ast; +using XamlX.Transform; +using XamlX.TypeSystem; +using XamlX.Emit; +using XamlX.IL; + +using XamlIlEmitContext = XamlX.Emit.XamlEmitContext; namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions { class XamlIlPropertyInfoAccessorFactoryEmitter { private const string IndexerClosureFactoryMethodName = "CreateAccessor"; - private readonly IXamlIlTypeBuilder _indexerClosureTypeBuilder; - private IXamlIlType _indexerClosureType; - public XamlIlPropertyInfoAccessorFactoryEmitter(IXamlIlTypeBuilder indexerClosureType) + private readonly IXamlTypeBuilder _indexerClosureTypeBuilder; + private IXamlType _indexerClosureType; + public XamlIlPropertyInfoAccessorFactoryEmitter(IXamlTypeBuilder indexerClosureType) { _indexerClosureTypeBuilder = indexerClosureType; } - public IXamlIlType EmitLoadInpcPropertyAccessorFactory(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public IXamlType EmitLoadInpcPropertyAccessorFactory(XamlIlEmitContext context, IXamlILEmitter codeGen) { codeGen.Ldnull(); EmitLoadPropertyAccessorFactory(context, codeGen, context.GetAvaloniaTypes().PropertyInfoAccessorFactory, "CreateInpcPropertyAccessor"); return EmitCreateAccessorFactoryDelegate(context, codeGen); } - public IXamlIlType EmitLoadAvaloniaPropertyAccessorFactory(XamlIlEmitContext context, IXamlIlEmitter codeGen) + public IXamlType EmitLoadAvaloniaPropertyAccessorFactory(XamlIlEmitContext context, IXamlILEmitter codeGen) { codeGen.Ldnull(); EmitLoadPropertyAccessorFactory(context, codeGen, context.GetAvaloniaTypes().PropertyInfoAccessorFactory, "CreateAvaloniaPropertyAccessor"); return EmitCreateAccessorFactoryDelegate(context, codeGen); } - private void EmitLoadPropertyAccessorFactory(XamlIlEmitContext context, IXamlIlEmitter codeGen, IXamlIlType type, string accessorFactoryName, bool isStatic = true) + private void EmitLoadPropertyAccessorFactory(XamlIlEmitContext context, IXamlILEmitter codeGen, IXamlType type, string accessorFactoryName, bool isStatic = true) { var types = context.GetAvaloniaTypes(); var weakReferenceType = context.Configuration.TypeSystem.GetType("System.WeakReference`1").MakeGenericType(context.Configuration.WellKnownTypes.Object); @@ -44,7 +48,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions codeGen.Ldftn(type.GetMethod(accessorFactorySignature)); } - public IXamlIlType EmitLoadIndexerAccessorFactory(XamlIlEmitContext context, IXamlIlEmitter codeGen, IXamlIlAstValueNode value) + public IXamlType EmitLoadIndexerAccessorFactory(XamlIlEmitContext context, IXamlILEmitter codeGen, IXamlAstValueNode value) { var intType = context.Configuration.TypeSystem.GetType("System.Int32"); if (_indexerClosureType is null) @@ -53,12 +57,12 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions } context.Emit(value, codeGen, intType); - codeGen.Newobj(_indexerClosureType.FindConstructor(new List { intType })); + codeGen.Newobj(_indexerClosureType.FindConstructor(new List { intType })); EmitLoadPropertyAccessorFactory(context, codeGen, _indexerClosureType, IndexerClosureFactoryMethodName, isStatic: false); return EmitCreateAccessorFactoryDelegate(context, codeGen); } - private IXamlIlType InitializeClosureType(XamlIlEmitContext context) + private IXamlType InitializeClosureType(XamlIlEmitContext context) { var types = context.GetAvaloniaTypes(); var intType = context.Configuration.TypeSystem.GetType("System.Int32"); @@ -97,7 +101,7 @@ namespace Avalonia.Markup.Xaml.XamlIl.CompilerExtensions return _indexerClosureTypeBuilder.CreateType(); } - private IXamlIlType EmitCreateAccessorFactoryDelegate(XamlIlEmitContext context, IXamlIlEmitter codeGen) + private IXamlType EmitCreateAccessorFactoryDelegate(XamlIlEmitContext context, IXamlILEmitter codeGen) { var types = context.GetAvaloniaTypes(); var weakReferenceType = context.Configuration.TypeSystem.GetType("System.WeakReference`1").MakeGenericType(context.Configuration.WellKnownTypes.Object); diff --git a/src/Markup/Avalonia.Markup.Xaml/XamlIl/xamlil.github b/src/Markup/Avalonia.Markup.Xaml/XamlIl/xamlil.github index 0681622454..0028377ce7 160000 --- a/src/Markup/Avalonia.Markup.Xaml/XamlIl/xamlil.github +++ b/src/Markup/Avalonia.Markup.Xaml/XamlIl/xamlil.github @@ -1 +1 @@ -Subproject commit 068162245473ec39ee36da12150e928072b96403 +Subproject commit 0028377ce7c7dc21f9fe71b45f62a95991b1ab58 diff --git a/src/Skia/Avalonia.Skia/FormattedTextImpl.cs b/src/Skia/Avalonia.Skia/FormattedTextImpl.cs index 5f876464e2..ade659f5eb 100644 --- a/src/Skia/Avalonia.Skia/FormattedTextImpl.cs +++ b/src/Skia/Avalonia.Skia/FormattedTextImpl.cs @@ -569,7 +569,7 @@ namespace Avalonia.Skia float constraint = -1; - if (_wrapping == TextWrapping.Wrap) + if (_wrapping != TextWrapping.NoWrap) { constraint = widthConstraint <= 0 ? MAX_LINE_WIDTH : widthConstraint; if (constraint > MAX_LINE_WIDTH) diff --git a/src/Skia/Avalonia.Skia/TextShaperImpl.cs b/src/Skia/Avalonia.Skia/TextShaperImpl.cs index 7a0823a223..786af7726c 100644 --- a/src/Skia/Avalonia.Skia/TextShaperImpl.cs +++ b/src/Skia/Avalonia.Skia/TextShaperImpl.cs @@ -1,9 +1,9 @@ using System; +using System.Globalization; using Avalonia.Media; -using Avalonia.Media.TextFormatting; using Avalonia.Media.TextFormatting.Unicode; using Avalonia.Platform; -using Avalonia.Utility; +using Avalonia.Utilities; using HarfBuzzSharp; using Buffer = HarfBuzzSharp.Buffer; @@ -11,7 +11,7 @@ namespace Avalonia.Skia { internal class TextShaperImpl : ITextShaperImpl { - public GlyphRun ShapeText(ReadOnlySlice text, TextFormat textFormat) + public GlyphRun ShapeText(ReadOnlySlice text, Typeface typeface, double fontRenderingEmSize, CultureInfo culture) { using (var buffer = new Buffer()) { @@ -61,9 +61,11 @@ namespace Avalonia.Skia buffer.AddUtf16(text.Buffer.Span); } + buffer.Language = new Language(culture ?? CultureInfo.CurrentCulture); + buffer.GuessSegmentProperties(); - var glyphTypeface = textFormat.Typeface.GlyphTypeface; + var glyphTypeface = typeface.GlyphTypeface; var font = ((GlyphTypefaceImpl)glyphTypeface.PlatformImpl).Font; @@ -71,7 +73,7 @@ namespace Avalonia.Skia font.GetScale(out var scaleX, out _); - var textScale = textFormat.FontRenderingEmSize / scaleX; + var textScale = fontRenderingEmSize / scaleX; var bufferLength = buffer.Length; @@ -101,7 +103,7 @@ namespace Avalonia.Skia SetOffset(glyphPositions, i, textScale, ref glyphOffsets); } - return new GlyphRun(glyphTypeface, textFormat.FontRenderingEmSize, + return new GlyphRun(glyphTypeface, fontRenderingEmSize, new ReadOnlySlice(glyphIndices), new ReadOnlySlice(glyphAdvances), new ReadOnlySlice(glyphOffsets), diff --git a/src/Windows/Avalonia.Direct2D1/Media/TextShaperImpl.cs b/src/Windows/Avalonia.Direct2D1/Media/TextShaperImpl.cs index 2d2865e2b9..254b5684a4 100644 --- a/src/Windows/Avalonia.Direct2D1/Media/TextShaperImpl.cs +++ b/src/Windows/Avalonia.Direct2D1/Media/TextShaperImpl.cs @@ -1,8 +1,9 @@ -using Avalonia.Media; +using System.Globalization; +using Avalonia.Media; using Avalonia.Media.TextFormatting; using Avalonia.Media.TextFormatting.Unicode; using Avalonia.Platform; -using Avalonia.Utility; +using Avalonia.Utilities; using HarfBuzzSharp; using Buffer = HarfBuzzSharp.Buffer; @@ -10,7 +11,7 @@ namespace Avalonia.Direct2D1.Media { internal class TextShaperImpl : ITextShaperImpl { - public GlyphRun ShapeText(ReadOnlySlice text, TextFormat textFormat) + public GlyphRun ShapeText(ReadOnlySlice text, Typeface typeface, double fontRenderingEmSize, CultureInfo culture) { using (var buffer = new Buffer()) { @@ -62,15 +63,17 @@ namespace Avalonia.Direct2D1.Media buffer.GuessSegmentProperties(); - var glyphTypeface = textFormat.Typeface.GlyphTypeface; + var glyphTypeface = typeface.GlyphTypeface; var font = ((GlyphTypefaceImpl)glyphTypeface.PlatformImpl).Font; + buffer.Language = new Language(culture ?? CultureInfo.CurrentCulture); + font.Shape(buffer); font.GetScale(out var scaleX, out _); - var textScale = textFormat.FontRenderingEmSize / scaleX; + var textScale = fontRenderingEmSize / scaleX; var len = buffer.Length; @@ -104,7 +107,7 @@ namespace Avalonia.Direct2D1.Media glyphOffsets[i] = new Vector(offsetX, offsetY); } - return new GlyphRun(glyphTypeface, textFormat.FontRenderingEmSize, + return new GlyphRun(glyphTypeface, fontRenderingEmSize, new ReadOnlySlice(glyphIndices), new ReadOnlySlice(glyphAdvances), new ReadOnlySlice(glyphOffsets), diff --git a/tests/Avalonia.Direct2D1.UnitTests/Media/FontManagerImplTests.cs b/tests/Avalonia.Direct2D1.UnitTests/Media/FontManagerImplTests.cs index 572749a58a..c6ecc0a7e5 100644 --- a/tests/Avalonia.Direct2D1.UnitTests/Media/FontManagerImplTests.cs +++ b/tests/Avalonia.Direct2D1.UnitTests/Media/FontManagerImplTests.cs @@ -41,7 +41,7 @@ namespace Avalonia.Direct2D1.UnitTests.Media var fontManager = new FontManagerImpl(); var glyphTypeface = (GlyphTypefaceImpl)fontManager.CreateGlyphTypeface( - new Typeface(new FontFamily("A, B, Arial"), FontWeight.Bold)); + new Typeface(new FontFamily("A, B, Arial"), weight: FontWeight.Bold)); var font = glyphTypeface.DWFont; @@ -105,7 +105,7 @@ namespace Avalonia.Direct2D1.UnitTests.Media var fontManager = new FontManagerImpl(); var glyphTypeface = (GlyphTypefaceImpl)fontManager.CreateGlyphTypeface( - new Typeface(s_fontUri, FontWeight.Black, FontStyle.Italic)); + new Typeface(s_fontUri, FontStyle.Italic, FontWeight.Black)); var font = glyphTypeface.DWFont; diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/MarkupExtensions/CompiledBindingExtensionTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/MarkupExtensions/CompiledBindingExtensionTests.cs index 0062093f4c..37aa123cfc 100644 --- a/tests/Avalonia.Markup.Xaml.UnitTests/MarkupExtensions/CompiledBindingExtensionTests.cs +++ b/tests/Avalonia.Markup.Xaml.UnitTests/MarkupExtensions/CompiledBindingExtensionTests.cs @@ -9,7 +9,7 @@ using Avalonia.Controls.Presenters; using Avalonia.Data.Core; using Avalonia.Markup.Data; using Avalonia.UnitTests; -using XamlIl; +using XamlX; using Xunit; namespace Avalonia.Markup.Xaml.UnitTests.MarkupExtensions @@ -328,7 +328,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.MarkupExtensions "; var loader = new AvaloniaXamlLoader(); - Assert.Throws(() => loader.Load(xaml)); + Assert.Throws(() => loader.Load(xaml)); } } @@ -347,7 +347,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.MarkupExtensions "; var loader = new AvaloniaXamlLoader(); - Assert.Throws(() => loader.Load(xaml)); + Assert.Throws(() => loader.Load(xaml)); } } @@ -406,7 +406,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.MarkupExtensions "; var loader = new AvaloniaXamlLoader(); - Assert.Throws(() => loader.Load(xaml)); + Assert.Throws(() => loader.Load(xaml)); } } @@ -562,7 +562,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.MarkupExtensions "; var loader = new AvaloniaXamlLoader(); - Assert.Throws(() => loader.Load(xaml)); + Assert.Throws(() => loader.Load(xaml)); } } @@ -579,7 +579,7 @@ namespace Avalonia.Markup.Xaml.UnitTests.MarkupExtensions x:CompileBindings='notabool'> "; var loader = new AvaloniaXamlLoader(); - Assert.Throws(() => loader.Load(xaml)); + Assert.Throws(() => loader.Load(xaml)); } } } diff --git a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/XamlIlTests.cs b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/XamlIlTests.cs index 727c09b2b7..ddeb558754 100644 --- a/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/XamlIlTests.cs +++ b/tests/Avalonia.Markup.Xaml.UnitTests/Xaml/XamlIlTests.cs @@ -249,51 +249,6 @@ namespace Avalonia.Markup.Xaml.UnitTests Assert.Equal(6, parsed.Count); } - [Fact] - public void Should_Provide_PropertyPath_For_Setters() - { - using (UnitTestApplication.Start(TestServices.StyledWindow)) - { - var parsed = AvaloniaXamlLoader.Parse"); - var s1e = ((Setter)parsed.Setters[0]).PropertyPath.Elements; - var s2e = ((Setter)parsed.Setters[1]).PropertyPath.Elements; - var s3e = ((Setter)parsed.Setters[2]).PropertyPath.Elements; - - Assert.Equal(typeof(Visual), ((CastTypePropertyPathElement)s1e[0]).Type); - Assert.IsType(s1e[1]); - Assert.Equal("Bounds", ((AvaloniaProperty)((PropertyPropertyPathElement)s1e[2]).Property).Name); - Assert.IsType(s1e[3]); - var bottomRight = ((PropertyPropertyPathElement)s1e[4]).Property; - Assert.IsType(s1e[5]); - var pointX = ((PropertyPropertyPathElement)s1e[6]).Property; - - var orect = (object)(new Rect(100, 100, 200, 200)); - var point = bottomRight.Get(orect); - var x = pointX.Get(point); - Assert.Equal(300, (double)x); - - Assert.Equal(typeof(Visual), ((CastTypePropertyPathElement)s2e[0]).Type); - Assert.IsType(s2e[1]); - Assert.Equal("RenderTransform", ((AvaloniaProperty)((PropertyPropertyPathElement)s2e[2]).Property).Name); - Assert.Equal(typeof(ScaleTransform), ((EnsureTypePropertyPathElement)s2e[3]).Type); - Assert.IsType(s2e[4]); - Assert.Equal("ScaleX", ((AvaloniaProperty)((PropertyPropertyPathElement)s2e[5]).Property).Name); - - - var s3fqp = (AvaloniaProperty)((PropertyPropertyPathElement)s3e[0]).Property; - Assert.Equal("RenderTransform", s3fqp.Name); - Assert.Equal(typeof(Visual), s3fqp.OwnerType); - Assert.Equal(typeof(ScaleTransform), ((EnsureTypePropertyPathElement)s3e[1]).Type); - Assert.IsType(s3e[2]); - Assert.Equal("ScaleX", ((AvaloniaProperty)((PropertyPropertyPathElement)s3e[3]).Property).Name); - } - } - [Fact] public void DataContextType_Resolution() { diff --git a/tests/Avalonia.Skia.UnitTests/CustomFontManagerImpl.cs b/tests/Avalonia.Skia.UnitTests/Media/CustomFontManagerImpl.cs similarity index 98% rename from tests/Avalonia.Skia.UnitTests/CustomFontManagerImpl.cs rename to tests/Avalonia.Skia.UnitTests/Media/CustomFontManagerImpl.cs index 8d64190ebd..feed1179ef 100644 --- a/tests/Avalonia.Skia.UnitTests/CustomFontManagerImpl.cs +++ b/tests/Avalonia.Skia.UnitTests/Media/CustomFontManagerImpl.cs @@ -6,7 +6,7 @@ using Avalonia.Media.Fonts; using Avalonia.Platform; using SkiaSharp; -namespace Avalonia.Skia.UnitTests +namespace Avalonia.Skia.UnitTests.Media { public class CustomFontManagerImpl : IFontManagerImpl { diff --git a/tests/Avalonia.Skia.UnitTests/FontManagerImplTests.cs b/tests/Avalonia.Skia.UnitTests/Media/FontManagerImplTests.cs similarity index 95% rename from tests/Avalonia.Skia.UnitTests/FontManagerImplTests.cs rename to tests/Avalonia.Skia.UnitTests/Media/FontManagerImplTests.cs index 8f80d89ac6..df286d709e 100644 --- a/tests/Avalonia.Skia.UnitTests/FontManagerImplTests.cs +++ b/tests/Avalonia.Skia.UnitTests/Media/FontManagerImplTests.cs @@ -1,13 +1,11 @@ using System; using System.Linq; -using System.Reflection; using Avalonia.Media; -using Avalonia.Platform; using Avalonia.UnitTests; using SkiaSharp; using Xunit; -namespace Avalonia.Skia.UnitTests +namespace Avalonia.Skia.UnitTests.Media { public class FontManagerImplTests { @@ -39,7 +37,7 @@ namespace Avalonia.Skia.UnitTests string fontName = fontManager.GetInstalledFontFamilyNames().First(); var glyphTypeface = (GlyphTypefaceImpl)fontManager.CreateGlyphTypeface( - new Typeface(new FontFamily($"A, B, {fontName}"), FontWeight.Bold)); + new Typeface(new FontFamily($"A, B, {fontName}"), weight: FontWeight.Bold)); var skTypeface = glyphTypeface.Typeface; @@ -88,7 +86,7 @@ namespace Avalonia.Skia.UnitTests var fontManager = new FontManagerImpl(); var glyphTypeface = (GlyphTypefaceImpl)fontManager.CreateGlyphTypeface( - new Typeface(s_fontUri, FontWeight.Black, FontStyle.Italic)); + new Typeface(s_fontUri, FontStyle.Italic, FontWeight.Black)); var skTypeface = glyphTypeface.Typeface; diff --git a/tests/Avalonia.Skia.UnitTests/SKTypefaceCollectionCacheTests.cs b/tests/Avalonia.Skia.UnitTests/Media/SKTypefaceCollectionCacheTests.cs similarity index 89% rename from tests/Avalonia.Skia.UnitTests/SKTypefaceCollectionCacheTests.cs rename to tests/Avalonia.Skia.UnitTests/Media/SKTypefaceCollectionCacheTests.cs index 726052351b..f9f924e782 100644 --- a/tests/Avalonia.Skia.UnitTests/SKTypefaceCollectionCacheTests.cs +++ b/tests/Avalonia.Skia.UnitTests/Media/SKTypefaceCollectionCacheTests.cs @@ -2,7 +2,7 @@ using Avalonia.UnitTests; using Xunit; -namespace Avalonia.Skia.UnitTests +namespace Avalonia.Skia.UnitTests.Media { public class SKTypefaceCollectionCacheTests { @@ -19,7 +19,7 @@ namespace Avalonia.Skia.UnitTests var notoMonoCollection = SKTypefaceCollectionCache.GetOrAddTypefaceCollection(notoMono); - var typeface = new Typeface("ABC", FontWeight.Bold, FontStyle.Italic); + var typeface = new Typeface("ABC", FontStyle.Italic, FontWeight.Bold); Assert.Equal("Noto Mono", notoMonoCollection.Get(typeface).FamilyName); diff --git a/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/FormattableTextSource.cs b/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/FormattableTextSource.cs new file mode 100644 index 0000000000..6a5065939e --- /dev/null +++ b/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/FormattableTextSource.cs @@ -0,0 +1,38 @@ +using System; +using Avalonia.Media.TextFormatting; +using Avalonia.Utilities; + +namespace Avalonia.Skia.UnitTests.Media.TextFormatting +{ + internal class FormattableTextSource : ITextSource + { + private readonly ReadOnlySlice _text; + private readonly TextRunProperties _defaultStyle; + private ReadOnlySlice> _styleSpans; + + public FormattableTextSource(string text, TextRunProperties defaultStyle, + ReadOnlySlice> styleSpans) + { + _text = text.AsMemory(); + + _defaultStyle = defaultStyle; + + _styleSpans = styleSpans; + } + + public TextRun GetTextRun(int textSourceIndex) + { + if (_styleSpans.IsEmpty) + { + return new TextEndOfParagraph(); + } + + var currentSpan = _styleSpans[0]; + + _styleSpans = _styleSpans.Skip(1); + + return new TextCharacters(_text.AsSlice(currentSpan.Start, currentSpan.Length), + _defaultStyle); + } + } +} diff --git a/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/MultiBufferTextSource.cs b/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/MultiBufferTextSource.cs new file mode 100644 index 0000000000..40aa862906 --- /dev/null +++ b/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/MultiBufferTextSource.cs @@ -0,0 +1,36 @@ +using System; +using Avalonia.Media.TextFormatting; +using Avalonia.Utilities; + +namespace Avalonia.Skia.UnitTests.Media.TextFormatting +{ + internal class MultiBufferTextSource : ITextSource + { + private readonly string[] _runTexts; + private readonly GenericTextRunProperties _defaultStyle; + + public MultiBufferTextSource(GenericTextRunProperties defaultStyle) + { + _defaultStyle = defaultStyle; + + _runTexts = new[] { "A123456789", "B123456789", "C123456789", "D123456789", "E123456789" }; + } + + public static TextRange TextRange => new TextRange(0, 50); + + public TextRun GetTextRun(int textSourceIndex) + { + if (textSourceIndex == 50) + { + return new TextEndOfParagraph(); + } + + var index = textSourceIndex / 10; + + var runText = _runTexts[index]; + + return new TextCharacters( + new ReadOnlySlice(runText.AsMemory(), textSourceIndex, runText.Length), _defaultStyle); + } + } +} diff --git a/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/SingleBufferTextSource.cs b/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/SingleBufferTextSource.cs new file mode 100644 index 0000000000..045deacd0b --- /dev/null +++ b/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/SingleBufferTextSource.cs @@ -0,0 +1,30 @@ +using System; +using Avalonia.Media.TextFormatting; +using Avalonia.Utilities; + +namespace Avalonia.Skia.UnitTests.Media.TextFormatting +{ + internal class SingleBufferTextSource : ITextSource + { + private readonly ReadOnlySlice _text; + private readonly GenericTextRunProperties _defaultGenericPropertiesRunProperties; + + public SingleBufferTextSource(string text, GenericTextRunProperties defaultProperties) + { + _text = text.AsMemory(); + _defaultGenericPropertiesRunProperties = defaultProperties; + } + + public TextRun GetTextRun(int textSourceIndex) + { + var runText = _text.Skip(textSourceIndex); + + if (runText.IsEmpty) + { + return new TextEndOfParagraph(); + } + + return new TextCharacters(runText, _defaultGenericPropertiesRunProperties); + } + } +} diff --git a/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/TextFormatterTests.cs b/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/TextFormatterTests.cs new file mode 100644 index 0000000000..697cc4fec7 --- /dev/null +++ b/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/TextFormatterTests.cs @@ -0,0 +1,275 @@ +using System; +using System.Collections.Generic; +using Avalonia.Media; +using Avalonia.Media.TextFormatting; +using Avalonia.Media.TextFormatting.Unicode; +using Avalonia.UnitTests; +using Avalonia.Utilities; +using Xunit; + +namespace Avalonia.Skia.UnitTests.Media.TextFormatting +{ + public class TextFormatterTests + { + [Fact] + public void Should_Format_TextRuns_With_Default_Style() + { + using (Start()) + { + const string text = "0123456789"; + + var defaultProperties = + new GenericTextRunProperties(Typeface.Default, 12, foregroundBrush: Brushes.Black); + + var textSource = new SingleBufferTextSource(text, defaultProperties); + + var formatter = new TextFormatterImpl(); + + var textLine = formatter.FormatLine(textSource, 0, double.PositiveInfinity, + new GenericTextParagraphProperties(defaultProperties)); + + Assert.Single(textLine.TextRuns); + + var textRun = textLine.TextRuns[0]; + + Assert.Equal(defaultProperties.Typeface, textRun.Properties.Typeface); + + Assert.Equal(defaultProperties.ForegroundBrush, textRun.Properties.ForegroundBrush); + + Assert.Equal(text.Length, textRun.Text.Length); + } + } + + [Fact] + public void Should_Format_TextRuns_With_Multiple_Buffers() + { + using (Start()) + { + var defaultProperties = + new GenericTextRunProperties(Typeface.Default, 12, foregroundBrush: Brushes.Black); + + var textSource = new MultiBufferTextSource(defaultProperties); + + var formatter = new TextFormatterImpl(); + + var textLine = formatter.FormatLine(textSource, 0, double.PositiveInfinity, + new GenericTextParagraphProperties(defaultProperties)); + + Assert.Equal(5, textLine.TextRuns.Count); + + Assert.Equal(50, textLine.TextRange.Length); + } + } + + [Fact] + public void Should_Format_TextRuns_With_TextRunStyles() + { + using (Start()) + { + const string text = "0123456789"; + + var defaultProperties = + new GenericTextRunProperties(Typeface.Default, 12, foregroundBrush: Brushes.Black); + + var GenericTextRunPropertiesRuns = new[] + { + new ValueSpan(0, 3, defaultProperties), + new ValueSpan(3, 3, + new GenericTextRunProperties(Typeface.Default, 13, foregroundBrush: Brushes.Black)), + new ValueSpan(6, 3, + new GenericTextRunProperties(Typeface.Default, 14, foregroundBrush: Brushes.Black)), + new ValueSpan(9, 1, defaultProperties) + }; + + var textSource = new FormattableTextSource(text, defaultProperties, GenericTextRunPropertiesRuns); + + var formatter = new TextFormatterImpl(); + + var textLine = formatter.FormatLine(textSource, 0, double.PositiveInfinity, + new GenericTextParagraphProperties(defaultProperties)); + + Assert.Equal(text.Length, textLine.TextRange.Length); + + for (var i = 0; i < GenericTextRunPropertiesRuns.Length; i++) + { + var GenericTextRunPropertiesRun = GenericTextRunPropertiesRuns[i]; + + var textRun = textLine.TextRuns[i]; + + Assert.Equal(GenericTextRunPropertiesRun.Length, textRun.Text.Length); + } + } + } + + [Theory] + [InlineData("0123", 1)] + [InlineData("\r\n", 1)] + [InlineData("👍b", 2)] + [InlineData("a👍b", 3)] + [InlineData("a👍子b", 4)] + public void Should_Produce_Unique_Runs(string text, int numberOfRuns) + { + using (Start()) + { + var defaultProperties = new GenericTextRunProperties(Typeface.Default); + + var textSource = new SingleBufferTextSource(text, defaultProperties); + + var formatter = new TextFormatterImpl(); + + var textLine = + formatter.FormatLine(textSource, 0, double.PositiveInfinity, + new GenericTextParagraphProperties(defaultProperties)); + + Assert.Equal(numberOfRuns, textLine.TextRuns.Count); + } + } + + [Fact] + public void Should_Split_Run_On_Script() + { + using (Start()) + { + const string text = "1234الدولي"; + + var defaultProperties = new GenericTextRunProperties(Typeface.Default); + + var textSource = new SingleBufferTextSource(text, defaultProperties); + + var formatter = new TextFormatterImpl(); + + var textLine = + formatter.FormatLine(textSource, 0, double.PositiveInfinity, + new GenericTextParagraphProperties(defaultProperties)); + + Assert.Equal(4, textLine.TextRuns[0].Text.Length); + } + } + + [InlineData("𐐷𐐷𐐷𐐷𐐷", 10, 1)] + [InlineData("01234 56789 01234 56789", 6, 4)] + [Theory] + public void Should_Wrap_With_Overflow(string text, int expectedCharactersPerLine, int expectedNumberOfLines) + { + using (Start()) + { + var defaultProperties = new GenericTextRunProperties(Typeface.Default); + + var textSource = new SingleBufferTextSource(text, defaultProperties); + + var formatter = new TextFormatterImpl(); + + var numberOfLines = 0; + + var currentPosition = 0; + + while (currentPosition < text.Length) + { + var textLine = + formatter.FormatLine(textSource, currentPosition, 1, + new GenericTextParagraphProperties(defaultProperties, textWrapping: TextWrapping.WrapWithOverflow)); + + if (text.Length - currentPosition > expectedCharactersPerLine) + { + Assert.Equal(expectedCharactersPerLine, textLine.TextRange.Length); + } + + currentPosition += textLine.TextRange.Length; + + numberOfLines++; + } + + Assert.Equal(expectedNumberOfLines, numberOfLines); + } + } + + [InlineData("Whether to turn off HTTPS. This option only applies if Individual, " + + "IndividualB2C, SingleOrg, or MultiOrg aren't used for ‑‑auth." + , "Noto Sans", 40)] + [InlineData("01234 56789 01234 56789", "Noto Mono", 7)] + [Theory] + public void Should_Wrap(string text, string familyName, int numberOfCharactersPerLine) + { + using (Start()) + { + var lineBreaker = new LineBreakEnumerator(text.AsMemory()); + + var expected = new List(); + + while (lineBreaker.MoveNext()) + { + expected.Add(lineBreaker.Current.PositionWrap - 1); + } + + var typeface = new Typeface("resm:Avalonia.Skia.UnitTests.Assets?assembly=Avalonia.Skia.UnitTests#" + + familyName); + + var defaultProperties = new GenericTextRunProperties(Typeface.Default); + + var textSource = new SingleBufferTextSource(text, defaultProperties); + + var formatter = new TextFormatterImpl(); + + var glyph = typeface.GlyphTypeface.GetGlyph('a'); + + var advance = typeface.GlyphTypeface.GetGlyphAdvance(glyph) * + (12.0 / typeface.GlyphTypeface.DesignEmHeight); + + var paragraphWidth = advance * numberOfCharactersPerLine; + + var currentPosition = 0; + + while (currentPosition < text.Length) + { + var textLine = + formatter.FormatLine(textSource, currentPosition, paragraphWidth, + new GenericTextParagraphProperties(defaultProperties, textWrapping: TextWrapping.Wrap)); + + Assert.True(expected.Contains(textLine.TextRange.End)); + + var index = expected.IndexOf(textLine.TextRange.End); + + for (var i = 0; i <= index; i++) + { + expected.RemoveAt(0); + } + + currentPosition += textLine.TextRange.Length; + } + } + } + + [Fact] + public void Should_Produce_Fixed_Height_Lines() + { + using (Start()) + { + const string text = "012345"; + + var defaultProperties = new GenericTextRunProperties(Typeface.Default); + + var textSource = new SingleBufferTextSource(text, defaultProperties); + + var formatter = new TextFormatterImpl(); + + var textLine = + formatter.FormatLine(textSource, 0, double.PositiveInfinity, + new GenericTextParagraphProperties(defaultProperties, lineHeight: 50)); + + Assert.Equal(50, textLine.LineMetrics.Size.Height); + } + } + + public static IDisposable Start() + { + var disposable = UnitTestApplication.Start(TestServices.MockPlatformRenderInterface + .With(renderInterface: new PlatformRenderInterface(null), + textShaperImpl: new TextShaperImpl())); + + AvaloniaLocator.CurrentMutable + .Bind().ToConstant(new FontManager(new CustomFontManagerImpl())); + + return disposable; + } + } +} diff --git a/tests/Avalonia.Skia.UnitTests/TextLayoutTests.cs b/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/TextLayoutTests.cs similarity index 77% rename from tests/Avalonia.Skia.UnitTests/TextLayoutTests.cs rename to tests/Avalonia.Skia.UnitTests/Media/TextFormatting/TextLayoutTests.cs index a2c9f8b8cd..5d9aa2cf97 100644 --- a/tests/Avalonia.Skia.UnitTests/TextLayoutTests.cs +++ b/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/TextLayoutTests.cs @@ -4,15 +4,33 @@ using Avalonia.Media; using Avalonia.Media.TextFormatting; using Avalonia.Media.TextFormatting.Unicode; using Avalonia.UnitTests; +using Avalonia.Utilities; using Xunit; -namespace Avalonia.Skia.UnitTests +namespace Avalonia.Skia.UnitTests.Media.TextFormatting { public class TextLayoutTests { private static readonly string s_singleLineText = "0123456789"; private static readonly string s_multiLineText = "012345678\r\r0123456789"; + [InlineData("01234\r01234\r", 3)] + [InlineData("01234\r01234", 2)] + [Theory] + public void Should_Break_Lines(string text, int numberOfLines) + { + using (Start()) + { + var layout = new TextLayout( + text, + Typeface.Default, + 12.0f, + Brushes.Black); + + Assert.Equal(numberOfLines, layout.TextLines.Count); + } + } + [Fact] public void Should_Apply_TextStyleSpan_To_Text_In_Between() { @@ -22,17 +40,16 @@ namespace Avalonia.Skia.UnitTests var spans = new[] { - new TextStyleRun( - new TextPointer(1, 2), - new TextStyle(Typeface.Default, 12, foreground)) + new ValueSpan(1, 2, + new GenericTextRunProperties(Typeface.Default, 12, foregroundBrush: foreground)) }; var layout = new TextLayout( s_multiLineText, - Typeface.Default, + Typeface.Default, 12.0f, Brushes.Black.ToImmutable(), - textStyleOverrides : spans); + textStyleOverrides: spans); var textLine = layout.TextLines[0]; @@ -46,7 +63,7 @@ namespace Avalonia.Skia.UnitTests Assert.Equal("12", actual); - Assert.Equal(foreground, textRun.Style.Foreground); + Assert.Equal(foreground, textRun.Properties.ForegroundBrush); } } @@ -61,9 +78,8 @@ namespace Avalonia.Skia.UnitTests { var spans = new[] { - new TextStyleRun( - new TextPointer(0, i), - new TextStyle(Typeface.Default, 12, foreground)) + new ValueSpan(0, i, + new GenericTextRunProperties(Typeface.Default, 12, foregroundBrush: foreground)) }; var expected = new TextLayout( @@ -72,22 +88,22 @@ namespace Avalonia.Skia.UnitTests 12.0f, Brushes.Black.ToImmutable(), textWrapping: TextWrapping.Wrap, - maxWidth : 25); + maxWidth: 25); var actual = new TextLayout( s_multiLineText, Typeface.Default, 12.0f, Brushes.Black.ToImmutable(), - textWrapping : TextWrapping.Wrap, - maxWidth : 25, - textStyleOverrides : spans); + textWrapping: TextWrapping.Wrap, + maxWidth: 25, + textStyleOverrides: spans); Assert.Equal(expected.TextLines.Count, actual.TextLines.Count); for (var j = 0; j < actual.TextLines.Count; j++) { - Assert.Equal(expected.TextLines[j].Text.Length, actual.TextLines[j].Text.Length); + Assert.Equal(expected.TextLines[j].TextRange.Length, actual.TextLines[j].TextRange.Length); Assert.Equal(expected.TextLines[j].TextRuns.Sum(x => x.Text.Length), actual.TextLines[j].TextRuns.Sum(x => x.Text.Length)); @@ -105,9 +121,8 @@ namespace Avalonia.Skia.UnitTests var spans = new[] { - new TextStyleRun( - new TextPointer(0, 2), - new TextStyle(Typeface.Default, 12, foreground)) + new ValueSpan(0, 2, + new GenericTextRunProperties(Typeface.Default, 12, foregroundBrush: foreground)) }; var layout = new TextLayout( @@ -115,7 +130,7 @@ namespace Avalonia.Skia.UnitTests Typeface.Default, 12.0f, Brushes.Black.ToImmutable(), - textStyleOverrides : spans); + textStyleOverrides: spans); var textLine = layout.TextLines[0]; @@ -130,7 +145,7 @@ namespace Avalonia.Skia.UnitTests Assert.Equal("01", actual); - Assert.Equal(foreground, textRun.Style.Foreground); + Assert.Equal(foreground, textRun.Properties.ForegroundBrush); } } @@ -143,9 +158,8 @@ namespace Avalonia.Skia.UnitTests var spans = new[] { - new TextStyleRun( - new TextPointer(8, 2), - new TextStyle(Typeface.Default, 12, foreground)) + new ValueSpan(8, 2, + new GenericTextRunProperties(Typeface.Default, 12, foregroundBrush: foreground)), }; var layout = new TextLayout( @@ -153,7 +167,7 @@ namespace Avalonia.Skia.UnitTests Typeface.Default, 12.0f, Brushes.Black.ToImmutable(), - textStyleOverrides : spans); + textStyleOverrides: spans); var textLine = layout.TextLines[0]; @@ -167,7 +181,7 @@ namespace Avalonia.Skia.UnitTests Assert.Equal("89", actual); - Assert.Equal(foreground, textRun.Style.Foreground); + Assert.Equal(foreground, textRun.Properties.ForegroundBrush); } } @@ -180,9 +194,8 @@ namespace Avalonia.Skia.UnitTests var spans = new[] { - new TextStyleRun( - new TextPointer(0, 1), - new TextStyle(Typeface.Default, 12, foreground)) + new ValueSpan(0, 1, + new GenericTextRunProperties(Typeface.Default, 12, foregroundBrush: foreground)) }; var layout = new TextLayout( @@ -190,7 +203,7 @@ namespace Avalonia.Skia.UnitTests Typeface.Default, 12.0f, Brushes.Black.ToImmutable(), - textStyleOverrides : spans); + textStyleOverrides: spans); var textLine = layout.TextLines[0]; @@ -200,7 +213,7 @@ namespace Avalonia.Skia.UnitTests Assert.Equal(1, textRun.Text.Length); - Assert.Equal(foreground, textRun.Style.Foreground); + Assert.Equal(foreground, textRun.Properties.ForegroundBrush); } } @@ -215,9 +228,8 @@ namespace Avalonia.Skia.UnitTests var spans = new[] { - new TextStyleRun( - new TextPointer(2, 2), - new TextStyle(Typeface.Default, 12, foreground)) + new ValueSpan(2, 2, + new GenericTextRunProperties(Typeface.Default, 12, foregroundBrush: foreground)) }; var layout = new TextLayout( @@ -239,7 +251,7 @@ namespace Avalonia.Skia.UnitTests Assert.Equal("😄", actual); - Assert.Equal(foreground, textRun.Style.Foreground); + Assert.Equal(foreground, textRun.Properties.ForegroundBrush); } } @@ -254,7 +266,7 @@ namespace Avalonia.Skia.UnitTests 12.0f, Brushes.Black.ToImmutable()); - Assert.Equal(s_multiLineText.Length, layout.TextLines.Sum(x => x.Text.Length)); + Assert.Equal(s_multiLineText.Length, layout.TextLines.Sum(x => x.TextRange.Length)); } } @@ -291,9 +303,8 @@ namespace Avalonia.Skia.UnitTests var spans = new[] { - new TextStyleRun( - new TextPointer(0, 24), - new TextStyle(Typeface.Default, 12, foreground)) + new ValueSpan(0, 24, + new GenericTextRunProperties(Typeface.Default, 12, foregroundBrush: foreground)) }; var layout = new TextLayout( @@ -301,8 +312,8 @@ namespace Avalonia.Skia.UnitTests Typeface.Default, 12.0f, Brushes.Black.ToImmutable(), - textWrapping : TextWrapping.Wrap, - maxWidth : 180, + textWrapping: TextWrapping.Wrap, + maxWidth: 180, textStyleOverrides: spans); Assert.Equal( @@ -322,9 +333,8 @@ namespace Avalonia.Skia.UnitTests var spans = new[] { - new TextStyleRun( - new TextPointer(5, 20), - new TextStyle(Typeface.Default, 12, foreground)) + new ValueSpan(5, 20, + new GenericTextRunProperties(Typeface.Default, 12, foregroundBrush: foreground)) }; var layout = new TextLayout( @@ -332,13 +342,13 @@ namespace Avalonia.Skia.UnitTests Typeface.Default, 12.0f, Brushes.Black.ToImmutable(), - maxWidth : 200, - maxHeight : 125, + maxWidth: 200, + maxHeight: 125, textStyleOverrides: spans); - Assert.Equal(foreground, layout.TextLines[0].TextRuns[1].Style.Foreground); - Assert.Equal(foreground, layout.TextLines[1].TextRuns[0].Style.Foreground); - Assert.Equal(foreground, layout.TextLines[2].TextRuns[0].Style.Foreground); + Assert.Equal(foreground, layout.TextLines[0].TextRuns[1].Properties.ForegroundBrush); + Assert.Equal(foreground, layout.TextLines[1].TextRuns[0].Properties.ForegroundBrush); + Assert.Equal(foreground, layout.TextLines[2].TextRuns[0].Properties.ForegroundBrush); } } @@ -355,7 +365,7 @@ namespace Avalonia.Skia.UnitTests 12.0f, Brushes.Black.ToImmutable()); - var shapedRun = (ShapedTextRun)layout.TextLines[0].TextRuns[0]; + var shapedRun = (ShapedTextCharacters)layout.TextLines[0].TextRuns[0]; var glyphRun = shapedRun.GlyphRun; @@ -390,7 +400,7 @@ namespace Avalonia.Skia.UnitTests foreach (var textRun in textLine.TextRuns) { - var shapedRun = (ShapedTextRun)textRun; + var shapedRun = (ShapedTextCharacters)textRun; var glyphRun = shapedRun.GlyphRun; @@ -426,13 +436,13 @@ namespace Avalonia.Skia.UnitTests Assert.Equal(1, layout.TextLines[0].TextRuns.Count); - Assert.Equal(expectedLength, ((ShapedTextRun)layout.TextLines[0].TextRuns[0]).GlyphRun.GlyphClusters.Length); + Assert.Equal(expectedLength, ((ShapedTextCharacters)layout.TextLines[0].TextRuns[0]).GlyphRun.GlyphClusters.Length); - Assert.Equal(5, ((ShapedTextRun)layout.TextLines[0].TextRuns[0]).GlyphRun.GlyphClusters[5]); + Assert.Equal(5, ((ShapedTextCharacters)layout.TextLines[0].TextRuns[0]).GlyphRun.GlyphClusters[5]); - if(expectedLength == 7) + if (expectedLength == 7) { - Assert.Equal(5, ((ShapedTextRun)layout.TextLines[0].TextRuns[0]).GlyphRun.GlyphClusters[6]); + Assert.Equal(5, ((ShapedTextCharacters)layout.TextLines[0].TextRuns[0]).GlyphRun.GlyphClusters[6]); } } } @@ -467,7 +477,7 @@ namespace Avalonia.Skia.UnitTests var textLine = layout.TextLines[0]; - var textRun = (ShapedTextRun)textLine.TextRuns[0]; + var textRun = (ShapedTextCharacters)textLine.TextRuns[0]; Assert.Equal(7, textRun.Text.Length); @@ -526,9 +536,28 @@ namespace Avalonia.Skia.UnitTests } } + [Fact] + public void Should_Produce_Fixed_Height_Lines() + { + using (Start()) + { + var layout = new TextLayout( + s_multiLineText, + Typeface.Default, + 12, + Brushes.Black, + lineHeight: 50); + + foreach (var line in layout.TextLines) + { + Assert.Equal(50, line.LineMetrics.Size.Height); + } + } + } + private const string Text = "日本でTest一番読まれている英字新聞・ジャパンタイムズが発信する国内外ニュースと、様々なジャンルの特集記事。"; - [Fact(Skip= "Only used for profiling.")] + [Fact(Skip = "Only used for profiling.")] public void Should_Wrap() { using (Start()) @@ -546,12 +575,12 @@ namespace Avalonia.Skia.UnitTests } } - public static IDisposable Start() + private static IDisposable Start() { var disposable = UnitTestApplication.Start(TestServices.MockPlatformRenderInterface .With(renderInterface: new PlatformRenderInterface(null), textShaperImpl: new TextShaperImpl(), - fontManagerImpl : new CustomFontManagerImpl())); + fontManagerImpl: new CustomFontManagerImpl())); return disposable; } diff --git a/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/TextLineTests.cs b/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/TextLineTests.cs new file mode 100644 index 0000000000..ed00d6aaed --- /dev/null +++ b/tests/Avalonia.Skia.UnitTests/Media/TextFormatting/TextLineTests.cs @@ -0,0 +1,175 @@ +using System; +using System.Linq; +using Avalonia.Media; +using Avalonia.Media.TextFormatting; +using Avalonia.UnitTests; +using Xunit; + +namespace Avalonia.Skia.UnitTests.Media.TextFormatting +{ + public class TextLineTests + { + [InlineData("𐐷𐐷𐐷𐐷𐐷")] + [InlineData("𐐷1234")] + [Theory] + public void Should_Get_Next_Caret_CharacterHit(string text) + { + using (Start()) + { + var defaultProperties = new GenericTextRunProperties(Typeface.Default); + + var textSource = new SingleBufferTextSource(text, defaultProperties); + + var formatter = new TextFormatterImpl(); + + var textLine = + formatter.FormatLine(textSource, 0, double.PositiveInfinity, + new GenericTextParagraphProperties(defaultProperties)); + + var clusters = textLine.TextRuns.Cast().SelectMany(x => x.GlyphRun.GlyphClusters) + .ToArray(); + + var nextCharacterHit = new CharacterHit(0); + + for (var i = 1; i < clusters.Length; i++) + { + nextCharacterHit = textLine.GetNextCaretCharacterHit(nextCharacterHit); + + Assert.Equal(clusters[i], nextCharacterHit.FirstCharacterIndex + nextCharacterHit.TrailingLength); + } + } + } + + [InlineData("𐐷𐐷𐐷𐐷𐐷")] + [InlineData("𐐷1234")] + [Theory] + public void Should_Get_Previous_Caret_CharacterHit(string text) + { + using (Start()) + { + var defaultProperties = new GenericTextRunProperties(Typeface.Default); + + var textSource = new SingleBufferTextSource(text, defaultProperties); + + var formatter = new TextFormatterImpl(); + + var textLine = + formatter.FormatLine(textSource, 0, double.PositiveInfinity, + new GenericTextParagraphProperties(defaultProperties)); + + var clusters = textLine.TextRuns.Cast().SelectMany(x => x.GlyphRun.GlyphClusters) + .ToArray(); + + var previousCharacterHit = new CharacterHit(clusters[^1]); + + for (var i = clusters.Length - 2; i > 0; i--) + { + previousCharacterHit = textLine.GetPreviousCaretCharacterHit(previousCharacterHit); + + Assert.Equal(clusters[i], previousCharacterHit.FirstCharacterIndex); + } + } + } + + [Fact] + public void Should_Get_Distance_From_CharacterHit() + { + using (Start()) + { + var defaultProperties = new GenericTextRunProperties(Typeface.Default); + + var textSource = new MultiBufferTextSource(defaultProperties); + + var formatter = new TextFormatterImpl(); + + var textLine = + formatter.FormatLine(textSource, 0, double.PositiveInfinity, + new GenericTextParagraphProperties(defaultProperties)); + + var currentDistance = 0.0; + + foreach (var run in textLine.TextRuns) + { + var textRun = (ShapedTextCharacters)run; + + var glyphRun = textRun.GlyphRun; + + for (var i = 0; i < glyphRun.GlyphClusters.Length; i++) + { + var cluster = glyphRun.GlyphClusters[i]; + + var glyph = glyphRun.GlyphIndices[i]; + + var advance = glyphRun.GlyphTypeface.GetGlyphAdvance(glyph) * glyphRun.Scale; + + var distance = textLine.GetDistanceFromCharacterHit(new CharacterHit(cluster)); + + Assert.Equal(currentDistance, distance); + + currentDistance += advance; + } + } + + Assert.Equal(currentDistance, + textLine.GetDistanceFromCharacterHit(new CharacterHit(MultiBufferTextSource.TextRange.Length))); + } + } + + [Fact] + public void Should_Get_CharacterHit_From_Distance() + { + using (Start()) + { + var defaultProperties = new GenericTextRunProperties(Typeface.Default); + + var textSource = new MultiBufferTextSource(defaultProperties); + + var formatter = new TextFormatterImpl(); + + var textLine = + formatter.FormatLine(textSource, 0, double.PositiveInfinity, + new GenericTextParagraphProperties(defaultProperties)); + + var currentDistance = 0.0; + + CharacterHit characterHit; + + foreach (var run in textLine.TextRuns) + { + var textRun = (ShapedTextCharacters)run; + + var glyphRun = textRun.GlyphRun; + + for (var i = 0; i < glyphRun.GlyphClusters.Length; i++) + { + var cluster = glyphRun.GlyphClusters[i]; + + var glyph = glyphRun.GlyphIndices[i]; + + var advance = glyphRun.GlyphTypeface.GetGlyphAdvance(glyph) * glyphRun.Scale; + + characterHit = textLine.GetCharacterHitFromDistance(currentDistance); + + Assert.Equal(cluster, characterHit.FirstCharacterIndex + characterHit.TrailingLength); + + currentDistance += advance; + } + } + + characterHit = textLine.GetCharacterHitFromDistance(textLine.LineMetrics.Size.Width); + + Assert.Equal(MultiBufferTextSource.TextRange.End, characterHit.FirstCharacterIndex); + } + } + + private static IDisposable Start() + { + var disposable = UnitTestApplication.Start(TestServices.MockPlatformRenderInterface + .With(renderInterface: new PlatformRenderInterface(null), + textShaperImpl: new TextShaperImpl(), + fontManagerImpl: new CustomFontManagerImpl())); + + return disposable; + } + } +} diff --git a/tests/Avalonia.Skia.UnitTests/SimpleTextFormatterTests.cs b/tests/Avalonia.Skia.UnitTests/SimpleTextFormatterTests.cs deleted file mode 100644 index 8e695a11c8..0000000000 --- a/tests/Avalonia.Skia.UnitTests/SimpleTextFormatterTests.cs +++ /dev/null @@ -1,373 +0,0 @@ -using System; -using System.Collections.Generic; -using Avalonia.Media; -using Avalonia.Media.TextFormatting; -using Avalonia.Media.TextFormatting.Unicode; -using Avalonia.UnitTests; -using Avalonia.Utility; -using Xunit; - -namespace Avalonia.Skia.UnitTests -{ - public class SimpleTextFormatterTests - { - [Fact] - public void Should_Format_TextRuns_With_Default_Style() - { - using (Start()) - { - const string text = "0123456789"; - - var defaultTextRunStyle = new TextStyle(Typeface.Default, 12, Brushes.Black); - - var textSource = new SimpleTextSource(text, defaultTextRunStyle); - - var formatter = new SimpleTextFormatter(); - - var textLine = formatter.FormatLine(textSource, 0, double.PositiveInfinity, new TextParagraphProperties()); - - Assert.Single(textLine.TextRuns); - - var textRun = textLine.TextRuns[0]; - - Assert.Equal(defaultTextRunStyle.TextFormat, textRun.Style.TextFormat); - - Assert.Equal(defaultTextRunStyle.Foreground, textRun.Style.Foreground); - - Assert.Equal(text.Length, textRun.Text.Length); - } - } - - [Fact] - public void Should_Format_TextRuns_With_Multiple_Buffers() - { - using (Start()) - { - var defaultTextRunStyle = new TextStyle(Typeface.Default, 12, Brushes.Black); - - var textSource = new MultiBufferTextSource(defaultTextRunStyle); - - var formatter = new SimpleTextFormatter(); - - var textLine = formatter.FormatLine(textSource, 0, double.PositiveInfinity, - new TextParagraphProperties(defaultTextRunStyle)); - - Assert.Equal(5, textLine.TextRuns.Count); - - Assert.Equal(50, textLine.Text.Length); - } - } - - private class MultiBufferTextSource : ITextSource - { - private readonly string[] _runTexts; - private readonly TextStyle _defaultStyle; - - public MultiBufferTextSource(TextStyle defaultStyle) - { - _defaultStyle = defaultStyle; - - _runTexts = new[] { "A123456789", "B123456789", "C123456789", "D123456789", "E123456789" }; - } - - public TextPointer TextPointer => new TextPointer(0, 50); - - public TextRun GetTextRun(int textSourceIndex) - { - if (textSourceIndex == 50) - { - return new TextEndOfParagraph(); - } - - var index = textSourceIndex / 10; - - var runText = _runTexts[index]; - - return new TextCharacters( - new ReadOnlySlice(runText.AsMemory(), textSourceIndex, runText.Length), _defaultStyle); - } - } - - [Fact] - public void Should_Format_TextRuns_With_TextRunStyles() - { - using (Start()) - { - const string text = "0123456789"; - - var defaultStyle = new TextStyle(Typeface.Default, 12, Brushes.Black); - - var textStyleRuns = new[] - { - new TextStyleRun(new TextPointer(0, 3), defaultStyle ), - new TextStyleRun(new TextPointer(3, 3), new TextStyle(Typeface.Default, 13, Brushes.Black) ), - new TextStyleRun(new TextPointer(6, 3), new TextStyle(Typeface.Default, 14, Brushes.Black) ), - new TextStyleRun(new TextPointer(9, 1), defaultStyle ) - }; - - var textSource = new FormattableTextSource(text, defaultStyle, textStyleRuns); - - var formatter = new SimpleTextFormatter(); - - var textLine = formatter.FormatLine(textSource, 0, double.PositiveInfinity, new TextParagraphProperties()); - - Assert.Equal(text.Length, textLine.Text.Length); - - for (var i = 0; i < textStyleRuns.Length; i++) - { - var textStyleRun = textStyleRuns[i]; - - var textRun = textLine.TextRuns[i]; - - Assert.Equal(textStyleRun.TextPointer.Length, textRun.Text.Length); - } - } - } - - private class FormattableTextSource : ITextSource - { - private readonly ReadOnlySlice _text; - private readonly TextStyle _defaultStyle; - private ReadOnlySlice _textStyleRuns; - - public FormattableTextSource(string text, TextStyle defaultStyle, ReadOnlySlice textStyleRuns) - { - _text = text.AsMemory(); - - _defaultStyle = defaultStyle; - - _textStyleRuns = textStyleRuns; - } - - public TextRun GetTextRun(int textSourceIndex) - { - if (_textStyleRuns.IsEmpty) - { - return new TextEndOfParagraph(); - } - - var styleRun = _textStyleRuns[0]; - - _textStyleRuns = _textStyleRuns.Skip(1); - - return new TextCharacters(_text.AsSlice(styleRun.TextPointer.Start, styleRun.TextPointer.Length), - _defaultStyle); - } - } - - [Theory] - [InlineData("0123", 1)] - [InlineData("\r\n", 1)] - [InlineData("👍b", 2)] - [InlineData("a👍b", 3)] - [InlineData("a👍子b", 4)] - public void Should_Produce_Unique_Runs(string text, int numberOfRuns) - { - using (Start()) - { - var textSource = new SimpleTextSource(text, new TextStyle(Typeface.Default)); - - var formatter = new SimpleTextFormatter(); - - var textLine = - formatter.FormatLine(textSource, 0, double.PositiveInfinity, new TextParagraphProperties()); - - Assert.Equal(numberOfRuns, textLine.TextRuns.Count); - } - } - - private class SimpleTextSource : ITextSource - { - private readonly ReadOnlySlice _text; - private readonly TextStyle _defaultTextStyle; - - public SimpleTextSource(string text, TextStyle defaultText) - { - _text = text.AsMemory(); - _defaultTextStyle = defaultText; - } - - public TextRun GetTextRun(int textSourceIndex) - { - var runText = _text.Skip(textSourceIndex); - - if (runText.IsEmpty) - { - return new TextEndOfParagraph(); - } - - return new TextCharacters(runText, _defaultTextStyle); - } - } - - [Fact] - public void Should_Split_Run_On_Script() - { - using (Start()) - { - const string text = "1234الدولي"; - - var textSource = new SimpleTextSource(text, new TextStyle(Typeface.Default)); - - var formatter = new SimpleTextFormatter(); - - var textLine = - formatter.FormatLine(textSource, 0, double.PositiveInfinity, new TextParagraphProperties()); - - Assert.Equal(4, textLine.TextRuns[0].Text.Length); - } - } - - [Fact] - public void Should_Get_Distance_From_CharacterHit() - { - using (Start()) - { - var textSource = new MultiBufferTextSource(new TextStyle(Typeface.Default)); - - var formatter = new SimpleTextFormatter(); - - var textLine = - formatter.FormatLine(textSource, 0, double.PositiveInfinity, new TextParagraphProperties()); - - var currentDistance = 0.0; - - foreach (var run in textLine.TextRuns) - { - var textRun = (ShapedTextRun)run; - - var glyphRun = textRun.GlyphRun; - - for (var i = 0; i < glyphRun.GlyphClusters.Length; i++) - { - var cluster = glyphRun.GlyphClusters[i]; - - var glyph = glyphRun.GlyphIndices[i]; - - var advance = glyphRun.GlyphTypeface.GetGlyphAdvance(glyph) * glyphRun.Scale; - - var distance = textLine.GetDistanceFromCharacterHit(new CharacterHit(cluster)); - - Assert.Equal(currentDistance, distance); - - currentDistance += advance; - } - } - - Assert.Equal(currentDistance, textLine.GetDistanceFromCharacterHit(new CharacterHit(textSource.TextPointer.Length))); - } - } - - [Fact] - public void Should_Get_CharacterHit_From_Distance() - { - using (Start()) - { - var textSource = new MultiBufferTextSource(new TextStyle(Typeface.Default)); - - var formatter = new SimpleTextFormatter(); - - var textLine = - formatter.FormatLine(textSource, 0, double.PositiveInfinity, new TextParagraphProperties()); - - var currentDistance = 0.0; - - CharacterHit characterHit; - - foreach (var run in textLine.TextRuns) - { - var textRun = (ShapedTextRun)run; - - var glyphRun = textRun.GlyphRun; - - for (var i = 0; i < glyphRun.GlyphClusters.Length; i++) - { - var cluster = glyphRun.GlyphClusters[i]; - - var glyph = glyphRun.GlyphIndices[i]; - - var advance = glyphRun.GlyphTypeface.GetGlyphAdvance(glyph) * glyphRun.Scale; - - characterHit = textLine.GetCharacterHitFromDistance(currentDistance); - - Assert.Equal(cluster, characterHit.FirstCharacterIndex + characterHit.TrailingLength); - - currentDistance += advance; - } - } - - characterHit = textLine.GetCharacterHitFromDistance(textLine.LineMetrics.Size.Width); - - Assert.Equal(textSource.TextPointer.End, characterHit.FirstCharacterIndex); - } - } - - [InlineData("Whether to turn off HTTPS. This option only applies if Individual, " + - "IndividualB2C, SingleOrg, or MultiOrg aren't used for ‑‑auth." - , "Noto Sans", 40)] - [InlineData("01234 56789 01234 56789", "Noto Mono", 7)] - [Theory] - public void Should_Wrap_Text(string text, string familyName, int numberOfCharactersPerLine) - { - using (Start()) - { - var lineBreaker = new LineBreakEnumerator(text.AsMemory()); - - var expected = new List(); - - while (lineBreaker.MoveNext()) - { - expected.Add(lineBreaker.Current.PositionWrap - 1); - } - - var typeface = new Typeface("resm:Avalonia.Skia.UnitTests.Assets?assembly=Avalonia.Skia.UnitTests#" + - familyName); - - var defaultStyle = new TextStyle(typeface); - - var textSource = new SimpleTextSource(text, defaultStyle); - - var formatter = new SimpleTextFormatter(); - - var glyph = typeface.GlyphTypeface.GetGlyph('a'); - - var advance = typeface.GlyphTypeface.GetGlyphAdvance(glyph) * - (12.0 / typeface.GlyphTypeface.DesignEmHeight); - - var paragraphWidth = advance * numberOfCharactersPerLine; - - var currentPosition = 0; - - while (currentPosition < text.Length) - { - var textLine = - formatter.FormatLine(textSource, currentPosition, paragraphWidth, - new TextParagraphProperties(defaultStyle, textWrapping: TextWrapping.Wrap)); - - Assert.True(expected.Contains(textLine.Text.End)); - - var index = expected.IndexOf(textLine.Text.End); - - for (var i = 0; i <= index; i++) - { - expected.RemoveAt(0); - } - - currentPosition += textLine.Text.Length; - } - } - } - - public static IDisposable Start() - { - var disposable = UnitTestApplication.Start(TestServices.MockPlatformRenderInterface - .With(renderInterface: new PlatformRenderInterface(null), - textShaperImpl: new TextShaperImpl())); - - AvaloniaLocator.CurrentMutable - .Bind().ToConstant(new FontManager(new CustomFontManagerImpl())); - - return disposable; - } - } -} diff --git a/tests/Avalonia.UnitTests/MockTextShaperImpl.cs b/tests/Avalonia.UnitTests/MockTextShaperImpl.cs index 0772e0e9bd..fe1c34385f 100644 --- a/tests/Avalonia.UnitTests/MockTextShaperImpl.cs +++ b/tests/Avalonia.UnitTests/MockTextShaperImpl.cs @@ -1,19 +1,19 @@ -using Avalonia.Media; -using Avalonia.Media.TextFormatting; +using System; +using System.Globalization; +using Avalonia.Media; using Avalonia.Media.TextFormatting.Unicode; using Avalonia.Platform; -using Avalonia.Utility; +using Avalonia.Utilities; namespace Avalonia.UnitTests { public class MockTextShaperImpl : ITextShaperImpl { - public GlyphRun ShapeText(ReadOnlySlice text, TextFormat textFormat) + public GlyphRun ShapeText(ReadOnlySlice text, Typeface typeface, double fontRenderingEmSize, CultureInfo culture) { - var glyphTypeface = textFormat.Typeface.GlyphTypeface; + var glyphTypeface = typeface.GlyphTypeface; var glyphIndices = new ushort[text.Length]; - var height = textFormat.FontMetrics.LineHeight; - var width = 0.0; + var glyphCount = 0; for (var i = 0; i < text.Length;) { @@ -27,10 +27,11 @@ namespace Avalonia.UnitTests glyphIndices[index] = glyph; - width += glyphTypeface.GetGlyphAdvance(glyph); + glyphCount++; } - return new GlyphRun(glyphTypeface, textFormat.FontRenderingEmSize, glyphIndices, characters: text); + return new GlyphRun(glyphTypeface, fontRenderingEmSize, + new ReadOnlySlice(glyphIndices.AsMemory(0, glyphCount)), characters: text); } } } diff --git a/tests/Avalonia.Visuals.UnitTests/Media/GlyphRunTests.cs b/tests/Avalonia.Visuals.UnitTests/Media/GlyphRunTests.cs index 028caa35c6..219c7ece46 100644 --- a/tests/Avalonia.Visuals.UnitTests/Media/GlyphRunTests.cs +++ b/tests/Avalonia.Visuals.UnitTests/Media/GlyphRunTests.cs @@ -1,7 +1,7 @@ using Avalonia.Media; using Avalonia.Platform; using Avalonia.UnitTests; -using Avalonia.Utility; +using Avalonia.Utilities; using Xunit; namespace Avalonia.Visuals.UnitTests.Media diff --git a/tests/Avalonia.Visuals.UnitTests/Media/TextFormatting/LineBreakerTests.cs b/tests/Avalonia.Visuals.UnitTests/Media/TextFormatting/LineBreakerTests.cs index 3ed5cfb0b2..3d489af3a2 100644 --- a/tests/Avalonia.Visuals.UnitTests/Media/TextFormatting/LineBreakerTests.cs +++ b/tests/Avalonia.Visuals.UnitTests/Media/TextFormatting/LineBreakerTests.cs @@ -1,6 +1,6 @@ using System; using Avalonia.Media.TextFormatting.Unicode; -using Avalonia.Utility; +using Avalonia.Utilities; using Xunit; namespace Avalonia.Visuals.UnitTests.Media.TextFormatting diff --git a/tests/Avalonia.Visuals.UnitTests/Media/TypefaceTests.cs b/tests/Avalonia.Visuals.UnitTests/Media/TypefaceTests.cs index 0e43c76da1..e526172622 100644 --- a/tests/Avalonia.Visuals.UnitTests/Media/TypefaceTests.cs +++ b/tests/Avalonia.Visuals.UnitTests/Media/TypefaceTests.cs @@ -9,7 +9,7 @@ namespace Avalonia.Visuals.UnitTests.Media [Fact] public void Exception_Should_Be_Thrown_If_FontWeight_LessThanEqualTo_Zero() { - Assert.Throws(() => new Typeface("foo", 0, (FontStyle)12)); + Assert.Throws(() => new Typeface("foo", (FontStyle)12, 0)); } [Fact]