diff --git a/.gitmodules b/.gitmodules index 63bc5f5de3..24ccfc3259 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +1,7 @@ [submodule "src/Perspex.ReactiveUI/src"] path = src/Perspex.ReactiveUI/src url = https://github.com/reactiveui/ReactiveUI.git +[submodule "src/Perspex.HtmlRenderer/external"] + path = src/Perspex.HtmlRenderer/external + url = https://github.com/Perspex/HTML-Renderer.git + branch = perspex-pcl diff --git a/Perspex.sln b/Perspex.sln index de7af4b229..54c810f636 100644 --- a/Perspex.sln +++ b/Perspex.sln @@ -94,6 +94,8 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Perspex.Markup.Xaml.UnitTes EndProject Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Perspex.Cairo.RenderTests", "tests\Perspex.RenderTests\Perspex.Cairo.RenderTests.csproj", "{E106CF37-4066-4615-B684-172A6D30B058}" EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Perspex.HtmlRenderer", "src\Perspex.HtmlRenderer\Perspex.HtmlRenderer.csproj", "{5FB2B005-0A7F-4DAD-ADD4-3ED01444E63D}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution Debug|Any CPU = Debug|Any CPU @@ -224,6 +226,10 @@ Global {E106CF37-4066-4615-B684-172A6D30B058}.Debug|Any CPU.Build.0 = Debug|Any CPU {E106CF37-4066-4615-B684-172A6D30B058}.Release|Any CPU.ActiveCfg = Release|Any CPU {E106CF37-4066-4615-B684-172A6D30B058}.Release|Any CPU.Build.0 = Release|Any CPU + {5FB2B005-0A7F-4DAD-ADD4-3ED01444E63D}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {5FB2B005-0A7F-4DAD-ADD4-3ED01444E63D}.Debug|Any CPU.Build.0 = Debug|Any CPU + {5FB2B005-0A7F-4DAD-ADD4-3ED01444E63D}.Release|Any CPU.ActiveCfg = Release|Any CPU + {5FB2B005-0A7F-4DAD-ADD4-3ED01444E63D}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE diff --git a/samples/TestApplication/Program.cs b/samples/TestApplication/Program.cs index de07b8d692..54f7686e8c 100644 --- a/samples/TestApplication/Program.cs +++ b/samples/TestApplication/Program.cs @@ -2,11 +2,13 @@ // Licensed under the MIT license. See licence.md file in the project root for full license information. using System; +using System.IO; using System.Reactive.Linq; using Perspex; using Perspex.Animation; using Perspex.Collections; using Perspex.Controls; +using Perspex.Controls.Html; using Perspex.Controls.Primitives; using Perspex.Controls.Shapes; using Perspex.Controls.Templates; @@ -219,6 +221,7 @@ namespace TestApplication { ButtonsTab(), TextTab(), + HtmlTab(), ImagesTab(), ListsTab(), LayoutTab(), @@ -365,6 +368,30 @@ namespace TestApplication return result; } + private static TabItem HtmlTab() + { + var htmlText = + new StreamReader(typeof (Program).Assembly.GetManifestResourceStream("TestApplication.html.htm")) + .ReadToEnd(); + return new TabItem + { + Header = "Html", + Content = new ScrollViewer() + { + Width = 600, + MaxHeight = 600, + HorizontalAlignment = HorizontalAlignment.Center, + CanScrollHorizontally = false, + VerticalScrollBarVisibility = ScrollBarVisibility.Visible, + Content = + new HtmlLabel() + { + Text = htmlText + } + } + }; + } + private static TabItem TextTab() { return new TabItem diff --git a/samples/TestApplication/TestApplication.csproj b/samples/TestApplication/TestApplication.csproj index 1a3a6287fc..463e885e2a 100644 --- a/samples/TestApplication/TestApplication.csproj +++ b/samples/TestApplication/TestApplication.csproj @@ -103,6 +103,10 @@ {7062AE20-5DCC-4442-9645-8195BDECE63E} Perspex.Diagnostics + + {5fb2b005-0a7f-4dad-add4-3ed01444e63d} + Perspex.HtmlRenderer + {62024B2D-53EB-4638-B26B-85EEAA54866E} Perspex.Input @@ -144,6 +148,7 @@ PreserveNewest + diff --git a/samples/TestApplication/html.htm b/samples/TestApplication/html.htm new file mode 100644 index 0000000000..85da0cdb87 --- /dev/null +++ b/samples/TestApplication/html.htm @@ -0,0 +1,128 @@ + + + Intro + + + +

+ HTML Renderer Project - Perspex port +
+ Beta support +

+
+

