public virtual GameWindow CreateWindow(GameContext gameContext)
        {
            gameContext = gameContext ?? new GameContext();

            var windows = GetSupportedGameWindows();

            foreach (var gameWindowToTest in windows)
            {
                if (gameWindowToTest.CanHandle(gameContext))
                {
                    gameWindowToTest.Initialize(gameContext);
                    return gameWindowToTest;
                }
            }

            throw new ArgumentException("Game Window context not supported on this platform");
        }

        internal override void Initialize(GameContext gameContext)
        {
            this.GameContext = gameContext;

            Control = (Control)gameContext.Control;

            // Setup the initial size of the window
            var width = gameContext.RequestedWidth;
            if (width == 0)
            {
                width = Control is Form ? GraphicsDeviceManager.DefaultBackBufferWidth : Control.ClientSize.Width;
            }

            var height = gameContext.RequestedHeight;
            if (height == 0)
            {
                height = Control is Form ? GraphicsDeviceManager.DefaultBackBufferHeight : Control.ClientSize.Height;
            }

            Control.ClientSize = new System.Drawing.Size(width, height);

            Control.MouseEnter += GameWindowForm_MouseEnter;
            Control.MouseLeave += GameWindowForm_MouseLeave;

            gameForm = Control as RenderForm;
            if (gameForm != null)
            {
                gameForm.AppActivated += OnActivated;
                gameForm.AppDeactivated += OnDeactivated;
                gameForm.UserResized += OnClientSizeChanged;
            }
            else
            {
                Control.Resize += OnClientSizeChanged;
            }
        }

 internal override bool CanHandle(GameContext gameContext)
 {
     return gameContext.ContextType == GameContextType.WindowsPhoneXaml;
 }

 internal override void Initialize(GameContext gameContext)
 {
     drawingSurface = (DrawingSurface)gameContext.Control;
 }

        public void Run(GameContext gameContext)
        {
            gameWindow = CreateWindow(gameContext);

            // Register on Activated 
            gameWindow.Activated += OnActivated;
            gameWindow.Deactivated += OnDeactivated;
            gameWindow.InitCallback = game.InitializeBeforeRun;
            gameWindow.RunCallback = game.Tick;
            gameWindow.ExitCallback = () => OnExiting(this, EventArgs.Empty);

            var windowCreated = WindowCreated;
            if (windowCreated != null)
            {
                windowCreated(this, EventArgs.Empty);
            }

            gameWindow.Run();
        }

        /// <inheritdoc />
        internal override void Initialize(GameContext gameContext)
        {
            GameContext = gameContext;

            if (gameContext.ContextType == GameContextType.Desktop)
            {
                Control = (Control)gameContext.Control;
                InitializeFromWinForm();
            }
            else if (gameContext.ContextType == GameContextType.DesktopHwndWpf)
            {
                InitializeFromWpfControl(gameContext.Control);
            }
        }

 internal override bool CanHandle(GameContext windowContext)
 {
     return windowContext.ContextType == GameContextType.WinRTBackgroundXaml;
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="GameWindowRenderer" /> class.
 /// </summary>
 /// <param name="registry">The registry.</param>
 /// <param name="gameContext">The window context.</param>
 public GameWindowRenderer(IServiceRegistry registry, GameContext gameContext = null)
     : base(registry)
 {
     GameContext = gameContext ?? new GameContext();
 }

        public void Run(GameContext gameContext)
        {
            gameWindow = CreateWindow(gameContext);

            // set the mouse visibility in case if it was set in the game constructor:
            gameWindow.IsMouseVisible = game.IsMouseVisible;

            // Register on Activated 
            gameWindow.Activated += OnActivated;
            gameWindow.Deactivated += OnDeactivated;
            gameWindow.InitCallback = game.InitializeBeforeRun;
            gameWindow.RunCallback = game.Tick;
            gameWindow.ExitCallback = () => OnExiting(this, EventArgs.Empty);

            var windowCreated = WindowCreated;
            if (windowCreated != null)
            {
                windowCreated(this, EventArgs.Empty);
            }

            gameWindow.Run();
        }

        internal override void Switch(GameContext context)
        {
            surfaceControl.SizeChanged -= SurfaceControlSizeChanged;

            BindSurfaceControl(context);
        }

        private void BindSurfaceControl(GameContext windowContext)
        {
            surfaceControl = windowContext.Control as FrameworkElement;
            if (surfaceControl == null)
                throw new ArgumentException("A FrameworkElement expected.");

            surfaceControl.SizeChanged += SurfaceControlSizeChanged;
        }

        internal override void Initialize(GameContext gameContext)
        {
            if (gameContext == null) throw new ArgumentNullException("gameContext");

            element = gameContext.Control as SharpDXElement;
            if (element == null) throw new ArgumentException("Only SharpDXElement is supported at this time", "gameContext");

            var width = gameContext.RequestedWidth;
            if (width <= 0)
                width = GraphicsDeviceManager.DefaultBackBufferWidth;

            var height = gameContext.RequestedHeight;
            if (height <= 0)
                height = GraphicsDeviceManager.DefaultBackBufferHeight;

            element.TrySetSize(width, height);

            element.ResizeCompleted += OnClientSizeChanged;
            element.MouseEnter += OnMouseEnter;
            element.MouseLeave += OnMouseLeave;
        }

        internal override void Switch(GameContext context)
        {
            isInitialized = false;

            drawingSurfaceBackgroundGrid.Loaded -= DrawingSurfaceBackgroundGridOnLoaded;
            drawingSurfaceBackgroundGrid.Unloaded -= drawingSurfaceBackgroundGrid_Unloaded;
            drawingSurfaceBackgroundGrid.SetBackgroundContentProvider(null);

            drawingSurfaceBackgroundGrid = (DrawingSurfaceBackgroundGrid)context.Control;

            BindDrawingSurfaceBackgroundGridEvents();
            // TODO: check if this can cause issues as event "Loaded" never gets called
            drawingSurfaceBackgroundGrid.SetBackgroundContentProvider(this);

            currentDevice = null;
            currentDeviceContext = null;
        }

        internal override bool CanHandle(GameContext gameContext)
        {
            if (gameContext == null) throw new ArgumentNullException("gameContext");

            return gameContext.ContextType == GameContextType.DesktopWpf;
        }

 internal override void Switch(GameContext context)
 {
     // Nothing to switch here, GameContext is not used in this implementation.
 }

 internal override void Initialize(GameContext windowContext)
 {
 }

 internal override void Initialize(GameContext gameContext)
 {
     drawingSurface = (DrawingSurface)gameContext.Control;
     graphicsDeviceService = (IGraphicsDeviceService)Services.GetService(typeof(IGraphicsDeviceService));
     graphicsDeviceManager = (IGraphicsDeviceManager)Services.GetService(typeof(IGraphicsDeviceManager));
 }

 internal override void Initialize(GameContext windowContext)
 {
     if (windowContext != null)
     {
         BindSurfaceControl(windowContext);
     }
 }

        internal override void Switch(GameContext context)
        {
            drawingSurface.Loaded -= DrawingSurfaceOnLoaded;
            drawingSurface.Unloaded -= DrawingSurfaceUnloaded;
            drawingSurface.SetContentProvider(null);

            drawingSurface = (DrawingSurface)context.Control;
            isInitialized = false;
            synchronizedTexture.Dispose();
            synchronizedTexture = null;

            drawingSurface.Loaded += DrawingSurfaceOnLoaded;
            drawingSurface.Unloaded += DrawingSurfaceUnloaded;

            drawingSurface.SetContentProvider(this);
        }

        private void BindSurfaceControl(GameContext windowContext)
        {
            surfaceControl = windowContext.Control as FrameworkElement;
            if (surfaceControl == null)
                throw new ArgumentException("A FrameworkElement expected.");

            surfaceControl.SizeChanged += SurfaceControlSizeChanged;

            var swapChainPanel = surfaceControl as SwapChainPanel;
            if (swapChainPanel != null)
                swapChainPanel.CompositionScaleChanged += SwapChainPanelCompositionScaleChanged;
        }