private void OnGestureTracked(object sender, GestureArgs args)
{
    // If it wasn't a swipe, we don't care!
    if (args.Gesture != Gesture.Swipe) return;
 
    // Get the direction of the swipe to determine what way
    // the menus should move
    if (args.Direction.X < 0)
    {
        // If we are capped at the right side of the menus, return
        if (current == menus.Length - 1) return;
 
        // Transition the menus
        menus[current].Transition(Menu.MoveDir.OffToLeft);
 
        current++;
 
        menus[current].Transition(Menu.MoveDir.OnFromRight);
    }
    else
    {
        if (current == 0) return;
 
        menus[current].Transition(Menu.MoveDir.OffToRight);
 
        current--;
 
        menus[current].Transition(Menu.MoveDir.OnFromLeft);
    }
}

public interface IModule
{
    event EventHandler DrawOrderChanged;
    event EventHandler UpdateOrderChanged;
 
    void Initialize(IGame game);
 
    void Draw(GameTime gameTime);
    void Update(GameTime gameTime);
 
    int DrawOrder { get; }
    int UpdateOrder { get; }
 
    bool IsVisible { get; set; }
    bool IsEnabled { get; set; }
    bool IsInitialized { get; set; }
 
    IModule Parent { get; set; }
    ModuleCollection Modules { get; }
}

public class ModuleCollection : Collection<IModule>
{
    private List<IModule> drawList = new List<IModule>();

    public T GetModule<T>() where T : class, IModule
    {
        for (int i = 0; i < Count; i++)
            if (this[i] is T)
                return this[i] as T;
 
        return default(T);
    }

    public void Initialize(IGame game)
    {
        if (IsInitialized) return;
 
        Game = game;
 
        for (int i = 0; i < Count; i++)
            if(!this[i].IsInitialized)
                this[i].Initialize(game);
 
        IsInitialized = true;
    }
 
    public void Draw(GameTime gameTime)
    {
        for (int i = 0; i < drawList.Count; i++)
            if(drawList[i].IsVisible)
                drawList[i].Draw(gameTime);
    }
 
    public void Update(GameTime gameTime)
    {
        for (int i = 0; i < Count; i++)
            if(this[i].IsEnabled)
                this[i].Update(gameTime);
    }

    protected override void OnItemAdded(object sender, CollectionChangedEventArgs args)
    {
        IModule module = args.Item as IModule;
 
        if (module == null) return;
 
        module.DrawOrderChanged += OnModuleDrawOrderChanged;
        module.UpdateOrderChanged += OnModuleUpdateOrderChanged;
 
        if (IsInitialized && !module.IsInitialized)
            module.Initialize(Game);
 
        drawList.Add(module);
        drawList.Sort(DrawOrderComparer.Default);
 
        Sort(UpdateOrderComparer.Default);
 
        base.OnItemAdded(sender, args);
    }
 
    protected virtual void OnModuleUpdateOrderChanged(object sender, EventArgs e)
    {
        Sort(UpdateOrderComparer.Default);
    }
 
    protected virtual void OnModuleDrawOrderChanged(object sender, EventArgs e)
    {
        drawList.Sort(DrawOrderComparer.Default);
    }

    protected override void OnItemRemoved(object sender, CollectionChangedEventArgs args)
    {
        IModule module = args.Item as IModule;
 
        if (module == null) return;
 
        module.DrawOrderChanged -= OnModuleDrawOrderChanged;
        module.UpdateOrderChanged -= OnModuleUpdateOrderChanged;
 
        drawList.Remove(module);
 
        base.OnItemRemoved(sender, args);
    }

    protected IGame Game { get; private set; }
    protected bool IsInitialized { get; private set; }
}

public class Module : NotifyPropertyChangedBase, IModule
{
    private int drawOrder = 0;
    private int updateOrder = 0;
 
    private bool isVisible = true;
    private bool isEnabled = true;
 
