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

public delegate void CollectionChangedHandler(object sender, CollectionChangedEventArgs args);

public class CollectionChangedEventArgs : EventArgs
{
    public CollectionChangedEventArgs()
    {
    }
 
    public CollectionChangedEventArgs(object item)
    {
        Item = item;
    }
 
    public CollectionChangedEventArgs(object item, int index)
        : this(item)
    {
        Index = index;
    }
 
    public object Item { get; set; }
    public int Index { get; set; }
}

public interface ICollection
{
    event CollectionChangedHandler ItemAdded;
    event CollectionChangedHandler ItemRemoved;
}

public class Collection<T> : ICollection, IList<T>, ICollection<T>, IEnumerable<T>, IList, System.Collections.ICollection, IEnumerable
{
    public event CollectionChangedHandler ItemAdded;
    public event CollectionChangedHandler ItemRemoved;
 
    private List<T> internalList = new List<T>();
 
    private bool IsViableType(object item)
    {
        if(item is T && item != null) return true;
        return false;
    }
 
    protected virtual void OnItemAdded(object sender, CollectionChangedEventArgs args)
    {
        if (ItemAdded != null) ItemAdded.Invoke(sender, args);
    }
 
    protected virtual void OnItemRemoved(object sender, CollectionChangedEventArgs args)
    {
        if (ItemRemoved != null) ItemRemoved.Invoke(sender, args);
    }

#region Sorting
    public void Sort()
    {
        internalList.Sort();
    }
 
    public void Sort(IComparer<T> comparer)
    {
        internalList.Sort(comparer);
    }
    #endregion
 
    public void AddRange(IEnumerable<T> items)
    {
        foreach (T item in items)
            Add(item);
    }
 
    #region IList<T> Members
    public int IndexOf(T item)
    {
        return internalList.IndexOf(item);
    }
 
    public void Insert(int index, T item)
    {
        internalList.Insert(index, item);
 
        OnItemAdded(this, new CollectionChangedEventArgs(item, index));
    }
 
    public void RemoveAt(int index)
    {
        T item = this[index];
 
        internalList.RemoveAt(index);
 
        OnItemRemoved(this, new CollectionChangedEventArgs(item, index));
    }
 
    public T this[int index]
    {
        get
        {
            return internalList[index];
        }
        set
        {
            internalList[index] = value;
        }
    }
    #endregion
 
    #region ICollection<T> Members
    public void Add(T item)
    {
        internalList.Add(item);
 
        OnItemAdded(this, new CollectionChangedEventArgs(item, Count - 1));
    }
 
    public void Clear()
    {
        // TODO: How do throw the event here?
        for (int i = Count - 1; i > 0; i--)
            RemoveAt(i);
 
        internalList.Clear();
    }
 
    public bool Contains(T item)
    {
        return internalList.Contains(item);
    }
 
    public void CopyTo(T[] array, int arrayIndex)
    {
        internalList.CopyTo(array, arrayIndex);
    }
 
    public int Count
    {
        get { return internalList.Count; }
    }
 
    bool ICollection<T>.IsReadOnly
    {
        get { return false; }
    }
 
    public bool Remove(T item)
    {
        int index = internalList.IndexOf(item);
 
        bool returnValue = internalList.Remove(item);
 
        OnItemRemoved(this, new CollectionChangedEventArgs(item, index));
 
        return returnValue;
    }
    #endregion
 
    #region IEnumerable<T> Members
    public IEnumerator<T> GetEnumerator()
    {
        return internalList.GetEnumerator();
    }
    #endregion
 
    #region IEnumerable Members
    IEnumerator IEnumerable.GetEnumerator()
    {
        return internalList.GetEnumerator();
    }
    #endregion
 
    #region IList Members
    int IList.Add(object value)
    {
        if (IsViableType(value))
        {
            Add((T)value);
 
            return internalList.IndexOf((T)value);
        }
 
        return -1;
    }
 
    bool IList.Contains(object value)
    {
        if (IsViableType(value))
        {
            return Contains((T)value);
        }
 
        return false;
    }
 
    int IList.IndexOf(object value)
    {
        if(IsViableType(value))
            return internalList.IndexOf((T)value);
 
        return -1;
    }
 
    void IList.Insert(int index, object value)
    {
        if (IsViableType(value))
            Insert(index, (T)value);
    }
 
    bool IList.IsFixedSize
    {
        get { return false; }
    }
 
    void IList.Remove(object value)
    {
        if (IsViableType(value))
            Remove((T)value);
    }
 
    object IList.this[int index]
    {
        get
        {
            return internalList[index];
        }
        set
        {
            if (value is T && value != null)
                internalList[index] = (T)value;
        }
    }
 
    bool IList.IsReadOnly
    {
        get { return false; }
    }
    #endregion
 
    #region ICollection Members
    void System.Collections.ICollection.CopyTo(Array array, int index)
    {
        throw new NotImplementedException();
    }
 
    bool System.Collections.ICollection.IsSynchronized
    {
        get { return false; }
    }
 
    object System.Collections.ICollection.SyncRoot
    {
        get { return null; }
    }
    #endregion
}

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

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