Fast GridView

using System;
using System.Net;
using System.Data;
using System.Configuration;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using Avg.Controls;
/// <summary>
/// Summary description for GridViewExtender
/// </summary>
/// 
namespace Avg.Controls
{
    public delegate void DataSourceChangedEventHandler(object sender, bool isEmpty);

    [ToolboxData("<{0}:GridViewPager runat=server></{0}:GridViewPager>")]
    public class GridViewPager : GridView
    {
        /// <summary>
        /// Handling when the DataSourceChange
        /// </summary>
        public event DataSourceChangedEventHandler DataSourceChanged;
       
        /// <summary>
        /// A readonly unique ID for the current view.
        /// </summary>
        public string CurrentViewID
        {
            get { return string.Concat("CurrentView_", UniqueID); }
        }
       
        /// <summary>
        /// Overrides the data source property, so that we get a chance to test whether the source
        /// being bound contains data or not.
        ///
        /// This is used to communicate with the pager so that for an empty list no pager is shown.
        /// </summary>
        public override object DataSource
        {
            get
            {
                if (ViewState[CurrentViewID] != null)
                    return ViewState[CurrentViewID];
                else
                    return base.DataSource;

            }
            set
            {

                base.DataSource = value;
                ViewState[CurrentViewID] = value;


                if (value == null)
                {
                    if (DataSourceChanged != null)
                        DataSourceChanged(this, true);
                }
                else
                {
                    if (DataSourceChanged != null)
                        DataSourceChanged(this, false);
                }
            }
        }

        /// <summary>
        /// Smart Pager
        /// </summary>
        protected SmartPager pager;

        /// <summary>
        /// Numero of Page cliked
        /// </summary>
        public int PageNumberCliked
        {
            get { return (ViewState["PageNumberCliked"] == null) ? 1 : Int32.Parse(ViewState["PageNumberCliked"].ToString()); }
            set { ViewState["PageNumberCliked"] = value; }
        }


        /// <summary>
        /// Display pager numeros grouped by  Display value before '...' buton
        /// </summary>
        public int Display
        {
            get { return pager.Display; }
            set { pager.Display = value; }
        }

        /// <summary>
        /// Current first row to display
        /// </summary>
        public int rowB
        {
            get { return (Page.Session["rowB"] == null) ? 0 : Int32.Parse(Page.Session["rowB"].ToString()); }
            set { Page.Session["rowB"] = value; }
        }
        
        /// <summary>
        /// Current end row to display
        /// </summary>
        public int rowE
        {
            get { return (Page.Session["rowE"] == null) ? PageSize : Int32.Parse(Page.Session["rowE"].ToString()); }
            set { Page.Session["rowE"] = value; }
        }

        /// <summary>
        /// Calculate Page Count
        /// </summary>
        public int PageCount
        {
            get
            {

                if (RowCount == 0)
                {
                    return PageSize;
                }

                if (this.DataSource == null)
                {
                    throw new Exception("Datasource is empy");
                }

                if (PageSize == 0)
                {
                    throw new Exception("Page size must be positive");
                }

                return (int)(RowCount / PageSize) + 1;


            }
        }

        /// <summary>
        /// Calculate Row Count
        /// </summary>
        public int RowCount
        {
            get { return (Page.Session["RowCount"] == null) ? 5 : Int32.Parse(Page.Session["RowCount"].ToString()); }
            set { Page.Session["RowCount"] = value; }
        }

        /// <summary>
        /// Current Page
        /// </summary>
        public int CurrentPage
        {
            get { return (ViewState["CurrentPage"] == null) ? 1 : Int32.Parse(ViewState["CurrentPage"].ToString()); }
            set { ViewState["CurrentPage"] = value; }
        }

        /// <summary>
        /// Constructor
        /// </summary>
        public GridViewPager() : base()
        {

            pager = new SmartPager();
            pager.OnClickEvent += new OnClickPagerNumberEventHandler(pager_OnClickEvent);
           
        }

        #region events to implement on the page side

        private static readonly object OnSelectRowEventKey = new object();
        /// <summary>
        /// This events must be implemented with a select statement to get rows
        /// </summary>
        public event EventHandler DoSelectRow
        {
            add { Events.AddHandler(OnSelectRowEventKey, value); }
            remove { Events.RemoveHandler(OnSelectRowEventKey, value); }
        }