    private IModule parent = null;
 
    public event EventHandler DrawOrderChanged;
    public event EventHandler UpdateOrderChanged;
 
    public Module()
    {
        Modules = new ModuleCollection();
 
        Modules.ItemAdded += OnModuleAdded;
        Modules.ItemRemoved += OnModuleRemoved;
    }

    protected virtual void OnDrawOrderChanged(object sender, EventArgs args)
    {
        if (DrawOrderChanged != null) DrawOrderChanged.Invoke(sender, args);
    }
 
    protected virtual void OnUpdateOrderChanged(object sender, EventArgs args)
    {
        if (UpdateOrderChanged != null) UpdateOrderChanged.Invoke(sender, args);
    }

    protected virtual void OnModuleAdded(object sender, CollectionChangedEventArgs args)
    {
        IModule module = args.Item as IModule;
 
        if (module == null) return;
 
        module.Parent = this;
    }
 
    protected virtual void OnModuleRemoved(object sender, CollectionChangedEventArgs args)
    {
        IModule module = args.Item as IModule;
 
        if (module == null) return;
 
        // First we check to ensure that the developer
        // hasn't set the parent manually to some other
        // object before we remove ourselves as parent.
        if(module.Parent == this)
            module.Parent = null;
    }

    public virtual void Initialize(IGame game)
    {
        Game = game;
 
        Modules.Initialize(game);
 
        IsInitialized = true;
    }
 
    public virtual void Draw(GameTime gameTime)
    {
        Modules.Draw(gameTime);
    }
 
    public virtual void Update(GameTime gameTime)
    {
        Modules.Update(gameTime);
    }

    public int DrawOrder
    {
        get { return drawOrder; }
        set
        {
            drawOrder = value;
 
            OnDrawOrderChanged(this, EventArgs.Empty);
        }
    }
 
    public int UpdateOrder
    {
        get { return updateOrder; }
        set
        {
            updateOrder = value;
 
            OnUpdateOrderChanged(this, EventArgs.Empty);
        }
    }
 
    public bool IsVisible
    {
        get { return isVisible; }
        set { isVisible = value; }
    }
 
    public bool IsEnabled
    {
        get { return isEnabled; }
        set { isEnabled = value; }
    }
 
    public IModule Parent
    {
        get { return parent; }
        set { parent = value; }
    }
 
    public bool IsInitialized { get; protected set; }
 
    public ModuleCollection Modules { get; private set; }
 
    protected IGame Game { get; private set; }
}

public class NotifyPropertyChangedBase : INotifyPropertyChanged
{
    private bool isDirty = false;
 
    public event PropertyChangedEventHandler PropertyChanged;

    protected virtual bool CanSetDirty()
    {
        return !DisableDirtyFlag;
    }

    protected void OnPropertyChanged(string propertyName)
    {
        OnPropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }
 
    protected virtual void OnPropertyChanged(object sender, PropertyChangedEventArgs args)
    {
        if (args.PropertyName != "IsDirty")
            IsDirty = true;
 
        if (PropertyChanged != null) PropertyChanged.Invoke(sender, args);
    }

    public bool DisableDirtyFlag { get; set; }
 
    public bool IsDirty
    {
        get { return isDirty; }
        set
        {
            if (CanSetDirty())
            {
                isDirty = value;
 
                OnPropertyChanged("IsDirty");
            }
        }
    }
}

DisplaySize = new Vector2(272, 480);
DisplayOrientation = DisplayOrientation.Rotated;
 
Console.WriteLine(OrientedDisplaySize.ToString());

public class Game1 : Application
{
    public Game1()
    {
        // Set the display size and the rotation
        DisplaySize = new Vector2(272, 480);
        DisplayOrientation = DisplayOrientation.Rotated;
    }
 
    // ...
}

public interface IAuthenticationProvider{
    bool CheckCredentials(string username, string password);
}

