internal static async Task Render(CompositionEngine compositionEngine, SharpDX.Direct2D1.RenderTarget renderTarget, FrameworkElement rootElement, Line line)
        {
            var rect = line.GetBoundingRect(rootElement).ToSharpDX();
            var stroke = await line.Stroke.ToSharpDX(renderTarget, rect);

            if (stroke == null ||
                line.StrokeThickness <= 0)
            {
                return;
            }

            var layer = line.CreateAndPushLayerIfNecessary(renderTarget, rootElement);

            renderTarget.DrawLine(
                new Vector2(
                    rect.Left + (float)line.X1,
                    rect.Top + (float)line.Y1),
                new Vector2(
                    rect.Left + (float)line.X2,
                    rect.Top + (float)line.Y2),
                    stroke,
                    (float)line.StrokeThickness,
                    line.GetStrokeStyle(compositionEngine.D2DFactory));

            if (layer != null)
            {
                renderTarget.PopLayer();
                layer.Dispose();
            }
        }
        internal static async Task Render(CompositionEngine compositionEngine, SharpDX.Direct2D1.RenderTarget renderTarget, FrameworkElement rootElement, Jupiter.Shapes.Path path)
        {
            var rect = path.GetBoundingRect(rootElement).ToSharpDX();
            var fill = await path.Fill.ToSharpDX(renderTarget, rect);
            var stroke = await path.Stroke.ToSharpDX(renderTarget, rect);

            var layer = path.CreateAndPushLayerIfNecessary(renderTarget, rootElement);
            var oldTransform = renderTarget.Transform;
            renderTarget.Transform = new Matrix3x2(
                1, 0, 0, 1, rect.Left, rect.Top);
            //renderTarget.PushLayer(ref layerParameters, layer);

            var d2dGeometry = path.Data.ToSharpDX(compositionEngine.D2DFactory, rect);

            if (fill != null)
            {
                renderTarget.FillGeometry(d2dGeometry, fill, null);
            }

            if (stroke != null &&
                path.StrokeThickness > 0)
            {
                renderTarget.DrawGeometry(
                d2dGeometry,
                stroke,
                (float)path.StrokeThickness,
                path.GetStrokeStyle(compositionEngine.D2DFactory));}

            //if (path.StrokeThickness > 0 &&
            //    stroke != null)
            //{
            //    var halfThickness = (float)(path.StrokeThickness * 0.5);
            //    roundedRect.Rect = rect.Eroded(halfThickness);

            //    if (fill != null)
            //    {
            //        renderTarget.FillRoundedRectangle(roundedRect, fill);
            //    }

            //    renderTarget.DrawRoundedRectangle(
            //        roundedRect,
            //        stroke,
            //        (float)path.StrokeThickness,
            //        path.GetStrokeStyle(compositionEngine.D2DFactory));
            //}
            //else
            //{
            //    renderTarget.FillRoundedRectangle(roundedRect, fill);
            //}

            if (layer != null)
            {
                renderTarget.PopLayer();
                layer.Dispose();
            }

            renderTarget.Transform = oldTransform;
        }
        internal static async Task Render(CompositionEngine compositionEngine, SharpDX.Direct2D1.RenderTarget renderTarget, FrameworkElement rootElement, Ellipse ellipse)
        {
            var rect = ellipse.GetBoundingRect(rootElement).ToSharpDX();

            var d2dEllipse = new D2D.Ellipse(
                new Vector2(
                    (float)((rect.Left + rect.Right) * 0.5),
                    (float)((rect.Top + rect.Bottom) * 0.5)),
                (float)(0.5 * rect.Width),
                (float)(0.5 * rect.Height));
            var fill = await ellipse.Fill.ToSharpDX(renderTarget, rect);

            var layer = ellipse.CreateAndPushLayerIfNecessary(renderTarget, rootElement);

            var stroke = await ellipse.Stroke.ToSharpDX(renderTarget, rect);

            if (ellipse.StrokeThickness > 0 &&
                stroke != null)
            {
                var halfStrokeThickness = (float)(ellipse.StrokeThickness * 0.5);
                d2dEllipse.RadiusX -= halfStrokeThickness;
                d2dEllipse.RadiusY -= halfStrokeThickness;

                if (fill != null)
                {
                    renderTarget.FillEllipse(d2dEllipse, fill);
                }

                renderTarget.DrawEllipse(
                    d2dEllipse,
                    stroke,
                    (float)ellipse.StrokeThickness,
                    ellipse.GetStrokeStyle(compositionEngine.D2DFactory));
            }
            else if (fill != null)
            {
                renderTarget.FillEllipse(d2dEllipse, fill);
            }

            if (layer != null)
            {
                renderTarget.PopLayer();
                layer.Dispose();
            }
        }
        internal static async Task Render(CompositionEngine compositionEngine, SharpDX.Direct2D1.RenderTarget renderTarget, FrameworkElement rootElement, Border border)
        {
            var rect = border.GetBoundingRect(rootElement).ToSharpDX();
            var brush = await border.Background.ToSharpDX(renderTarget, rect);

            if (brush != null)
            {
                var geometry = GetBorderFillGeometry(compositionEngine, border, rect);

                var layer = border.CreateAndPushLayerIfNecessary(renderTarget, rootElement);

                renderTarget.FillGeometry(geometry, brush);

                if (layer != null)
                {
                    renderTarget.PopLayer();
                    layer.Dispose();
                }
            }

            await compositionEngine.RenderChildren(renderTarget, rootElement, border);
        }
        internal static async Task Render(CompositionEngine compositionEngine, SharpDX.Direct2D1.RenderTarget renderTarget, Jupiter.FrameworkElement rootElement, Jupiter.Controls.Image image)
        {
            var rect = image.GetBoundingRect(rootElement).ToSharpDX();
            if (rect.Width == 0 ||
                rect.Height == 0)
            {
                return;
            }

            var bitmap = await image.Source.ToSharpDX(renderTarget);

            if (bitmap == null)
            {
                return;
            }

            try
            {
                var layer = image.CreateAndPushLayerIfNecessary(renderTarget, rootElement);

                renderTarget.DrawBitmap(
                    bitmap,
                    rect,
                    (float)image.Opacity,
                    D2D.BitmapInterpolationMode.Linear);

                if (layer != null)
                {
                    renderTarget.PopLayer();
                    layer.Dispose();
                }
            }
            finally
            {
                bitmap.Dispose();
            }
        }
        internal static async Task Render(CompositionEngine compositionEngine, SharpDX.Direct2D1.RenderTarget renderTarget, FrameworkElement rootElement, Rectangle rectangle)
        {
            var rect = rectangle.GetBoundingRect(rootElement).ToSharpDX();
            var fill = await rectangle.Fill.ToSharpDX(renderTarget, rect);
            var stroke = await rectangle.Stroke.ToSharpDX(renderTarget, rect);

            try
            {
                var layer = rectangle.CreateAndPushLayerIfNecessary(renderTarget, rootElement);

                if (rectangle.RadiusX > 0 &&
                    rectangle.RadiusY > 0)
                {
                    var roundedRect = new SharpDX.Direct2D1.RoundedRectangle();
                    roundedRect.Rect = rect;
                    roundedRect.RadiusX = (float)rectangle.RadiusX;
                    roundedRect.RadiusY = (float)rectangle.RadiusY;

                    if (rectangle.StrokeThickness > 0 &&
                        stroke != null)
                    {
                        var halfThickness = (float)(rectangle.StrokeThickness * 0.5);
                        roundedRect.Rect = rect.Eroded(halfThickness);

                        if (fill != null)
                        {
                            renderTarget.FillRoundedRectangle(roundedRect, fill);
                        }

                        renderTarget.DrawRoundedRectangle(
                            roundedRect,
                            stroke,
                            (float)rectangle.StrokeThickness,
                            rectangle.GetStrokeStyle(compositionEngine.D2DFactory));
                    }
                    else
                    {
                        renderTarget.FillRoundedRectangle(roundedRect, fill);
                    }
                }
                else
                {
                    if (rectangle.StrokeThickness > 0 &&
                        stroke != null)
                    {
                        var halfThickness = (float)(rectangle.StrokeThickness * 0.5);

                        if (fill != null)
                        {
                            renderTarget.FillRectangle(rect.Eroded(halfThickness), fill);
                        }

                        var strokeRect = rect.Eroded(halfThickness);
                        renderTarget.DrawRectangle(
                            strokeRect,
                            stroke,
                            (float)rectangle.StrokeThickness,
                            rectangle.GetStrokeStyle(compositionEngine.D2DFactory));
                    }
                    else
                    {
                        renderTarget.FillRectangle(rect, fill);
                    }
                }

                if (layer != null)
                {
                    renderTarget.PopLayer();
                    layer.Dispose();
                }
            }
            finally
            {
                if (fill != null)
                    fill.Dispose();
                if (stroke != null)
                    stroke.Dispose();
            }
        }