private void AnimatedControl_CreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { // Initialize the brushes. backgroundDefaultBrush = CreateRadialGradientBrush(sender, Color.FromArgb(0x00, 0x6E, 0xEF, 0xF8), Color.FromArgb(0x4D, 0x6E, 0xEF, 0xF8)); backgroundAnswerCorrectBrush = CreateRadialGradientBrush(sender, Color.FromArgb(0x00, 0x42, 0xC9, 0xC5), Color.FromArgb(0x4D, 0x42, 0xC9, 0xC5)); backgroundAnswerIncorrectBrush = CreateRadialGradientBrush(sender, Color.FromArgb(0x00, 0xDE, 0x01, 0x99), Color.FromArgb(0x4D, 0xDE, 0x01, 0x99)); borderDefaultBrush = new CanvasSolidColorBrush(sender, Color.FromArgb(0xFF, 0x6E, 0xEF, 0xF8)); borderGradientBrush = new CanvasLinearGradientBrush(sender, Color.FromArgb(0xFF, 0x0F, 0x56, 0xA4), Color.FromArgb(0xFF, 0x6E, 0xEF, 0xF8)) { StartPoint = new Vector2(centerPoint.X - radius, centerPoint.Y), EndPoint = new Vector2(centerPoint.X + radius, centerPoint.Y) }; borderAnswerCorrectBrush = new CanvasSolidColorBrush(sender, Color.FromArgb(0xFF, 0x42, 0xC9, 0xC5)); borderAnswerIncorrectBrush = new CanvasSolidColorBrush(sender, Color.FromArgb(0xFF, 0xDE, 0x01, 0x99)); // Calculate the text position for vertical centering to account for the // fact that text is not vertically centered within its layout bounds. var textLayout = new CanvasTextLayout(sender, "0123456789", textFormat, 0, 0); var drawMidpoint = (float)(textLayout.DrawBounds.Top + (textLayout.DrawBounds.Height / 2)); var layoutMidpoint = (float)(textLayout.LayoutBounds.Top + (textLayout.LayoutBounds.Height / 2)); var textPositionDelta = drawMidpoint - layoutMidpoint; textPosition = new Vector2(centerPoint.X, centerPoint.Y - textPositionDelta); }
public override void Draw(CanvasControl CanvasControl, CanvasDrawingSession ds, HSL HSL, Vector2 Center, float SquareHalfWidth, float SquareHalfHeight) { //Palette Rect rect = new Rect(Center.X - SquareHalfWidth, Center.Y - SquareHalfHeight, SquareHalfWidth * 2, SquareHalfHeight * 2); using (CanvasLinearGradientBrush rainbow = new CanvasLinearGradientBrush(CanvasControl, this.BackgroundStops)) { rainbow.StartPoint = new Vector2(Center.X - SquareHalfWidth, Center.Y); rainbow.EndPoint = new Vector2(Center.X + SquareHalfWidth, Center.Y); ds.FillRoundedRectangle(rect, 4, 4, rainbow); } using (CanvasLinearGradientBrush brush = new CanvasLinearGradientBrush(CanvasControl, this.ForegroundStops)) { brush.StartPoint = new Vector2(Center.X, Center.Y - SquareHalfHeight); brush.EndPoint = new Vector2(Center.X, Center.Y + SquareHalfHeight); ds.FillRoundedRectangle(rect, 4, 4, brush); } ds.DrawRoundedRectangle(rect, 4, 4, Windows.UI.Colors.Gray); //Thumb float px = ((float)HSL.H - 180) * SquareHalfWidth / 180 + Center.X; float py = (50 - (float)HSL.S) * SquareHalfHeight / 50 + Center.Y; ds.DrawCircle(px, py, 8, Windows.UI.Colors.Black, 4); ds.DrawCircle(px, py, 8, Windows.UI.Colors.White, 2); }
protected void CreateInnerCircleBrush(CanvasControl sender) { Color step1Color = this.GaugeColor; Color step2Color = ColorHelper.FromArgb(step1Color.A, Convert.ToByte(~step1Color.R & 0xFF), Convert.ToByte(~step1Color.G & 0xFF), Convert.ToByte(~step1Color.B & 0xFF)); if (step1Color == Colors.Red) { step2Color = Colors.Black; } var stops = new CanvasGradientStop[] { new CanvasGradientStop() { Color = step1Color, Position = -0.2f }, new CanvasGradientStop() { Color = step2Color, Position = 1.0f }, }; InnerCircleBrush = new CanvasLinearGradientBrush(sender, stops); InnerCircleBrush.StartPoint = new Vector2(Center.X, Center.Y - InnerCircleRadius); InnerCircleBrush.EndPoint = new Vector2(Center.X, Center.Y + InnerCircleRadius); }
void EnsureResources(ICanvasResourceCreatorWithDpi resourceCreator, Size targetSize) { if (resourceRealizationSize != targetSize && !needsResourceRecreation) { return; } float canvasWidth = (float)targetSize.Width; float canvasHeight = (float)targetSize.Height; if (textLayout != null) { textLayout.Dispose(); } textLayout = CreateTextLayout(resourceCreator, canvasWidth, canvasHeight); Rect layoutBounds = textLayout.LayoutBounds; textBrush = new CanvasLinearGradientBrush(resourceCreator, Colors.Red, Colors.Green); textBrush.StartPoint = new System.Numerics.Vector2((float)(layoutBounds.Left + layoutBounds.Right) / 2, (float)layoutBounds.Top); textBrush.EndPoint = new System.Numerics.Vector2((float)(layoutBounds.Left + layoutBounds.Right) / 2, (float)layoutBounds.Bottom); selectionTextBrush = new CanvasLinearGradientBrush(resourceCreator, Colors.Green, Colors.Red); selectionTextBrush.StartPoint = textBrush.StartPoint; selectionTextBrush.EndPoint = textBrush.EndPoint; needsResourceRecreation = false; resourceRealizationSize = targetSize; }
/// <summary> Override <see cref="PalettePicker.Draw"/>. </summary> public override void Draw(CanvasControl sender, CanvasDrawingSession ds, HSV hsv, Vector2 center, float squareHalfWidth, float squareHalfHeight, SolidColorBrush stroke) { //Palette Rect rect = new Rect(center.X - squareHalfWidth, center.Y - squareHalfHeight, squareHalfWidth * 2, squareHalfHeight * 2); using (CanvasLinearGradientBrush rainbow = new CanvasLinearGradientBrush(sender, this.BackgroundStops)) { rainbow.StartPoint = new Vector2(center.X - squareHalfWidth, center.Y); rainbow.EndPoint = new Vector2(center.X + squareHalfWidth, center.Y); ds.FillRoundedRectangle(rect, 4, 4, rainbow); } using (CanvasLinearGradientBrush brush = new CanvasLinearGradientBrush(sender, this.ForegroundStops)) { brush.StartPoint = new Vector2(center.X, center.Y - squareHalfHeight); brush.EndPoint = new Vector2(center.X, center.Y + squareHalfHeight); ds.FillRoundedRectangle(rect, 4, 4, brush); } ds.DrawRoundedRectangle(rect, 4, 4, stroke.Color); //Thumb float px = ((float)hsv.H - 180) * squareHalfWidth / 180 + center.X; float py = (50 - (float)hsv.S) * squareHalfHeight / 50 + center.Y; ds.FillCircle(px, py, 12, stroke.Color); ds.FillCircle(px, py, 11, HSV.HSVtoRGB(hsv)); }
private void canvasControl_Draw(CanvasControl sender, CanvasDrawEventArgs args) { //图片 args.DrawingSession.DrawImage(App.GrayWhiteGrid); //渐变 CanvasLinearGradientBrush Linear = new CanvasLinearGradientBrush(App.Model.VirtualControl, App.Setting.GradientStops.ToArray()); Linear.StartPoint = new Vector2(0, CanvasHalfHeight); Linear.EndPoint = new Vector2(CanvasWidth, CanvasHalfHeight); args.DrawingSession.FillRectangle(0, 0, CanvasWidth + Space + Space, CanvasHeight, Linear); //点 for (int i = 0; i < App.Setting.GradientStops.Count; i++) { Vector2 v = new Vector2(App.Setting.GradientStops[i].Position * CanvasWidth + Space, CanvasHalfHeight); //主点 args.DrawingSession.FillEllipse(v, 10, 10, Colors.Black);//环线 if (i == App.Setting.GradientCurrent) { args.DrawingSession.FillEllipse(v, 9, 9, Colors.White); } else { args.DrawingSession.FillEllipse(v, 9, 9, Colors.DarkGray); args.DrawingSession.FillEllipse(v, 6, 6, Colors.White); } args.DrawingSession.FillEllipse(v, 6, 6, App.Setting.GradientStops[i].Color);//主题色 } }
/// <summary> Override <see cref="PaletteBase.Draw"/>. </summary> public override void Draw(CanvasControl sender, CanvasDrawingSession ds, HSV HSV, Vector2 center, float squareHalfWidth, float squareHalfHeight) { //Palette Rect rect = new Rect(center.X - squareHalfWidth, center.Y - squareHalfHeight, squareHalfWidth * 2, squareHalfHeight * 2); using (CanvasLinearGradientBrush rainbow = new CanvasLinearGradientBrush(sender, this.BackgroundStops)) { rainbow.StartPoint = new Vector2(center.X - squareHalfWidth, center.Y); rainbow.EndPoint = new Vector2(center.X + squareHalfWidth, center.Y); ds.FillRoundedRectangle(rect, 4, 4, rainbow); } using (CanvasLinearGradientBrush brush = new CanvasLinearGradientBrush(sender, this.ForegroundStops)) { brush.StartPoint = new Vector2(center.X, center.Y - squareHalfHeight); brush.EndPoint = new Vector2(center.X, center.Y + squareHalfHeight); ds.FillRoundedRectangle(rect, 4, 4, brush); } ds.DrawRoundedRectangle(rect, 4, 4, Windows.UI.Colors.Gray); //Thumb float px = ((float)HSV.H - 180) * squareHalfWidth / 180 + center.X; float py = ((float)(50 - HSV.V)) * squareHalfHeight / 50 + center.Y; ds.DrawCircle(px, py, 9, Windows.UI.Colors.Black, 5); ds.DrawCircle(px, py, 9, Windows.UI.Colors.White, 3); }
private void Dispose(bool disposing) { if (_canvasLinearGradientBrush != null) { _canvasLinearGradientBrush.Dispose(); _canvasLinearGradientBrush = null; } }
//@Constructs /// <summary> /// Initialize a brush for drawing dotted-line. /// </summary> /// <param name="resourceCreator"> The resource-creator. </param> /// <param name="distance"> The sistance between two gradient points. </param> public DottedLineBrush(ICanvasResourceCreator resourceCreator, float distance = 6) { this.Brush = new CanvasLinearGradientBrush(resourceCreator, Stops, CanvasEdgeBehavior.Mirror, CanvasAlphaMode.Premultiplied) { StartPoint = new Vector2(0, 0), EndPoint = new Vector2(distance, distance) }; }
private void CustomVisualizer_Draw(IVisualizer sender, VisualizerDrawEventArgs args) { if (!MainPageViewModel.Current.IsVisualizing) { return; } var drawingSession = (CanvasDrawingSession)args.DrawingSession; float barWidth = canvasWidth / (2 * Consts.SpectrumBarCount); // Calculate spectum metrics var barSize = new Vector2(barWidth, canvasHeight - 2 * barWidth); // Get the data if data exists and source is in play state, else use empty var spectrumData = args.Data != null && Visualizer.Source?.PlaybackState == SourcePlaybackState.Playing ? args.Data.Spectrum.LogarithmicTransform(Consts.SpectrumBarCount, 20f, 20000f) : _emptySpectrum; _previousSpectrum = spectrumData.ApplyRiseAndFall(_previousSpectrum, _rmsRiseTime, _rmsFallTime, _frameDuration); _previousPeakSpectrum = spectrumData.ApplyRiseAndFall(_previousPeakSpectrum, _peakRiseTime, _peakFallTime, _frameDuration); var logSpectrum = _previousSpectrum.ConvertToDecibels(-50, 0); var logPeakSpectrum = _previousPeakSpectrum.ConvertToDecibels(-50, 0); var step = canvasWidth / Consts.SpectrumBarCount; var flaw = (step - barSize.X) / 2; using (var brush = new CanvasLinearGradientBrush(drawingSession, new CanvasGradientStop[] { new CanvasGradientStop() { Color = Context.CurrentColor[0], Position = 0f }, new CanvasGradientStop() { Color = Context.CurrentColor[1], Position = 1f } }) { StartPoint = new Vector2(canvasWidth, 0), EndPoint = new Vector2(0, canvasHeight) }) { // Draw spectrum bars for (int index = 0; index < Consts.SpectrumBarCount; index++) { float barX = step * index + flaw; // use average of 2 channel float spectrumBarHeight = barSize.Y * (1.0f - (logSpectrum[0][index] + logSpectrum[1][index]) / -100.0f); drawingSession.FillRoundedRectangle(barX, canvasHeight - barWidth - spectrumBarHeight, barSize.X, spectrumBarHeight, barSize.X / 2, barSize.X / 2, brush); } } // Spectrum points to draw a slow decay line for (int index = 0; index < Consts.SpectrumBarCount; index++) { float X = (index + 0.5f) * step; float spectrumBarHeight = barSize.Y * (1.0f - (logPeakSpectrum[0][index] + logPeakSpectrum[1][index]) / -100.0f); var decayPoint = new Vector2(X, canvasHeight - barWidth - spectrumBarHeight); drawingSession.FillCircle(decayPoint, barSize.X / 2, Context.CurrentColor[0]); } }
private CanvasLinearGradientBrush CreateLinearGradient(CanvasDrawingSession session, Rect area, SvgLinearGradientElement element) { if (this.ResourceCache.ContainsKey(element)) { return((CanvasLinearGradientBrush)this.ResourceCache[element]); } var stops = element.ChildNodes.Cast <SvgStopElement>().Select(s => { var alpha = s.Style.StopOpacity.HasValue ? (byte)(255.0F * s.Style.StopOpacity.Value) : (byte)0xff; var stop = new CanvasGradientStop() { Position = s.Offset, Color = s.Style.StopColor.StopColorType == SvgStopColorType.CurrentColor ? s.Style.Color.ToPlatformColor(alpha) : s.Style.StopColor?.ToPlatformColor(alpha) ?? Color.FromArgb(alpha, 0, 0, 0) }; return(stop); }).ToArray(); var m = element.GradientTransform.Result; var transform = new Matrix3x2 { M11 = (float)m.A, M12 = (float)m.B, M21 = (float)m.C, M22 = (float)m.D, M31 = (float)m.E, M32 = (float)m.F }; float x1, y1, x2, y2; if (element.GradientUnits != SvgUnitType.UserSpaceOnUse) { x1 = this.LengthConverter.ConvertXForOBBU(element.X1, (float)area.X, (float)area.Width); y1 = this.LengthConverter.ConvertYForOBBU(element.Y1, (float)area.Y, (float)area.Height); x2 = this.LengthConverter.ConvertXForOBBU(element.X2, (float)area.X, (float)area.Width); y2 = this.LengthConverter.ConvertYForOBBU(element.Y2, (float)area.Y, (float)area.Height); } else { x1 = this.LengthConverter.ConvertX(element.X1); y1 = this.LengthConverter.ConvertY(element.Y1); x2 = this.LengthConverter.ConvertX(element.X2); y2 = this.LengthConverter.ConvertY(element.Y2); } var spreadMethod = GetSpreadMethod(element.SpreadMethod); var brush = new CanvasLinearGradientBrush(this.ResourceCreator, stops, spreadMethod, CanvasAlphaMode.Straight) { StartPoint = new Vector2 { X = x1, Y = y1 }, EndPoint = new Vector2 { X = x2, Y = y2 }, Transform = transform, }; this.DisposableObjects.Add(brush); this.ResourceCache.Add(element, brush); return(brush); }
/// <summary> /// background design /// </summary> /// <param name="dp"></param> /// <param name="sr"></param> protected virtual void drawBackground(DrawProperty dp, ScreenRect sr) { var bg = new CanvasLinearGradientBrush(dp.Canvas, Parent.BackgroundColor1, Parent.BackgroundColor2) { StartPoint = _(ScreenPos.From(sr.LT.X, sr.LT.Y)), EndPoint = _(ScreenPos.From(sr.RB.X, sr.RB.Y)), }; dp.Graphics.FillRectangle(_(dp.PaneRect), bg); }
/// <summary> /// Creates the CanvasLinearGradientBrush from the parsed data /// </summary> /// <param name="resourceCreator">ICanvasResourceCreator object</param> /// <returns></returns> public override ICanvasBrush CreateBrush(ICanvasResourceCreator resourceCreator) { var brush = CanvasLinearGradientBrush.CreateHdr(resourceCreator, _gradientStopHdrs.ToArray(), _edgeBehavior, _alphaMode, _preInterpolationColorSpace, _postInterpolationColorSpace, _bufferPrecision); brush.StartPoint = _startPoint; brush.EndPoint = _endPoint; brush.Opacity = _opacity; return(brush); }
async Task Canvas_CreateResourcesAsync(CanvasControl sender) { bitmap = await CanvasBitmap.LoadAsync(sender, "imageTiger.jpg"); redBrush = CreateGradientBrush(sender, 255, 0, 0); greenBrush = CreateGradientBrush(sender, 0, 255, 0); blueBrush = CreateGradientBrush(sender, 0, 0, 255); brightnessEffect = new BrightnessEffect { Source = bitmap }; saturationEffect = new SaturationEffect { Source = brightnessEffect }; hueEffect = new HueRotationEffect { Source = saturationEffect }; }
//初始化:?????? public Lasso2(ICanvasResourceCreator rc, float Distance = 6, float Spa = 1) { CommandList = new CanvasCommandList(rc); StartPoint = new Vector2(0, 0); EndPoint = new Vector2(Distance, Distance); Space = new Vector2(Spa, Spa); lgb = new CanvasLinearGradientBrush(rc, stop, CanvasEdgeBehavior.Mirror, CanvasAlphaMode.Premultiplied); lgb.StartPoint = StartPoint; lgb.EndPoint = EndPoint; }
public void SetGradientPoints(winFound.Rect bounds) { CanvasLinearGradientBrush brush = Brush as CanvasLinearGradientBrush; if (brush == null) { return; } brush.StartPoint = new Vector2((float)(bounds.Left + StartPoint.X * bounds.Width), (float)(bounds.Top + StartPoint.Y * bounds.Height)); brush.EndPoint = new Vector2((float)(bounds.Left + EndPoint.X * bounds.Width), (float)(bounds.Top + EndPoint.Y * bounds.Height)); }
private CanvasLinearGradientBrush CreateLinearGradient(CanvasDrawingSession session, Rect area, SvgLinearGradientElement element) { if (this.ResourceCache.ContainsKey(element)) { return((CanvasLinearGradientBrush)this.ResourceCache[element]); } var stops = element.ChildNodes.Cast <SvgStopElement>().Select(s => { var alpha = s.Style.StopOpacity.HasValue ? (byte)(255.0F * s.Style.StopOpacity.Value) : (byte)0xff; var stop = new CanvasGradientStop() { Position = s.Offset, Color = Color.FromArgb(alpha, s.Style.StopColor.RgbColor.Red, s.Style.StopColor.RgbColor.Green, s.Style.StopColor.RgbColor.Blue) }; return(stop); }).ToArray(); var m = element.GradientTransform.Result; if (element.GradientUnits == SvgUnitType.ObjectBoundingBox) { m = new SvgMatrix(area.Width, 0.0, 0.0, area.Height, area.X, area.Y) * m; } var transform = new Matrix3x2 { M11 = (float)m.A, M12 = (float)m.B, M21 = (float)m.C, M22 = (float)m.D, M31 = (float)m.E, M32 = (float)m.F }; var x1 = this.LengthConverter.ConvertX(element.X1); var y1 = this.LengthConverter.ConvertY(element.Y1); var x2 = this.LengthConverter.ConvertX(element.X2); var y2 = this.LengthConverter.ConvertY(element.Y2); var spreadMethod = GetSpreadMethod(element.SpreadMethod); var brush = new CanvasLinearGradientBrush(this.ResourceCreator, stops, spreadMethod, CanvasAlphaMode.Straight) { StartPoint = new Vector2 { X = x1, Y = y1 }, EndPoint = new Vector2 { X = x2, Y = y2 }, Transform = transform, }; this.DisposableObjects.Add(brush); this.ResourceCache.Add(element, brush); return(brush); }
private void prologControl_CreateResources(Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.CanvasCreateResourcesEventArgs args) { var stops = new CanvasGradientStop[] { new CanvasGradientStop() { Color = Colors.Transparent, Position = 0.0f }, new CanvasGradientStop() { Color = Color.FromArgb(0xff, 0x53, 0xef, 0xef), Position = 0.1f }, new CanvasGradientStop() { Color = Color.FromArgb(0xff, 0x53, 0xef, 0xef), Position = 0.9f }, new CanvasGradientStop() { Color = Colors.Transparent, Position = 1.0f } }; mTextOpacityBrush = new CanvasLinearGradientBrush(sender, stops, CanvasEdgeBehavior.Clamp, CanvasAlphaMode.Premultiplied); stops = new CanvasGradientStop[] { new CanvasGradientStop() { Color = Colors.White, Position = 0.0f }, new CanvasGradientStop() { Color = Colors.Transparent, Position = 0.3f }, new CanvasGradientStop() { Color = Colors.Transparent, Position = 0.7f }, new CanvasGradientStop() { Color = Colors.White, Position = 1.0f }, }; mBlurOpacityBrush = new CanvasLinearGradientBrush(sender, stops, CanvasEdgeBehavior.Clamp, CanvasAlphaMode.Premultiplied); }
public UGLinearGradientBrush(IUGContext context, Vector2 startPoint, Vector2 endPoint, IEnumerable <UGGradientStop> gradientStops, UGEdgeBehavior edgeBehavior) { var count = gradientStops.Count(); if (count < 2) { throw new ArgumentException(nameof(gradientStops)); } var device = ((UGContext)context).Device; var winrtStops = gradientStops.ToWinRTGradientStops(); var native = new CanvasLinearGradientBrush(device, winrtStops, edgeBehavior.ToWinRTEdgeBehavior(), CanvasAlphaMode.Premultiplied); native.StartPoint = startPoint; native.EndPoint = endPoint; _native = native; }
private void OnCreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { var stops = new CanvasGradientStop[] { new CanvasGradientStop() { Color = Colors.Transparent, Position = 0.1f }, new CanvasGradientStop() { Color = Colors.White, Position = 0.3f }, new CanvasGradientStop() { Color = Colors.White, Position = 0.7f }, new CanvasGradientStop() { Color = Colors.Transparent, Position = 0.9f }, }; textOpacityBrush = new CanvasLinearGradientBrush(sender, stops, CanvasEdgeBehavior.Clamp, CanvasAlphaMode.Premultiplied); stops = new CanvasGradientStop[] { new CanvasGradientStop() { Color = Colors.White, Position = 0.0f }, new CanvasGradientStop() { Color = Colors.Transparent, Position = 0.3f }, new CanvasGradientStop() { Color = Colors.Transparent, Position = 0.7f }, new CanvasGradientStop() { Color = Colors.White, Position = 1.0f }, }; blurOpacityBrush = new CanvasLinearGradientBrush(sender, stops, CanvasEdgeBehavior.Clamp, CanvasAlphaMode.Premultiplied); }
public static void CalculateGradient( Color clr1, Color clr2, int nThickness, IList <Color> list) { list.Clear(); int nWidth = nThickness; CanvasGradientStop[] grad_stops = new CanvasGradientStop[2]; grad_stops[0] = new CanvasGradientStop(); grad_stops[0].Color = clr1; grad_stops[0].Position = 0.0f; grad_stops[1] = new CanvasGradientStop(); grad_stops[1].Color = clr2; grad_stops[1].Position = 1.0f; CanvasDevice device = CanvasDevice.GetSharedDevice(); CanvasLinearGradientBrush brush = new CanvasLinearGradientBrush(device, grad_stops); brush.StartPoint = new Vector2(0, 0); brush.EndPoint = new Vector2(nWidth, 0); using (CanvasRenderTarget offscreen = new CanvasRenderTarget(device, nWidth, 1, 96, Windows.Graphics.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized, CanvasAlphaMode.Premultiplied)) { using (CanvasDrawingSession ds = offscreen.CreateDrawingSession()) { ds.DrawRectangle(new Rect(0, 0, nWidth, 1), brush); } uint stride = 4; byte[] pixels = offscreen.GetPixelBytes(); for (uint row = 0; row < 1; ++row) { for (uint col = 0; col < nWidth; ++col) { uint index = (uint)(row * stride + col) * 4; uint color = pixels[index]; Color gdiColor = Color.FromArgb(pixels[index + 3], pixels[index + 2], pixels[index + 1], pixels[index]); list.Add(gdiColor); } } } }
public TextControl() { this.InitializeComponent(); _textFormat = new CanvasTextFormat { FontFamily = "Consolas", FontSize = 12, WordWrapping = CanvasWordWrapping.NoWrap }; CanvasRoot.CreateResources += (s, e) => { _defaultForegroundBrush = new CanvasSolidColorBrush(s, _defaultForegroundColor); _addedForegroundBrush = new CanvasSolidColorBrush(s, _addedForegroundColor); _removedForegroundBrush = new CanvasSolidColorBrush(s, _removedForegroundColor); var stops = new CanvasGradientStop[4] { new CanvasGradientStop { Color = _defaultBackgroundColor, Position = 0 }, new CanvasGradientStop { Color = _defaultBackgroundColor, Position = 0.5f }, new CanvasGradientStop { Color = _nullBackgroundColor, Position = 0.5f }, new CanvasGradientStop { Color = _nullBackgroundColor, Position = 1 } }; _nullBrush = new CanvasLinearGradientBrush(s, stops, CanvasEdgeBehavior.Mirror, CanvasAlphaMode.Premultiplied) { StartPoint = new System.Numerics.Vector2(0, 0), EndPoint = new System.Numerics.Vector2(4, 4) }; }; CanvasRoot.SizeChanged += (s, e) => { CanvasRoot.Invalidate(); }; }
private void Dispose(bool disposing) { if (_canvasLinearGradientBrush != null) { try { _canvasLinearGradientBrush.Dispose(); } catch { // Ignore } finally { _canvasLinearGradientBrush = null; } } }
public override ICanvasBrush GetBrush(CanvasDevice device, byte alpha) { var startPoint = new Vector2(_x0, _y0); var endPoint = new Vector2(_x1, _y1); startPoint = LocalMatrix.Transform(startPoint); endPoint = LocalMatrix.Transform(endPoint); var canvasLinearGradientBrush = new CanvasLinearGradientBrush(device, _canvasGradientStopCollection, CanvasEdgeBehavior.Clamp, CanvasAlphaMode.Straight) { StartPoint = startPoint, EndPoint = endPoint, Opacity = alpha / 255f }; return(canvasLinearGradientBrush); }
private void CanvasAnimatedControl_Draw(Microsoft.Graphics.Canvas.UI.Xaml.ICanvasAnimatedControl sender, Microsoft.Graphics.Canvas.UI.Xaml.CanvasAnimatedDrawEventArgs args) { using (var cpb = new CanvasPathBuilder(args.DrawingSession)) { cpb.BeginFigure(0, height); average = averageSmoother.Smooth(AudioManager.AudioAverage); Vector2 p0 = new Vector2(Point0, height - Adjust(smoother1.Smooth(AudioManager.AudioSpec1)) * height); Vector2 p1 = new Vector2(Point1, height - Adjust(smoother2.Smooth(AudioManager.AudioSpec2)) * height); Vector2 p2 = new Vector2(Point2, height - Adjust(smoother3.Smooth(AudioManager.AudioSpec3)) * height); Vector2 p3 = new Vector2(Point3, height - Adjust(smoother4.Smooth(AudioManager.AudioSpec4)) * height); Vector2 p4 = new Vector2(Point4, height - Adjust(smoother5.Smooth(AudioManager.AudioSpec5)) * height); Vector2 p5 = new Vector2(Point5, height - Adjust(smoother6.Smooth(AudioManager.AudioSpec6)) * height); Vector2 p6 = new Vector2(Point6, height - Adjust(smoother7.Smooth(AudioManager.AudioSpec7)) * height); Vector2 p7 = new Vector2(Point7, height - Adjust(smoother8.Smooth(AudioManager.AudioSpec8)) * height); Vector2 p8 = new Vector2(Point8, height - Adjust(smoother9.Smooth(AudioManager.AudioSpec9)) * height); cpb.AddLine(p0); cpb.AddCubicBezier(GetC1(p0), GetC2(p1), p1); cpb.AddCubicBezier(GetC1(p1), GetC2(p2), p2); cpb.AddCubicBezier(GetC1(p2), GetC2(p3), p3); cpb.AddCubicBezier(GetC1(p3), GetC2(p4), p4); cpb.AddCubicBezier(GetC1(p4), GetC2(p5), p5); cpb.AddCubicBezier(GetC1(p5), GetC2(p6), p6); cpb.AddCubicBezier(GetC1(p6), GetC2(p7), p7); cpb.AddCubicBezier(GetC1(p7), GetC2(p8), p8); cpb.AddLine(new Vector2(p8.X, height)); cpb.EndFigure(CanvasFigureLoop.Closed); CanvasLinearGradientBrush gradient = new CanvasLinearGradientBrush(sender, TransparentBlurple, Blurple) { EndPoint = new Vector2(0, height + 48), StartPoint = new Vector2(0, -12) }; var path = CanvasGeometry.CreatePath(cpb); //args.DrawingSession.DrawGeometry(path, Blurple, 1); args.DrawingSession.FillGeometry(path, gradient); } }
internal virtual void fillLinearGradient(int startColor, int endColor, int x, int y, int width, int height, bool horizontal) { //using (createAlphaLayer()) //{ var starcolor = new Color() { A = (byte)alpha, B = (byte)(startColor & 0xff), G = (byte)((startColor >> 8) & 0xff), R = (byte)((startColor >> 16) & 0xff) }; var endcolor = new Color() { A = (byte)alpha, B = (byte)(endColor & 0xff), G = (byte)((endColor >> 8) & 0xff), R = (byte)((endColor >> 16) & 0xff) }; CanvasLinearGradientBrush brush = new CanvasLinearGradientBrush(graphics, starcolor, endcolor); brush.StartPoint = new Vector2() { X = x, Y = y, }; if (horizontal) { brush.EndPoint = new Vector2() { X = x + width, Y = y, }; } else { brush.EndPoint = new Vector2() { X = x, Y = y + height, }; } graphics.FillRectangle(x, y, width, height, brush); //} }
void CreateLinearGradient(ICanvasResourceCreator resourceCreator) { var commandList = new CanvasCommandList(resourceCreator); using (var drawingSession = commandList.CreateDrawingSession()) { var brush = new CanvasLinearGradientBrush(resourceCreator, Colors.White, Colors.Black) { StartPoint = new Vector2(-tigerSize.X / 4, 0), EndPoint = new Vector2(tigerSize.X * 5 / 4, 0), }; // Expand the bounds to avoid going past the edge of the gradient as we rotate it. var expandedBounds = new Rect((-tigerSize).ToPoint(), (tigerSize * 2).ToPoint()); drawingSession.FillRectangle(expandedBounds, brush); } linearGradient = new Transform2DEffect { Source = commandList }; }
void m_canvasControl_CreateResources(CanvasControl sender, object args) { m_bitmap_tiger = null; m_bitmap_colorGrids = null; UpdateCanvasControlSize(); m_imageBrush = new CanvasImageBrush(sender); m_offscreenTarget = new CanvasRenderTarget(sender, 100, 100); using (CanvasDrawingSession ds = m_offscreenTarget.CreateDrawingSession()) { ds.Clear(Colors.DarkBlue); ds.FillRoundedRectangle(new Rect(0, 0, 100, 100), 30, 30, Colors.DarkRed); ds.DrawRoundedRectangle(new Rect(0, 0, 100, 100), 30, 30, Colors.LightGreen); ds.DrawText("Abc", 0, 0, Colors.LightGray); ds.DrawText("Def", 25, 25, Colors.LightGray); ds.DrawText("Efg", 50, 50, Colors.LightGray); } CanvasGradientStop[] stops = new CanvasGradientStop[4]; stops[0].Position = 0; stops[0].Color = Colors.Black; stops[1].Position = 1; stops[1].Color = Colors.White; stops[2].Position = 0.2f; stops[2].Color = Colors.Purple; stops[3].Position = 0.7f; stops[3].Color = Colors.Green; m_linearGradientBrush = CanvasLinearGradientBrush.CreateRainbow(sender, 0.0f); m_radialGradientBrush = new CanvasRadialGradientBrush( sender, stops, CanvasEdgeBehavior.Clamp, CanvasAlphaMode.Premultiplied); }
public static CanvasRenderTarget GenImage(int width, int height, CanvasLinearGradientBrush brush, byte alpha) { CanvasDevice device = CanvasDevice.GetSharedDevice(); CanvasRenderTarget offscreen = new CanvasRenderTarget(device, width, height, 96, Windows.Graphics.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized, CanvasAlphaMode.Premultiplied); using (CanvasDrawingSession ds = offscreen.CreateDrawingSession()) { ds.FillRectangle(new Rect(0.0, 0.0, offscreen.SizeInPixels.Width, offscreen.SizeInPixels.Height), brush); } byte[] pixels = offscreen.GetPixelBytes(); if (pixels == null) { return(null); } uint col = 0; uint stride = offscreen.SizeInPixels.Width; for (uint row = 0; row < offscreen.SizeInPixels.Height; ++row) { uint total_row_len = (uint)(row * stride); for (col = 0; col < offscreen.SizeInPixels.Width; ++col) { uint index = (total_row_len + col) * 4; pixels[index + 3] = alpha; } } offscreen.SetPixelBytes(pixels); return(offscreen); }
void CreateLinearGradient(ICanvasResourceCreator resourceCreator) { var commandList = new CanvasCommandList(resourceCreator); using (var drawingSession = commandList.CreateDrawingSession()) { var brush = new CanvasLinearGradientBrush(resourceCreator, Colors.White, Colors.Black) { StartPoint = new Vector2(-tigerSize.X / 4, 0), EndPoint = new Vector2(tigerSize.X * 5 / 4, 0), }; drawingSession.FillRectangle(bitmapTiger.Bounds, brush); } // Wrap the gradient with a border effect to avoid edge artifacts as we rotate it. linearGradient = new Transform2DEffect { Source = new BorderEffect { Source = commandList } }; }
private void OnCreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args) { var stops = new CanvasGradientStop[] { new CanvasGradientStop() { Color=Colors.Transparent, Position=0.1f }, new CanvasGradientStop() { Color=Colors.White, Position = 0.3f }, new CanvasGradientStop() { Color=Colors.White, Position = 0.7f }, new CanvasGradientStop() { Color=Colors.Transparent, Position = 0.9f }, }; textOpacityBrush = new CanvasLinearGradientBrush(sender, stops, CanvasEdgeBehavior.Clamp, CanvasAlphaMode.Premultiplied); stops = new CanvasGradientStop[] { new CanvasGradientStop() { Color=Colors.White, Position=0.0f }, new CanvasGradientStop() { Color=Colors.Transparent, Position = 0.3f }, new CanvasGradientStop() { Color=Colors.Transparent, Position = 0.7f }, new CanvasGradientStop() { Color=Colors.White, Position = 1.0f }, }; blurOpacityBrush = new CanvasLinearGradientBrush(sender, stops, CanvasEdgeBehavior.Clamp, CanvasAlphaMode.Premultiplied); }
void DrawHistogram(CanvasDrawingSession drawingSession, Size size, EffectChannelSelect channelSelect, CanvasLinearGradientBrush brush) { const int binCount = 64; const float graphPower = 0.25f; // Nonlinear scale makes the graph show small changes more clearly. float[] histogram = CanvasImage.ComputeHistogram(hueEffect, bitmap.Bounds, drawingSession, channelSelect, binCount); var w = (float)size.Width / binCount; var h = (float)size.Height; for (int i = 0; i < binCount; i++) { var x = i * w; var y = (1 - (float)Math.Pow(histogram[i], graphPower)) * h; brush.StartPoint = new Vector2(x, y); brush.EndPoint = new Vector2(x, h); drawingSession.FillRectangle(x, y, w, h - y, brush); } }
/// <summary> /// Creates a reflection of the given Visual /// </summary> /// <param name="visual">Visual whose reflection has to be created</param> /// <param name="reflectionDistance">Distance of the reflection from the visual</param> /// <param name="reflectionLength">Normalized Length of the reflected visual that will be visible.</param> /// <param name="location"> <see cref="ReflectionLocation"/> - Location of the reflection with respect /// to the Visual - Bottom, Top, Left or Right</param> public void CreateReflection(ContainerVisual visual, float reflectionDistance = 0f, float reflectionLength = 0.7f, ReflectionLocation location = ReflectionLocation.Bottom) { // Create the visual layer that will contained the visual's reflection var reflectionLayer = _compositor.CreateLayerVisual(); reflectionLayer.Size = visual.Size; reflectionLayer.CenterPoint = new Vector3(visual.Size * 0.5f, 0); // Create the effect to create the opacity mask var effect = new CompositeEffect { // CanvasComposite.DestinationIn - Intersection of source and mask. // Equation: O = MA * S // where O - Output pixel, MA - Mask Alpha, S - Source pixel. Mode = CanvasComposite.DestinationIn, Sources = { new CompositionEffectSourceParameter("source"), new CompositionEffectSourceParameter("mask") } }; var effectFactory = _compositor.CreateEffectFactory(effect); var effectBrush = effectFactory.CreateBrush(); // Create the gradient brush for the effect var gradientBrush = new CanvasLinearGradientBrush(_canvasDevice, Colors.White, Colors.Transparent); // Based on the reflection location, // Set the Offset, RotationAxis and RotationAngleInDegrees of the reflectionLayer and // set the StartPoint and EndPoint of the gradientBrush switch (location) { case ReflectionLocation.Bottom: reflectionLayer.RotationAxis = new Vector3(1, 0, 0); reflectionLayer.RotationAngleInDegrees = 180; reflectionLayer.Offset = new Vector3(0, visual.Size.Y + reflectionDistance, 0); gradientBrush.StartPoint = new Vector2(visual.Size.X * 0.5f, 0); gradientBrush.EndPoint = new Vector2(visual.Size.X * 0.5f, visual.Size.Y * reflectionLength); break; case ReflectionLocation.Top: reflectionLayer.RotationAxis = new Vector3(1, 0, 0); reflectionLayer.RotationAngleInDegrees = -180; reflectionLayer.Offset = new Vector3(0, -visual.Size.Y - reflectionDistance, 0); gradientBrush.StartPoint = new Vector2(visual.Size.X * 0.5f, visual.Size.Y); gradientBrush.EndPoint = new Vector2(visual.Size.X * 0.5f, visual.Size.Y * (1f - reflectionLength)); break; case ReflectionLocation.Left: reflectionLayer.RotationAxis = new Vector3(0, 1, 0); reflectionLayer.RotationAngleInDegrees = -180; reflectionLayer.Offset = new Vector3(-visual.Size.X - reflectionDistance, 0, 0); gradientBrush.StartPoint = new Vector2(visual.Size.X, visual.Size.Y * 0.5f); gradientBrush.EndPoint = new Vector2(visual.Size.X * (1f - reflectionLength), visual.Size.Y * 0.5f); break; case ReflectionLocation.Right: reflectionLayer.RotationAxis = new Vector3(0, 1, 0); reflectionLayer.RotationAngleInDegrees = 180; reflectionLayer.Offset = new Vector3(visual.Size.X + reflectionDistance, 0, 0); gradientBrush.StartPoint = new Vector2(0, visual.Size.Y * 0.5f); gradientBrush.EndPoint = new Vector2(visual.Size.X * reflectionLength, visual.Size.Y * 0.5f); break; } // Create a mask filled with gradientBrush var mask = CreateGeometrySurface(visual.Size.ToSize(), null, Colors.Transparent, gradientBrush); // Set the 'mask' parameter of the effectBrush effectBrush.SetSourceParameter("mask", _compositor.CreateSurfaceBrush(mask.Surface)); // Set the effect for the reflection layer reflectionLayer.Effect = effectBrush; // Now we need to duplicate the visual tree of the visual ArrangeVisualReflection(visual, reflectionLayer, true); visual.Children.InsertAtTop(reflectionLayer); }
void EnsureResources(ICanvasResourceCreatorWithDpi resourceCreator, Size targetSize) { if (resourceRealizationSize == targetSize && !needsResourceRecreation) return; float canvasWidth = (float)targetSize.Width; float canvasHeight = (float)targetSize.Height; if (textLayout != null) textLayout.Dispose(); textLayout = CreateTextLayout(resourceCreator, canvasWidth, canvasHeight); inlineObject.SetLayout(textLayout); Rect layoutBounds = textLayout.LayoutBounds; textBrush = new CanvasLinearGradientBrush(resourceCreator, Colors.Red, Colors.Green); textBrush.StartPoint = new System.Numerics.Vector2((float)(layoutBounds.Left + layoutBounds.Right) / 2, (float)layoutBounds.Top); textBrush.EndPoint = new System.Numerics.Vector2((float)(layoutBounds.Left + layoutBounds.Right) / 2, (float)layoutBounds.Bottom); selectionTextBrush = new CanvasLinearGradientBrush(resourceCreator, Colors.Green, Colors.Red); selectionTextBrush.StartPoint = textBrush.StartPoint; selectionTextBrush.EndPoint = textBrush.EndPoint; inlineObjectsEnabledChanged = true; needsResourceRecreation = false; resourceRealizationSize = targetSize; }
internal virtual void fillLinearGradient( int startColor, int endColor, int x, int y, int width, int height, bool horizontal) { var starcolor = new Color() { A = 0xff, B = (byte)(startColor & 0xff), G = (byte)((startColor >> 8) & 0xff), R = (byte)((startColor >> 16) & 0xff) }; var endcolor = new Color() { A = 0xff, B = (byte)(endColor & 0xff), G = (byte)((endColor >> 8) & 0xff), R = (byte)((endColor >> 16) & 0xff) }; CanvasLinearGradientBrush brush = new CanvasLinearGradientBrush(graphics, starcolor, endcolor); brush.StartPoint = new Vector2() { X = x, Y = y, }; if (horizontal) { brush.EndPoint = new Vector2() { X = x + width, Y = y, }; } else { brush.EndPoint = new Vector2() { X = x, Y = y + height, }; } graphics.FillRectangle(x, y, width, height, brush); }