public class SqlAuthenticationProvider : IAuthenticationProvider{
    public bool CheckCredentials(string username, string password){
        if(!IsValid(username, password)) return false;
 
        // Run some SQL statement - set result to a bool
        bool result = false;
 
        return result;
    }
}
 
public class TextAuthenticationProvider : IAuthenticationProvider{
    public bool CheckCredentials(string username, string password){
        return (username == "root" && password == "hello");
    }
}

public class LoginPage : Page{
    protected void Submit_Click(object sender, EventArgs e){
        foreach(IAuthenticationProvider provider in Configuration.AuthenticationProviders){
            if(provider.CheckCredentials(txtUsername.Text, txtPassword.Text)){
                // set some session variables or a cookie
                Response.Redirect("UserProfile.aspx");
            }
        }
    }
}

namespace Microsoft.Xna.Framework{
    public interface IGameComponent{
        void Initialize();
    }
 
    public interface IDrawable{
        event EventHandler DrawOrderChanged;
        event EventHandler VisibleChanged;
        void Draw(GameTime gameTime);
        int DrawOrder { get; }
        bool Visible { get; }
    }
 
    public interface IUpdateable{
        event EventHandler EnabledChanged;
        event EventHandler UpdateOrderChanged;
        void Update(GameTime gameTime);
        bool Enabled { get; }
        int UpdateOrder { get; }
    }
}

namespace Microsoft.Xna.Framework{
    public class GameComponent : IGameComponent, IUpdateable, IDisposable{
        // ...
    }
 
    public class DrawableGameComponent : GameComponent, IDrawable{
        // ...
    }
}

using System;
 
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
 
namespace FocusedGames.Xna.Graphics
{
    public static class GraphicsHelper
    {
        public static RenderTarget2D CreateRenderTarget(GraphicsDevice device)
        {
            return CreateRenderTarget(
                device, 
                device.PresentationParameters.BackBufferWidth, 
                device.PresentationParameters.BackBufferHeight, 
                1, 
                device.PresentationParameters.BackBufferFormat
            );
        }

        public static RenderTarget2D CreateRenderTarget(GraphicsDevice device, int width, int height, int levels, SurfaceFormat format)
        {
            MultiSampleType sampleType = device.PresentationParameters.MultiSampleType;
 
            if (
                !GraphicsAdapter.DefaultAdapter.CheckDeviceFormat(
                    DeviceType.Hardware, 
                    GraphicsAdapter.DefaultAdapter.CurrentDisplayMode.Format, 
                    TextureUsage.None, 
                    QueryUsages.None, 
                    ResourceType.RenderTarget, 
                    format
                )
            )
            {
                format = device.DisplayMode.Format;
            }
            else if (
                !GraphicsAdapter.DefaultAdapter.CheckDeviceMultiSampleType(
                    DeviceType.Hardware, 
                    format, 
                    device.PresentationParameters.IsFullScreen, 
                    sampleType
                )
            )
            {
                sampleType = MultiSampleType.None;
            }
 
            CheckTextureSize(width, height, out width, out height);
 
            return new RenderTarget2D(device, width, height, levels, format, sampleType, 0);
        }

public static bool CheckTextureSize(int width, int height, out int newWidth, out int newHeight)
        {
            bool returnValue = false;
 
            GraphicsDeviceCapabilities caps = GraphicsAdapter.DefaultAdapter.GetCapabilities(DeviceType.Hardware);
 
            if (caps.TextureCapabilities.RequiresPower2)
            {
                returnValue = true;
 
                // Perform a simple check before doing (possibly) unecessary math
                if (!IsPowerOfTwo(width))
                {
                    // Find the nearest base two log of the current width,
                    // and go up to the next integer
                    double exponent = Math.Ceiling(Math.Log(width) / Math.Log(2));
 
                    width = (int)Math.Pow(2, exponent);
                }
 
                // Perform a simple check before doing (possibly) unecessary math
                if (!IsPowerOfTwo(height))
                {
                    // Find the nearest base two log of the current height,
                    // and go up to the next integer
                    double exponent = Math.Ceiling(Math.Log(height) / Math.Log(2));
 
                    height = (int)Math.Pow(2, exponent);
                }
            }
 
            if (caps.TextureCapabilities.RequiresSquareOnly)
            {
                returnValue = true;
 
                width = Math.Max(width, height);
 
                height = width;
            }
 
            newWidth = Math.Min(caps.MaxTextureWidth, width);
            newHeight = Math.Min(caps.MaxTextureHeight, height);
 
            return returnValue;
        }

