HttpContext.Response.AddHeader("cache-control", "no-cache");

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 class SampleObject
{
    public int PublicInteger = 6;
 
    [NotNullable(-1)]
    [UniqueIdentifier]
    [NumberConstraint(0, double.MaxValue)]
    public int Id { get; set; }
 
    [LengthConstraint(0, 50)]
    public string Title { get; set; }
 
    [NonSerialized]
    public int Secret = 3;
 
    public List<int> RawData { get; set; }
 
    public int[] Data = new int[] { 5, 6, 7, 8 };
 
    public SampleObject()
    {
        RawData = new List<int>();
        RawData.Add(32);
        RawData.Add(64);
    }
}

<?xml version="1.0" encoding="utf-16"?>
<ns1:SampleObject 
    xmlns:ns2="clr-namespace:System;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" 
    xmlns:ns3="clr-namespace:System.Collections.Generic;Assembly=mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" 
    xmlns:ns1="clr-namespace:DMS.Driver;Assembly=DMS.Driver">
    <ns2:Int32 Name="Id">5</ns2:Int32>
    <ns2:String Name="Title">Hello!</ns2:String>
    <Generic Type="System.Collections.Generic.List`1[[System.Int32, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]" Name="RawData">
        <ns2:Int32>32</ns2:Int32>
        <ns2:Int32>64</ns2:Int32>
    </Generic>
    <ns2:Int32 Name="PublicInteger">6</ns2:Int32>
    <Array Type="System.Int32[]" Name="Data">
      <ns2:Int32>5</ns2:Int32>
      <ns2:Int32>6</ns2:Int32>
      <ns2:Int32>7</ns2:Int32>
      <ns2:Int32>8</ns2:Int32>
    </Array>
</ns1:SampleObject>

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; }
}

<link rel="Stylesheet" href="<%= ResolveUrl("css/Master.css") %>" type="text/css" media="screen" />

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;
    }
 
    // ...
}

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);
}