+ + +
  • Lightweight (~300K).
    • +
  • High performance and low memory footprint.
    • +
  • Extendable and configurable.
    • + +

    + Limitations +

    +
      +
    • All HTML end tags marked as + optional should be there. No problem with tags marked as forbidden.
      • +
    +
    +

    + On the roadmap

    + Of course it's not quite finished yet. Here are some of the important things to + do. +
      +
    • Better performance
      • +
    • Support of position CSS property
      • +
    • Support of height and min-height CSS property
      • +
    • Better tables support, especially layouts
      • +
    • Support image align
      • +
    • Handle :hover selector
      • +
    • Selection by shift+arrows
      • +
    • Better HTML tag parsing (optional closing tags)
      • +
    • More styles support
      • +
    +

    + Vision +

    +
      +
    • Most complete static HTML Renderer (no java script).
      • +
    • Commercial web browser performance level.
      • +
    +
    +

    + 2015 - Nikita Tsukanov (Perspex Port) + +

    +
    + https://perspex.github.io/ +
    + +

    + 2012 - Arthur Teplitzki +

    +
    + http://TheArtOfDev.com +
    +

    + 2009 - Jose Manuel Menendez Poo +

    +
    + www.menendezpoo.com +
    + + + \ No newline at end of file diff --git a/src/Perspex.HtmlRenderer/Adapters/BrushAdapter.cs b/src/Perspex.HtmlRenderer/Adapters/BrushAdapter.cs new file mode 100644 index 0000000000..4c8b06345e --- /dev/null +++ b/src/Perspex.HtmlRenderer/Adapters/BrushAdapter.cs @@ -0,0 +1,47 @@ +// "Therefore those skilled at the unorthodox +// are infinite as heaven and earth, +// inexhaustible as the great rivers. +// When they come to an end, +// they begin again, +// like the days and months; +// they die and are reborn, +// like the four seasons." +// +// - Sun Tsu, +// "The Art of War" + +using Perspex.Media; +using TheArtOfDev.HtmlRenderer.Adapters; + +namespace TheArtOfDev.HtmlRenderer.Perspex.Adapters +{ + /// + /// Adapter for Perspex brushes. + /// + internal sealed class BrushAdapter : RBrush + { + /// + /// The actual Perspex brush instance. + /// + private readonly Brush _brush; + + /// + /// Init. + /// + public BrushAdapter(Brush brush) + { + _brush = brush; + } + + /// + /// The actual Perspex brush instance. + /// + public Brush Brush + { + get { return _brush; } + } + + public override void Dispose() + { } + } +} \ No newline at end of file diff --git a/src/Perspex.HtmlRenderer/Adapters/ContextMenuAdapter.cs b/src/Perspex.HtmlRenderer/Adapters/ContextMenuAdapter.cs new file mode 100644 index 0000000000..abc64e7047 --- /dev/null +++ b/src/Perspex.HtmlRenderer/Adapters/ContextMenuAdapter.cs @@ -0,0 +1,51 @@ +// "Therefore those skilled at the unorthodox +// are infinite as heaven and earth, +// inexhaustible as the great rivers. +// When they come to an end, +// they begin again, +// like the days and months; +// they die and are reborn, +// like the four seasons." +// +// - Sun Tsu, +// "The Art of War" + +using System; +using TheArtOfDev.HtmlRenderer.Adapters; +using TheArtOfDev.HtmlRenderer.Adapters.Entities; + +namespace TheArtOfDev.HtmlRenderer.Perspex.Adapters +{ + /// + /// Adapter for Perspex context menu for core. + /// + internal sealed class NullContextMenuAdapter : RContextMenu + { + //TODO: actually implement context menu + + private int _itemCount; + public override int ItemsCount => _itemCount; + public override void AddDivider() + { + + } + + public override void AddItem(string text, bool enabled, EventHandler onClick) + { + _itemCount++; + } + + public override void RemoveLastDivider() + { + _itemCount++; + } + + public override void Show(RControl parent, RPoint location) + { + } + + public override void Dispose() + { + } + } +} \ No newline at end of file diff --git a/src/Perspex.HtmlRenderer/Adapters/ControlAdapter.cs b/src/Perspex.HtmlRenderer/Adapters/ControlAdapter.cs new file mode 100644 index 0000000000..f0f84cb64f --- /dev/null +++ b/src/Perspex.HtmlRenderer/Adapters/ControlAdapter.cs @@ -0,0 +1,108 @@ +// "Therefore those skilled at the unorthodox +// are infinite as heaven and earth, +// inexhaustible as the great rivers. +// When they come to an end, +// they begin again, +// like the days and months; +// they die and are reborn, +// like the four seasons." +// +// - Sun Tsu, +// "The Art of War" + +using Perspex.Controls; +using Perspex.Controls.Html; +using Perspex.Input; +using TheArtOfDev.HtmlRenderer.Adapters; +using TheArtOfDev.HtmlRenderer.Adapters.Entities; +using TheArtOfDev.HtmlRenderer.Core.Utils; +using TheArtOfDev.HtmlRenderer.Perspex.Utilities; +// ReSharper disable ConvertPropertyToExpressionBody + +namespace TheArtOfDev.HtmlRenderer.Perspex.Adapters +{ + /// + /// Adapter for Perspex Control for core. + /// + internal sealed class ControlAdapter : RControl + { + /// + /// the underline Perspex control. + /// + private readonly Control _control; + + /// + /// Init. + /// + public ControlAdapter(Control control) + : base(PerspexAdapter.Instance) + { + ArgChecker.AssertArgNotNull(control, "control"); + + _control = control; + } + + /// + /// Get the underline Perspex control + /// + public Control Control + { + get { return _control; } + } + + public override RPoint MouseLocation + { + get + { + return Util.Convert(MouseDevice.Instance.GetPosition(_control)); + } + } + + private bool _leftMouseButton; + public override bool LeftMouseButton => (_control as HtmlControl)?.LeftMouseButton ?? false; + + public override bool RightMouseButton + { + get + { + return false; + //TODO: Implement right mouse click + //return Mouse.RightButton == MouseButtonState.Pressed; + } + } + + public override void SetCursorDefault() + { + _control.Cursor = new Cursor(StandardCursorType.Arrow); + } + + public override void SetCursorHand() + { + _control.Cursor = new Cursor(StandardCursorType.Hand); + } + + public override void SetCursorIBeam() + { + _control.Cursor = new Cursor(StandardCursorType.Ibeam); + } + + public override void DoDragDropCopy(object dragDropData) + { + //TODO: Implement DragDropCopy + //DragDrop.DoDragDrop(_control, dragDropData, DragDropEffects.Copy); + } + + public override void MeasureString(string str, RFont font, double maxWidth, out int charFit, out double charFitWidth) + { + using (var g = new GraphicsAdapter()) + { + g.MeasureString(str, font, maxWidth, out charFit, out charFitWidth); + } + } + + public override void Invalidate() + { + _control.InvalidateVisual(); + } + } +} \ No newline at end of file diff --git a/src/Perspex.HtmlRenderer/Adapters/FontAdapter.cs b/src/Perspex.HtmlRenderer/Adapters/FontAdapter.cs new file mode 100644 index 0000000000..1e645cd96c --- /dev/null +++ b/src/Perspex.HtmlRenderer/Adapters/FontAdapter.cs @@ -0,0 +1,106 @@ +// "Therefore those skilled at the unorthodox +// are infinite as heaven and earth, +// inexhaustible as the great rivers. +// When they come to an end, +// they begin again, +// like the days and months; +// they die and are reborn, +// like the four seasons." +// +// - Sun Tsu, +// "The Art of War" + +using Perspex.Media; +using TheArtOfDev.HtmlRenderer.Adapters; +using TheArtOfDev.HtmlRenderer.Adapters.Entities; + +namespace TheArtOfDev.HtmlRenderer.Perspex.Adapters +{ + /// + /// Adapter for Perspex Font. + /// + internal sealed class FontAdapter : RFont + { + public RFontStyle Style { get; } + + #region Fields and Consts + + + /// + /// the size of the font + /// + private readonly double _size; + + /// + /// the vertical offset of the font underline location from the top of the font. + /// + private readonly double _underlineOffset = -1; + + /// + /// Cached font height. + /// + private readonly double _height = -1; + + /// + /// Cached font whitespace width. + /// + private double _whitespaceWidth = -1; + + + #endregion + + + /// + /// Init. + /// + public FontAdapter(string fontFamily, double size, RFontStyle style) + { + Style = style; + Name = fontFamily; + _size = size; + //TODO: Somehow get proper line spacing and underlinePosition + var lineSpacing = 1; + var underlinePosition = 0; + + _height = 96d / 72d * _size * lineSpacing; + _underlineOffset = 96d / 72d * _size * (lineSpacing + underlinePosition); + + } + + public string Name { get; set; } + + + public override double Size + { + get { return _size; } + } + + public override double UnderlineOffset + { + get { return _underlineOffset; } + } + + public override double Height + { + get { return _height; } + } + + public override double LeftPadding + { + get { return _height / 6f; } + } + + public override double GetWhitespaceWidth(RGraphics graphics) + { + if (_whitespaceWidth < 0) + { + _whitespaceWidth = graphics.MeasureString(" ", this).Width; + } + return _whitespaceWidth; + } + + public FontStyle FontStyle => Style.HasFlag(RFontStyle.Italic) ? FontStyle.Italic : FontStyle.Normal; + + public FontWeight Weight => Style.HasFlag(RFontStyle.Bold) ? FontWeight.Bold : FontWeight.Normal; + } +} \ No newline at end of file diff --git a/src/Perspex.HtmlRenderer/Adapters/FontFamilyAdapter.cs b/src/Perspex.HtmlRenderer/Adapters/FontFamilyAdapter.cs new file mode 100644 index 0000000000..eefc632dcf --- /dev/null +++ b/src/Perspex.HtmlRenderer/Adapters/FontFamilyAdapter.cs @@ -0,0 +1,29 @@ +// "Therefore those skilled at the unorthodox +// are infinite as heaven and earth, +// inexhaustible as the great rivers. +// When they come to an end, +// they begin again, +// like the days and months; +// they die and are reborn, +// like the four seasons." +// +// - Sun Tsu, +// "The Art of War" + +using TheArtOfDev.HtmlRenderer.Adapters; + +namespace TheArtOfDev.HtmlRenderer.Perspex.Adapters +{ + /// + /// Adapter for Perspex Font family object for core. + /// + internal sealed class FontFamilyAdapter : RFontFamily + { + public FontFamilyAdapter(string fontFamily) + { + Name = fontFamily; + } + + public override string Name { get; } + } +} \ No newline at end of file diff --git a/src/Perspex.HtmlRenderer/Adapters/GraphicsAdapter.cs b/src/Perspex.HtmlRenderer/Adapters/GraphicsAdapter.cs new file mode 100644 index 0000000000..415363a5c0 --- /dev/null +++ b/src/Perspex.HtmlRenderer/Adapters/GraphicsAdapter.cs @@ -0,0 +1,295 @@ +// "Therefore those skilled at the unorthodox +// are infinite as heaven and earth, +// inexhaustible as the great rivers. +// When they come to an end, +// they begin again, +// like the days and months; +// they die and are reborn, +// like the four seasons." +// +// - Sun Tsu, +// "The Art of War" + +using System; +using System.Collections.Generic; +using System.Globalization; +using Perspex; +using Perspex.Media; +using TheArtOfDev.HtmlRenderer.Adapters; +using TheArtOfDev.HtmlRenderer.Adapters.Entities; +using TheArtOfDev.HtmlRenderer.Core.Utils; +using TheArtOfDev.HtmlRenderer.Perspex.Utilities; + +namespace TheArtOfDev.HtmlRenderer.Perspex.Adapters +{ + /// + /// Adapter for Perspex Graphics. + /// + internal sealed class GraphicsAdapter : RGraphics + { + #region Fields and Consts + + /// + /// The wrapped Perspex graphics object + /// + private readonly IDrawingContext _g; + + /// + /// if to release the graphics object on dispose + /// + private readonly bool _releaseGraphics; + + #endregion + + + private Stack _clipStack = new Stack(); + + + /// + /// Init. + /// + /// the Perspex graphics object to use + /// the initial clip of the graphics + /// optional: if to release the graphics object on dispose (default - false) + public GraphicsAdapter(IDrawingContext g, RRect initialClip, bool releaseGraphics = false) + : base(PerspexAdapter.Instance, initialClip) + { + ArgChecker.AssertArgNotNull(g, "g"); + + _g = g; + _releaseGraphics = releaseGraphics; + } + + /// + /// Init. + /// + public GraphicsAdapter() + : base(PerspexAdapter.Instance, RRect.Empty) + { + _g = null; + _releaseGraphics = false; + } + + + + public override void PopClip() + { + _clipStack.Pop()?.Dispose(); + } + + public override void PushClip(RRect rect) + { + _clipStack.Push(_g.PushClip(Util.Convert(rect))); + //_clipStack.Push(rect); + //_g.PushClip(new RectangleGeometry(Utils.Convert(rect))); + } + + public override void PushClipExclude(RRect rect) + { + _clipStack.Push(null); + + //TODO: Implement exclude rect, see #128 + //var geometry = new CombinedGeometry(); + //geometry.Geometry1 = new RectangleGeometry(Utils.Convert(_clipStack.Peek())); + //geometry.Geometry2 = new RectangleGeometry(Utils.Convert(rect)); + //geometry.GeometryCombineMode = GeometryCombineMode.Exclude; + + //_clipStack.Push(_clipStack.Peek()); + //_g.PushClip(geometry); + } + + public override Object SetAntiAliasSmoothingMode() + { + return null; + } + + public override void ReturnPreviousSmoothingMode(Object prevMode) + { } + + public override RSize MeasureString(string str, RFont font) + { + var text = GetText(str, font); + var measure = text.Measure(); + return new RSize(measure.Width, measure.Height); + + } + + FormattedText GetText(string str, RFont font) + { + var f = ((FontAdapter)font); + return new FormattedText(str, f.Name, font.Size, f.FontStyle, TextAlignment.Left, f.Weight); + } + + public override void MeasureString(string str, RFont font, double maxWidth, out int charFit, out double charFitWidth) + { + var text = GetText(str, font); + var fullLength = text.Measure().Width; + if (fullLength < maxWidth) + { + charFitWidth = fullLength; + charFit = str.Length; + return; + } + + int lastLen = 0; + double lastMeasure = 0; + BinarySearch(len => + { + text = GetText(str.Substring(0, len), font); + var size = text.Measure().Width; + lastMeasure = size; + lastLen = len; + if (size <= maxWidth) + return -1; + return 1; + + }, 0, str.Length); + if (lastMeasure > maxWidth) + { + lastLen--; + lastMeasure = GetText(str.Substring(0, lastLen), font).Measure().Width; + } + charFit = lastLen; + charFitWidth = lastMeasure; + + } + + private static int BinarySearch(Func condition, int start, int end) + { + do + { + int ind = start + (end - start)/2; + int res = condition(ind); + if (res == 0) + return ind; + else if (res > 0) + { + if (start != ind) + start = ind; + else + start = ind + 1; + } + else + end = ind; + + } while (end > start); + return -1; + } + + public override void DrawString(string str, RFont font, RColor color, RPoint point, RSize size, bool rtl) + { + var text = GetText(str, font); + text.Constraint = Util.Convert(size); + _g.DrawText(new SolidColorBrush(Util.Convert(color)), Util.Convert(point), text); + } + + public override RBrush GetTextureBrush(RImage image, RRect dstRect, RPoint translateTransformLocation) + { + //TODO: Implement texture brush + return PerspexAdapter.Instance.GetSolidBrush(Util.Convert(Colors.Magenta)); + + //var brush = new ImageBrush(((ImageAdapter)image).Image); + //brush.Stretch = Stretch.None; + //brush.TileMode = TileMode.Tile; + //brush.Viewport = Utils.Convert(dstRect); + //brush.ViewportUnits = BrushMappingMode.Absolute; + //brush.Transform = new TranslateTransform(translateTransformLocation.X, translateTransformLocation.Y); + //brush.Freeze(); + //return new BrushAdapter(brush); + } + + public override RGraphicsPath GetGraphicsPath() + { + return new GraphicsPathAdapter(); + } + + public override void Dispose() + { + while (_clipStack.Count != 0) + PopClip(); + if (_releaseGraphics) + _g.Dispose(); + } + + + #region Delegate graphics methods + + public override void DrawLine(RPen pen, double x1, double y1, double x2, double y2) + { + x1 = (int)x1; + x2 = (int)x2; + y1 = (int)y1; + y2 = (int)y2; + + var adj = pen.Width; + if (Math.Abs(x1 - x2) < .1 && Math.Abs(adj % 2 - 1) < .1) + { + x1 += .5; + x2 += .5; + } + if (Math.Abs(y1 - y2) < .1 && Math.Abs(adj % 2 - 1) < .1) + { + y1 += .5; + y2 += .5; + } + + _g.DrawLine(((PenAdapter)pen).CreatePen(), new Point(x1, y1), new Point(x2, y2)); + } + + public override void DrawRectangle(RPen pen, double x, double y, double width, double height) + { + var adj = pen.Width; + if (Math.Abs(adj % 2 - 1) < .1) + { + x += .5; + y += .5; + } + _g.DrawRectange(((PenAdapter) pen).CreatePen(), new Rect(x, y, width, height)); + } + + public override void DrawRectangle(RBrush brush, double x, double y, double width, double height) + { + _g.FillRectange(((BrushAdapter) brush).Brush, new Rect(x, y, width, height)); + } + + public override void DrawImage(RImage image, RRect destRect, RRect srcRect) + { + _g.DrawImage(((ImageAdapter) image).Image, 1, Util.Convert(srcRect), Util.Convert(destRect)); + } + + public override void DrawImage(RImage image, RRect destRect) + { + _g.DrawImage(((ImageAdapter) image).Image, 1, new Rect(0, 0, image.Width, image.Height), + Util.Convert(destRect)); + } + + public override void DrawPath(RPen pen, RGraphicsPath path) + { + _g.DrawGeometry(null, ((PenAdapter)pen).CreatePen(), ((GraphicsPathAdapter)path).GetClosedGeometry()); + } + + public override void DrawPath(RBrush brush, RGraphicsPath path) + { + _g.DrawGeometry(((BrushAdapter)brush).Brush, null, ((GraphicsPathAdapter)path).GetClosedGeometry()); + } + + public override void DrawPolygon(RBrush brush, RPoint[] points) + { + if (points != null && points.Length > 0) + { + var g = new StreamGeometry(); + using (var context = g.Open()) + { + context.BeginFigure(Util.Convert(points[0]), true); + for (int i = 1; i < points.Length; i++) + context.LineTo(Util.Convert(points[i])); + context.EndFigure(false); + } + + _g.DrawGeometry(((BrushAdapter)brush).Brush, null, g); + } + } + + #endregion + } +} \ No newline at end of file diff --git a/src/Perspex.HtmlRenderer/Adapters/GraphicsPathAdapter.cs b/src/Perspex.HtmlRenderer/Adapters/GraphicsPathAdapter.cs new file mode 100644 index 0000000000..5ccfa7140c --- /dev/null +++ b/src/Perspex.HtmlRenderer/Adapters/GraphicsPathAdapter.cs @@ -0,0 +1,67 @@ +// "Therefore those skilled at the unorthodox +// are infinite as heaven and earth, +// inexhaustible as the great rivers. +// When they come to an end, +// they begin again, +// like the days and months; +// they die and are reborn, +// like the four seasons." +// +// - Sun Tsu, +// "The Art of War" + +using Perspex; +using Perspex.Media; +using TheArtOfDev.HtmlRenderer.Adapters; + +namespace TheArtOfDev.HtmlRenderer.Perspex.Adapters +{ + /// + /// Adapter for Perspex graphics path object for core. + /// + internal sealed class GraphicsPathAdapter : RGraphicsPath + { + /// + /// The actual Perspex graphics geometry instance. + /// + private readonly StreamGeometry _geometry = new StreamGeometry(); + + /// + /// The context used in Perspex geometry to render path + /// + private readonly StreamGeometryContext _geometryContext; + + public GraphicsPathAdapter() + { + _geometryContext = _geometry.Open(); + } + + public override void Start(double x, double y) + { + _geometryContext.BeginFigure(new Point(x, y), true); + } + + public override void LineTo(double x, double y) + { + _geometryContext.LineTo(new Point(x, y)); + } + + public override void ArcTo(double x, double y, double size, Corner corner) + { + _geometryContext.ArcTo(new Point(x, y), new Size(size, size), 0, false, SweepDirection.Clockwise); + } + + /// + /// Close the geometry to so no more path adding is allowed and return the instance so it can be rendered. + /// + public StreamGeometry GetClosedGeometry() + { + _geometryContext.EndFigure(true); + _geometryContext.Dispose(); + return _geometry; + } + + public override void Dispose() + { } + } +} \ No newline at end of file diff --git a/src/Perspex.HtmlRenderer/Adapters/ImageAdapter.cs b/src/Perspex.HtmlRenderer/Adapters/ImageAdapter.cs new file mode 100644 index 0000000000..ed6a41d20b --- /dev/null +++ b/src/Perspex.HtmlRenderer/Adapters/ImageAdapter.cs @@ -0,0 +1,52 @@ +// "Therefore those skilled at the unorthodox +// are infinite as heaven and earth, +// inexhaustible as the great rivers. +// When they come to an end, +// they begin again, +// like the days and months; +// they die and are reborn, +// like the four seasons." +// +// - Sun Tsu, +// "The Art of War" + +using Perspex.Media.Imaging; +using TheArtOfDev.HtmlRenderer.Adapters; + +namespace TheArtOfDev.HtmlRenderer.Perspex.Adapters +{ + /// + /// Adapter for Perspex Image object for core. + /// + internal sealed class ImageAdapter : RImage + { + /// + /// the underline Perspex image. + /// + private readonly Bitmap _image; + + /// + /// Init. + /// + public ImageAdapter(Bitmap image) + { + _image = image; + } + + /// + /// the underline Perspex image. + /// + public Bitmap Image => _image; + + public override double Width => _image.PixelWidth; + + public override double Height => _image.PixelHeight; + + public override void Dispose() + { + //TODO: Implement image disposal + /*if (_image.StreamSource != null) + _image.StreamSource.Dispose();*/ + } + } +} \ No newline at end of file diff --git a/src/Perspex.HtmlRenderer/Adapters/PenAdapter.cs b/src/Perspex.HtmlRenderer/Adapters/PenAdapter.cs new file mode 100644 index 0000000000..fa0960cf3f --- /dev/null +++ b/src/Perspex.HtmlRenderer/Adapters/PenAdapter.cs @@ -0,0 +1,79 @@ +// "Therefore those skilled at the unorthodox +// are infinite as heaven and earth, +// inexhaustible as the great rivers. +// When they come to an end, +// they begin again, +// like the days and months; +// they die and are reborn, +// like the four seasons." +// +// - Sun Tsu, +// "The Art of War" + +using System.Collections.Generic; +using Perspex.Media; +using TheArtOfDev.HtmlRenderer.Adapters; +using TheArtOfDev.HtmlRenderer.Adapters.Entities; + +namespace TheArtOfDev.HtmlRenderer.Perspex.Adapters +{ + /// + /// Adapter for Perspex pens objects for core. + /// + internal sealed class PenAdapter : RPen + { + /// + /// The actual Perspex brush instance. + /// + private readonly Brush _brush; + + /// + /// the width of the pen + /// + private double _width; + + private DashStyle _dashStyle; + + /// + /// the dash style of the pen + /// + //private DashStyle _dashStyle = DashStyles.Solid; + + /// + /// Init. + /// + public PenAdapter(Brush brush) + { + _brush = brush; + } + + public override double Width + { + get { return _width; } + set { _width = value; } + } + + public override RDashStyle DashStyle + { + set { DashStyles.TryGetValue(value, out _dashStyle); } + } + + private static readonly Dictionary DashStyles = new Dictionary + { + {RDashStyle.Solid,null }, + {RDashStyle.Dash, global::Perspex.Media.DashStyle.Dash }, + {RDashStyle.DashDot, global::Perspex.Media.DashStyle.DashDot }, + {RDashStyle.DashDotDot, global::Perspex.Media.DashStyle.DashDotDot }, + {RDashStyle.Dot, global::Perspex.Media.DashStyle.Dot } + }; + + /// + /// Create the actual Perspex pen instance. + /// + public Pen CreatePen() + { + var pen = new Pen(_brush, _width, _dashStyle); + return pen; + } + } +} \ No newline at end of file diff --git a/src/Perspex.HtmlRenderer/Adapters/PerspexAdapter.cs b/src/Perspex.HtmlRenderer/Adapters/PerspexAdapter.cs new file mode 100644 index 0000000000..67d3c812c6 --- /dev/null +++ b/src/Perspex.HtmlRenderer/Adapters/PerspexAdapter.cs @@ -0,0 +1,112 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Reflection; +using System.Text; +using System.Threading.Tasks; +using Perspex; +using Perspex.Media; +using Perspex.Media.Imaging; +using TheArtOfDev.HtmlRenderer.Adapters; +using TheArtOfDev.HtmlRenderer.Adapters.Entities; +using TheArtOfDev.HtmlRenderer.Perspex.Utilities; + +namespace TheArtOfDev.HtmlRenderer.Perspex.Adapters +{ + class PerspexAdapter : RAdapter + { + public static PerspexAdapter Instance { get; } = new PerspexAdapter(); + + /// + /// List of valid predefined color names in lower-case + /// + private static readonly Dictionary ColorNameDic = new Dictionary(); + + + static PerspexAdapter() + { + foreach (var colorProp in typeof(Colors).GetRuntimeProperties() + .Where(p=>p.PropertyType == typeof(Color))) + { + ColorNameDic[colorProp.Name.ToLower()] = (Color)colorProp.GetValue(null); + } + } + + protected override RColor GetColorInt(string colorName) + { + Color c; + if(!ColorNameDic.TryGetValue(colorName.ToLower(), out c)) + return RColor.Empty; + return Util.Convert(c); + } + + protected override RPen CreatePen(RColor color) + { + return new PenAdapter(GetSolidColorBrush(color)); + } + + /// + /// Get solid color brush for the given color. + /// + private static Brush GetSolidColorBrush(RColor color) + { + Brush solidBrush; + if (color == RColor.White) + solidBrush = Brushes.White; + else if (color == RColor.Black) + solidBrush = Brushes.Black; + else if (color.A < 1) + solidBrush = Brushes.Transparent; + else + solidBrush = new SolidColorBrush(Util.Convert(color)); + return solidBrush; + } + + protected override RBrush CreateSolidBrush(RColor color) + { + return new BrushAdapter(GetSolidColorBrush(color)); + } + + protected override RBrush CreateLinearGradientBrush(RRect rect, RColor color1, RColor color2, double angle) + { + var startColor = angle <= 180 ? Util.Convert(color1) : Util.Convert(color2); + var endColor = angle <= 180 ? Util.Convert(color2) : Util.Convert(color1); + angle = angle <= 180 ? angle : angle - 180; + double x = angle < 135 ? Math.Max((angle - 45) / 90, 0) : 1; + double y = angle <= 45 ? Math.Max(0.5 - angle / 90, 0) : angle > 135 ? Math.Abs(1.5 - angle / 90) : 0; + return new BrushAdapter(new LinearGradientBrush + { + StartPoint = new Point(x, y), + EndPoint = new Point(1 - x, 1 - y), + GradientStops = + { + new GradientStop(startColor, 0), + new GradientStop(endColor, 1) + } + }); + + } + + protected override RImage ConvertImageInt(object image) + { + return image != null ? new ImageAdapter((Bitmap)image) : null; + } + + protected override RImage ImageFromStreamInt(Stream memoryStream) + { + //TODO: Implement bitmap loader + return null; + } + + protected override RFont CreateFontInt(string family, double size, RFontStyle style) + { + return new FontAdapter(family, size, style); + } + + protected override RFont CreateFontInt(RFontFamily family, double size, RFontStyle style) + { + return new FontAdapter(family.Name, size, style); + } + } +} diff --git a/src/Perspex.HtmlRenderer/Compat/Attributes.cs b/src/Perspex.HtmlRenderer/Compat/Attributes.cs new file mode 100644 index 0000000000..87ca0819a1 --- /dev/null +++ b/src/Perspex.HtmlRenderer/Compat/Attributes.cs @@ -0,0 +1,28 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +internal class CategoryAttribute : Attribute +{ + public CategoryAttribute(string s) + { + + } +} +internal class DescriptionAttribute : Attribute +{ + public DescriptionAttribute(string s) + { + + } +} + +internal class BrowsableAttribute : Attribute +{ + public BrowsableAttribute(bool b) + { + + } +} \ No newline at end of file diff --git a/src/Perspex.HtmlRenderer/Compat/ThreadPool.cs b/src/Perspex.HtmlRenderer/Compat/ThreadPool.cs new file mode 100644 index 0000000000..140625d189 --- /dev/null +++ b/src/Perspex.HtmlRenderer/Compat/ThreadPool.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using TheArtOfDev.HtmlRenderer.Core.Handlers; + +namespace System.Threading +{ + class ThreadPool + { + public static void QueueUserWorkItem(Action cb, object state) + { + Task.Factory.StartNew(() => cb(state)); + } + + public static void QueueUserWorkItem(Action cb) + { + Task.Factory.StartNew(() => cb(null)); + } + } +} diff --git a/src/Perspex.HtmlRenderer/HtmlContainer.cs b/src/Perspex.HtmlRenderer/HtmlContainer.cs new file mode 100644 index 0000000000..ead879b116 --- /dev/null +++ b/src/Perspex.HtmlRenderer/HtmlContainer.cs @@ -0,0 +1,471 @@ +// "Therefore those skilled at the unorthodox +// are infinite as heaven and earth, +// inexhaustible as the great rivers. +// When they come to an end, +// they begin again, +// like the days and months; +// they die and are reborn, +// like the four seasons." +// +// - Sun Tsu, +// "The Art of War" + +using System; +using System.Collections.Generic; +using Perspex; +using Perspex.Controls; +using Perspex.Controls.Html; +using Perspex.Input; +using Perspex.Media; +using TheArtOfDev.HtmlRenderer.Adapters.Entities; +using TheArtOfDev.HtmlRenderer.Core; +using TheArtOfDev.HtmlRenderer.Core.Entities; +using TheArtOfDev.HtmlRenderer.Core.Parse; +using TheArtOfDev.HtmlRenderer.Core.Utils; +using TheArtOfDev.HtmlRenderer.Perspex.Adapters; +using TheArtOfDev.HtmlRenderer.Perspex.Utilities; + +namespace TheArtOfDev.HtmlRenderer.Perspex +{ + /// + /// Low level handling of Html Renderer logic, this class is used by , + /// , and .
    + ///     + /// + public sealed class HtmlContainer : IDisposable + { + #region Fields and Consts + + /// + /// The internal core html container + /// + private readonly HtmlContainerInt _htmlContainerInt; + + #endregion + + + /// + /// Init. + /// + public HtmlContainer() + { + _htmlContainerInt = new HtmlContainerInt(PerspexAdapter.Instance); + } + + /// + /// Raised when the set html document has been fully loaded.
    + /// Allows manipulation of the html dom, scroll position, etc. + ///     + public event EventHandler LoadComplete + { + add { _htmlContainerInt.LoadComplete += value; } + remove { _htmlContainerInt.LoadComplete -= value; } + } + + /// + /// Raised when the user clicks on a link in the html.
    + /// Allows canceling the execution of the link. + ///     + public event EventHandler LinkClicked + { + add { _htmlContainerInt.LinkClicked += value; } + remove { _htmlContainerInt.LinkClicked -= value; } + } + + /// + /// Raised when html renderer requires refresh of the control hosting (invalidation and re-layout). + /// + /// + /// There is no guarantee that the event will be raised on the main thread, it can be raised on thread-pool thread. + /// + public event EventHandler Refresh + { + add { _htmlContainerInt.Refresh += value; } + remove { _htmlContainerInt.Refresh -= value; } + } + + /// + /// Raised when Html Renderer request scroll to specific location.
    + /// This can occur on document anchor click. + ///     + public event EventHandler ScrollChange + { + add { _htmlContainerInt.ScrollChange += value; } + remove { _htmlContainerInt.ScrollChange -= value; } + } + + /// + /// Raised when an error occurred during html rendering.
    + ///     + /// + /// There is no guarantee that the event will be raised on the main thread, it can be raised on thread-pool thread. + /// + public event EventHandler RenderError + { + add { _htmlContainerInt.RenderError += value; } + remove { _htmlContainerInt.RenderError -= value; } + } + + /// + /// Raised when a stylesheet is about to be loaded by file path or URI by link element.
    + /// This event allows to provide the stylesheet manually or provide new source (file or Uri) to load from.
    + /// If no alternative data is provided the original source will be used.
    + ///     + public event EventHandler StylesheetLoad + { + add { _htmlContainerInt.StylesheetLoad += value; } + remove { _htmlContainerInt.StylesheetLoad -= value; } + } + + /// + /// Raised when an image is about to be loaded by file path or URI.
    + /// This event allows to provide the image manually, if not handled the image will be loaded from file or download from URI. + ///     + public event EventHandler ImageLoad + { + add { _htmlContainerInt.ImageLoad += value; } + remove { _htmlContainerInt.ImageLoad -= value; } + } + + /// + /// The internal core html container + /// + internal HtmlContainerInt HtmlContainerInt + { + get { return _htmlContainerInt; } + } + + /// + /// the parsed stylesheet data used for handling the html + /// + public CssData CssData + { + get { return _htmlContainerInt.CssData; } + } + + /// + /// Gets or sets a value indicating if image asynchronous loading should be avoided (default - false).
    + /// True - images are loaded synchronously during html parsing.
    + /// False - images are loaded asynchronously to html parsing when downloaded from URL or loaded from disk.
    + ///     + /// + /// Asynchronously image loading allows to unblock html rendering while image is downloaded or loaded from disk using IO + /// ports to achieve better performance.
    + /// Asynchronously image loading should be avoided when the full html content must be available during render, like render to image. + ///     + public bool AvoidAsyncImagesLoading + { + get { return _htmlContainerInt.AvoidAsyncImagesLoading; } + set { _htmlContainerInt.AvoidAsyncImagesLoading = value; } + } + + /// + /// Gets or sets a value indicating if image loading only when visible should be avoided (default - false).
    + /// True - images are loaded as soon as the html is parsed.
    + /// False - images that are not visible because of scroll location are not loaded until they are scrolled to. + ///     + /// + /// Images late loading improve performance if the page contains image outside the visible scroll area, especially if there is large + /// amount of images, as all image loading is delayed (downloading and loading into memory).
    + /// Late image loading may effect the layout and actual size as image without set size will not have actual size until they are loaded + /// resulting in layout change during user scroll.
    + /// Early image loading may also effect the layout if image without known size above the current scroll location are loaded as they + /// will push the html elements down. + ///     + public bool AvoidImagesLateLoading + { + get { return _htmlContainerInt.AvoidImagesLateLoading; } + set { _htmlContainerInt.AvoidImagesLateLoading = value; } + } + + /// + /// Is content selection is enabled for the rendered html (default - true).
    + /// If set to 'false' the rendered html will be static only with ability to click on links. + ///     + public bool IsSelectionEnabled + { + get { return _htmlContainerInt.IsSelectionEnabled; } + set { _htmlContainerInt.IsSelectionEnabled = value; } + } + + /// + /// Is the build-in context menu enabled and will be shown on mouse right click (default - true) + /// + public bool IsContextMenuEnabled + { + get { return _htmlContainerInt.IsContextMenuEnabled; } + set { _htmlContainerInt.IsContextMenuEnabled = value; } + } + + /// + /// The scroll offset of the html.
    + /// This will adjust the rendered html by the given offset so the content will be "scrolled".
    + ///     + /// + /// Element that is rendered at location (50,100) with offset of (0,200) will not be rendered as it + /// will be at -100 therefore outside the client Rect. + /// + public Point ScrollOffset + { + get { return Util.Convert(_htmlContainerInt.ScrollOffset); } + set { _htmlContainerInt.ScrollOffset = Util.Convert(value); } + } + + /// + /// The top-left most location of the rendered html.
    + /// This will offset the top-left corner of the rendered html. + ///     + public Point Location + { + get { return Util.Convert(_htmlContainerInt.Location); } + set { _htmlContainerInt.Location = Util.Convert(value); } + } + + /// + /// The max width and height of the rendered html.
    + /// The max width will effect the html layout wrapping lines, resize images and tables where possible.
    + /// The max height does NOT effect layout, but will not render outside it (clip).
    + /// can be exceed the max size by layout restrictions (unwrappable line, set image size, etc.).
    + /// Set zero for unlimited (width\height separately).
    + ///     + public Size MaxSize + { + get { return Util.Convert(_htmlContainerInt.MaxSize); } + set { _htmlContainerInt.MaxSize = Util.Convert(value); } + } + + /// + /// The actual size of the rendered html (after layout) + /// + public Size ActualSize + { + get { return Util.Convert(_htmlContainerInt.ActualSize); } + internal set { _htmlContainerInt.ActualSize = Util.Convert(value); } + } + + /// + /// Get the currently selected text segment in the html. + /// + public string SelectedText + { + get { return _htmlContainerInt.SelectedText; } + } + + /// + /// Copy the currently selected html segment with style. + /// + public string SelectedHtml + { + get { return _htmlContainerInt.SelectedHtml; } + } + + /// + /// Clear the current selection. + /// + public void ClearSelection() + { + HtmlContainerInt.ClearSelection(); + } + + /// + /// Init with optional document and stylesheet. + /// + /// the html to init with, init empty if not given + /// optional: the stylesheet to init with, init default if not given + public void SetHtml(string htmlSource, CssData baseCssData = null) + { + _htmlContainerInt.SetHtml(htmlSource, baseCssData); + } + + /// + /// Clear the content of the HTML container releasing any resources used to render previously existing content. + /// + public void Clear() + { + _htmlContainerInt.Clear(); + } + + /// + /// Get html from the current DOM tree with style if requested. + /// + /// Optional: controls the way styles are generated when html is generated (default: ) + /// generated html + public string GetHtml(HtmlGenerationStyle styleGen = HtmlGenerationStyle.Inline) + { + return _htmlContainerInt.GetHtml(styleGen); + } + + /// + /// Get attribute value of element at the given x,y location by given key.
    + /// If more than one element exist with the attribute at the location the inner most is returned. + ///     + /// the location to find the attribute at + /// the attribute key to get value by + /// found attribute value or null if not found + public string GetAttributeAt(Point location, string attribute) + { + return _htmlContainerInt.GetAttributeAt(Util.Convert(location), attribute); + } + + /// + /// Get all the links in the HTML with the element Rect and href data. + /// + /// collection of all the links in the HTML + public List> GetLinks() + { + var linkElements = new List>(); + foreach (var link in HtmlContainerInt.GetLinks()) + { + linkElements.Add(new LinkElementData(link.Id, link.Href, Util.Convert(link.Rectangle))); + } + return linkElements; + } + + /// + /// Get css link href at the given x,y location. + /// + /// the location to find the link at + /// css link href if exists or null + public string GetLinkAt(Point location) + { + return _htmlContainerInt.GetLinkAt(Util.Convert(location)); + } + + /// + /// Get the Rect of html element as calculated by html layout.
    + /// Element if found by id (id attribute on the html element).
    + /// Note: to get the screen Rect you need to adjust by the hosting control.
    + ///     + /// the id of the element to get its Rect + /// the Rect of the element or null if not found + public Rect? GetElementRectangle(string elementId) + { + var r = _htmlContainerInt.GetElementRectangle(elementId); + return r.HasValue ? Util.Convert(r.Value) : (Rect?)null; + } + + /// + /// Measures the bounds of box and children, recursively. + /// + public void PerformLayout() + { + using (var ig = new GraphicsAdapter()) + { + _htmlContainerInt.PerformLayout(ig); + } + } + + /// + /// Render the html using the given device. + /// + /// the device to use to render + /// the clip rectangle of the html container + public void PerformPaint(IDrawingContext g, Rect clip) + { + ArgChecker.AssertArgNotNull(g, "g"); + + using (var ig = new GraphicsAdapter(g, Util.Convert(clip))) + { + _htmlContainerInt.PerformPaint(ig); + } + } + + /// + /// Handle mouse down to handle selection. + /// + /// the control hosting the html to invalidate + /// the mouse event args + public void HandleLeftMouseDown(Control parent, PointerEventArgs e) + { + ArgChecker.AssertArgNotNull(parent, "parent"); + ArgChecker.AssertArgNotNull(e, "e"); + + _htmlContainerInt.HandleMouseDown(new ControlAdapter(parent), Util.Convert(e.GetPosition(parent))); + } + + /// + /// Handle mouse up to handle selection and link click. + /// + /// the control hosting the html to invalidate + /// the mouse event args + public void HandleLeftMouseUp(Control parent, PointerEventArgs e) + { + ArgChecker.AssertArgNotNull(parent, "parent"); + ArgChecker.AssertArgNotNull(e, "e"); + + var mouseEvent = new RMouseEvent(true); + _htmlContainerInt.HandleMouseUp(new ControlAdapter(parent), Util.Convert(e.GetPosition(parent)), mouseEvent); + } + + /// + /// Handle mouse double click to select word under the mouse. + /// + /// the control hosting the html to set cursor and invalidate + /// mouse event args + public void HandleMouseDoubleClick(Control parent, PointerEventArgs e) + { + ArgChecker.AssertArgNotNull(parent, "parent"); + ArgChecker.AssertArgNotNull(e, "e"); + + _htmlContainerInt.HandleMouseDoubleClick(new ControlAdapter(parent), Util.Convert(e.GetPosition(parent))); + } + + /// + /// Handle mouse move to handle hover cursor and text selection. + /// + /// the control hosting the html to set cursor and invalidate + /// the mouse event args + public void HandleMouseMove(Control parent, Point mousePos) + { + ArgChecker.AssertArgNotNull(parent, "parent"); + + _htmlContainerInt.HandleMouseMove(new ControlAdapter(parent), Util.Convert(mousePos)); + } + + /// + /// Handle mouse leave to handle hover cursor. + /// + /// the control hosting the html to set cursor and invalidate + public void HandleMouseLeave(Control parent) + { + ArgChecker.AssertArgNotNull(parent, "parent"); + + _htmlContainerInt.HandleMouseLeave(new ControlAdapter(parent)); + } + + /// + /// Handle key down event for selection and copy. + /// + /// the control hosting the html to invalidate + /// the pressed key + public void HandleKeyDown(Control parent, KeyEventArgs e) + { + ArgChecker.AssertArgNotNull(parent, "parent"); + ArgChecker.AssertArgNotNull(e, "e"); + + _htmlContainerInt.HandleKeyDown(new ControlAdapter(parent), CreateKeyEevent(e)); + } + + /// + /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources. + /// + public void Dispose() + { + _htmlContainerInt.Dispose(); + } + + + #region Private methods + + /// + /// Create HtmlRenderer key event from Perspex key event. + /// + private static RKeyEvent CreateKeyEevent(KeyEventArgs e) + { + var control = (e.Modifiers & ModifierKeys.Control) == ModifierKeys.Control; + return new RKeyEvent(control, e.Key == Key.A, e.Key == Key.C); + } + + #endregion + } +} \ No newline at end of file diff --git a/src/Perspex.HtmlRenderer/HtmlControl.cs b/src/Perspex.HtmlRenderer/HtmlControl.cs new file mode 100644 index 0000000000..2b42e6960c --- /dev/null +++ b/src/Perspex.HtmlRenderer/HtmlControl.cs @@ -0,0 +1,608 @@ +// "Therefore those skilled at the unorthodox +// are infinite as heaven and earth, +// inexhaustible as the great rivers. +// When they come to an end, +// they begin again, +// like the days and months; +// they die and are reborn, +// like the four seasons." +// +// - Sun Tsu, +// "The Art of War" + +using System; +using Perspex.Controls.Primitives; +using Perspex.HtmlRenderer; +using Perspex.Input; +using Perspex.Interactivity; +using Perspex.Media; +using Perspex.Threading; +using TheArtOfDev.HtmlRenderer.Core; +using TheArtOfDev.HtmlRenderer.Core.Entities; +using TheArtOfDev.HtmlRenderer.Perspex; +using TheArtOfDev.HtmlRenderer.Perspex.Adapters; + +namespace Perspex.Controls.Html +{ + /// + /// Provides HTML rendering using the text property.
    + /// Perspex control that will render html content in it's client rectangle.
    + /// The control will handle mouse and keyboard events on it to support html text selection, copy-paste and mouse clicks.
    + /// + /// The major differential to use HtmlPanel or HtmlLabel is size and scrollbars.
    + /// If the size of the control depends on the html content the HtmlLabel should be used.
    + /// If the size is set by some kind of layout then HtmlPanel is more suitable, also shows scrollbars if the html contents is larger than the control client rectangle.
    + ///     + /// + ///

    LinkClicked event:

    + /// Raised when the user clicks on a link in the html.
    + /// Allows canceling the execution of the link. + ///     + /// + ///

    StylesheetLoad event:

    + /// Raised when a stylesheet is about to be loaded by file path or URI by link element.
    + /// This event allows to provide the stylesheet manually or provide new source (file or uri) to load from.
    + /// If no alternative data is provided the original source will be used.
    + ///     + /// + ///

    ImageLoad event:

    + /// Raised when an image is about to be loaded by file path or URI.
    + /// This event allows to provide the image manually, if not handled the image will be loaded from file or download from URI. + ///     + /// + ///

    RenderError event:

    + /// Raised when an error occurred during html rendering.
    + ///     + ///     + + public class HtmlControl : Control + { + /// + /// Underline html container instance. + /// + protected readonly HtmlContainer _htmlContainer; + + /// + /// the base stylesheet data used in the control + /// + protected CssData _baseCssData; + + /// + /// The last position of the scrollbars to know if it has changed to update mouse + /// + protected Point _lastScrollOffset; + + public static readonly PerspexProperty AvoidImagesLateLoadingProperty = + PropertyHelper.Register("AvoidImagesLateLoading", false, OnPerspexProperty_valueChanged); + public static readonly PerspexProperty IsSelectionEnabledProperty = + PropertyHelper.Register("IsSelectionEnabled", true, OnPerspexProperty_valueChanged); + public static readonly PerspexProperty IsContextMenuEnabledProperty = + PropertyHelper.Register("IsContextMenuEnabled", true, OnPerspexProperty_valueChanged); + + public static readonly PerspexProperty BaseStylesheetProperty = + PropertyHelper.Register("BaseStylesheet", null, OnPerspexProperty_valueChanged); + + public static readonly PerspexProperty TextProperty = + PropertyHelper.Register("Text", null, OnPerspexProperty_valueChanged); + + public static readonly PerspexProperty BackgroundProperty = + PerspexProperty.Register("Background", Brushes.White); + + public static readonly PerspexProperty BorderThicknessProperty = + PerspexProperty.Register("BorderThickness", new Thickness(0)); + + public static readonly PerspexProperty BorderBrushProperty = + PerspexProperty.Register("BorderBrush"); + + public static readonly PerspexProperty PaddingProperty = + PerspexProperty.Register("Padding", new Thickness(0)); + + public static readonly RoutedEvent LoadCompleteEvent = + RoutedEvent.Register("LoadComplete", RoutingStrategies.Bubble, typeof(HtmlControl)); + public static readonly RoutedEvent LinkClickedEvent = + RoutedEvent.Register>("LinkClicked", RoutingStrategies.Bubble, typeof(HtmlControl)); + public static readonly RoutedEvent RenderErrorEvent + = RoutedEvent.Register>("RenderError", RoutingStrategies.Bubble, typeof(HtmlControl)); + public static readonly RoutedEvent RefreshEvent + = RoutedEvent.Register>("Refresh", RoutingStrategies.Bubble, typeof(HtmlControl)); + public static readonly RoutedEvent StylesheetLoadEvent + = RoutedEvent.Register>("StylesheetLoad", RoutingStrategies.Bubble, typeof(HtmlControl)); + + public static readonly RoutedEvent ImageLoadEvent + = RoutedEvent.Register>("ImageLoad", RoutingStrategies.Bubble, + typeof (HtmlControl)); + + + + /// + /// Creates a new HtmlPanel and sets a basic css for it's styling. + /// + protected HtmlControl() + { + _htmlContainer = new HtmlContainer(); + _htmlContainer.LoadComplete += (_, e) => OnLoadComplete(e); + _htmlContainer.LinkClicked += (_, e) => OnLinkClicked(e); + _htmlContainer.RenderError += (_, e) => OnRenderError(e); + _htmlContainer.Refresh += (_, e) => OnRefresh(e); + _htmlContainer.StylesheetLoad += (_, e) => OnStylesheetLoad(e); + _htmlContainer.ImageLoad += (_, e) => OnImageLoad(e); + } + + //Hack for adapter + internal bool LeftMouseButton { get; private set; } + + /// + /// Raised when the set html document has been fully loaded.
    + /// Allows manipulation of the html dom, scroll position, etc. + ///     + public event EventHandler> LoadComplete + { + add { AddHandler(LoadCompleteEvent, value); } + remove { RemoveHandler(LoadCompleteEvent, value); } + } + + /// + /// Raised when the user clicks on a link in the html.
    + /// Allows canceling the execution of the link. + ///     + public event EventHandler> LinkClicked + { + add { AddHandler(LinkClickedEvent, value); } + remove { RemoveHandler(LinkClickedEvent, value); } + } + + /// + /// Raised when an error occurred during html rendering.
    + ///     + public event EventHandler> RenderError + { + add { AddHandler(RenderErrorEvent, value); } + remove { RemoveHandler(RenderErrorEvent, value); } + } + + /// + /// Raised when a stylesheet is about to be loaded by file path or URI by link element.
    + /// This event allows to provide the stylesheet manually or provide new source (file or uri) to load from.
    + /// If no alternative data is provided the original source will be used.
    + ///     + public event EventHandler> StylesheetLoad + { + add { AddHandler(StylesheetLoadEvent, value); } + remove { RemoveHandler(StylesheetLoadEvent, value); } + } + + /// + /// Raised when an image is about to be loaded by file path or URI.
    + /// This event allows to provide the image manually, if not handled the image will be loaded from file or download from URI. + ///     + public event EventHandler> ImageLoad + { + add { AddHandler(ImageLoadEvent, value); } + remove { RemoveHandler(ImageLoadEvent, value); } + } + + /// + /// Gets or sets a value indicating if image loading only when visible should be avoided (default - false).
    + /// True - images are loaded as soon as the html is parsed.
    + /// False - images that are not visible because of scroll location are not loaded until they are scrolled to. + ///     + /// + /// Images late loading improve performance if the page contains image outside the visible scroll area, especially if there is large + /// amount of images, as all image loading is delayed (downloading and loading into memory).
    + /// Late image loading may effect the layout and actual size as image without set size will not have actual size until they are loaded + /// resulting in layout change during user scroll.
    + /// Early image loading may also effect the layout if image without known size above the current scroll location are loaded as they + /// will push the html elements down. + ///     + [Category("Behavior")] + [Description("If image loading only when visible should be avoided")] + public bool AvoidImagesLateLoading + { + get { return (bool)GetValue(AvoidImagesLateLoadingProperty); } + set { SetValue(AvoidImagesLateLoadingProperty, value); } + } + + /// + /// Is content selection is enabled for the rendered html (default - true).
    + /// If set to 'false' the rendered html will be static only with ability to click on links. + ///     + [Category("Behavior")] + [Description("Is content selection is enabled for the rendered html.")] + public bool IsSelectionEnabled + { + get { return (bool)GetValue(IsSelectionEnabledProperty); } + set { SetValue(IsSelectionEnabledProperty, value); } + } + + /// + /// Is the build-in context menu enabled and will be shown on mouse right click (default - true) + /// + [Category("Behavior")] + [Description("Is the build-in context menu enabled and will be shown on mouse right click.")] + public bool IsContextMenuEnabled + { + get { return (bool)GetValue(IsContextMenuEnabledProperty); } + set { SetValue(IsContextMenuEnabledProperty, value); } + } + + /// + /// Set base stylesheet to be used by html rendered in the panel. + /// + [Category("Appearance")] + [Description("Set base stylesheet to be used by html rendered in the control.")] + public string BaseStylesheet + { + get { return (string)GetValue(BaseStylesheetProperty); } + set { SetValue(BaseStylesheetProperty, value); } + } + + /// + /// Gets or sets the text of this panel + /// + [Description("Sets the html of this control.")] + public string Text + { + get { return (string)GetValue(TextProperty); } + set { SetValue(TextProperty, value); } + } + + public Thickness BorderThickness + { + get { return (Thickness) GetValue(BorderThicknessProperty); } + set { SetValue(BorderThicknessProperty, value); } + } + + public Brush BorderBrush + { + get { return (Brush)GetValue(BorderBrushProperty); } + set { SetValue(BorderThicknessProperty, value); } + } + + public Thickness Padding + { + get { return (Thickness)GetValue(PaddingProperty); } + set { SetValue(PaddingProperty, value); } + } + + public Brush Background + { + get { return (Brush) GetValue(BackgroundProperty); } + set { SetValue(BackgroundProperty, value);} + } + + /// + /// Get the currently selected text segment in the html. + /// + [Browsable(false)] + public virtual string SelectedText + { + get { return _htmlContainer.SelectedText; } + } + + /// + /// Copy the currently selected html segment with style. + /// + [Browsable(false)] + public virtual string SelectedHtml + { + get { return _htmlContainer.SelectedHtml; } + } + + /// + /// Get html from the current DOM tree with inline style. + /// + /// generated html + public virtual string GetHtml() + { + return _htmlContainer != null ? _htmlContainer.GetHtml() : null; + } + + /// + /// Get the rectangle of html element as calculated by html layout.
    + /// Element if found by id (id attribute on the html element).
    + /// Note: to get the screen rectangle you need to adjust by the hosting control.
    + ///     + /// the id of the element to get its rectangle + /// the rectangle of the element or null if not found + public virtual Rect? GetElementRectangle(string elementId) + { + return _htmlContainer != null ? _htmlContainer.GetElementRectangle(elementId) : null; + } + + /// + /// Clear the current selection. + /// + public void ClearSelection() + { + if (_htmlContainer != null) + _htmlContainer.ClearSelection(); + } + + + + //HACK: We don't have support for RenderSize for now + private Size RenderSize => new Size(Bounds.Width, Bounds.Height); + + + public override void Render(IDrawingContext context) + { + context.FillRectange(Background, new Rect(RenderSize)); + + if (BorderThickness != new Thickness(0) && BorderBrush != null) + { + var brush = new SolidColorBrush(Colors.Black); + if (BorderThickness.Top > 0) + context.FillRectange(brush, new Rect(0, 0, RenderSize.Width, BorderThickness.Top)); + if (BorderThickness.Bottom > 0) + context.FillRectange(brush, new Rect(0, RenderSize.Height - BorderThickness.Bottom, RenderSize.Width, BorderThickness.Bottom)); + if (BorderThickness.Left > 0) + context.FillRectange(brush, new Rect(0, 0, BorderThickness.Left, RenderSize.Height)); + if (BorderThickness.Right > 0) + context.FillRectange(brush, new Rect(RenderSize.Width - BorderThickness.Right, 0, BorderThickness.Right, RenderSize.Height)); + } + + var htmlWidth = HtmlWidth(RenderSize); + var htmlHeight = HtmlHeight(RenderSize); + if (_htmlContainer != null && htmlWidth > 0 && htmlHeight > 0) + { + /* + //TODO: Revert antialiasing fixes + var windows = Window.GetWindow(this); + if (windows != null) + { + // adjust render location to round point so we won't get anti-alias smugness + var wPoint = TranslatePoint(new Point(0, 0), windows); + wPoint.Offset(-(int)wPoint.X, -(int)wPoint.Y); + var xTrans = wPoint.X < .5 ? -wPoint.X : 1 - wPoint.X; + var yTrans = wPoint.Y < .5 ? -wPoint.Y : 1 - wPoint.Y; + context.PushTransform(new TranslateTransform(xTrans, yTrans)); + }*/ + + using (context.PushClip(new Rect(Padding.Left + BorderThickness.Left, Padding.Top + BorderThickness.Top, + htmlWidth, (int) htmlHeight))) + { + _htmlContainer.Location = new Point(Padding.Left + BorderThickness.Left, + Padding.Top + BorderThickness.Top); + _htmlContainer.PerformPaint(context, + new Rect(Padding.Left + BorderThickness.Left, Padding.Top + BorderThickness.Top, htmlWidth, + htmlHeight)); + } + + if (!_lastScrollOffset.Equals(_htmlContainer.ScrollOffset)) + { + _lastScrollOffset = _htmlContainer.ScrollOffset; + InvokeMouseMove(); + } + } + } + + /// + /// Handle mouse move to handle hover cursor and text selection. + /// + protected override void OnPointerMoved(PointerEventArgs e) + { + base.OnPointerMoved(e); + if (_htmlContainer != null) + _htmlContainer.HandleMouseMove(this, e.GetPosition(this)); + } + /// + /// Handle mouse leave to handle cursor change. + /// + protected override void OnPointerLeave(PointerEventArgs e) + { + base.OnPointerLeave(e); + if (_htmlContainer != null) + _htmlContainer.HandleMouseLeave(this); + } + + /// + /// Handle mouse down to handle selection. + /// + protected override void OnPointerPressed(PointerPressEventArgs e) + { + base.OnPointerPressed(e); + LeftMouseButton = true; + _htmlContainer?.HandleLeftMouseDown(this, e); + } + + + + /// + /// Handle mouse up to handle selection and link click. + /// + protected override void OnPointerReleased(PointerEventArgs e) + { + base.OnPointerReleased(e); + LeftMouseButton = false; + if (_htmlContainer != null) + _htmlContainer.HandleLeftMouseUp(this, e); + } + + //TODO: Implement double click + /* + /// + /// Handle mouse double click to select word under the mouse. + /// + protected override void OnMouseDoubleClick(MouseButtonEventArgs e) + { + base.OnMouseDoubleClick(e); + if (_htmlContainer != null) + _htmlContainer.HandleMouseDoubleClick(this, e); + } + */ + /// + /// Handle key down event for selection, copy and scrollbars handling. + /// + protected override void OnKeyDown(KeyEventArgs e) + { + base.OnKeyDown(e); + if (_htmlContainer != null) + _htmlContainer.HandleKeyDown(this, e); + } + + void RaiseRouted(RoutedEvent ev, T arg) + { + var e =new HtmlRendererRoutedEventArgs + { + Event = arg, + Source = this, + RoutedEvent = ev, + Route = ev.RoutingStrategies + }; + RaiseEvent(e); + } + + /// + /// Propagate the LoadComplete event from root container. + /// + protected virtual void OnLoadComplete(EventArgs e) => RaiseRouted(LoadCompleteEvent, e); + + /// + /// Propagate the LinkClicked event from root container. + /// + protected virtual void OnLinkClicked(HtmlLinkClickedEventArgs e) => RaiseRouted(LinkClickedEvent, e); + + /// + /// Propagate the Render Error event from root container. + /// + protected virtual void OnRenderError(HtmlRenderErrorEventArgs e) => RaiseRouted(RenderErrorEvent, e); + + /// + /// Propagate the stylesheet load event from root container. + /// + protected virtual void OnStylesheetLoad(HtmlStylesheetLoadEventArgs e) => RaiseRouted(StylesheetLoadEvent, e); + + /// + /// Propagate the image load event from root container. + /// + protected virtual void OnImageLoad(HtmlImageLoadEventArgs e) => RaiseRouted(ImageLoadEvent, e); + + /// + /// Handle html renderer invalidate and re-layout as requested. + /// + protected virtual void OnRefresh(HtmlRefreshEventArgs e) + { + if (e.Layout) + InvalidateMeasure(); + InvalidateVisual(); + } + + /// + /// Get the width the HTML has to render in (not including vertical scroll iff it is visible) + /// + protected virtual double HtmlWidth(Size size) + { + return size.Width - Padding.Left - Padding.Right - BorderThickness.Left - BorderThickness.Right; + } + + /// + /// Get the width the HTML has to render in (not including vertical scroll iff it is visible) + /// + protected virtual double HtmlHeight(Size size) + { + return size.Height - Padding.Top - Padding.Bottom - BorderThickness.Top - BorderThickness.Bottom; + } + + /// + /// call mouse move to handle paint after scroll or html change affecting mouse cursor. + /// + protected virtual void InvokeMouseMove() + { + + _htmlContainer.HandleMouseMove(this, MouseDevice.Instance?.GetPosition(this) ?? default(Point)); + } + + /// + /// Handle when dependency property value changes to update the underline HtmlContainer with the new value. + /// + private static void OnPerspexProperty_valueChanged(PerspexObject PerspexObject, + PerspexPropertyChangedEventArgs e) + { + var control = PerspexObject as HtmlControl; + if (control != null) + { + var htmlContainer = control._htmlContainer; + if (e.Property == AvoidImagesLateLoadingProperty) + { + htmlContainer.AvoidImagesLateLoading = (bool) e.NewValue; + } + else if (e.Property == IsSelectionEnabledProperty) + { + htmlContainer.IsSelectionEnabled = (bool) e.NewValue; + } + else if (e.Property == IsContextMenuEnabledProperty) + { + htmlContainer.IsContextMenuEnabled = (bool) e.NewValue; + } + else if (e.Property == BaseStylesheetProperty) + { + var baseCssData = CssData.Parse(PerspexAdapter.Instance, (string) e.NewValue); + control._baseCssData = baseCssData; + htmlContainer.SetHtml(control.Text, baseCssData); + } + else if (e.Property == TextProperty) + { + htmlContainer.ScrollOffset = new Point(0, 0); + htmlContainer.SetHtml((string) e.NewValue, control._baseCssData); + control.InvalidateMeasure(); + control.InvalidateVisual(); + control.InvokeMouseMove(); + } + } + } + + + //TODO: Implement CheckAccess calls + /* + private void OnLoadComplete(object sender, EventArgs e) + { + + if (CheckAccess()) + OnLoadComplete(e); + else + Dispatcher.Invoke(new Action(OnLinkClicked), e); + + } + + private void OnLinkClicked(object sender, HtmlLinkClickedEventArgs e) + { + if (CheckAccess()) + OnLinkClicked(e); + else + Dispatcher.Invoke(new Action(OnLinkClicked), e); + } + + private void OnRenderError(object sender, HtmlRenderErrorEventArgs e) + { + if (CheckAccess()) + OnRenderError(e); + else + Dispatcher.Invoke(new Action(OnRenderError), e); + } + + private void OnStylesheetLoad(object sender, HtmlStylesheetLoadEventArgs e) + { + if (CheckAccess()) + OnStylesheetLoad(e); + else + Dispatcher.Invoke(new Action(OnStylesheetLoad), e); + } + + private void OnImageLoad(object sender, HtmlImageLoadEventArgs e) + { + if (CheckAccess()) + OnImageLoad(e); + else + Dispatcher.Invoke(new Action(OnImageLoad), e); + } + + private void OnRefresh(object sender, HtmlRefreshEventArgs e) + { + if (CheckAccess()) + OnRefresh(e); + else + Dispatcher.Invoke(new Action(OnRefresh), e); + } + */ + } +} \ No newline at end of file diff --git a/src/Perspex.HtmlRenderer/HtmlLabel.cs b/src/Perspex.HtmlRenderer/HtmlLabel.cs new file mode 100644 index 0000000000..8d96576937 --- /dev/null +++ b/src/Perspex.HtmlRenderer/HtmlLabel.cs @@ -0,0 +1,112 @@ +// "Therefore those skilled at the unorthodox +// are infinite as heaven and earth, +// inexhaustible as the great rivers. +// When they come to an end, +// they begin again, +// like the days and months; +// they die and are reborn, +// like the four seasons." +// +// - Sun Tsu, +// "The Art of War" + +using System; +using Perspex.HtmlRenderer; +using Perspex.Media; +using TheArtOfDev.HtmlRenderer.Adapters.Entities; +using TheArtOfDev.HtmlRenderer.Core; +using TheArtOfDev.HtmlRenderer.Perspex.Adapters; + +namespace Perspex.Controls.Html +{ + /// + /// Provides HTML rendering using the text property.
    + /// WPF control that will render html content in it's client rectangle.
    + /// Using and client can control how the html content effects the + /// size of the label. Either case scrollbars are never shown and html content outside of client bounds will be clipped. + /// MaxWidth/MaxHeight and MinWidth/MinHeight with AutoSize can limit the max/min size of the control
    + /// The control will handle mouse and keyboard events on it to support html text selection, copy-paste and mouse clicks.
    + ///     + /// + /// See for more info. + /// + public class HtmlLabel : HtmlControl + { + #region Dependency properties + + public static readonly PerspexProperty AutoSizeProperty = PropertyHelper.Register("AutoSize", true, OnPerspexProperty_valueChanged); + public static readonly PerspexProperty AutoSizeHeightOnlyProperty = PropertyHelper.Register("AutoSizeHeightOnly", false, OnPerspexProperty_valueChanged); + + #endregion + + + /// + /// Init. + /// + static HtmlLabel() + { + BackgroundProperty.OverrideDefaultValue(Brushes.Transparent); + } + + #region Private methods + + /// + /// Perform the layout of the html in the control. + /// + protected override Size MeasureOverride(Size constraint) + { + if (_htmlContainer != null) + { + using (var ig = new GraphicsAdapter()) + { + var horizontal = Padding.Left + Padding.Right + BorderThickness.Left + BorderThickness.Right; + var vertical = Padding.Top + Padding.Bottom + BorderThickness.Top + BorderThickness.Bottom; + + var size = new Size(Math.Min(MaxWidth, constraint.Width), Math.Min(MaxHeight, constraint.Height)); + var maxSize = new RSize(size.Width < Double.PositiveInfinity ? size.Width - horizontal : 0, size.Height < Double.PositiveInfinity ? size.Height - vertical : 0); + _htmlContainer.HtmlContainerInt.MaxSize = maxSize; + + _htmlContainer.HtmlContainerInt.PerformLayout(ig); + var newSize = _htmlContainer.ActualSize; + constraint = new Size(newSize.Width + horizontal, newSize.Height + vertical); + } + } + + if (double.IsPositiveInfinity(constraint.Width) || double.IsPositiveInfinity(constraint.Height)) + constraint = Size.Empty; + + return constraint; + } + + /// + /// Handle when dependency property value changes to update the underline HtmlContainer with the new value. + /// + private static void OnPerspexProperty_valueChanged(PerspexObject PerspexObject, PerspexPropertyChangedEventArgs e) + { + var control = PerspexObject as HtmlLabel; + if (control != null) + { + if (e.Property == AutoSizeProperty) + { + if ((bool)e.NewValue) + { + PerspexObject.SetValue(AutoSizeHeightOnlyProperty, false); + control.InvalidateMeasure(); + control.InvalidateVisual(); + } + } + else if (e.Property == AutoSizeHeightOnlyProperty) + { + if ((bool)e.NewValue) + { + PerspexObject.SetValue(AutoSizeProperty, false); + control.InvalidateMeasure(); + control.InvalidateVisual(); + } + } + } + } + + #endregion + } +} \ No newline at end of file diff --git a/src/Perspex.HtmlRenderer/HtmlRendererRoutedEventArgs.cs b/src/Perspex.HtmlRenderer/HtmlRendererRoutedEventArgs.cs new file mode 100644 index 0000000000..34db5ff548 --- /dev/null +++ b/src/Perspex.HtmlRenderer/HtmlRendererRoutedEventArgs.cs @@ -0,0 +1,14 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using Perspex.Interactivity; + +namespace Perspex.Controls.Html +{ + public class HtmlRendererRoutedEventArgs : RoutedEventArgs + { + public T Event { get; set; } + } +} diff --git a/src/Perspex.HtmlRenderer/Perspex.HtmlRenderer.csproj b/src/Perspex.HtmlRenderer/Perspex.HtmlRenderer.csproj new file mode 100644 index 0000000000..197ca7634d --- /dev/null +++ b/src/Perspex.HtmlRenderer/Perspex.HtmlRenderer.csproj @@ -0,0 +1,197 @@ + + + + + 10.0 + Debug + AnyCPU + {5FB2B005-0A7F-4DAD-ADD4-3ED01444E63D} + Library + Properties + Perspex.HtmlRenderer + Perspex.HtmlRenderer + en-US + 512 + {786C830F-07A1-408B-BD7F-6EE04809D6DB};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + Profile7 + v4.5 + + + true + full + false + bin\Debug\ + TRACE;DEBUG;PCL + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + {d211e587-d8bc-45b9-95a4-f297c8fa5200} + Perspex.Animation + + + {b09b78d8-9b26-48b0-9149-d64a2f120f3f} + Perspex.Base + + + {D2221C82-4A25-4583-9B43-D791E3F6820C} + Perspex.Controls + + + {62024b2d-53eb-4638-b26b-85eeaa54866e} + Perspex.Input + + + {6b0ed19d-a08b-461c-a9d9-a9ee40b0c06b} + Perspex.Interactivity + + + {42472427-4774-4c81-8aff-9f27b8e31721} + Perspex.Layout + + + {EB582467-6ABB-43A1-B052-E981BA910E3A} + Perspex.SceneGraph + + + {f1baa01a-f176-4c6a-b39d-5b40bb1b148f} + Perspex.Styling + + + + + + + + ..\..\packages\Rx-Core.2.2.5\lib\portable-windows8+net45+wp8\System.Reactive.Core.dll + True + + + ..\..\packages\Rx-Interfaces.2.2.5\lib\portable-windows8+net45+wp8\System.Reactive.Interfaces.dll + True + + + + + + + + + + \ No newline at end of file diff --git a/src/Perspex.HtmlRenderer/Perspex.HtmlRenderer.csproj.DotSettings b/src/Perspex.HtmlRenderer/Perspex.HtmlRenderer.csproj.DotSettings new file mode 100644 index 0000000000..73e96563f9 --- /dev/null +++ b/src/Perspex.HtmlRenderer/Perspex.HtmlRenderer.csproj.DotSettings @@ -0,0 +1,2 @@ + + CSharp60 \ No newline at end of file diff --git a/src/Perspex.HtmlRenderer/Properties/AssemblyInfo.cs b/src/Perspex.HtmlRenderer/Properties/AssemblyInfo.cs new file mode 100644 index 0000000000..9ab512fab5 --- /dev/null +++ b/src/Perspex.HtmlRenderer/Properties/AssemblyInfo.cs @@ -0,0 +1,30 @@ +using System.Resources; +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("Perspex.HtmlRenderer")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Perspex.HtmlRenderer")] +[assembly: AssemblyCopyright("Copyright © 2015")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] +[assembly: NeutralResourcesLanguage("en")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/src/Perspex.HtmlRenderer/PropertyHelper.cs b/src/Perspex.HtmlRenderer/PropertyHelper.cs new file mode 100644 index 0000000000..bd322babf0 --- /dev/null +++ b/src/Perspex.HtmlRenderer/PropertyHelper.cs @@ -0,0 +1,24 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace Perspex.HtmlRenderer +{ + static class PropertyHelper + { + + public static PerspexProperty Register(string name, T def, Action changed) where TOwner : PerspexObject + { + var pp = PerspexProperty.Register(name, def); + Action cb = args => + { + changed(args.Sender, args); + }; + + pp.Changed.Subscribe(cb); + return pp; + } + } +} diff --git a/src/Perspex.HtmlRenderer/Utilities/Util.cs b/src/Perspex.HtmlRenderer/Utilities/Util.cs new file mode 100644 index 0000000000..10722785a6 --- /dev/null +++ b/src/Perspex.HtmlRenderer/Utilities/Util.cs @@ -0,0 +1,123 @@ +// "Therefore those skilled at the unorthodox +// are infinite as heaven and earth, +// inexhaustible as the great rivers. +// When they come to an end, +// they begin again, +// like the days and months; +// they die and are reborn, +// like the four seasons." +// +// - Sun Tsu, +// "The Art of War" + +using Perspex; +using Perspex.Media; +using TheArtOfDev.HtmlRenderer.Adapters.Entities; + +namespace TheArtOfDev.HtmlRenderer.Perspex.Utilities +{ + /// + /// Utilities for converting WPF entities to HtmlRenderer core entities. + /// + internal static class Util + { + /// + /// Convert from WPF point to core point. + /// + public static RPoint Convert(Point p) + { + return new RPoint(p.X, p.Y); + } + + /// + /// Convert from WPF point to core point. + /// + public static Point[] Convert(RPoint[] points) + { + Point[] myPoints = new Point[points.Length]; + for (int i = 0; i < points.Length; i++) + myPoints[i] = Convert(points[i]); + return myPoints; + } + + /// + /// Convert from core point to WPF point. + /// + public static Point Convert(RPoint p) + { + return new Point(p.X, p.Y); + } + + /// + /// Convert from core point to WPF point. + /// + public static Point ConvertRound(RPoint p) + { + return new Point((int)p.X, (int)p.Y); + } + + /// + /// Convert from WPF size to core size. + /// + public static RSize Convert(Size s) + { + return new RSize(s.Width, s.Height); + } + + /// + /// Convert from core size to WPF size. + /// + public static Size Convert(RSize s) + { + return new Size(s.Width, s.Height); + } + + /// + /// Convert from core point to WPF point. + /// + public static Size ConvertRound(RSize s) + { + return new Size((int)s.Width, (int)s.Height); + } + + /// + /// Convert from WPF rectangle to core rectangle. + /// + public static RRect Convert(Rect r) + { + return new RRect(r.X, r.Y, r.Width, r.Height); + } + + /// + /// Convert from core rectangle to WPF rectangle. + /// + public static Rect Convert(RRect r) + { + return new Rect(r.X, r.Y, r.Width, r.Height); + } + + /// + /// Convert from core rectangle to WPF rectangle. + /// + public static Rect ConvertRound(RRect r) + { + return new Rect((int)r.X, (int)r.Y, (int)r.Width, (int)r.Height); + } + + /// + /// Convert from WPF color to core color. + /// + public static RColor Convert(Color c) + { + return RColor.FromArgb(c.A, c.R, c.G, c.B); + } + + /// + /// Convert from core color to WPF color. + /// + public static Color Convert(RColor c) + { + return Color.FromArgb(c.A, c.R, c.G, c.B); + } + } +} \ No newline at end of file diff --git a/src/Perspex.HtmlRenderer/external b/src/Perspex.HtmlRenderer/external new file mode 160000 index 0000000000..9b58697e1c --- /dev/null +++ b/src/Perspex.HtmlRenderer/external @@ -0,0 +1 @@ +Subproject commit 9b58697e1cba93bb86a40eb33b7d8b8fc743e3c0 diff --git a/src/Perspex.HtmlRenderer/packages.config b/src/Perspex.HtmlRenderer/packages.config new file mode 100644 index 0000000000..f23358716a --- /dev/null +++ b/src/Perspex.HtmlRenderer/packages.config @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file