        public static bool IsPowerOfTwo(int number)
        {
            return (number & (number - 1)) == 0;
        }
    }
}

protected virtual void ResetRenderTarget()
{
    if (renderTarget != null && !renderTarget.IsDisposed)
        renderTarget.Dispose();
 
    renderTarget = GraphicsHelper.CreateRenderTarget(GraphicsDevice, (int)orientedDisplaySize.X, (int)orientedDisplaySize.Y, 1, SurfaceFormat.Color);
}

using Microsoft.Xna.Framework;
 
namespace FocusedGames.Xna
{
    public interface IGame
    {
        void Run();
        void Exit();
 
        Vector2 ObjectToScreen(Vector2 objectVector);
        Vector2 ScreenToObject(Vector2 screenVector);
 
        GraphicsDeviceManager DeviceManager { get; }
 
        DisplayOrientation DisplayOrientation { get; set; }
        Vector2 DisplaySize { get; set; }
 
        bool IsLoaded { get; }
 
        float TargetFrameRate { get; set; }
 
        ModuleCollection Modules { get; }
    }
}

namespace FocusedGames.Xna
{
    /// <summary>
    /// Represents the orientation of the display.
    /// </summary>
    public enum DisplayOrientation : byte
    {
        /// <summary>
        /// Represents the standard orientation of the display. For Zune and Zune HD this is portrait mode.
        /// </summary>
        Standard = 0,
 
        /// <summary>
        /// Represents a 180 degree flip of the standard orientation.
        /// </summary>
        Flipped = 1,
 
        /// <summary>
        /// Represents a 90 degree rotation of the standard orientation. For the Zune and Zune HD this is landscape mode.
        /// </summary>
        Rotated = 2,
 
        /// <summary>
        /// Represents a -90 degree rotation of the standard orientation.
        /// </summary>
        ReverseRotated = 3
    }
}

namespace FocusedGames.Xna
{
    public class ModuleCollection
    {
    }
}

using System;
 
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
 
namespace FocusedGames.Xna
{
    public class Application : Game, IGame
    {

        private DisplayOrientation displayOrientation;
        private float displayRotation = 0f;
        private SpriteEffects displaySpriteEffects = SpriteEffects.None;
 
        private Vector2 orientedDisplaySize = new Vector2(800, 600);
        private Vector2 displaySize = new Vector2(800, 600);
 
        private SpriteBatch spriteBatch;
        private RenderTarget2D renderTarget;

        public Application()
        {
            Modules = new ModuleCollection();
 
            DeviceManager = new GraphicsDeviceManager(this);
 
            ClearColor = Color.Black;
            DisplayOrientation = DisplayOrientation.Standard;
 
            Content.RootDirectory = "Content";
 
#if ZUNE
            // Frame rate is 30 fps by default for Zune.
            TargetElapsedTime = TimeSpan.FromSeconds(1 / 30.0);
#endif
        }

        protected override void LoadContent()
        {
            spriteBatch = new SpriteBatch(GraphicsDevice);
 
            SetDisplaySize(displaySize);
 
            ResetRenderTarget();
 
            base.LoadContent();
 
            IsLoaded = true;
        }
 
