/// <summary>
/// Unselected the given object.
/// </summary>
/// <param name="obj"></param>
public void UnselectObject(CanvasObject obj)
{
obj.Selected = false;
_selectedObjects.Remove(obj);
this.Invalidate();
}
private void OnLoaded(object sender, RoutedEventArgs e)
{
_compositor = ElementCompositionPreview.GetElementVisual(this).Compositor;
_generator = _compositor.CreateCompositionGenerator();
_backdropBrush = _compositor.CreateBackdropBrush();
_width = 300f;
_height = 300f;
_center = new Vector2(150f);
// Create the combined geometry
_ellipse1 = CanvasGeometry.CreateEllipse(_generator.Device, _width / 2, _height / 2, 0.45f * _width, 0.225f * _height);
_ellipse2 = CanvasGeometry.CreateEllipse(_generator.Device, _width / 2, _height / 2, 0.225f * _width, 0.45f * _height);
var combinedGeometry = _ellipse1.CombineWith(_ellipse2, Matrix3x2.Identity, CanvasGeometryCombine.Union);
_outerGeometry = CanvasObject.CreateSquircle(_generator.Device, 0, 0, _width, _height, _width, _height);
var excludedGeometry = _outerGeometry.CombineWith(combinedGeometry, Matrix3x2.Identity, CanvasGeometryCombine.Exclude);
// Create custom shaped visual using CompositionMaskBrush
_visual1 = _compositor.CreateSpriteVisual();
_visual1.Size = new Vector2(_width, _height);
_visual1.Offset = new Vector3(((RenderGrid1.ActualWidth - _width) / 2).ToSingle(),
((RenderGrid1.ActualHeight - _height) / 2).ToSingle(), 0);
_animatedMaskSurface = _generator.CreateMaskSurface(_visual1.Size.ToSize(), excludedGeometry);
// Create SurfaceBrush from CompositionMask
var mask = _compositor.CreateSurfaceBrush(_animatedMaskSurface);
var source = _compositor.CreateColorBrush(Color.FromArgb(255, 192, 0, 0));
// Create mask brush
var maskBrush = _compositor.CreateMaskBrush();
maskBrush.Mask = mask;
maskBrush.Source = source;
_visual1.Brush = maskBrush;
ElementCompositionPreview.SetElementChildVisual(RenderGrid1, _visual1);
// Create custom shaped visual using CompositionMaskBrush
_visual2 = _compositor.CreateSpriteVisual();
_visual2.Size = new Vector2(_width, _height);
_visual2.Brush =
_compositor.CreateMaskedBackdropBrush(_animatedMaskSurface, Colors.AntiqueWhite, 10, _backdropBrush);
_container = _compositor.CreateContainerVisual();
_container.Size = new Vector2(_width, _height);
_container.Offset = new Vector3(((RenderGrid2.ActualWidth - _width) / 2).ToSingle(),
((RenderGrid2.ActualHeight - _height) / 2).ToSingle(), 0);
var bgVisual = _compositor.CreateSpriteVisual();
bgVisual.Size = _container.Size * 0.6f;
bgVisual.Brush = _compositor.CreateColorBrush(Colors.Maroon);
bgVisual.Offset = new Vector3(_container.Size * 0.2f, 0);
_container.Children.InsertAtTop(bgVisual);
_container.Children.InsertAtTop(_visual2);
ElementCompositionPreview.SetElementChildVisual(RenderGrid2, _container);
}
private void OnCanvasDraw(CanvasControl sender, CanvasDrawEventArgs args)
{
if (String.IsNullOrWhiteSpace(_data))
{
CommandsList.Text = string.Empty;
return;
}
if (_errorGeometry == null)
{
_errorGeometry = CanvasObject.CreateGeometry(sender, ErrorString);
}
_logger?.Clear();
CommandsList.Text = string.Empty;
try
{
var geometry = CanvasObject.CreateGeometry(sender, _data, _logger);
CommandsList.Text = _logger.ToString();
args.DrawingSession.FillGeometry(geometry, _fillColor);
args.DrawingSession.DrawGeometry(geometry, _strokeColor, _strokeThickness);
}
catch (Exception e)
{
args.DrawingSession.FillGeometry(_errorGeometry, Colors.Red);
CommandsList.Text = "Parsing error! Invalid input data!";
}
}
private void OnCreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args)
{
_c = Window.Current.Compositor;
_g = _c.CreateCompositionGenerator();
_rootShape = _c.CreateShapeVisual();
_rootShape.Size = new Vector2((float)RenderGrid.ActualWidth, (float)RenderGrid.ActualHeight);
_rootSize = _rootShape.Size.ToSize();
var rectGeom = _c.CreatePathGeometry(new CompositionPath(CanvasGeometry.CreateRectangle(_g.Device, new Rect(new Point(), _rootSize))));
var bgShape = _c.CreateSpriteShape(rectGeom);
bgShape.FillBrush = _c.CreateColorBrush(CanvasObject.CreateColor("#161616"));
_rootShape.Shapes.Add(bgShape);
for (var i = 0; i < MaxLayerCount; i++)
{
var shape = _c.CreateSpriteShape(_c.CreatePathGeometry(GetClip(_rootSize, 0f)));
// Offset each of the shape to the right to hide the bump of lower layers
shape.Offset = HideOffset;
shape.FillBrush = _c.CreateColorBrush(_colors[i]);
_rootShape.Shapes.Add(shape);
}
_selectedIndex = -1;
_swipeRightIndex = -1;
_swipeLeftIndex = MaxLayerCount;
_nextShapeIndex = -1;
// Reset offset of top most shape
_rootShape.Shapes[MaxLayerCount].Offset = Vector2.Zero;
ElementCompositionPreview.SetElementChildVisual(RenderGrid, _rootShape);
}
public MainPageWithSwipe()
{
InitializeComponent();
_colors = new[]
{
Colors.Crimson,
CanvasObject.CreateColor("#007aff"),
CanvasObject.CreateColor("#4cd964"),
CanvasObject.CreateColor("#ff2d55"),
CanvasObject.CreateColor("#ff9600")
};
// Keeps track of the duration of the swipe
_sw0 = new Stopwatch();
_sw0.Reset();
// Timeline for the top layer whose geometry is being animated
_sw1 = new Stopwatch();
_sw1.Reset();
// Timeline for the lower layer whose offset is being animated
_sw2 = new Stopwatch();
_sw2.Reset();
// The bump will appear at 2/3rd of the height from the top
_verticalReveal = 1f;
_swipeDir = SwipeDirection.None;
// Duration of the top layer geometry animation
_a0 = TimeSpan.FromMilliseconds(DefaultGeometryAnimDuration);
// Duration of the lower layer offset animation
_a1 = TimeSpan.FromMilliseconds(DefaultOffsetAnimDuration);
}
public static CompositionSpriteShape CreateSpriteShape(this Compositor compositor, string path)
{
var canvasGeometry = CanvasObject.CreateGeometry(new CanvasDevice(), path);
var compositionPath = new CompositionPath(canvasGeometry);
var pathGeometry = compositor.CreatePathGeometry(compositionPath);
return(compositor.CreateSpriteShape(pathGeometry));
}
/// <summary>
/// Parses the given Path data and converts it to CompositionGeometricClip
/// </summary>
/// <param name="compositor">Compositor</param>
/// <param name="pathData">Path data in string format.</param>
/// <returns>CompositionGeometricClip</returns>
public static CompositionGeometricClip CreateGeometricClip(this Compositor compositor, string pathData)
{
// Create the CanvasGeometry from the path data
var geometry = CanvasObject.CreateGeometry(pathData);
// Create the CompositionGeometricClip
return(compositor.CreateGeometricClip(geometry));
}
protected override void DisposeManagedResources()
{
base.DisposeManagedResources();
CanvasObject.Dispose();
CanvasObject = null;
BorderVM.Dispose();
BorderVM = null;
}
/// <summary>
/// Creates a CompositionPathGeometry based on the given path data.
/// </summary>
/// <param name="compositor">Compositor</param>
/// <param name="pathData">Path data in string format.</param>
/// <returns>CompositionPathGeometry</returns>
public static CompositionPathGeometry CreatePathGeometry(this Compositor compositor, string pathData)
{
// Create CanvasGeometry
var geometry = CanvasObject.CreateGeometry(pathData);
// Create CompositionPathGeometry
return(compositor.CreatePathGeometry(new CompositionPath(geometry)));
}
/// <summary>
/// Updates selected objects with the given ones.
/// </summary>
/// <param name="objects"></param>
private void HandleSelection(List <CanvasObject> objects)
{
// If there's only one object, select it.
if (objects.Count == 1)
{
this.SelectObject(objects[0], false);
this.OnObjectSelected(new ObjectSelectedEventArgs(objects[0]));
return;
}
var priority = objects[0].Priority;
var foundSelected = false;
CanvasObject unselectedObject = null;
var ignorePriority = (ModifierKeys == Keys.Alt);
// Go through all objects and cycle through the ones with the
// lowest priority.
for (var i = 0; i < objects.Count; ++i)
{
var obj = objects[i];
// Stop once the priority changed, we only want to cycle
// through the lowest priority ones.
if (priority != obj.Priority && !ignorePriority)
{
break;
}
// If the object is selected the next unselected one is the
// one to select.
if (obj.Selected)
{
foundSelected = true;
}
else if (foundSelected)
{
unselectedObject = obj;
break;
}
// If this is the last iteration or the next object has a
// different priority, and we haven't found any objects yet,
// use the first one to complete the cycle.
if (i + 1 == objects.Count || (objects[i + 1].Priority != obj.Priority && !ignorePriority))
{
unselectedObject = objects[0];
break;
}
}
if (unselectedObject != null)
{
this.SelectObject(unselectedObject, false);
this.OnObjectSelected(new ObjectSelectedEventArgs(unselectedObject));
}
}
/// <summary>
/// Validate Canvas sise
/// </summary>
/// <param name="result">output error message</param>
/// <returns>false if the Canvas size is so big</returns>
public static bool ValidateCanvasSize(CanvasObject obj)
{
if (obj.CanvasSizeX > 51 || obj.CanvasSizeY > 51)
{
obj.Result = "The max value for Canvas in x: 50, y: 50";
return(false);
}
obj.Result = string.Empty;
return(true);
}
public ComControlNode(CanvasObject canvasObject)
{
this.canvasObject = canvasObject;
this.CSCom.SetCanvasObject(canvasObject.GetCSVisual());
this.Visible = (this.VisibleForFrame = true);
TimelineActionManager.Instance.CurrentFrameIndexChangedEvent += new CurrentFrameIndexChangedHandler(this.OnFrameIndexChanged);
Services.Workbench.ActiveDocumentChanged += new EventHandler(this.DocumentChanged);
Services.EventsService.GetEvent <AlignedObjectsEvent>().Subscribe(new Action <AlignedObjectsArgs>(this.OnAlignedObjects));
Services.EventsService.GetEvent <ScaleLockedChangeEvent>().Subscribe(new Action <bool>(this.OnScaleLockedChange));
Services.EventsService.GetEvent <CanvasSizeChangeEvent>().Subscribe(new Action <CanvasSizeChangeEventArgs>(this.OnCanvasSizeChange));
}
/// <summary>
/// Adds object to the canvas for it to be drawn.
/// </summary>
/// <param name="obj"></param>
public void Add(CanvasObject obj)
{
obj.Canvas = this;
_objects.Add(obj);
if (!_updating)
{
this.SortObjects();
}
this.Invalidate();
}
protected override void SelectionChanged(List <Selection> selections)
{
TimelineEvent ev = null;
if (selections.Count > 0)
{
CanvasObject d = selections.Last().Drawable as CanvasObject;
if (d is TimelineEventObject)
{
ev = (d as TimelineEventObject).Event;
loadedEvent = ev;
}
}
Config.EventsBroker.EmitLoadEvent(ev);
}
void Setting()
{
canvas = new Dictionary<CanvasType, CanvasObject>();
GameObject[] g = GameObject.FindGameObjectsWithTag("Canvas");
foreach (var i in g)
{
foreach (CanvasType j in Enum.GetValues(typeof(CanvasType))){
if (i.name == j.ToString())
{
CanvasObject co = new CanvasObject();
co.Set(i,j);
canvas.Add(j, co);
}
}
}
}
static void ExpandNode(DependencyObject d, CanvasObject o)
{
o.ExpandBranch = new UVMCommand(p => {
var l = (d.GetValue(ItemsSourceProperty) as IEnumerable <object>).ToList();
if (o.Male != null)
{
if (o.MaleParentsPair != null)
{
o.MaleParentsPair = new CanvasObject()
{
X = o.X + 200,
Y = o.Y - 100,
Male = o.Male.Father,
Female = o.Male.Mother
}
}
;
l.Add(o.MaleParentsPair);
ExpandNode(d, o.MaleParentsPair);
}
if (o.Female != null)
{
if (o.FemaleParentsPair != null)
{
o.FemaleParentsPair = new CanvasObject()
{
X = o.X + 200,
Y = o.Y + 100,
Male = o.Female.Father,
Female = o.Female.Mother
}
}
;
l.Add(o.FemaleParentsPair);
ExpandNode(d, o.FemaleParentsPair);
}
d.SetValue(ItemsSourceProperty, l);
UpdateLayout(d);
});
o.CollapseBranch = new UVMCommand(p => {
var l = (d.GetValue(ItemsSourceProperty) as IEnumerable <object>).ToList();
l.Remove(o.MaleParentsPair);
l.Remove(o.FemaleParentsPair);
d.SetValue(ItemsSourceProperty, l);
UpdateLayout(d);
});
}
public MainPage()
{
InitializeComponent();
_sw = new Stopwatch();
_sw.Reset();
verReveal = 1f;
_animDuration = TimeSpan.FromSeconds(1.5);
_colors = new Color[]
{
Colors.Crimson,
CanvasObject.CreateColor("#007aff"),
CanvasObject.CreateColor("#4cd964"),
CanvasObject.CreateColor("#ff2d55"),
CanvasObject.CreateColor("#ff9600")
};
}
private void OnCreateResources(CanvasAnimatedControl sender, CanvasCreateResourcesEventArgs args)
{
_c = Window.Current.Compositor;
_g = _c.CreateCompositionGenerator();
_rootShape = _c.CreateShapeVisual();
_rootShape.Size = new Vector2((float)RenderGrid.ActualWidth, (float)RenderGrid.ActualHeight);
_rootSize = _rootShape.Size.ToSize();
var rectGeom = _c.CreatePathGeometry(new CompositionPath(CanvasGeometry.CreateRectangle(_g.Device, new Rect(new Point(), _rootSize))));
var bgShape = _c.CreateSpriteShape(rectGeom);
bgShape.FillBrush = _c.CreateColorBrush(CanvasObject.CreateColor("#161616"));
_rootShape.Shapes.Add(bgShape);
_slideLeftImplicitAnimationCollection = _c.CreateImplicitAnimationCollection();
var slideLeftAnim = _c.GenerateVector2KeyFrameAnimation()
.HavingDuration(700)
.ForTarget(() => _c.CreateSpriteShape().Offset);
slideLeftAnim.InsertFinalValueKeyFrame(1f, _c.CreateEaseInOutBackEasingFunction());
_slideLeftImplicitAnimationCollection["Offset"] = slideLeftAnim.Animation;
_slideRightImplicitAnimationCollection = _c.CreateImplicitAnimationCollection();
var slideRightAnim = _c.GenerateVector2KeyFrameAnimation()
.HavingDuration(2000)
.ForTarget(() => _c.CreateSpriteShape().Offset);
slideRightAnim.InsertFinalValueKeyFrame(1f, _c.CreateEaseInOutBackEasingFunction());
_slideRightImplicitAnimationCollection["Offset"] = slideRightAnim.Animation;
for (var i = 0; i < MaxShapeCount; i++)
{
var shape = _c.CreateSpriteShape(_c.CreatePathGeometry(GetClip(_rootSize)));
shape.Offset = HideOffset;
shape.FillBrush = _c.CreateColorBrush(_colors[i]);
_rootShape.Shapes.Add(shape);
}
_selIndex = MaxShapeCount;
_rootShape.Shapes[_selIndex].Offset = Vector2.Zero;
ElementCompositionPreview.SetElementChildVisual(RenderGrid, _rootShape);
PrevBtn.IsEnabled = false;
}
/// <summary>
/// Returns the first object at the given world position.
/// </summary>
/// <param name="position"></param>
/// <returns></returns>
private CanvasObject GetFirstObjectAt(PointF position)
{
CanvasObject result = null;
for (var i = 0; i < _objects.Count; ++i)
{
var obj = _objects[i];
if (obj.IsInside(position))
{
result = obj;
break;
}
}
return(result);
}
protected override void SelectionChanged(List <Selection> selections)
{
TimelineEventVM eventVM = null;
if (selections.Count > 0)
{
CanvasObject d = selections.Last().Drawable as CanvasObject;
if (d is TimelineEventView)
{
eventVM = (d as TimelineEventView).TimelineEvent;
// If event is in selections list, must be selected but
// in the first time it is incorrectly marked as false
eventVM.Playing = true;
loadedEvent = eventVM.Model;
}
}
App.Current.EventsBroker.Publish(
new LoadEventEvent {
TimelineEvent = eventVM
}
);
}
private static void OnRootPersonChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
Person p = e.NewValue as Person;
CanvasObject r = new CanvasObject();
if (p.Gender == 0)
{
r.Male = p;
r.Female = p.Spouse;
}
else
{
r.Female = p;
r.Male = p.Spouse;
}
if (r.Male != null)
{
r.MaleParentsPair = new CanvasObject()
{
Male = r.Male.Father,
Female = r.Male.Mother,
ExpandBranch = new UVMCommand(par => ExpandNode(d, r.MaleParentsPair))
};
}
if (r.Female != null)
{
r.FemaleParentsPair = new CanvasObject()
{
Male = r.Female.Father,
Female = r.Female.Mother,
ExpandBranch = new UVMCommand(par => ExpandNode(d, r.FemaleParentsPair))
};
}
List <object> l = new List <object>();
l.Add(r);
d.SetValue(ItemsSourceProperty, l);
UpdateLayout(d);
}
private void OnRadiusChanged(object sender, RangeBaseValueChangedEventArgs e)
{
_radius = (float)RadiusSlider.Value;
if (_compositor == null)
{
return;
}
var roundRectGeometry =
CanvasGeometry.CreateRoundedRectangle(_generator.Device, 0, 0, _width, _height, _radius, _radius);
var squircleGeometry =
CanvasObject.CreateSquircle(_generator.Device, 0, 0, _width, _height, _radius, _radius);
var differenceGeometry =
roundRectGeometry.CombineWith(squircleGeometry, Matrix3x2.Identity, CanvasGeometryCombine.Exclude);
var xorGeometry =
roundRectGeometry.CombineWith(squircleGeometry, Matrix3x2.Identity, CanvasGeometryCombine.Xor);
_roundedRectangleSurface.Redraw(roundRectGeometry);
_squircleSurface.Redraw(squircleGeometry);
_differenceSurface.Redraw(differenceGeometry);
_xorSurface.Redraw(xorGeometry);
}
/// <summary>
/// TODO
/// </summary>
public override void OnMouseMove(MouseEventArgs e, Keys modifierKeys)
{
var location = Canvas.SnapToInterval && (modifierKeys & Keys.Control) != Keys.Control ? e.Location.Snap(Canvas.SnapInterval) : e.Location;
var dx = location.X - previousMouseLocation.X;
var dy = location.Y - previousMouseLocation.Y;
previousMouseLocation = location;
objectUnderMouse = FindObjectAt(Layer.CanvasObjects, e.Location, modifierKeys);
if (IsMouseDown && allowMove)
{
selectedObjects.ForEach(o => o.MoveBy(dx, dy, modifierKeys));
}
var feedback = objectUnderMouse?.GetFeedback(e.Location, modifierKeys) ?? new Feedback(Cursors.Default, string.Empty);
Canvas.OnFeedbackChanged(feedback.Cursor, feedback.Hint);
Refresh();
base.OnMouseMove(e, modifierKeys);
}
/// <summary>
/// Marks the given object as selected.
/// </summary>
/// <param name="obj">Canvas object to select.</param>
/// <param name="addToSelection">
/// Set to true if object should be added to the currently
/// selected objects.
/// </param>
public void SelectObject(CanvasObject obj, bool addToSelection)
{
if (obj == null)
{
this.ClearSelection();
return;
}
if (!obj.Visible)
{
return;
}
if (!this.MultiSelect || !addToSelection)
{
this.ClearSelectionInternal();
}
_selectedObjects.Add(obj);
obj.Selected = true;
this.Invalidate();
}
private void OnCanvas_CreateResources(CanvasControl sender, CanvasCreateResourcesEventArgs args)
{
var geom1 = CanvasObject.CreateGeometry(sender, "O 116 116 128 128");
var fill1 = CanvasObject.CreateBrush(sender, "SC #00adef");
var stroke1 = CanvasObject.CreateStroke(sender, "ST 8 SC #2a388f");
_layer1 = new CanvasRenderLayer(geom1, fill1, stroke1);
var geom2 = CanvasObject.CreateGeometry(sender, "U 56 56 64 64 8 8");
var fill2 = CanvasObject.CreateBrush(sender, "SC #ed1c24");
var stroke2 = CanvasObject.CreateStroke(sender, "ST 2 SC #404041");
_layer2 = new CanvasRenderLayer(geom2, fill2, stroke2);
var geom3 = CanvasObject.CreateGeometry(sender, "U 136 56 64 64 8 8");
var fill3 = CanvasObject.CreateBrush(sender, "SC #38b449");
_layer3 = new CanvasRenderLayer(geom3, fill3, stroke2);
var geom4 = CanvasObject.CreateGeometry(sender, "U 56 136 64 64 8 8");
var fill4 = CanvasObject.CreateBrush(sender, "SC #fff100");
_layer4 = new CanvasRenderLayer(geom4, fill4, stroke2);
var geom5 = CanvasObject.CreateGeometry(sender, "R 96 96 64 64");
var fill5 = CanvasObject.CreateBrush(sender, "SC #f7931d");
_layer5 = new CanvasRenderLayer(geom5, fill5, stroke2);
var layers = new List <CanvasRenderLayer> {
_layer1, _layer2, _layer3, _layer4, _layer5
};
_element = new CanvasElement(256f, 256f, layers);
_isInitialized = true;
}
private void btnSelectSubQuery_Click(object sender, EventArgs e)
{
Stream myStream;
ofd.DefaultExt = "TAI Query Reporter Files|*.TQR";
ofd.Title = "Open a saved TAI Query Reporter file";
if (ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
//btnClearCurrentQuery_Click(sender, e);
oc1.ClearObjects();
if ((myStream = ofd.OpenFile()) != null)
{
StreamReader wText = new StreamReader(myStream);
string ln = "";
// skip the first two lines
ln = wText.ReadLine();
ln = wText.ReadLine();
// read the connection string
ConnectionString = wText.ReadLine();
// skip a line
wText.ReadLine();
// read the number of canvas objects
ln = wText.ReadLine();
int num = int.Parse(ln);
for (int tt = 0; tt < num; tt++)
{
string name = wText.ReadLine();
string loc = wText.ReadLine();
string meta = "";
string meta2 = "";
string meta3 = "";
if (name.StartsWith("LOOKUP") || name.StartsWith("HCLOOKUP"))
{
string m = wText.ReadLine();
while (m != "")
{
meta += m + System.Environment.NewLine;
m = wText.ReadLine();
}
meta2 = "";
}
else
{
meta = wText.ReadLine();
meta2 = wText.ReadLine();
}
meta3 = wText.ReadLine();
string sz = wText.ReadLine();
ln = wText.ReadLine();
int c = int.Parse(ln);
Color fg = Color.FromArgb(c);
ln = wText.ReadLine();
c = int.Parse(ln);
Color bg = Color.FromArgb(c);
loc = loc.Replace("{", "").Replace("}", "");
string[] ll = loc.Split(",".ToCharArray());
string xx = ll[0].Replace("X=", "");
string yy = ll[1].Replace("Y=", "");
CanvasObject ob = new CanvasObject(oc1, name, meta, meta2, meta3, int.Parse(xx), int.Parse(yy), fg, bg);
oc1.AddObject(ob);
}
// skip a line
wText.ReadLine();
// read the number of canvas connections
ln = wText.ReadLine();
num = int.Parse(ln);
for (int tt = 0; tt < num; tt++)
{
ln = wText.ReadLine();
int c = int.Parse(ln);
Color bg = Color.FromArgb(c);
ln = wText.ReadLine();
int lw = int.Parse(ln);
string cty = wText.ReadLine();
string stnode = wText.ReadLine();
string ednode = wText.ReadLine();
CanvasObjectConnection cn = new CanvasObjectConnection(stnode, ednode, bg, lw, ConnectionType.DotArrow);
oc1.AddConnection(cn);
}
myStream.Close();
}
GenerateSQLCode();
}
}
private void SquirclePage_Loaded(object sender, RoutedEventArgs e)
{
_compositor = Window.Current.Compositor;
_generator = _compositor.CreateCompositionGenerator();
// Create Squircle shaped visual using CompositionSurfaceBrush
_roundedRectangleVisual = _compositor.CreateSpriteVisual();
_roundedRectangleVisual.Size = new Vector2(_width, _height);
_roundedRectangleVisual.Offset = new Vector3(((RoundedRectangleGrid.ActualWidth - _width) / 2).ToSingle(),
((RoundedRectangleGrid.ActualHeight - _height) / 2).ToSingle(), 0);
// Create the geometry surface for squircle filled with red color
var roundedRectGeometry = CanvasGeometry.CreateRoundedRectangle(_generator.Device, 0, 0, _width, _height, _radius, _radius);
_roundedRectangleSurface = _generator.CreateGeometrySurface(_roundedRectangleVisual.Size.ToSize(), roundedRectGeometry, Color.FromArgb(255, 192, 0, 0));
// Create SurfaceBrush from CompositionMask
var rectSurfaceBrush = _compositor.CreateSurfaceBrush(_roundedRectangleSurface.Surface);
_roundedRectangleVisual.Brush = rectSurfaceBrush;
ElementCompositionPreview.SetElementChildVisual(RoundedRectangleGrid, _roundedRectangleVisual);
// Create Squircle shaped visual using CompositionSurfaceBrush
_squircleVisual = _compositor.CreateSpriteVisual();
_squircleVisual.Size = new Vector2(_width, _height);
_squircleVisual.Offset = new Vector3(((SquircleGrid.ActualWidth - _width) / 2).ToSingle(),
((SquircleGrid.ActualHeight - _height) / 2).ToSingle(), 0);
// Create the geometry surface for squircle filled with red color
var squircleGeometry = CanvasObject.CreateSquircle(_generator.Device, 0, 0, _width, _height, _radius, _radius);
_squircleSurface = _generator.CreateGeometrySurface(_squircleVisual.Size.ToSize(), squircleGeometry, Color.FromArgb(255, 192, 0, 0));
// Create SurfaceBrush from CompositionMask
var surfaceBrush = _compositor.CreateSurfaceBrush(_squircleSurface);
_squircleVisual.Brush = surfaceBrush;
ElementCompositionPreview.SetElementChildVisual(SquircleGrid, _squircleVisual);
// Create visual showing difference between the two geometries
_differenceVisual = _compositor.CreateSpriteVisual();
_differenceVisual.Size = new Vector2(_width, _height);
// Create the geometry surface for squircle filled with red color
var differenceGeometry =
roundedRectGeometry.CombineWith(squircleGeometry, Matrix3x2.Identity, CanvasGeometryCombine.Exclude);
_differenceSurface = _generator.CreateGeometrySurface(_differenceVisual.Size.ToSize(), differenceGeometry, Color.FromArgb(255, 192, 192, 0));
// Create SurfaceBrush from CompositionMask
_differenceVisual.Brush = _compositor.CreateSurfaceBrush(_differenceSurface);
_xorVisual = _compositor.CreateSpriteVisual();
_xorVisual.Size = _differenceVisual.Size;
_xorVisual.Offset = new Vector3(((DifferenceGrid.ActualWidth - _width) / 2).ToSingle(),
((DifferenceGrid.ActualHeight - _height) / 2).ToSingle(), 0);
var xorGeometry =
roundedRectGeometry.CombineWith(squircleGeometry, Matrix3x2.Identity, CanvasGeometryCombine.Xor);
_xorSurface = _generator.CreateGeometrySurface(_xorVisual.Size.ToSize(), xorGeometry, Color.FromArgb(255, 192, 0, 0));
// Create SurfaceBrush from CompositionMask
_xorVisual.Brush = _compositor.CreateSurfaceBrush(_xorSurface);
_xorVisual.Children.InsertAtTop(_differenceVisual);
ElementCompositionPreview.SetElementChildVisual(DifferenceGrid, _xorVisual);
}
private void Form1_Load(object sender, EventArgs e)
{
//Canvas.InteractionMode = InteractionMode.Tools;
Canvas.SetCanvasArea(300, 300);
Canvas.ScaleType = ScaleType.Dynamic;
Canvas.MouseClick += this.Canvas1_MouseClick;
Canvas.KeyDown += this.Canvas1_KeyDown;
Canvas.InvertY = checkBox1.Checked;
//CanvasObject pic = new Picture(new Bitmap(@"..."), new RectangleF(0, 0, 300, 300), new RectangleF(0, 0, 3000, 3000));
//pic.Interactions = ObjectInteractions.None;
//Canvas.Add(pic);
//var flat = new FlatRect(new RectangleF(0, 0, 150, 150), Color.AliceBlue);
//Canvas.Add(new CanvasObject(0, 0, flat)
//{
// Interactions = ObjectInteractions.None,
// //DrawOrder = 1,
// Visible = true
//});
CanvasObject o1 = new Rect(140, 140, 43, 43);
Canvas.Add(o1);
CanvasObject o2 = new Rect(160, 160, 43, 43);
Canvas.Add(o2);
CanvasObject o3 = new Circle(150, 150, 30);
o3.Priority = 0;
Canvas.Add(o3);
obj1 = new CanvasObject(30, 20);
obj1.Add(new Rect(20, 10, 10, 10));
obj1.Add(new Rect(40, 10, 10, 10));
obj1.Add(new Rect(30, 30, 10, 10));
obj1.Add(new Polygon(new PointF(20, 10), new PointF(40, 10), new PointF(30, 30)));
obj1.Interactions = ObjectInteractions.Selectable | ObjectInteractions.Movable;
Canvas.Add(obj1);
var obj = new CanvasObject(130, 120);
obj.Add(new FlatRect(new RectangleF(130, 120, 10, 10), Color.Black));
//obj.Add(new Picture(new Bitmap(@"..."), new RectangleF(0, 0, 600, 851), new RectangleF(130, 120, 20, 20)));
obj.Add(new Rect(120, 110, 10, 10));
obj.Add(new Rect(140, 110, 10, 10));
obj.Add(new Circle(130, 130, 5));
obj.Add(new Polygon(new PointF(120, 110), new PointF(140, 110), new PointF(130, 130)));
Canvas.Add(obj);
Canvas.Add(new TextString(new PointF(10, 10), "Hello, World!")
{
StringFormat = new StringFormat()
{
Alignment = StringAlignment.Near, LineAlignment = StringAlignment.Near
}
});
//canvas1.Add(new Rect(180, 180, 10, 10));
}
protected ScreenBase()
{
CanvasObject = GameObject.Find("Canvas");
CanvasRect = CanvasObject.GetComponent <RectTransform>().rect;
}
private void OnLoaded(object sender, RoutedEventArgs e)
{
_compositor = ElementCompositionPreview.GetElementVisual(this).Compositor;
_generator = _compositor.CreateCompositionGenerator();
_backdropBrush = _compositor.CreateBackdropBrush();
_width = 300f;
_height = 300f;
// Create the combined geometry
var ellipse1 = CanvasGeometry.CreateEllipse(_generator.Device, _width / 2, _height / 2, 0.45f * _width, 0.225f * _height);
var ellipse2 = CanvasGeometry.CreateEllipse(_generator.Device, _width / 2, _height / 2, 0.225f * _width, 0.45f * _height);
_combinedGeometry = ellipse1.CombineWith(ellipse2, Matrix3x2.Identity, CanvasGeometryCombine.Union);
// Create the container to host the visuals
var container1 = _compositor.CreateContainerVisual();
container1.Size = new Vector2(CompositionGrid1.ActualWidth.ToSingle(), CompositionGrid1.ActualHeight.ToSingle());
var parentVisual = _compositor.CreateSpriteVisual();
parentVisual.Size = new Vector2(_width, _height);
parentVisual.Offset = new Vector3(((CompositionGrid1.ActualWidth - _width) / 2).ToSingle(),
((CompositionGrid1.ActualHeight - _height) / 2).ToSingle(), 0);
// Background Visual
_bgVisual1 = _compositor.CreateSpriteVisual();
_bgVisual1.Size = new Vector2(_width * 0.5f, _height * 0.5f);
_bgVisual1.Offset = new Vector3(((parentVisual.Size.X - _width * 0.5f) / 2f),
((parentVisual.Size.Y - _height * 0.5f) / 2f), 0f);
//_bgVisual1.Brush = _compositor.CreateColorBrush(Colors.DarkOrange);
// Create the CompositionMask
var gaussianMask = _generator.CreateGaussianMaskSurface();
// Create SurfaceBrush from CompositionMask
var mask = _compositor.CreateSurfaceBrush(gaussianMask.Surface);
//mask = ((CompositionBrush)_compositor.CreateGaussianMaskedBackdropBrush(gaussianMask, Colors.AntiqueWhite, 10, _backdropBrush));
var source = _compositor.CreateColorBrush(Colors.DarkOrange);
// Create mask brush
var maskBrush = _compositor.CreateMaskBrush();
maskBrush.Mask = mask;
maskBrush.Source = source;
_bgVisual1.Brush = maskBrush;
parentVisual.Children.InsertAtBottom(_bgVisual1);
// Create custom shaped visual using CompositionMaskBrush
_visual1 = _compositor.CreateSpriteVisual();
_visual1.Size = new Vector2(_width, _height);
//_visual1.Offset = new Vector3(((CompositionGrid1.ActualWidth - _width) / 2).ToSingle(),
// ((CompositionGrid1.ActualHeight - _height) / 2).ToSingle(), 0);
// Create the CompositionMask
var ellipseGeometry = CanvasGeometry.CreateEllipse(_generator.Device, _width / 2, _height / 2, 0.4f * _width, 0.4f * _height);
var rectGeometry = CanvasGeometry.CreateRectangle(_generator.Device, 50, 50, _width - 50, _height - 50);
var compositionMask = _generator.CreateGaussianMaskSurface(_visual1.Size.ToSize(), ellipseGeometry, new Vector2(20), 20);
// Create Masked BackdropBrush from CompositionMask
_visual1.Brush = _compositor.CreateGaussianMaskedBackdropBrush(compositionMask, Colors.Transparent, 20f, _backdropBrush);
parentVisual.Children.InsertAtTop(_visual1);
var visual = _compositor.CreateSpriteVisual();
visual.Size = new Vector2(400, 400);
visual.Offset = new Vector3(((3 * CompositionGrid1.ActualWidth / 4f) - (_width / 2)).ToSingle(),
((3 * CompositionGrid1.ActualHeight / 4f) - (_height / 2)).ToSingle(), 0);
var roundRectGeometry = CanvasObject.CreateSquircle(_generator.Device, 0, 0, _width, _height, _width / 8f, _height / 8f);
var maskSurface = _generator.CreateMaskSurface(visual.Size.ToSize(), roundRectGeometry);
var frostedBrush = _compositor.CreateFrostedGlassBrush(maskSurface, Colors.DarkGray, 30f, _backdropBrush);
var shadow = _compositor.CreateDropShadow();
shadow.Opacity = 0.5f;
shadow.Color = Colors.Black;
shadow.Offset = new Vector3(10, 10, 0);
shadow.BlurRadius = 15;
shadow.Mask = frostedBrush.GetSourceParameter("mask");
visual.Brush = frostedBrush;
visual.Shadow = shadow;
container1.Children.InsertAtTop(visual);
ElementCompositionPreview.SetElementChildVisual(CompositionGrid1, parentVisual);
// Initialize the visuals for the Animated Canvas
// Create the container to host the visuals
var container2 = _compositor.CreateContainerVisual();
container2.Size = new Vector2(CompositionGrid2.ActualWidth.ToSingle(), CompositionGrid2.ActualHeight.ToSingle());
// Background Visual
_bgVisual2 = _compositor.CreateSpriteVisual();
_bgVisual2.Size = new Vector2(_width * Factor, _height * Factor);
_bgVisual2.Offset = new Vector3(((CompositionGrid2.ActualWidth - (_width * Factor)) / 2).ToSingle(),
((CompositionGrid2.ActualHeight - (_height * Factor)) / 2).ToSingle(), 0);
//var radians = ((45f * Math.PI) / 180).ToSingle();
//var bgGeometry = _combinedGeometry.Transform(Matrix3x2.CreateRotation(radians, new Vector2(_width / 2, _height / 2)));
//var bgMask = await _generator.CreateMaskAsync(_bgVisual2.Size.ToSize(), bgGeometry, Colors.DarkRed);
//_bgVisual2.Brush = _compositor.CreateSurfaceBrush(bgMask.Surface);
_bgVisual2.Brush = _compositor.CreateColorBrush(Colors.LawnGreen);
container2.Children.InsertAtBottom(_bgVisual2);
// Animated Visual
_animatedVisual = _compositor.CreateSpriteVisual();
_animatedVisual.Size = new Vector2(_width, _height);
_animatedVisual.Offset = new Vector3(((CompositionGrid2.ActualWidth - _width) / 2).ToSingle(),
((CompositionGrid2.ActualHeight - _height) / 2).ToSingle(), 0);
// Create the Excluded geometry
_outerGeometry = CanvasObject.CreateSquircle(_generator.Device, 0, 0, _width, _height, _width / 8f, _height / 8f);
var excludedGeometry = _outerGeometry.CombineWith(_combinedGeometry, Matrix3x2.Identity, CanvasGeometryCombine.Exclude);
// Create the CompositionMask
_animatedCompositionMask = _generator.CreateMaskSurface(_animatedVisual.Size.ToSize(), excludedGeometry);
var animBrush = _compositor.CreateMaskedBackdropBrush(_animatedCompositionMask, Colors.AntiqueWhite, 10f, _backdropBrush);
_animatedVisual.Brush = animBrush;
container2.Children.InsertAtTop(_animatedVisual);
ElementCompositionPreview.SetElementChildVisual(CompositionGrid2, container2);
}
/// <summary>
/// Removes the given object from this canvas.
/// </summary>
/// <param name="obj"></param>
public void Remove(CanvasObject obj)
{
obj.Selected = false;
_objects.Remove(obj);
_selectedObjects.Remove(obj);
}
