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 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
});
}
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;
}