        protected override void UnloadContent()
        {
            if(spriteBatch != null && !spriteBatch.IsDisposed)
                spriteBatch.Dispose();
 
            base.UnloadContent();
 
            IsLoaded = false;
        }

        protected virtual void SetDisplayOrientation(DisplayOrientation newOrientation)
        {
            // Removed so this method can act as a reset as well
            // if (newOrientation == displayOrientation) return;
 
            displayOrientation = newOrientation;
 
            // TODO: Handle orientations
            switch (displayOrientation)
            {
                case DisplayOrientation.Standard:
                    orientedDisplaySize = displaySize;
                    displayRotation = 0;
                    displaySpriteEffects = SpriteEffects.None;
                    break;
                case DisplayOrientation.Flipped:
                    orientedDisplaySize = displaySize;
                    displayRotation = 0;
                    displaySpriteEffects = SpriteEffects.FlipVertically | SpriteEffects.FlipHorizontally;
                    break;
                case DisplayOrientation.Rotated:
                    orientedDisplaySize.X = displaySize.Y;
                    orientedDisplaySize.Y = displaySize.X;
                    displayRotation = MathHelper.PiOver2;
                    displaySpriteEffects = SpriteEffects.None;
                    break;
                case DisplayOrientation.ReverseRotated:
                    orientedDisplaySize.X = displaySize.Y;
                    orientedDisplaySize.Y = displaySize.X;
                    displayRotation = MathHelper.PiOver2;
                    displaySpriteEffects = SpriteEffects.FlipVertically | SpriteEffects.FlipHorizontally; //SpriteEffects.FlipHorizontally;
                    break;
            }
 
            if(IsLoaded)
                ResetRenderTarget();
        }

        protected virtual void SetDisplaySize(Vector2 newSize)
        {
            // Removed so this method can act as a reset as well
            // if (newSize == displaySize) return;
 
            displaySize = newSize;
            orientedDisplaySize = newSize;
 
            // Reset the backbuffer
            DeviceManager.PreferredBackBufferWidth = (int)displaySize.X;
            DeviceManager.PreferredBackBufferHeight = (int)displaySize.Y;
 
            // If we already loaded, apply the changed
            if (IsLoaded)
                DeviceManager.ApplyChanges();
 
            // Reset the orientation details
            SetDisplayOrientation(displayOrientation);
        }

        private void ResetRenderTarget()
        {
#if ZUNE
            if (renderTarget != null && !renderTarget.IsDisposed)
                renderTarget.Dispose();
 
            renderTarget = new RenderTarget2D(GraphicsDevice, (int)orientedDisplaySize.X, (int)orientedDisplaySize.Y, 1, SurfaceFormat.Color);
#else
            // TODO: Do some RT work here for Windows / Xbox 360
#endif
        }

        /// <summary>
        /// Clears the GraphicsDevice.
        /// </summary>
        protected virtual void ClearGraphicsDevice()
        {
            GraphicsDevice.Clear(ClearColor);
        }

        protected override bool BeginDraw()
        {
            if (base.BeginDraw())
            {
                if (DisplayOrientation == DisplayOrientation.Standard)
                {
                    ClearGraphicsDevice();
                    return true;
                }
 
                if (renderTarget == null || renderTarget.IsDisposed)
                {
                    ClearGraphicsDevice();
                    return false;
                }
 
                GraphicsDevice.SetRenderTarget(0, renderTarget);
 
                ClearGraphicsDevice();
 
                GraphicsDevice.Viewport = new Viewport
                {
                    X = 0,
                    Y = 0,
                    Width = (int)orientedDisplaySize.X,
                    Height = (int)orientedDisplaySize.Y,
                    MinDepth = GraphicsDevice.Viewport.MinDepth,
                    MaxDepth = GraphicsDevice.Viewport.MaxDepth
                };
 
                return true;
            }
 
            return false;
        }

