protected override void UpdateScreen(GameTime gameTime, DisplayOrientation displayOrientation)
 {
     if (input.CheckMousePress(ScreenRectangle))
     {
         changeScreenDelegate(ScreenState.Title);
     }
 }

 protected override void DrawScreen(SpriteBatch batch, DisplayOrientation screenOrientation)
 {
     Globals.map.Draw(batch);
     Globals.Mobs.Draw(batch);
     player.Draw(batch);
     HUDPlayerInfo.Draw(batch);
 }

 protected override void DrawScreen(SpriteBatch batch, DisplayOrientation displayOrientation)
 {
     background.Draw(batch);
     batch.Draw(optionsText, new Rectangle(0, 0, ScreenWidth, ScreenHeight), Color.White);
     fullscreenButton.Draw(batch);
     backButton.Draw(batch);
 }

 protected override void UpdateScreen(GameTime gameTime, DisplayOrientation displayOrientation)
 {
     if (input.CheckMousePress(gameButton))
     {
         changeScreenDelegate(ScreenState.Gameplay);
     }
 }

		private Orientation GetOrientation(DisplayOrientation xnaOrientation)
		{
			Orientation = xnaOrientation == DisplayOrientation.LandscapeLeft ||
				xnaOrientation == DisplayOrientation.LandscapeRight
				? Orientation.Landscape : Orientation.Portrait;
			return Orientation;
		}

        public GraphicsDeviceManager(Game game)
        {
            if (game == null)
            {
                throw new ArgumentNullException("The game cannot be null!");
            }

            this.game = game;

            supportedOrientations = DisplayOrientation.Default;

            PreferredBackBufferHeight = DefaultBackBufferHeight;
            PreferredBackBufferWidth = DefaultBackBufferWidth;

            PreferredBackBufferFormat = SurfaceFormat.Color;
            PreferredDepthStencilFormat = DepthFormat.Depth24;

            SynchronizeWithVerticalRetrace = true;

            if (game.Services.GetService(typeof(IGraphicsDeviceManager)) != null)
            {
                throw new ArgumentException("Graphics Device Manager Already Present");
            }

            game.Services.AddService(typeof(IGraphicsDeviceManager), this);
            game.Services.AddService(typeof(IGraphicsDeviceService), this);
        }

 protected override void DrawScreen(SpriteBatch spriteBatch, DisplayOrientation screenOrientation)
 {
     background.Draw(spriteBatch);
     road.Draw(spriteBatch);
     car.Draw(spriteBatch);
     hazards.Draw(spriteBatch);
 }

 protected override void DrawScreen(SpriteBatch spriteBatch, DisplayOrientation screenOrientation)
 {
     background.Draw(spriteBatch);
     titleText.Draw(spriteBatch);
     startButton.Draw(spriteBatch);
     exitButton.Draw(spriteBatch);
 }

 public ScreenConfig()
 {
     // set defaults.
     this.Width = 0; // make default resolution 0x0, so that it'll be only set if a platform requires so and sets the values - otherwise the system default will be used.
     this.Height = 0;
     this.IsFullScreen = false;
     this.SupportedOrientations = DisplayOrientation.Default;
 }

 protected override void DrawScreen(SpriteBatch batch, DisplayOrientation displayOrientation)
 {
     background.Draw(batch);
     batch.Draw(titleText, new Rectangle(0, 0, ScreenWidth, ScreenHeight), Color.White);
     gameButton.Draw(batch);
     optionsButton.Draw(batch);
     exitButton.Draw(batch);
 }

 protected override void UpdateScreen(GameTime gameTime, DisplayOrientation screenOrientation)
 {
     road.Update(gameTime);
     car.Update(gameTime);
     hazards.Update(gameTime, car, HandleCarCollision);
     if (previousHazardCount != hazards.HazardCount)
     {
         soundEffects.PlaySound("SoundEffects/HazardPass");
         previousHazardCount = hazards.HazardCount;
     }
 }

        protected override void UpdateScreen(GameTime gameTime, DisplayOrientation displayOrientation)
        {
            if(input.CheckMousePress(fullscreenButton))
            {
                graphics.ToggleFullScreen();
            }

            if(input.CheckMousePress(backButton))
            {
                changeScreenDelegate(ScreenState.Title);
            }
        }

 protected override void UpdateScreen(GameTime gameTime, DisplayOrientation screenOrientation)
 {
     if (input.IsPressed(ActionStart))
     {
         soundEffects.PlaySound("SoundEffects/Select");
         changeScreenDelegate(ScreenState.MainGame);
     }
     else if (input.IsPressed(ActionExit))
     {
         soundEffects.PlaySound("SoundEffects/Select");
         changeScreenDelegate(ScreenState.Exit);
     }
 }

 public static AccelerometerReading GetReading(DisplayOrientation orientation)
 {
     if (orientation == DisplayOrientation.Portrait)
     {
         return new AccelerometerReading(state,timeStamp);
     }
     var landLeft = new Vector3(-state.Y, state.X, state.Z);
     if (orientation == DisplayOrientation.LandscapeLeft || orientation == DisplayOrientation.Default)
     {
         return new AccelerometerReading(landLeft, timeStamp);
     }
     return new AccelerometerReading(landLeft,timeStamp );
 }

 public Monitor(double left, double top, double width, double height, DisplayOrientation orientation)
     : base("Monitor", new Size(width, height))
 {
     Top = top;
     Left = left;
     Width = width;
     Height = height;
     _orientation = orientation;
     if (Top == 0 && Left == 0)
     {
         _fillBackground = false;
     }
 }

            public void UpdateWP7InputState(GameTime gameTime, DisplayOrientation currentOrientation)
            {
                // DAK - Disabled this code because it was consuming Gestures before our app could process them.
                //mCurrentOrientation = currentOrientation;

                //#region Gesture support
                //mHasTap = false;
                //mHasTapTwo = false;
                //mHDelta = 0.0f;
                //mVDelta = 0.0f;

                //if (TouchPanel.IsGestureAvailable) {
                //    GestureSample g = TouchPanel.ReadGesture();
                //    switch (g.GestureType)
                //    {
                //        case GestureType.Tap:
                //            mHasTap = true;
                //            break;

                //        case GestureType.Pinch:
                //            if (!mPinchHasBegin)
                //            {
                //                mHasTapTwo = true;
                //                mPinchHasBegin = true;
                //            }
                //            break;

                //        case GestureType.PinchComplete:
                //            mPinchHasBegin = false;
                //            break;

                //        case GestureType.FreeDrag:
                //            float x= (g.Delta.X) * kDRAG_UNIT;
                //            x = MathHelper.Clamp(x, -1f, 1f);

                //            float y= -(g.Delta.Y) * kDRAG_UNIT;
                //            y = MathHelper.Clamp(y, -1f, 1f);

                //            mHDelta = x;
                //            mVDelta = y;
                //            break;
                //    }
                //}
                //#endregion
            }

 public void Draw(GameTime gameTime, SpriteBatch spriteBatch, DisplayOrientation orientation)
 {
     switch (orientation)
     {
         case DisplayOrientation.LandscapeLeft:
             Draw_Content(spriteBatch, _landscape);
             break;
         case DisplayOrientation.LandscapeRight:
             Draw_Content(spriteBatch, _landscape);
             break;
         case DisplayOrientation.Portrait:
             Draw_Content(spriteBatch, _portrait);
             break;
         case DisplayOrientation.Default:
             Draw_Content(spriteBatch, _portrait);
             break;
     }
 }

        public void ApplyChanges()
        {
            ThrowIfNotService();

            // Store software settings
            appliedSupportedOrientations = SupportedOrientations;
            if(appliedSupportedOrientations == DisplayOrientation.Default)
            {
                if(PreferredBackBufferHeight > PreferredBackBufferWidth)
                    appliedSupportedOrientations = DisplayOrientation.Portrait;
                else
                    appliedSupportedOrientations = DisplayOrientation.LandscapeLeft | DisplayOrientation.LandscapeRight;
            }

            Console.WriteLine("Setting supported orientations = " + appliedSupportedOrientations);

            // Not supporting this for the time being...
            // UIApplication.SharedApplication.StatusBarHidden = IsFullScreen;
        }

        public GraphicsDeviceManager(Game game)
        {
            if (game == null) {
                throw new ArgumentNullException ("Game Cannot Be Null");
            }

            _game = game;

            _supportedOrientations = DisplayOrientation.Default;
            _preferredBackBufferHeight = PresentationParameters._defaultBackBufferHeight;
            _preferredBackBufferWidth = PresentationParameters._defaultBackBufferWidth;

            if (game.Services.GetService (typeof(IGraphicsDeviceManager)) != null) {
                throw new ArgumentException ("Graphics Device Manager Already Present");
            }

            game.Services.AddService (typeof(IGraphicsDeviceManager), this);
            game.Services.AddService (typeof(IGraphicsDeviceService), this);
        }

        public void ApplyChanges()
        {
            ThrowIfNotService();

            // Store software settings
            appliedSupportedOrientations = SupportedOrientations;
            if(appliedSupportedOrientations == DisplayOrientation.Default)
            {
                if(PreferredBackBufferHeight > PreferredBackBufferWidth)
                    appliedSupportedOrientations = DisplayOrientation.Portrait;
                else
                    appliedSupportedOrientations = DisplayOrientation.LandscapeLeft | DisplayOrientation.LandscapeRight;
            }

            // Set Android requested orientations
            bool portrait = (appliedSupportedOrientations & DisplayOrientation.Portrait) != 0;
            bool landscapeLeft = (appliedSupportedOrientations & DisplayOrientation.LandscapeLeft) != 0;
            bool landscapeRight = (appliedSupportedOrientations & DisplayOrientation.LandscapeRight) != 0;
            // BUG: Android makes it difficult to support both landscape orientations...
            //      so for the time being, ExEn for Android doesn't either.
            if(landscapeLeft != landscapeRight)
                ExEnLog.WriteLine("WARNING: ExEn for Android cannot handle mismatched landscape modes");
            bool landscape = landscapeLeft || landscapeRight;
            if(portrait == landscape) // both (or neither, which shouldn't happen)
            {
                //activity.SetRequestedOrientation(Android.Content.PM.ScreenOrientation.Sensor);
            }
            else if(landscape)
            {
                // NOTE: Would prefer to use sensorLandscape, but that is only introduced in API level 9
                // TODO: If adding support for different API versions, add a conditional that uses
                //       sensorLandscape on API level 9+
                //activity.SetRequestedOrientation(Android.Content.PM.ScreenOrientation.Landscape);
            }
            else // portrait
            {
                // As above, would prefer to use sensorPortrait, but this requires API level 9
                // I'm fairly sure that a phone-style device will treat sensorPortrait as portrait
                // (no upside-down-portrait), and a pad will support it fully. This matches the
                // difference between iPhone and iPad.
                //activity.SetRequestedOrientation(Android.Content.PM.ScreenOrientation.Portrait);
            }
        }