public TileRenderer(Canvas canvas, string displayText, Tile tile)
        {
            storyboard = new Storyboard();
            Tile = tile;
            this.canvas = canvas;
            Width = DefaultWidth;
            Height = DefaultHeight;
            rectangle = new Rectangle
            {
                HorizontalAlignment = HorizontalAlignment.Stretch,
                VerticalAlignment = VerticalAlignment.Stretch,
                Stroke = new SolidColorBrush(Colors.Black),
                Fill = new SolidColorBrush(Colors.WhiteSmoke)
            };
            Children.Add(rectangle);

            text = new TextBlock
            {
                Text = displayText,
                HorizontalAlignment = HorizontalAlignment.Stretch,
                TextAlignment = TextAlignment.Center,
                FontSize = 36,
                Foreground = new SolidColorBrush(Colors.Black),
                FontWeight = FontWeights.Bold,
                VerticalAlignment = VerticalAlignment.Top,
                Margin = new Thickness(0, 26, 0, 26)

            };

            Children.Add(text);
            canvas.Children.Add(this);
            SetPosition();
            tile.PositionChanged += UpdatePosition;
        }

 public Game(Canvas canvas, Action gameOverAction)
 {
     _canvas = canvas;
     gameOver = gameOverAction;
     timer = new Timer(Loop, Utility.GAME_TICK_MS);
     reinitialize = false;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="RenderContext" /> class.
 /// </summary>
 /// <param name="canvas">The canvas.</param>
 public RenderContext(Canvas canvas)
 {
     this.canvas = canvas;
     this.Width = canvas.ActualWidth;
     this.Height = canvas.ActualHeight;
     this.RendersToScreen = true;
 }

        private void SetTime(Canvas canvas)
        {
            var time = DateTime.Now;
            double curHour = time.Hour % 12;
            double curMinute = time.Minute;
            double curSecond = time.Second;

            List<Line> lines = TreeHelper.FindChildren<Line>(canvas);

            if(lines.Count < 3) return;
            var xhour = lines[2];
            var xminute = lines[1];
            var xsecond = lines[0];

            xhour.RenderTransform = new RotateTransform
            {
                CenterX = 100,
                CenterY = 100,
                Angle = curHour * 30 + curMinute / 2
            };

            xminute.RenderTransform = new RotateTransform
            {
                CenterX = 100,
                CenterY = 100,
                Angle = curMinute * 6 + curSecond / 10
            };

            xsecond.RenderTransform = new RotateTransform
            {
                CenterX = 100,
                CenterY = 100,
                Angle = curSecond * 6
            };
        }

        /// <summary>
        /// Builds the visual tree for the ColorPicker control when the template is applied. 
        /// </summary>
        protected override void OnApplyTemplate()
        {
            base.OnApplyTemplate();

            m_rootElement = GetTemplateChild("RootElement") as Panel;
            m_hueMonitor = GetTemplateChild("HueMonitor") as Rectangle;
            m_sampleSelector = GetTemplateChild("SampleSelector") as Canvas;
            m_hueSelector = GetTemplateChild("HueSelector") as Canvas;
            m_selectedColorView = GetTemplateChild("SelectedColorView") as Rectangle;
            m_colorSample = GetTemplateChild("ColorSample") as Rectangle;
            m_hexValue = GetTemplateChild("HexValue") as TextBlock;


            m_rootElement.RenderTransform = m_scale = new ScaleTransform();

            m_hueMonitor.PointerPressed += m_hueMonitor_PointerPressed;
            m_hueMonitor.PointerReleased += m_hueMonitor_PointerReleased;
            m_hueMonitor.PointerMoved += m_hueMonitor_PointerMoved;

            m_colorSample.PointerPressed += m_colorSample_PointerPressed;
            m_colorSample.PointerReleased += m_colorSample_PointerReleased;
            m_colorSample.PointerMoved += m_colorSample_PointerMoved;

            m_sampleX = m_colorSample.Width;
            m_sampleY = 0;
            m_huePos = 0;

            UpdateVisuals();
        }

        private UIElement CreateMarker() {
            Canvas marker = new Canvas();
            Ellipse outer = new Ellipse() {
                Width = 25,
                Height = 25,
            };
            outer.Fill = new SolidColorBrush(Color.FromArgb(255,240,240,240));
            outer.Margin = new Thickness(-12.5, -12.5, 0, 0);

            Ellipse inner = new Ellipse() {
                Width = 20,
                Height = 20,
            };
            inner.Fill = new SolidColorBrush(Colors.Black);
            inner.Margin = new Thickness(-10, -10, 0, 0);

            Ellipse core = new Ellipse() {
                Width = 10,
                Height = 10,
            };
            core.Fill = new SolidColorBrush(Colors.White);
            core.Margin = new Thickness(-5, -5, 0, 0);
            marker.Children.Add(outer);
            marker.Children.Add(inner);
            marker.Children.Add(core);

            return marker;
        }

        public static void Render(Viewport viewport, Canvas canvas, IEnumerable<Tile<Image>> tiles)
        {
            if (viewport == null) return;

            canvas.Children.Clear();

            var tileList = tiles.ToList();
            for (int i = 0; i < tileList.Count; i++)
            {
                var tile = tileList[i];
                if (tile.Image == null) continue;
                var point1 = viewport.WorldToScreen(tile.Info.Extent.MinX, tile.Info.Extent.MaxY);
                var point2 = viewport.WorldToScreen(tile.Info.Extent.MaxX, tile.Info.Extent.MinY);

                var dest = new Rect(point1.ToMetroPoint(), point2.ToMetroPoint());
                dest = RoundToPixel(dest);

                Canvas.SetLeft(tile.Image, dest.X);
                Canvas.SetTop(tile.Image, dest.Y);
                tile.Image.Width = dest.Width;
                tile.Image.Height = dest.Height;
                canvas.Children.Add(tile.Image);

                if (tile.StartAnimation == default(long))
                {
                    tile.StartAnimation = DateTime.Now.Ticks;
                    Animate(tile.Image, "Opacity", 0, 1, 600, (s, e) => { });
                }
            }
        }

        public FaceTrackerProxy (Canvas canvas, MainPage page, CaptureElement capture, MediaCapture mediacapture ) {


            if (this.faceTracker == null)
            {
                this.faceTracker = FaceTracker.CreateAsync().AsTask().Result;
            }

            rootPage = page;
            VisualizationCanvas = canvas;

            this.VisualizationCanvas.Children.Clear();

            mediaCapture = mediacapture;

            var deviceController = mediaCapture.VideoDeviceController;
            this.videoProperties = deviceController.GetMediaStreamProperties(MediaStreamType.VideoPreview) as VideoEncodingProperties;
            currentState = ScenarioState.Streaming;

            // Ensure the Semaphore is in the signalled state.
            this.frameProcessingSemaphore.Release();

            // Use a 66 milisecond interval for our timer, i.e. 15 frames per second 
            TimeSpan timerInterval = TimeSpan.FromMilliseconds(200);
            this.frameProcessingTimer = Windows.System.Threading.ThreadPoolTimer.CreatePeriodicTimer(new Windows.System.Threading.TimerElapsedHandler(ProcessCurrentVideoFrame), timerInterval);


        }

 //constructor
 public Game(Canvas canvas)
 {
     this.canvas = canvas;
     CreateBall();
     CreatePaddle();
     CreateBlocks();
 }

        // --- Methods of the class ---
        /// <summary>Constructor takes as parameters the x and y coordinate on the 1000-page</summary>
        public Pit(Canvas canvasToPaintOn,
                    PitType pitType,
                    int x, int y, int width, int height,
                    int pitFrameThicknessX, int pitFrameThicknessY,
                    PitPosition position)
        {
            _pitId = _staticPitCounter++;
            _canvasToPaintOn = canvasToPaintOn;
            _pitType = pitType;
            _seeds = new List<Seed>();
            _topLeftCorner = new Point(0, 0);
            _height = 0;
            _width = 0;
            _image = new Image[_numImageTypes];
            _touchField = null;
            _numberField = null;
            SetTopLeftCorner(x, y);
            _width = width;
            _height = height;
            _pitFrameThicknessX = pitFrameThicknessX;
            _pitFrameThicknessY = pitFrameThicknessY;
            _position = position;

            //DEBUG     Logging.Inst.LogMessage("Created " + this.ToString() + " at " + _topLeftCorner + " with width " + _width + ", height " + _height +
            //DEBUG                             ", xPitFrameThickness " + _xPitFrameThickness + ", and yPitFrameThickness " + _yPitFrameThickness + "\n");
        }

        private void InitializeControl()
        {
            try
            {

                if (root == null)
                {
                    root = (Canvas)GetTemplateChild("root");
                    layerStoryboard = (Storyboard)root.Resources["layerStoryboard"];

                    layerAnimationX = (DoubleAnimation)layerStoryboard.Children[0];
                    layerAnimationY = (DoubleAnimation)layerStoryboard.Children[1];

                    layerState = new LayerState(SensitivityX, SensitivityY);

                    Conductor.Beat += Conductor_Beat;

                    rootParent = (Canvas)this.Parent;
                    //rootParent.PointerPressed += rootParent_PointerPressed;
                    rootParent.ManipulationDelta += rootParent_ManipulationDelta;
                    rootParent.ManipulationMode = this.ManipulationMode; // &ManipulationModes.TranslateY;

                }


            }
            catch { }
        }

        //-------------------------------------------------------------------------------
        #endregion (Util)

        //-------------------------------------------------------------------------------
        #region Constructor
        //-------------------------------------------------------------------------------
        //
        public ListPage()
        {
            this.InitializeComponent();
            this.navigationHelper = new NavigationHelper(this);
            this.navigationHelper.LoadState += navigationHelper_LoadState;
            this.navigationHelper.SaveState += navigationHelper_SaveState;

            CANVASES = new Canvas[] {
                    canvasMap1_E123, canvasMap1_E456, canvasMap1_W,
                    canvasMap2_E123, canvasMap2_E456, canvasMap2_W,
                    canvasMap3_E123, canvasMap3_E456, canvasMap3_W
                };
            SCROLLVIEWERS = new ScrollViewer[] {
                    scImgMap1_E123, scImgMap1_E456, scImgMap1_W,
                    scImgMap2_E123, scImgMap2_E456, scImgMap2_W,
                    scImgMap3_E123, scImgMap3_E456, scImgMap3_W
                };
            SELECT_BORDERS = new Border[] {
                borderMap1_E123, borderMap1_E456, borderMap1_W,
                borderMap2_E123, borderMap2_E456, borderMap2_W,
                borderMap3_E123, borderMap3_E456, borderMap3_W
            };
            RADIOBUTTONS = new RadioButton[] {
                rbSearch_Checklist, rbSearch_SearchString, rbSearch_Genre
            };
        }

        public BoundaryHelperBox2d(Canvas cnvGame)
        {
            _cnvGame = cnvGame;

            // TODO: tweak margin/etc of Canvas

            if (Double.IsNaN(_cnvGame.Width) || Double.IsNaN(_cnvGame.Height))
            {
                if (Double.IsNaN(_cnvGame.ActualWidth) || Double.IsNaN(_cnvGame.ActualHeight)
                    || _cnvGame.ActualWidth == 0 || _cnvGame.ActualHeight == 0)
                {
                    _cnvGame.Width = 1366;
                    _cnvGame.Height = 768;
                }
                else
                {
                    _cnvGame.Width = _cnvGame.ActualWidth;
                    _cnvGame.Height = _cnvGame.ActualHeight;
                }
                System.Diagnostics.Debug.WriteLine("Your game canvas did not specify a width and height, so it was forced to 1366x768.");
            }

            ScreenTopLeft = new xna.Vector2(0, 0);
            ScreenBottomRight = new xna.Vector2((float)_cnvGame.Width, (float)_cnvGame.Height);

            xna.Vector2 screenSize = new xna.Vector2((float)cnvGame.Width, (float)cnvGame.Height);
            float ratio = screenSize.X / screenSize.Y;
            float halfWorldSize = (float)GetWorldSize(screenSize) / 2.0f;
            xna.Vector2 extent = new xna.Vector2(-ratio * halfWorldSize, halfWorldSize);

            WorldTopLeft = extent;
            WorldBottomRight = -extent;
        }

        //default invaders contructor accepted the canvas and current level
        public Invaders(Canvas canvas, int lvl)
        {
            //initialize variables and grid
            createRowsAndColumns();
            invaderGrid = new Image[columns, rows];
            invaderBullets = new Image[3];
            
            isMovingLeft = invadersAreMoving = isMovingDown = toggleSprite = false;
            isShooting = true;
            isPlayerAlive = true;
            count = 0;
            speed = lvl;

            //loops to set the alien grid and images
            for (int c = 0; c < columns; c++)
            {
                for (int r = 0; r < rows; r++)
                {
                    Image invader = new Image();
                    BitmapImage bitmapSource;

                    //If the row number is smaller than 1, use this sprite
                    if (r < 1)
                    {
                        invader.Height = 24 * sizeModifier();
                        invader.Tag = new BitmapImage(new Uri("ms-appx:///Assets/sprites/alien-1-2.png"));
                        bitmapSource = new BitmapImage(new Uri("ms-appx:///Assets/sprites/alien-1-1.png"));
                    }
                    //If the row number is smaller than 3, use this sprite
                    else if (r < 3)
                    {
                        invader.Height = 28 * sizeModifier();
                        invader.Tag = new BitmapImage(new Uri("ms-appx:///Assets/sprites/alien-2-2.png"));
                        bitmapSource = new BitmapImage(new Uri("ms-appx:///Assets/sprites/alien-2-1.png"));
                    }
                    //If the row number is bigger than 3, use this sprite
                    else
                    {
                        invader.Height = 32 * sizeModifier();
                        invader.Tag = new BitmapImage(new Uri("ms-appx:///Assets/sprites/alien-3-2.png"));
                        bitmapSource = new BitmapImage(new Uri("ms-appx:///Assets/sprites/alien-3-1.png"));
                    }

                    //Set the x coords for selected the invader
                    Canvas.SetLeft(invader, 32 + (50 * c));
                    
                    //Set the y coords for the selected invader
                    if (rows * 32 >= Window.Current.Bounds.Height / 2) Canvas.SetTop(invader, -((rows * 32) - 64) + (50 * r));
                    else Canvas.SetTop(invader, 32 + (50 * r));

                    invader.Width = 32 * sizeModifier();
                    invader.Source = bitmapSource;

                    //add invader to the canvas and invaderGrid
                    canvas.Children.Add(invader);
                    invaderGrid[c, r] = invader;
                }
            }
        }

 public GameBoard(int rows, int cols, Canvas gameCanvas)
 {
     _cCols = cols;
     _cRows = rows;
     _gameCanvas = gameCanvas;
     _solution = new List<Point>();
     CreateAndInitBoard(rows, cols);
 }

        public MosaicImage()
        {
            _layoutRoot = new Canvas();
            Content = _layoutRoot;
            MaxImageSize = 300;

            SizeChanged += MosaicImage_SizeChanged;
        }

 public Scale()
 {
     // Maybe add containers for ranges as well
     indicatorContainer = new Canvas();
     Children.Add(indicatorContainer);
     //CreateLabels();
     //CreateTicks();
 }

 // Create a node for trails test B
 public TrailNode(char l, Point p, Canvas c, bool r = true)
 {
     number = 0;
     letter = l;
     position = p;
     rotate = r;
     createShapes(letter.ToString(), position, c);
 }

 /// <summary>
 /// Конструктор.
 /// </summary>
 /// <param name="textCanvas">Канва.</param>
 /// <param name="factory">Фабрика элементов.</param>
 /// <param name="splitter">Средство разбивки на слова.</param>
 public CanvasTextRenderCommandExecutor(Canvas textCanvas, ICanvasElementFactory factory, IWordSplitter splitter)
 {
     if (textCanvas == null) throw new ArgumentNullException("textCanvas");
     if (factory == null) throw new ArgumentNullException("factory");
     if (splitter == null) throw new ArgumentNullException("splitter");
     TextCanvas = textCanvas;
     Factory = factory;
     Splitter = splitter;
     FirstInLine = true;
 }

        public Platform(Windows.UI.Xaml.Controls.Page page)
        {
            _page = page;
            _renderer = new Canvas();
            _renderer.SizeChanged += renderer_SizeChanged;
            NavigationService.Current.OnNewPage += Current_OnNewPage;
            _tracker = new ToolbarTracker();
            _tracker.CollectionChanged += (s, e) => UpdateAppBar();

        }