        protected override void EndDraw()
        {
            if (!IsLoaded)
                return;
 
            if (DisplayOrientation == DisplayOrientation.Standard ||
                (renderTarget == null || renderTarget.IsDisposed))
            {
                //base.EndDraw();
                FinalizeDraw();
 
                return;
            }
 
            GraphicsDevice.SetRenderTarget(0, null);
            GraphicsDevice.Viewport = new Viewport
            {
                X = 0,
                Y = 0,
                Width = (int)displaySize.X,
                Height = (int)displaySize.Y,
                MinDepth = GraphicsDevice.Viewport.MinDepth,
                MaxDepth = GraphicsDevice.Viewport.MaxDepth
            };
 
            spriteBatch.Begin(SpriteBlendMode.None, SpriteSortMode.Immediate, SaveStateMode.SaveState);
 
            spriteBatch.Draw(
                renderTarget.GetTexture(),
                displaySize / 2,
                null,
                Color.White,
                DisplayRotation,
                orientedDisplaySize / 2,
                1f,
                DisplaySpriteEffects,
                0
            );
 
            spriteBatch.End();
 
            //base.EndDraw();
            FinalizeDraw();
        }
 
        private void FinalizeDraw()
        {
            DrawOverlay();
 
            base.EndDraw();
        }
 
        /// <summary>
        /// Draw's unrotated graphics.
        /// </summary>
        protected virtual void DrawOverlay()
        {
        }

        /// <summary>
        /// Gets screen coordinates from object coordinates.
        /// </summary>
        /// <param name="objectVector">The object's coordinates.</param>
        /// <returns>Coordinates in screen space.</returns>
        public Vector2 ObjectToScreen(Vector2 objectVector)
        {
            return new Vector2(displaySize.X - objectVector.Y, objectVector.X);
        }
 
        /// <summary>
        /// Gets object coordinates from screen coordinates.
        /// </summary>
        /// <param name="screenVector">The coordinates in screen space.</param>
        /// <returns>Coordinates in object space.</returns>
        public Vector2 ScreenToObject(Vector2 screenVector)
        {
            return new Vector2(screenVector.Y, displaySize.X - screenVector.X);
        }
 
        public GraphicsDeviceManager DeviceManager { get; private set; }
 
        /// <summary>
        /// Gets or Sets the orientation of the display.
        /// </summary>
        public DisplayOrientation DisplayOrientation
        {
            get { return displayOrientation; }
            set { SetDisplayOrientation(value); }
        }
 
        /// <summary>
        /// Gets or Sets the size of the display.
        /// </summary>
        public Vector2 DisplaySize
        {
            get { return displaySize; }
            set { SetDisplaySize(value); }
        }
 
        /// <summary>
        /// Gets the rotation of the display.
        /// </summary>
        /// <seealso cref="DisplaySpriteEffects"/>
        public float DisplayRotation { get { return displayRotation; } }
 
        /// <summary>
        /// Gets the SpriteEffects for the display's render target.
        /// </summary>
        /// <seealso cref="DisplayRotation"/>
        public SpriteEffects DisplaySpriteEffects { get { return displaySpriteEffects; } }
 
        /// <summary>
        /// Gets whether or not the application has been loaded.
        /// </summary>
        public bool IsLoaded { get; private set; }
 
        /// <summary>
        /// Gets or Sets the clear color of the graphics device.
        /// </summary>
        protected Color ClearColor { get; set; }
 
        /// <summary>
        /// Gets the SpriteBatch used to draw the main render target.
        /// </summary>
        protected SpriteBatch SpriteBatch { get { return spriteBatch; } }
 
        /// <summary>
        /// Gets or Sets the target frame rate for the underlying loop code.
        /// </summary>
        public float TargetFrameRate
        {
            get { return 1 / (float)TargetElapsedTime.TotalSeconds; }
            set
            {
                TargetElapsedTime = TimeSpan.FromSeconds(1 / value);
            }
        }
 
        public ModuleCollection Modules { get; private set; }
    }
}