private void DrawLine(CanvasControl sender, CanvasDrawingSession ds) { var width = (float)sender.ActualWidth; var height = (float)sender.ActualHeight; var middle = height / 2; int steps = Math.Min((int)(width / 10), 30); for (int i = 0; i < steps; ++i) { var mu = (float)i / steps; var a = (float)(mu * Math.PI * 2); var color = GradientColor(mu); var x = width * mu; var y = (float)(middle + Math.Sin(a) * (middle * 0.3)); var strokeWidth = (float)(Math.Cos(a) + 1) * 5; ds.DrawLine(x, 0, x, y, color, strokeWidth); ds.DrawLine(x, height, x, y, color, 10 - strokeWidth); } }
protected override void OnNavigatedTo(NavigationEventArgs e) { base.OnNavigatedTo(e); var currentView = SystemNavigationManager.GetForCurrentView(); displayRequest.RequestActive(); //to request keep display on currentView.AppViewBackButtonVisibility = AppViewBackButtonVisibility.Visible; currentView.BackRequested += CurrentView_BackRequested; if (e.NavigationMode != NavigationMode.Back) { try { _mainPageViewModel = MainPage.Current.MainPageViewModel; LayoutRoot.DataContext = _mainPageViewModel; _currentTrack = _mainPageViewModel.PlayingTrack; _canvasControl = new CanvasControl(); _canvasControl.Draw += _canvasControl_Draw; App.AudioPlayer.CurrentTrackChanged += AudioPlayer_CurrentTrackChanged; ContentPresenter.Content = _canvasControl; CreateWaveForm(); } catch (Exception ex) { ErrorLogProxy.LogError(ex.ToString()); ErrorLogProxy.NotifyErrorInDebug(ex.ToString()); } } }
private void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { var a = new Vector2(10, 10); var b = new Vector2(100, 100); args.DrawingSession.DrawLine(a, b, Colors.Yellow); }
/// <summary> /// Export SVG file. /// </summary> /// <param name="canvas"></param> /// <param name="filename"></param> public static void ExportSVG(CanvasControl canvas, string filename) { // Start writing SVG format. StreamWriter writer = new StreamWriter(filename); writer.WriteLine(XML_HEADER); writer.WriteLine(CreateSVGHeader(canvas)); // Create brushes. foreach (ComponentSetting setting in canvas.Control.ComponentManager.GetAllSettings()) writer.WriteLine(GetGradationBrush(setting)); // Create SVG objects. foreach (PNode node in canvas.PCanvas.Root.ChildrenReference) { if (!(node is PPathwayLayer) || !node.Visible) continue; PPathwayLayer layer = (PPathwayLayer)node; foreach (PPathwayObject obj in layer.GetNodes()) writer.WriteLine(CreateSVGObject(obj)); } // Create Graph foreach (PNode node in canvas.ControlLayer.ChildrenReference) { if (!(node is PPathwayGraph)) continue; writer.WriteLine(CreateSVGGraph((PPathwayGraph)node)); } // Close SVG file. writer.WriteLine(SVG_FOOTER); writer.Flush(); writer.Close(); }
protected override void OnApplyTemplate() { base.OnApplyTemplate(); this._canvasControl = (CanvasControl)this.GetTemplateChild(CANVAS_CONTROL_NAME); this._canvasControl.Draw += OnDraw; }
private void OnUnloaded(object sender, RoutedEventArgs routedEventArgs) { if (_canvasControl == null) return; _canvasControl.RemoveFromVisualTree(); _canvasControl = null; }
void TextDirectionControl_Loaded(object sender, RoutedEventArgs e) { canvas = new CanvasControl(); canvas.Draw += OnDraw; Content = canvas; }
/// <summary> /// Constructor /// </summary> /// <param name="canvas"></param> public POverviewCanvas(CanvasControl canvas) { m_canvas = canvas; this.Dock = DockStyle.Fill; m_area = new PDisplayedArea(); m_transparentNode = PPath.CreateRectangle(-500, -500, 1300, 1300); m_transparentNode.Brush = new SolidBrush(Color.Transparent); m_transparentNode.Pickable = true; this.AnimatingRenderQuality = RenderQuality.HighQuality; this.DefaultRenderQuality = RenderQuality.HighQuality; this.InteractingRenderQuality = RenderQuality.HighQuality; this.Interacting = true; this.Camera.AddLayer(canvas.PCanvas.Layer); this.RemoveInputEventListener(this.PanEventHandler); this.RemoveInputEventListener(this.ZoomEventHandler); this.Camera.AddInputEventListener(new AreaDragEventHandler(canvas.PCanvas.Camera)); this.Camera.ScaleViewBy(REDUCTION_SCALE); this.Camera.TranslateViewBy(500, 500); this.Layer.AddChild(m_transparentNode); this.Layer.AddChild(m_area); m_ctrlLayer = this.Layer; this.Camera.AddLayer(this.Layer); this.Camera.ChildrenPickable = false; this.Camera.BoundsChanged += new PPropertyEventHandler(Camera_BoundsChanged); }
private void canvasCtrl_Draw(CanvasControl sender, CanvasDrawEventArgs args) { if (!this.initialized) { return; } this.host.CallFunction("drawScene"); var target = (CanvasRenderTarget)this.host.Window.Render(); args.DrawingSession.DrawImage(target); if (drawCount == 0) { this.start = DateTime.Now; } drawCount++; var seconds = (DateTime.Now - this.start).TotalSeconds; if (seconds > 0) { var fps = drawCount / seconds; args.DrawingSession.DrawText(fps.ToString("0.#") + "fps", 10, 10, Colors.Red); } // triggers next Draw event at max 60fps this.canvasCtrl.Invalidate(); }
public WindowsPurchase(CanvasControl _screen) { screen = _screen; grantedConsumableTransactionIds = new Dictionary<string, List<Guid>>(); CurrentApp.LicenseInformation.LicenseChanged += licenseChangeHandler; grantedConsumableTransactionIds = new Dictionary<string, List<Guid>>(); }
void TextDirectionControl_Unloaded(object sender, RoutedEventArgs e) { // Explicitly remove references to allow the Win2D controls to get garbage collected if (canvas != null) { canvas.RemoveFromVisualTree(); canvas = null; } }
private void EffectLayer_Unloaded(object sender, RoutedEventArgs e) { // Explicitly remove references to allow the Win2D controls to get garbage collected if (canvas != null) { canvas.Draw -= OnDraw; canvas.RemoveFromVisualTree(); canvas = null; } }
private void CanvasControl_Draw(CanvasControl sender, CanvasDrawEventArgs args) { CubeHelper helper = new CubeHelper(GetLength()); foreach (Tuple<Vector2, Vector2> edge in helper.GetEdges(currentTransformation)) { ColorValue colorValue = ColorComboBox.SelectedValue as ColorValue; Color color = (colorValue == null ? Colors.Black : colorValue.Color); args.DrawingSession.DrawLine(edge.Item1, edge.Item2, color); } }
protected override void OnApplyTemplate() { base.OnApplyTemplate(); _canvasControl = GetTemplateChild(CanvasControlPartName) as CanvasControl; if (_canvasControl != null) _canvasControl.Draw += Draw; _contentPresenter = GetTemplateChild(ContentPresenterPartName) as ContentPresenter; }
private void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { GaussianBlurEffect effect = new GaussianBlurEffect() { Source = _bitmap, BlurAmount = 5, BorderMode = EffectBorderMode.Hard }; args.DrawingSession.DrawImage(effect); }
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 }; }
private void BackgroundCanvas_CreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { args.TrackAsyncAction(Task.Run(async () => { // Load the background image and create an image brush from it this.backgroundImage = await CanvasBitmap.LoadAsync(sender, new Uri("ms-appx:///Background.jpg")); this.backgroundBrush = new CanvasImageBrush(sender, this.backgroundImage); // Set the brush's edge behaviour to wrap, so the image repeats if the drawn region is too big this.backgroundBrush.ExtendX = this.backgroundBrush.ExtendY = CanvasEdgeBehavior.Wrap; this.resourcesLoaded = true; }).AsAsyncAction()); }
void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { var ds = args.DrawingSession; ds.Clear(Color.FromArgb(0,0,0,0)); var shape = this.Shapes.SelectedItem as Shape; if (shape == null) return; var width = sender.ActualWidth; var height = sender.ActualHeight; if (shape.Drawer != null) shape.Drawer(sender, ds); }
/// <summary> /// Constructor /// </summary> /// <param name="canvas">CanvasControl instance</param> public PPathwayCanvas(CanvasControl canvas) { m_canvas = canvas; m_con = canvas.Control; // Preparing context menus. this.ContextMenuStrip = m_con.Menu.PopupMenu; this.KeyDown += new KeyEventHandler(m_con.Menu.Canvas_KeyDown); // this.HighQuality = m_con.HighQuality; // this.RemoveInputEventListener(PanEventHandler); this.RemoveInputEventListener(ZoomEventHandler); this.Dock = DockStyle.Fill; this.Name = canvas.ModelID; this.Camera.ScaleViewBy(1.0f); }
void OnDraw(CanvasControl sender, CanvasDrawEventArgs args) { float strokeWidth = 1; sharedResources = GetSharedResources(sender); var arrow = sharedResources.GetArrow(TextDirection); var bounds = arrow.ComputeStrokeBounds(strokeWidth); var ds = args.DrawingSession; var foregroundBrush = (SolidColorBrush)this.Foreground; var color = foregroundBrush.Color; arrow = arrow.Transform(CalculateTransform(bounds, new Rect(new Point(0, 0), sender.Size))); ds.DrawGeometry(arrow, color, strokeWidth, ArrowStrokeStyle); }
public void Draw(CanvasControl sender, CanvasDrawEventArgs args) { var size = sender.Size; using (var ds = args.DrawingSession) { ds.DrawImage(effect, (size.ToVector2() - currentEffectSize) / 2); var brush = new CanvasImageBrush(sender, this.effect) { ExtendX = CanvasEdgeBehavior.Wrap, ExtendY = CanvasEdgeBehavior.Wrap, SourceRectangle = new Rect(0, bitmap.SizeInPixels.Height - 96, 96, 96) }; ds.FillRectangle(0, 0, (float)this.ActualWidth, (float)this.ActualHeight, brush); } sender.Invalidate(); }
private void Draw(CanvasControl sender, CanvasDrawEventArgs args) { if (_contentPresenter == null) { return; } var border = VisualTreeHelper.GetChild(_contentPresenter, 0) as Border; if (border == null) { return; } var borderPoint = border.TransformToVisual(this).TransformPoint(new Point(0, 0)); var cl = new CanvasCommandList(sender); using (var clds = cl.CreateDrawingSession()) { clds.FillRoundedRectangle(new Rect(borderPoint.X, borderPoint.Y, border.ActualWidth, border.ActualHeight), (float)border.CornerRadius.TopLeft, (float)border.CornerRadius.TopLeft, Color.FromArgb(128, 0, 0, 0)); } var shadowEffect = new Transform2DEffect { Source = new Transform2DEffect { Source = new ShadowEffect { BlurAmount = 2, ShadowColor = Color.FromArgb(160, 0, 0, 0), Source = cl }, //TODO not doing any scaling right now, confirm with larger shadows TransformMatrix = Matrix3x2.CreateScale(1.0f, new Vector2((float)(border.ActualWidth / 2), ((float)border.ActualHeight / 2))) }, TransformMatrix = Matrix3x2.CreateTranslation(0, 1) }; args.DrawingSession.DrawImage(shadowEffect); // args.DrawingSession.DrawImage(cl); }
private void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { EnsureResources(sender, sender.Size); drawingSession = args.DrawingSession; CustomTextRenderer textRenderer = new CustomTextRenderer(textBrush); textLayout.DrawToTextRenderer(textRenderer, 0, 0); if (ShowNonCustomText) { Color semitrans = Colors.White; semitrans.A = 127; float strokeWidth = ThumbnailGenerator.IsDrawingThumbnail ? 22.0f : 5.0f; args.DrawingSession.DrawGeometry(textReference, semitrans, strokeWidth); } }
void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { if (photo.SourceBitmap == null) { return; } var drawingSession = args.DrawingSession; drawingSession.Units = CanvasUnits.Pixels; drawingSession.Blend = CanvasBlend.Copy; // Draw the main photo image. ICanvasImage image; if (editingRegion != null) { image = cachedImage.Get() ?? cachedImage.Cache(photo, photo.GetImage()); } else { image = photo.GetImage(); } drawingSession.DrawImage(image); // Highlight the current region (if any). lastDrawnZoomFactor = null; foreach (var edit in photo.Edits) { if (edit.DisplayRegionMask(drawingSession, scrollView.ZoomFactor, editingRegion != null)) { lastDrawnZoomFactor = scrollView.ZoomFactor; } } // Display any in-progress region edits. if (editingRegion != null) { editingRegion.DisplayRegionEditInProgress(drawingSession, regionPoints, scrollView.ZoomFactor); } }
public async Task Paste(DataPackageView dataView, CanvasControl control = null) { IRandomAccessStreamWithContentType stream = null; try { if (dataView.Contains(StandardDataFormats.Bitmap)) { var data = await dataView.GetBitmapAsync(); stream = await data.OpenReadAsync(); } else if (dataView.Contains(StandardDataFormats.StorageItems)) { var items = await dataView.GetStorageItemsAsync(); if (items.Count > 0) { var(IsImage, Stream) = await TryParseImage(items[0]); if (IsImage) { stream = Stream; } } } if (stream != null) { var bitmap = await CanvasBitmap.LoadAsync(control ?? this.canvas, stream); this.Update(bitmap); } } catch (Exception e) { Debug.WriteLine(e.GetType() + ":\n" + e);//ignore } finally { stream?.Dispose(); } }
internal override void Draw(CanvasControl cc, CanvasDrawingSession ds, float scale, Vector2 center, FlipState flip) { var color = GetColor(Coloring.Normal); var(cp, r1, r2) = GetCenterRadius(center, scale); var radius = new Vector2(r1, r2); var min = cp - radius; var len = radius * 2; var corner = Corner * scale; if (FillStroke == Fill_Stroke.Filled) { ds.FillRoundedRectangle(min.X, min.Y, len.X, len.Y, corner, corner, color); } else { ds.DrawRoundedRectangle(min.X, min.Y, len.X, len.Y, corner, corner, color, StrokeWidth, StrokeStyle()); } }
private void OnCreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { lock (_reusableLock) { if (_reusableBuffer == null) { _reusableBuffer = new byte[256 * 256 * 4]; } } _device = sender; _bitmap = CanvasBitmap.CreateFromBytes(sender, _reusableBuffer, _frameSize.Width, _frameSize.Height, DirectXPixelFormat.B8G8R8A8UIntNormalized); if (args.Reason == CanvasCreateResourcesReason.FirstTime) { OnSourceChanged(UriToPath(Source), _source); Invalidate(); } }
private void DrawCircles(CanvasControl sender, CanvasDrawingSession ds) { float width = (float)sender.ActualWidth; float height = (float)sender.ActualHeight; float endpointMargin = Math.Min(width, height) / 8; float controlMarginX = endpointMargin * 4; float controlMarginY = endpointMargin * 2; for (int i = 0; i < 25; i++) { Vector2[] bez = new Vector2[4]; int n = (i * 24) + 9 - (i / 2); for (int k = 0; k < 3; k++) { int j = 4 - (2 * k); bez[k].X = (0 + (((n >> (j + 1)) & 1) * (width - controlMarginX))); bez[k].Y = (0 + (((n >> j) & 1) * (height - controlMarginY))); } bez[3].X = width - endpointMargin; // Collect the ends in the lower right bez[3].Y = height - endpointMargin; const int nSteps = 80; const float tStep = 1.0f / nSteps; float t = 0; for (int step = 0; step < nSteps; step++) { float s = 1 - t; float ss = s * s; float sss = ss * s; float tt = t * t; float ttt = tt * t; float x = (sss * bez[0].X) + (3 * ss * t * bez[1].X) + (3 * s * tt * bez[2].X) + (ttt * bez[3].X); float y = (sss * bez[0].Y) + (3 * ss * t * bez[1].Y) + (3 * s * tt * bez[2].Y) + (ttt * bez[3].Y); float radius = ttt * endpointMargin; float strokeWidth = (0.5f - Math.Abs(ss - 0.5f)) * 10; ds.DrawCircle(x, y, radius, GradientColor(t), strokeWidth); t += tStep; } } }
void canvas_CreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { switch (args.Reason) { case CanvasCreateResourcesReason.FirstTime: // First time initialization: either restore suspended app state, load a // photo that was passed in from the shell, or bring up the file selector. if (launchArg is ApplicationExecutionState && (ApplicationExecutionState)launchArg == ApplicationExecutionState.Terminated) { var restoreTask = RestoreSuspendedState(sender.Device); args.TrackAsyncAction(restoreTask.AsAsyncAction()); } else { if (!TryLoadPhoto(launchArg as IReadOnlyList<IStorageItem>)) { LoadButton_Click(null, null); } } break; case CanvasCreateResourcesReason.NewDevice: // Recovering after a lost device (GPU reset). if (photo.SourceBitmap != null) { photo.RecoverAfterDeviceLost(sender.Device); } cachedImage.RecoverAfterDeviceLost(); break; case CanvasCreateResourcesReason.DpiChanged: // We mostly work in pixels rather than DIPs, so only need // minimal layout updates in response to DPI changes. if (photo.SourceBitmap != null) { ZoomToFitPhoto(); } break; } }
void MainCanvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { var ds = args.DrawingSession; ds.Clear(Colors.Black); float dt = m_stopwatch.ElapsedMilliseconds / 1000.0f; m_stopwatch.Restart(); // We are abusing the Draw call as our "game loop" = create new fireworks here // independent of the timing of input events. //if (m_wasPointerPressed == true) // Disable check so we always are rendering. { for (int i = 0; i < Constants.NumPerFrame; i++) { var firework = new Firework( (float)m_pointerPos.X + RndFloat(-Constants.PosRndMax, Constants.PosRndMax), (float)m_pointerPos.Y + RndFloat(-Constants.PosRndMax, Constants.PosRndMax), (float)(m_pointerPos.X - m_pointerPrevPos.X) / dt * Constants.PointerVelCoeff + RndFloat(-Constants.VelRndMax, Constants.VelRndMax), (float)(m_pointerPos.Y - m_pointerPrevPos.Y) / dt * Constants.PointerVelCoeff + RndFloat(-Constants.VelRndMax, Constants.VelRndMax), RndFloat(Constants.RadiusMin, Constants.RadiusMax), Color.FromArgb( 255, RndByte(0, 255), RndByte(0, 255), RndByte(0, 255) )); m_controller.AddFirework(firework); } } m_controller.UpdateFireworks(dt); m_controller.RenderFireworks(ds); // We snap the pointer position with each Draw call, independent of the frequency of input events. m_pointerPrevPos = m_pointerPos; // Render loop. sender.Invalidate(); }
private void ResultCanvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { if (!string.IsNullOrEmpty(responseJsonText.Text)) { // For demo purposes and keeping the initially loaded ink consistent a value of 96 for DPI was used // For production, it is most likely better to use the device's DPI when generating the request JSON and an example of that is below //float dpi = args.DrawingSession.Dpi; //dipsPerMm = inkRecognizer.GetDipsPerMm(dpi); dipsPerMm = inkRecognizer.GetDipsPerMm(96); var backgroundColor = GetColorFromHex("#2B2B2B"); args.DrawingSession.Clear(backgroundColor); foreach (var recoUnit in inkResponse.RecognitionUnits) { string category = recoUnit.category; switch (category) { case "inkBullet": case "inkWord": AddText(recoUnit); break; case "line": DrawText(recoUnit, sender, args); break; case "inkDrawing": DrawShape(recoUnit, args); break; } } recoText.Clear(); } else { var backgroundColor = GetColorFromHex("#2B2B2B"); args.DrawingSession.Clear(backgroundColor); } }
void canvas_CreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { switch (args.Reason) { case CanvasCreateResourcesReason.FirstTime: // First time initialization: either restore suspended app state, load a // photo that was passed in from the shell, or bring up the file selector. if (launchArg is ApplicationExecutionState && (ApplicationExecutionState)launchArg == ApplicationExecutionState.Terminated) { var restoreTask = RestoreSuspendedState(sender.Device); args.TrackAsyncAction(restoreTask.AsAsyncAction()); } else { if (!TryLoadPhoto(launchArg as IReadOnlyList <IStorageItem>)) { LoadButton_Click(null, null); } } break; case CanvasCreateResourcesReason.NewDevice: // Recovering after a lost device (GPU reset). if (photo.SourceBitmap != null) { photo.RecoverAfterDeviceLost(sender.Device); } cachedImage.RecoverAfterDeviceLost(); break; case CanvasCreateResourcesReason.DpiChanged: // We mostly work in pixels rather than DIPs, so only need // minimal layout updates in response to DPI changes. if (photo.SourceBitmap != null) { ZoomToFitPhoto(); } break; } }
private void Canvas_OnDraw(CanvasControl sender, CanvasDrawEventArgs args) { Debug.WriteLine($"drawing {frames}"); var drawingSession = args.DrawingSession; foreach (var hex in _gameManager.Board.GetVisibleHexes(_gameManager.Camera)) { DrawHex(drawingSession, hex, _gameManager.Camera); } if (_gameManager.Board.PossibleMoves != null) { foreach (var coordinate in _gameManager.Board.PossibleMoves) { var currentHex = _gameManager.Board.Hexes[coordinate]; HighlightHex(currentHex, drawingSession, Color.FromArgb(100, 0, 0, 100)); } } if (_gameManager.Board.Hexes.ContainsKey(_gameManager.Board.Coordinate)) { var currentHex = _gameManager.Board.Hexes[_gameManager.Board.Coordinate]; HighlightHex(currentHex, drawingSession, Color.FromArgb(100, 255, 0, 100)); } frames++; time += Environment.TickCount - previousTime; previousTime = Environment.TickCount; if (time >= 1000) { fps = frames; frames = 0; time = 0; } drawingSession.FillRectangle(0, 0, 150, 90, Colors.White); drawingSession.DrawText($"FPS: {fps}", 10, 10, Colors.Black); drawingSession.DrawText($"Hex: {_gameManager.Board.Coordinate}", 10, 30, Colors.Black); drawingSession.DrawText($"Pnt: {(int)_gameManager.Input.PointerPosition.X}, {(int)_gameManager.Input.PointerPosition.Y}", 10, 50, Colors.Black); _signal.Set(); }
private void Canvas_OnDraw(CanvasControl sender, CanvasDrawEventArgs args) { if (PageViewModel?.SelectedEffect == null) { return; } var cl = new CanvasCommandList(sender); using (var clds = cl.CreateDrawingSession()) { switch (PageViewModel.SelectedEffect.DisplayName) { case "EdgeDetection": clds.DrawImage(new EdgeDetectionEffect { Source = cl, Amount = (float)SelectedEffectSlider.Value }); break; case "Saturation": clds.DrawImage(new SaturationEffect { Source = cl, Saturation = (float)SelectedEffectSlider.Value }); break; case "Sepia": clds.DrawImage(new SepiaEffect { Source = cl, Intensity = (float)SelectedEffectSlider.Value }); break; case "Vignette": clds.DrawImage(new VignetteEffect { Source = cl, Amount = (float)SelectedEffectSlider.Value }); break; default: break; } } }
private void CanvasControl_Draw(CanvasControl sender, CanvasDrawEventArgs args) { if (!Window.Current.Visible) { return; } var sesion = args.DrawingSession; float width = (float)canvasControl.ActualWidth; float height = (float)canvasControl.ActualHeight; sesion.Clear(Colors.BlueViolet); if (i < width) { sesion.DrawCircle(i, F(height * 0.7f, width / 2, i, width / 2, height), 1, Colors.Crimson, 2); } else { i = 0; } }
protected override void OnApplyTemplate() { var canvas = GetTemplateChild("Canvas") as CanvasControl; if (canvas == null) { return; } _canvas = canvas; _canvas.CreateResources += OnCreateResources; _canvas.Draw += OnDraw; _canvas.Unloaded += OnUnloaded; _thumbnail = (Image)GetTemplateChild("Thumbnail"); SetValue(_previousState, _previous); base.OnApplyTemplate(); }
private void OnUnloaded(object sender, RoutedEventArgs e) { IsUnloaded = true; Subscribe(false); _canvas.CreateResources -= OnCreateResources; _canvas.Draw -= OnDraw; _canvas.Unloaded -= OnUnloaded; _canvas.RemoveFromVisualTree(); _canvas = null; Dispose(); //_animation?.Dispose(); _animations = null; //_bitmap?.Dispose(); _bitmaps = null; }
public void SetUp() { _window = new Window(); _canvas = new CanvasControl(); _image = new BitmapImage(); _mockWindowService = new Mock <IWindowService>(); _mockWindowService.Setup(p => p.GetMainWindow()).Returns(_window); _mockFinder = new Mock <IControlFinder>(); _mockFinder.Setup(p => p.FindDecendant <CanvasControl>(_window)).Returns(_canvas); _mockRenderer = new Mock <IControlToBitmapRenderer>(); _mockRenderer.Setup(p => p.Render(_canvas)).Returns(_image); _exporter = new CanvasToBitmapExporter( _mockWindowService.Object, _mockFinder.Object, _mockRenderer.Object); }
protected void DrawUnits(CanvasControl sender, CanvasDrawEventArgs args, string units) { var ds = args.DrawingSession; using (var textFormat = new CanvasTextFormat() { HorizontalAlignment = CanvasHorizontalAlignment.Center, VerticalAlignment = CanvasVerticalAlignment.Top, FontSize = (float)UnitsFontSize, }) { Rect bounds = Utilities.CalculateStringBoundingRectangle(sender, args, units, textFormat); float atX = Center.X; float atY = Center.Y + InnerCircleRadius + ((float)(bounds.Height / 2)); Vector2 at = new Vector2(atX, atY); ds.DrawText(units, at, this.GaugeColor, textFormat); } }
public OffsetDemo(DrawImageEmulations example, CanvasControl sender) { fillPattern = example.checkedFillPattern; var rt = new CanvasRenderTarget(sender, (float)example.tiger.Size.Width, (float)example.tiger.Size.Height, sender.Dpi / 3); using (var ds = rt.CreateDrawingSession()) { ds.DrawImage(example.tiger, rt.Bounds); } sourceBitmap = rt; sourceEffect = new HueRotationEffect() { Source = sourceBitmap, Angle = 1 }; showSourceRectRT = new CanvasRenderTarget(sender, (float)rt.Size.Width, (float)rt.Size.Height, rt.Dpi); }
private void DrawCanvasState(CanvasControl canvas, CanvasDrawingSession ds, int drawCount) { ds.Clear(Color.FromArgb(0, 0, 0, 0)); ds.DrawLine(0, 0, (float)canvas.ActualWidth, (float)canvas.ActualHeight, Colors.Aqua); ds.DrawLine(0, (float)canvas.ActualHeight, (float)canvas.ActualWidth, 0, Colors.Aqua); var text = String.Format("{0}x{1}\n{2} redraws", (int)canvas.ActualWidth, (int)canvas.ActualHeight, drawCount); ds.DrawText( text, 0, 0, Colors.FloralWhite, new CanvasTextFormat() { VerticalAlignment = CanvasVerticalAlignment.Top, ParagraphAlignment = ParagraphAlignment.Left, FontSize = 10 }); }
/// <summary> /// Creates the rectangle with the necessary properties. /// </summary> /// <param name="layout">The intended layout for the rectangle.</param> /// <returns></returns> private Rectangle CreateRectangle(RectD layout) { var rect = new Rectangle { Width = layout.Width, Height = layout.Height, Fill = Fill, Stroke = Stroke.Brush, SnapsToDevicePixels = true }; // Disable everything remotely related to anti-aliasing and pretty scaling. RenderOptions.SetEdgeMode(rect, EdgeMode.Aliased); // The bitmap scaling mode is necessary for the scaled stroke brush not to show moiré. RenderOptions.SetBitmapScalingMode(rect, BitmapScalingMode.NearestNeighbor); CanvasControl.SetCanvasControlArrangeRect(rect, layout); return(rect); }
internal void Click(INode node, CanvasControl hostingControl) { var commandParameter = CommandParameter; if (commandParameter == UseNodeParameter) { commandParameter = node; } else if (commandParameter == UseNodeTagParameter) { commandParameter = node.Tag; } var commandTarget = CommandTarget; if (commandTarget == UseCanvasControlTarget) { commandTarget = hostingControl; } Command.Execute(commandParameter, commandTarget); }
public Win2DCanvas() { Background = new SolidColorBrush(NativeColors.Transparent); MinFps = 4; MaxFps = 30; Continuous = true; _drawTimer = new DispatcherTimer(); _drawTimer.Tick += DrawTick; canvasControl = new CanvasControl(); canvasControl.Draw += Draw; SetRow(canvasControl, 0); SetColumn(canvasControl, 0); Unloaded += HandleUnloaded; Loaded += HandleLoaded; SizeChanged += Win2DCanvas_SizeChanged; }
public BaseTool(CanvasControl canvas) { m_Canvas = canvas; m_Canvas.MouseDown += MouseDown; m_Canvas.MouseMove += MouseMove; m_Canvas.MouseUp += MouseUp; m_Canvas.MouseLeave += MouseLeave; m_Canvas.MouseClick += MouseClick; m_Canvas.Click += Click; m_Canvas.DoubleClick += DoubleClick; m_Canvas.Paint += Paint; Form frm = m_Canvas.FindForm(); if (frm != null) { frm.KeyPress += KeyPress; } Execute += this.ExecuteEvent; }
private void _TextOverlaysCanvas_CreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args) { CanvasPathBuilder pathBuilder = new CanvasPathBuilder(sender); pathBuilder.BeginFigure(0, 2.5f); pathBuilder.AddLine(2, 0); pathBuilder.AddLine(6, 4); pathBuilder.AddLine(10, 0); pathBuilder.AddLine(14, 4); pathBuilder.AddLine(18, 0); pathBuilder.AddLine(22, 4); pathBuilder.AddLine(24, 1.5f); pathBuilder.EndFigure(CanvasFigureLoop.Open); CanvasGeometry canvasGeometry = CanvasGeometry.CreatePath(pathBuilder); _SquigglyLineGeometry = CanvasCachedGeometry.CreateStroke(canvasGeometry, 1); CreateOverlayResources?.Invoke(sender, args); }
internal bool CanExecute(INode node, CanvasControl hostingControl) { var commandParameter = CommandParameter; if (commandParameter == UseNodeParameter) { commandParameter = node; } else if (commandParameter == UseNodeTagParameter) { commandParameter = node.Tag; } var commandTarget = CommandTarget; if (commandTarget == UseCanvasControlTarget) { commandTarget = hostingControl; } return(Command.CanExecute(commandParameter, commandTarget)); }
private void OnDraw(CanvasControl sender, CanvasDrawEventArgs args) { foreach (var item in this.strokes) { IReadOnlyList <InkStroke> strokes = item.GetStrokes(); this.renderedStrokes.AddRange(strokes); args.DrawingSession.DrawInk(strokes); } if (this.pendingDry != null && this.deferredDryDelay == 0) { this.deferredDryDelay = 1; CompositionTarget.Rendering += this.OnDeferEndDry; } if (this.isErasing) { args.DrawingSession.DrawRectangle(eraser, ColorHelper.FromArgb(255, 255, 0, 0)); } }
private async void DoStreamsEffect(CanvasControl sender, CanvasDrawingSession ds) { foreach (var stream in _streams) { var offset = (float)ExpandAmount / 2; using (var cl = new CanvasCommandList(ds)) { using (var clds = cl.CreateDrawingSession()) { stream.Seek(0); var canvasbmp = await CanvasBitmap.LoadAsync(sender, stream); clds.DrawImage(canvasbmp, 0, 0); } _eg.Setup(cl, (float)GlowAmount, GlowColor); ds.DrawImage(_eg.Output, offset, offset); } } }
protected void valueControl_Draw(CanvasControl sender, CanvasDrawEventArgs args) { this.EnsureResources(sender, args); CanvasDrawingSession ds = args.DrawingSession; string format = "{0:F" + string.Format("{0:F0}", this.Resolution) + "}"; float atX = (float)sender.ActualWidth / 2; float atY = (float)sender.ActualHeight; Vector2 at = new Vector2(atX, atY); using (var textFormat = new CanvasTextFormat() { HorizontalAlignment = CanvasHorizontalAlignment.Center, VerticalAlignment = CanvasVerticalAlignment.Bottom, FontSize = (float)this.ValueFontSize, }) { ds.DrawText(string.Format(format, this.Value), at, this.GaugePointerColor, textFormat); } }
protected void MaxValueControl_Draw(CanvasControl sender, CanvasDrawEventArgs args) { this.EnsureResources(sender, args); CanvasDrawingSession ds = args.DrawingSession; float xRight = (float)(sender.ActualWidth * _gaugeGridWidth); float center = xRight - (c_gaugeWidth / 2); Vector2 at = new Vector2(center, (float)sender.ActualHeight); string format = "{0:F" + string.Format("{0:F0}", this.Resolution) + "}"; using (var textFormat = new CanvasTextFormat() { HorizontalAlignment = CanvasHorizontalAlignment.Center, VerticalAlignment = CanvasVerticalAlignment.Bottom, FontSize = (float)this.LabelsFontSize, }) { ds.DrawText(string.Format(format, this.MaxValue), at, this.GaugeColor, textFormat); } }
private void DoUIElementsEffect(CanvasControl sender, CanvasDrawingSession ds) { foreach (var elm in _uielements) { var offset = (float)ExpandAmount / 2; using (var cl = new CanvasCommandList(ds)) { using (var clds = cl.CreateDrawingSession()) { using (var canvasbmp = CanvasBitmap.CreateFromBytes(sender.Device, elm.Item1, elm.Item2, elm.Item3, Windows.Graphics.DirectX.DirectXPixelFormat.B8G8R8A8UIntNormalized)) { clds.DrawImage(canvasbmp, 0, 0); } } _eg.Setup(cl, (float)GlowAmount, GlowColor); ds.DrawImage(_eg.Output, offset + (float)elm.Item4, offset + (float)elm.Item5); } } }
//~AnimationView() //{ // Dispose(); //} protected override void OnApplyTemplate() { var canvas = GetTemplateChild("Canvas") as CanvasControl; if (canvas == null) { return; } _canvas = canvas; _canvas.CreateResources += OnCreateResources; _canvas.Draw += OnDraw; _canvas.Unloaded += OnUnloaded; _thumbnail = (Image)GetTemplateChild("Thumbnail"); OnSourceChanged(UriToPath(Source), _source); base.OnApplyTemplate(); }
public void InitLayer(double canvasWidth, double canvasHeight) { ParentWidth = canvasWidth - offsetX; ParentHeight = canvasHeight - offsetY; //x canvas = new CanvasControl(); if (ShowGlowArea) canvas.ClearColor = Windows.UI.Colors.CornflowerBlue; canvas.Width = ParentWidth + ExpandAmount; canvas.Height = ParentWidth + ExpandAmount; _bkgLayer.Width = canvas.Width; _bkgLayer.Height = canvas.Height; ((CompositeTransform)_bkgLayer.RenderTransform).TranslateX = -1 * (ExpandAmount / 2) + offsetX; ((CompositeTransform)_bkgLayer.RenderTransform).TranslateY = -1 * (ExpandAmount / 2) + offsetY; canvas.Draw += OnDraw; _bkgLayer.Content = canvas; //canvas.Visibility = Visibility.Collapsed; }
private void DrawRectangle(CanvasControl sender, CanvasDrawingSession ds) { var width = (float)sender.ActualWidth; var height = (float)sender.ActualHeight; int steps = Math.Min((int)(width / 10), 20); for (int i = 0; i < steps; ++i) { var mu = (float)i / steps; var color = GradientColor(mu); mu *= 0.5f; var x = mu * width; var y = mu * height; var xx = (1 - mu) * width; var yy = (1 - mu) * height; ds.DrawRectangle(x, y, xx - x, yy - y, color, 2.0f); } }
private void OnDraw(CanvasControl sender, CanvasDrawEventArgs args) { if (_graphics == null) { _graphics = new NativeGraphics(); _graphics.destination = new AsyncGraphics(args.DrawingSession); _graphics.resetClip(); } else { ((AsyncGraphics)_graphics.destination).getInternal().setGraphics(args.DrawingSession); } if (renderingOperations.Count > 0) { foreach (AsyncOp o in renderingOperations) { //Debug.WriteLine("OnDraw - execute " + o); o.executeWithClip(((AsyncGraphics)_graphics.destination).getInternal()); } } args.DrawingSession.Dispose(); renderingOperations.Clear(); }
void Canvas_Draw(CanvasControl sender, CanvasDrawEventArgs args) { // Transform and clip so the scene will fit whatever size display we are running on. Vector2 sceneSize = sceneSizes[whichScene]; args.DrawingSession.Transform = Utils.GetDisplayTransform(sender.Size.ToVector2(), sceneSize); using (args.DrawingSession.CreateLayer(1f, new Rect(0, 0, sceneSize.X, sceneSize.Y))) { // Draw the vector art. currentDrawingSession = args.DrawingSession; switch (whichScene) { case 0: DrawScene0(); break; case 1: DrawScene1(randomSeed); break; } } }
private void Draw(CanvasControl sender, CanvasDrawEventArgs args) { if (_contentPresenter == null) return; var border = VisualTreeHelper.GetChild(_contentPresenter, 0) as Border; if (border == null) return; var borderPoint = border.TransformToVisual(this).TransformPoint(new Point(0, 0)); var cl = new CanvasCommandList(sender); using (var clds = cl.CreateDrawingSession()) { clds.FillRoundedRectangle(new Rect(borderPoint.X, borderPoint.Y, border.ActualWidth, border.ActualHeight), (float)border.CornerRadius.TopLeft, (float)border.CornerRadius.TopLeft, Color.FromArgb(128, 0, 0, 0)); } var shadowEffect = new Transform2DEffect { Source = new Transform2DEffect { Source = new ShadowEffect { BlurAmount = 2, ShadowColor = Color.FromArgb(160, 0, 0, 0), Source = cl }, //TODO not doing any scaling right now, confirm with larger shadows TransformMatrix = Matrix3x2.CreateScale(1.0f, new Vector2((float)(border.ActualWidth / 2), ((float)border.ActualHeight / 2))) }, TransformMatrix = Matrix3x2.CreateTranslation(0, 1) }; args.DrawingSession.DrawImage(shadowEffect); // args.DrawingSession.DrawImage(cl); }
public BitmapSourceOption NextBitmapSourceOption { get; set; } // databinded async Task LoadBitmaps(CanvasControl sender) { var newTestBitmaps = new CanvasBitmap[fileNames.Length]; for (int i = 0; i < fileNames.Length; i++) { Package package = Package.Current; StorageFolder installedLocation = package.InstalledLocation; string pathName = installedLocation.Path + "\\" + "BitmapOrientation" + "\\" + fileNames[i]; if (currentBitmapSourceOption == BitmapSourceOption.FromStream) { StorageFile storageFile = await StorageFile.GetFileFromPathAsync(pathName); using (IRandomAccessStreamWithContentType stream = await storageFile.OpenReadAsync()) { newTestBitmaps[i] = await CanvasBitmap.LoadAsync(sender, stream); } } else { newTestBitmaps[i] = await CanvasBitmap.LoadAsync(sender, pathName); } } testBitmaps = newTestBitmaps; }