        protected virtual void OnSelectedRow(EventArgs e)
        {
            EventHandler handler = Events[OnSelectRowEventKey] as EventHandler;

            if (handler != null)
                handler(this, e);
            else
                throw new Exception("You must implement OnSelectRow method");
        }

        private static readonly object OnLoadRowCountEventKey = new object();
        /// <summary>
        /// This events must be implemented to know the row count
        /// </summary>
        public event EventHandler DoLoadRowCount
        {
            add { Events.AddHandler(OnLoadRowCountEventKey, value); }
            remove { Events.RemoveHandler(OnLoadRowCountEventKey, value); }
        }

        protected virtual void OnLoadedRowCount(EventArgs e)
        {
            EventHandler handler = Events[OnLoadRowCountEventKey] as EventHandler;

            if (handler != null)
                handler(this, e);
            else
                throw new Exception("You must implement OnLoadRowCount method");
        }


        #endregion events to implement on the page side


        #region Component event

        /// <summary>
        /// OnInit Event
        /// </summary>
        /// <param name="e"></param>
        protected override void OnInit(EventArgs e)
        {
            base.OnInit(e);
            Page.Load += new EventHandler(Page_Load);
        }

        /// <summary>
        /// PageLoad Event
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void Page_Load(object sender, EventArgs e)
        {

            if (!Page.IsPostBack)
                OnLoadedRowCount(EventArgs.Empty);

            bool goodCall = true;

            //the current page is posted 2 times : 
            // 1- in javascript SmartPager.js by SmartPagerSelectPage when a new page is clicked (with callback parameter)
            // 2- on  the pager_OnClickEvent (without callback parameter)
            foreach (string Key in Page.Request.Form.AllKeys)
            {
                if (Key.EndsWith("CALLBACKPARAM"))
                {
                    goodCall = false;
                }
            }

            //Handle just one time after pager_OnClickEvent call when the  CALLBACKPARAM is missing        
            if (goodCall)
            OnSelectedRow(EventArgs.Empty);
        }

        /// <summary>
        /// Load the Control
        /// </summary>
        /// <param name="e"></param>
        protected override void OnLoad(EventArgs e)
        {
            base.OnLoad(e);
            Controls.Add(pager);
        }

        /// <summary>
        /// PreRender the Control
        /// </summary>
        /// <param name="e"></param>
        protected override void OnPreRender(EventArgs e)
        {
            base.OnPreRender(e);
            pager.PageCount = PageCount;

        }

        /// <summary>
        /// Event Handler Click Page with ICallBackEventHandler in SmartPager
        /// </summary>
        void pager_OnClickEvent(object sender, string pPageNum)
        {

            PageNumberCliked = Int32.Parse(pPageNum);

            CurrentPage = PageNumberCliked;

            if (CurrentPage == 1)
            {
                rowB = 0;
                rowE = PageSize;
            }
            else 
            {
                rowE = (PageSize * CurrentPage) - 1;
                rowB = rowE - (PageSize - 1);
            }

            //Call postabck without call back parameters
            Page.Response.Write(
            "<script language='Javascript'>__doPostBack('__Page', 'MyCustomArgument');</script>"
            );

        }
        
        #endregion Component event
        

        #region IStateManager Members

        /// <summary>
        /// Load the ViewState
        /// </summary>
        /// <param name="savedState"></param>
        protected override void LoadViewState(object savedState)
        {
            if (savedState != null)
            {
                object[] state = savedState as object[];
                if (state != null && state.Length == 2)
                {
                    base.LoadViewState(state[0]);
                    if (state[1] != null)
                        ((IStateManager)this.pager).LoadViewState(state[1]);
                }
            }
            else
                base.LoadViewState(savedState);
        }

        /// <summary>
        /// Save the ViewState
        /// </summary>
        /// <param name="savedState"></param>
        protected override object SaveViewState()
        {
            object[] state = new object[2];
            state[0] = base.SaveViewState();
            if (pager != null)
                state[1] = ((IStateManager)this.pager).SaveViewState();
            return state;
        }

        /// <summary>
        /// Track the Viewstate
        /// </summary>
        protected override void TrackViewState()
        {
            base.TrackViewState();
            if (pager != null)
                ((IStateManager)this.pager).TrackViewState();
        }

        #endregion

    }

}