using System;
using System.IO;
using System.Drawing;
using System.Data;
using System.Data.SqlClient;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.ComponentModel;
using Base.Data;

namespace Base.Web
{
    PagingMode 
enum#region PagingMode enum
    
public enum PagingMode
    
{
        Cached,
        NonCached
    }

    
#endregion

    
    PagerStyle 
enum#region PagerStyle enum
    
public enum PagerStyle
    
{
        NextPrev,
        NumericPages,
        NumericList
    }

    
#endregion


    VirtualRecordCount 
class#region VirtualRecordCount class
    
public class VirtualRecordCount
    
{
        
public int RecordCount;
        
public int PageCount;
        
public int RecordsInLastPage;
    }

    
#endregion


    PageChangedEventArgs 
class#region PageChangedEventArgs class
    
public class PageChangedEventArgs : EventArgs 
    
{
        
public int OldPageIndex;
        
public int NewPageIndex;
    }

    
#endregion
 

    ListChangedEventArgs 
class#region ListChangedEventArgs class
    
public class ListChangedEventArgs : EventArgs 
    
{
        
public int OldListIndex;
        
public int NewListIndex;
    }

    
#endregion
 

    Page Control
#region Page Control

    [DefaultProperty(
"SelectCommand")]
    [DefaultEvent(
"PageIndexChanged")]
    
public class PageControl : WebControl, INamingContainer
    
{
        PRIVATE DATA MEMBERS
#region  PRIVATE DATA MEMBERS 
        
// ***********************************************************************
        
// PRIVATE members
        private PagedDataSource _dataSource;
        
private Control _controlToPaginate;
        
private string CacheKeyName 
        
{
            
get {return Page.Request.FilePath + "_" + UniqueID + "_Data";}
        }

        
private string CurrentPageText = "【当前{0}页】【总共{1}页】";
        
private string RecordCountText = "【总共{0}条记录】";

        
private string NoPageSelectedText = "无选中页";
        
private string QueryPageCommandText = "SELECT * FROM " + 
            
"(SELECT TOP {0} * FROM " + 
            
"(SELECT TOP {1} * FROM ({2}) AS t0 ORDER BY {3} {4}) AS t1 " + 
            
"ORDER BY {3} {5}) AS t2 " + 
            
"ORDER BY {3}";
        
private string QueryCountCommandText = "SELECT COUNT(*) FROM ({0}) AS t0";
        
// ***********************************************************************
        #endregion


        CTOR(s)
#region CTOR(s) 
        
// ***********************************************************************
        
// Ctor
        public PageControl() : base()
        
{
            _dataSource 
= null;
            _controlToPaginate 
= null;

            Font.Name 
= "verdana";
            Font.Size 
= FontUnit.Point(8);
            BackColor 
= Color.Transparent; 
            ForeColor 
= Color.Black;
            BorderStyle 
= BorderStyle.None;
            BorderWidth 
= Unit.Parse("1px"); 
            Width
=Unit.Parse("100%");
            PagingMode 
= PagingMode.NonCached;
            PagerStyle 
= PagerStyle.NextPrev;
            CurrentPageIndex 
= 0;
            SelectCommand 
= "";
            ItemsPerPage 
= 20;
            TotalPages 
= -1;
            CacheDuration 
= 60;
        }

        
// ***********************************************************************
        #endregion


        PUBLIC PROGRAMMING INTERFACE
#region PUBLIC PROGRAMMING INTERFACE 
        
// ***********************************************************************
        
// METHOD ClearCache
        
// Removes any data cached for paging
        public void ClearCache()
        
{
            
if (PagingMode == PagingMode.Cached)
                Page.Cache.Remove(CacheKeyName); 
        }

        
// ***********************************************************************

        
// ***********************************************************************
        
// EVENT PageIndexChanged
        
// Fires when the pager is about to switch to a new page
        public delegate void PageChangedEventHandler(object sender, PageChangedEventArgs e);
        
public event PageChangedEventHandler PageIndexChanged;
        
protected virtual void OnPageIndexChanged(PageChangedEventArgs e)
        
{
            
if (PageIndexChanged != null)
                PageIndexChanged(
this, e);
        }

        
// ***********************************************************************
        public delegate void ListChangedEventHandler(object sender, ListChangedEventArgs e);
        
public event ListChangedEventHandler ListIndexChanged;
        
protected virtual void OnListIndexChanged(ListChangedEventArgs e)
        
{
            
if (ListIndexChanged != null)
                ListIndexChanged(
this, e);
        }

        
// ***********************************************************************
        
// PROPERTY CacheDuration
        [Description("Gets and sets for how many seconds the data should stay in the cache")]
        
public int CacheDuration
        
{
            
get {return Convert.ToInt32(ViewState["CacheDuration"]);}
            
set {ViewState["CacheDuration"= value;}
        }

        
// ***********************************************************************

        
// ***********************************************************************
        
// PROPERTY PagingMode
        [Description("Indicates whether the data are retrieved page by page or can be cached")]
        
public PagingMode PagingMode
        
{
            
get {return (PagingMode) ViewState["PagingMode"];}
            
set {ViewState["PagingMode"= value;}
        }

        
// ***********************************************************************

        
// ***********************************************************************
        
// PROPERTY PagerStyle
        [Description("Indicates the style of the pager's navigation bar")]
        
public PagerStyle PagerStyle
        
{
            
get {return (PagerStyle) ViewState["PagerStyle"];}
            
set {ViewState["PagerStyle"= value;}
        }

        
// ***********************************************************************

        
// ***********************************************************************
        
// PROPERTY ControlToPaginate
        [Description("Gets and sets the name of the control to paginate")]
        
public string ControlToPaginate
        
{
            
get {return Convert.ToString(ViewState["ControlToPaginate"]);}
            
set {ViewState["ControlToPaginate"= value;}
        }

        
// ***********************************************************************

        
// ***********************************************************************
        
// PROPERTY ItemsPerPage
        [Description("Gets and sets the number of items to display per page")]
        
public int ItemsPerPage
        
{
            
get {return Convert.ToInt32(ViewState["ItemsPerPage"]);}
            
set {ViewState["ItemsPerPage"= value;}
        }

        
// ***********************************************************************

        
// ***********************************************************************
        
// PROPERTY CurrentPageIndex
        [Description("Gets and sets the index of the currently displayed page")]
        
public int CurrentPageIndex
        
{
            
get {return Convert.ToInt32(ViewState["CurrentPageIndex"]);}
            
set {ViewState["CurrentPageIndex"= value;}
        }

        
// ***********************************************************************

        
public int RecordCount
        
{
            
get {return Convert.ToInt32(ViewState["RecordCount"]);}
            
set {ViewState["RecordCount"= value;}
        }


        
public int CurrentListIndex
        
{
            
get {return Convert.ToInt32(ViewState["CurrentListIndex"]);}
            
set {ViewState["CurrentListIndex"= value;}
        }


        
public int ListCount
        
{
            
get {return Convert.ToInt32(ViewState["ListCount"]);}
            
set {ViewState["ListCount"= value;}
        }


        
// ***********************************************************************
        
// PROPERTY SelectCommand
        [Description("Gets and sets the SQL query to get data")]
        
public string SelectCommand
        
{
            
get {return Convert.ToString(ViewState["SelectCommand"]);}
            
set {ViewState["SelectCommand"= value;}
        }

        
// ***********************************************************************

        
// ***********************************************************************
        
// PROPERTY SortField
        [Description("Gets and sets the sort-by field. It is mandatory in NonCached mode.)")]
        
public string SortField
        
{
            
get {return Convert.ToString(ViewState["SortKeyField"]);}
            
set {ViewState["SortKeyField"= value;}
        }

        
// ***********************************************************************

        
// ***********************************************************************
        
// PROPERTY PageCount
        
// Gets the number of displayable pages 
        [Browsable(false)]
        
public int PageCount
        
{
            
get {return TotalPages;}
        }

        
// ***********************************************************************

        
// ***********************************************************************
        
// PROPERTY TotalPages
        
// Gets and sets the number of pages to display 
        protected int TotalPages
        
{
            
get {return Convert.ToInt32(ViewState["TotalPages"]);}
            
set {ViewState["TotalPages"= value;}
        }

        
// ***********************************************************************


        
// ***********************************************************************
        
// OVERRIDE DataBind
        
// Fetches and stores the data
        public override void DataBind()
        
{
            
// Fires the data binding event
            base.DataBind();

            
// Controls must be recreated after data binding 
            ChildControlsCreated = false;

            
// Ensures the control exists and is a list control
            if (ControlToPaginate == "")
                
return;
            _controlToPaginate 
= Page.FindControl(ControlToPaginate);
            
if (_controlToPaginate == null)
                
return;
            
if (!(_controlToPaginate is BaseDataList || _controlToPaginate is ListControl||_controlToPaginate is Repeater))
                
return;

            
// Ensures enough info to connect and query is specified
            if (SelectCommand == "")
                
return;

            
// Fetch data
            if (PagingMode == PagingMode.Cached)
            
{
                FetchAllData();
            }

            
else
            
{
                
//if (SortField == "")
                
//    return;
                FetchPageData();
            }


            
// Bind data to the buddy control
            BaseDataList baseDataListControl = null;
            ListControl listControl 
= null;
            
if (_controlToPaginate is BaseDataList)
            
{
                baseDataListControl 
= (BaseDataList) _controlToPaginate;
                baseDataListControl.DataSource 
= _dataSource; 
                baseDataListControl.DataBind();
                
return;
            }

            
if (_controlToPaginate is ListControl)
            
{
                listControl 
= (ListControl) _controlToPaginate;
                listControl.Items.Clear(); 
                listControl.DataSource 
= _dataSource; 
                listControl.DataBind();
                
return;
            }


            
if (_controlToPaginate is Repeater)
            
{
                ( _controlToPaginate 
as Repeater).DataSource=_dataSource;
                ( _controlToPaginate 
as Repeater).DataBind();
                
return;
            }

        }

        
// ***********************************************************************

        
// ***********************************************************************
        
// OVERRIDE Render
        
// Writes the content to be rendered on the client
        protected override void Render(HtmlTextWriter output)
        
{
            
// If in design-mode ensure that child controls have been created.
            
// Child controls are not created at this time in design-mode because
            
// there's no pre-render stage. Do so for composite controls like this 
            if (Site != null && Site.DesignMode) 
                CreateChildControls();

            
base.Render(output);
        }

        
// ***********************************************************************

        
// ***********************************************************************
        
// OVERRIDE CreateChildControls
        
// Outputs the HTML markup for the control
        protected override void CreateChildControls()
        
{
            Controls.Clear();
            ClearChildViewState();

            BuildControlHierarchy();
        }

        
// ***********************************************************************
        #endregion


        PRIVATE HELPER METHODS
#region PRIVATE HELPER METHODS 
        
// ***********************************************************************
        
// PRIVATE BuildControlHierarchy
        
// Control the building of the control's hierarchy
        private void BuildControlHierarchy()
        
{
            
// Build the surrounding table (one row, two cells)
            Table t = new Table();
            t.Font.Name 
= Font.Name;
            t.Font.Size 
= Font.Size;
            t.BorderStyle 
= BorderStyle;
            t.BorderWidth 
= BorderWidth;
            t.BorderColor 
= BorderColor;
            t.Width 
= Width;
            t.Height 
= Height;
            t.BackColor 
= BackColor;
            t.ForeColor 
= ForeColor;

            
// Build the table row
            TableRow row = new TableRow();
            t.Rows.Add(row);

            
// Build the cell with the page index
            TableCell cellPageDesc = new TableCell();
            cellPageDesc.HorizontalAlign 
= HorizontalAlign.Left;
            BuildCurrentPage(cellPageDesc);
            row.Cells.Add(cellPageDesc);    
            
            
// Build the cell with navigation bar
            TableCell cellNavBar = new TableCell();
            
switch(PagerStyle)
            
{
                
case PagerStyle.NextPrev:
                    BuildNextPrevUI(cellNavBar);
                    
break;
                
case PagerStyle.NumericPages:
                    BuildNumericPagesUI(cellNavBar);
                    
break;
                
case PagerStyle.NumericList:
                    BuildNumericListUI(cellNavBar);
                    
break;
            }


            cellNavBar.HorizontalAlign
=HorizontalAlign.Justify;
            row.Cells.Add(cellNavBar);

            TableCell cellRecordCountDesc 
= new TableCell();
            cellRecordCountDesc.HorizontalAlign 
= HorizontalAlign.Right;
            BuildRecordCount(cellRecordCountDesc);
            row.Cells.Add(cellRecordCountDesc);

            
// Add the table to the control tree
            Controls.Add(t);
        }

        
// ***********************************************************************

        
// ***********************************************************************
        
// PRIVATE BuildNextPrevUI
        
// Generates the HTML markup for the Next/Prev navigation bar
        private void BuildNextPrevUI(TableCell cell)
        
{
            
bool isValidPage = (CurrentPageIndex >=0 && CurrentPageIndex <= TotalPages-1);
            
bool canMoveBack = (CurrentPageIndex>0);
            
bool canMoveForward = (CurrentPageIndex<TotalPages-1);

            
// Render the << button
            LinkButton first = new LinkButton();
            first.ID 
= "First";
            first.Click 
+= new EventHandler(first_Click);
            first.Font.Name 
= "webdings";
            first.Font.Size 
= FontUnit.Medium;
            first.ForeColor 
= ForeColor;
            first.ToolTip 
= "First page";
            first.Text 
= "7";    
            first.Enabled 
= isValidPage && canMoveBack;
            cell.Controls.Add(first);

            
// Add a separator
            cell.Controls.Add(new LiteralControl("&nbsp;"));

            
// Render the < button
            LinkButton prev = new LinkButton();
            prev.ID 
= "Prev";
            prev.Click 
+= new EventHandler(prev_Click);
            prev.Font.Name 
= "webdings";
            prev.Font.Size 
= FontUnit.Medium;
            prev.ForeColor 
= ForeColor;
            prev.ToolTip 
= "Previous page";
            prev.Text 
= "3";    
            prev.Enabled 
= isValidPage && canMoveBack;
            cell.Controls.Add(prev);

            
// Add a separator
            cell.Controls.Add(new LiteralControl("&nbsp;"));

            
// Render the > button
            LinkButton next = new LinkButton();
            next.ID 
= "Next";
            next.Click 
+= new EventHandler(next_Click);
            next.Font.Name 
= "webdings";
            next.Font.Size 
= FontUnit.Medium;
            next.ForeColor 
= ForeColor;
            next.ToolTip 
= "Next page";
            next.Text 
= "4";    
            next.Enabled 
= isValidPage && canMoveForward;
            cell.Controls.Add(next);

            
// Add a separator
            cell.Controls.Add(new LiteralControl("&nbsp;"));

            
// Render the >> button
            LinkButton last = new LinkButton();
            last.ID 
= "Last";
            last.Click 
+= new EventHandler(last_Click);
            last.Font.Name 
= "webdings";
            last.Font.Size 
= FontUnit.Medium;
            last.ForeColor 
= ForeColor;
            last.ToolTip 
= "Last page";
            last.Text 
= "8";
            last.Enabled 
= isValidPage && canMoveForward;
            cell.Controls.Add(last);
        }

        
// ***********************************************************************
        private void BuildNumericListUI(TableCell cell)
        
{
            
bool isValidList = (CurrentListIndex >=0 && CurrentListIndex <= ListCount-1);
            
bool canMoveBack = (CurrentListIndex>0);
            
bool canMoveForward = (CurrentListIndex<ListCount-1);

            
// Render the << button
            LinkButton first = new LinkButton();
            first.ID 
= "First";
            first.Click 
+= new EventHandler(firstList_Click);
            first.Font.Name 
= "webdings";
            first.Font.Size 
= FontUnit.Medium;
            first.ForeColor 
= ForeColor;
            first.ToolTip 
= "First page";
            first.Text 
= "7";    
            first.Enabled 
= isValidList && canMoveBack;
            cell.Controls.Add(first);

            
// Add a separator
            cell.Controls.Add(new LiteralControl("&nbsp;"));

            
// Render the < button
            LinkButton prev = new LinkButton();
            prev.ID 
= "Prev";
            prev.Click 
+= new EventHandler(prevList_Click);
            prev.Font.Name 
= "webdings";
            prev.Font.Size 
= FontUnit.Medium;
            prev.ForeColor 
= ForeColor;
            prev.ToolTip 
= "Previous page";
            prev.Text 
= "3";    
            prev.Enabled 
= isValidList && canMoveBack;
            cell.Controls.Add(prev);

            cell.Controls.Add(
new LiteralControl("&nbsp;"));

            
for(int i=CurrentListIndex*10;i<(CurrentListIndex+1)*10&&i<PageCount;i++)
            
{
                LinkButton lbtn 
= new LinkButton();
                lbtn.ID 
= "lbtn_"+i.ToString();
                lbtn.Click 
+= new EventHandler(lbtn_Click);
                
if(i==CurrentPageIndex)
                
{
                    lbtn.ForeColor 
= Color.Red;
                }

                
else
                
{
                    lbtn.ForeColor 
= ForeColor;
                }

                lbtn.ToolTip 
= ""+i.ToString()+"";
                lbtn.Text 
= (i+1).ToString();    
                cell.Controls.Add(lbtn);
                cell.Controls.Add(
new LiteralControl("&nbsp;|&nbsp;"));
            }


            
// Render the > button
            LinkButton next = new LinkButton();
            next.ID 
= "Next";
            next.Click 
+= new EventHandler(nextList_Click);
            next.Font.Name 
= "webdings";
            next.Font.Size 
= FontUnit.Medium;
            next.ForeColor 
= ForeColor;
            next.ToolTip 
= "Next page";
            next.Text 
= "4";    
            next.Enabled 
= isValidList && canMoveForward;
            cell.Controls.Add(next);

            
// Add a separator
            cell.Controls.Add(new LiteralControl("&nbsp;"));

            
// Render the >> button
            LinkButton last = new LinkButton();
            last.ID 
= "Last";
            last.Click 
+= new EventHandler(lastList_Click);
            last.Font.Name 
= "webdings";
            last.Font.Size 
= FontUnit.Medium;
            last.ForeColor 
= ForeColor;
            last.ToolTip 
= "Last page";
            last.Text 
= "8";
            last.Enabled 
= isValidList && canMoveForward;
            cell.Controls.Add(last);
        }

        
// ***********************************************************************
        
// PRIVATE BuildNumericPagesUI
        
// Generates the HTML markup for the Numeric Pages button bar
        private void BuildNumericPagesUI(TableCell cell)
        
{
            
// Render a drop-down list  
            DropDownList pageList = new DropDownList();
            pageList.ID 
= "PageList";
            pageList.AutoPostBack 
= true;
            pageList.SelectedIndexChanged 
+= new EventHandler(PageList_Click);
            pageList.Font.Name 
= Font.Name;
            pageList.Font.Size 
= Font.Size;
            pageList.ForeColor 
= ForeColor;

            
// Embellish the list when there are no pages to list 
            if (TotalPages <=0 || CurrentPageIndex == -1)
            
{
                pageList.Items.Add(
"No pages");
                pageList.Enabled 
= false;
                pageList.SelectedIndex 
= 0
            }

            
else // Populate the list
            {
                
for(int i=1; i<=TotalPages; i++)
                
{
                    ListItem item 
= new ListItem(i.ToString(), (i-1).ToString());
                    pageList.Items.Add(item);
                }

                pageList.SelectedIndex 
= CurrentPageIndex;
            }

            cell.Controls.Add(pageList);
        }

        
// ***********************************************************************

        
// ***********************************************************************
        
// PRIVATE BuildCurrentPage
        
// Generates the HTML markup to describe the current page (0-based)
        private void BuildCurrentPage(TableCell cell)
        
{
            
// Use a standard template: Page X of Y
            if (CurrentPageIndex <0 || CurrentPageIndex >= TotalPages)
                cell.Text 
= NoPageSelectedText;
            
else
                cell.Text 
= String.Format(CurrentPageText, (CurrentPageIndex+1), TotalPages);
        }

        
// ***********************************************************************


        
private void BuildRecordCount(TableCell cell)
        
{
            cell.Text 
= String.Format(RecordCountText,RecordCount.ToString());
        }


        
// ***********************************************************************
        
// PRIVATE ValidatePageIndex
        
// Ensures the CurrentPageIndex is either valid [0,TotalPages) or -1
        private void ValidatePageIndex()
        
{
            
if (!(CurrentPageIndex >=0 && CurrentPageIndex < TotalPages))
                CurrentPageIndex 
= -1;
            
return;
        }


        
private void ValidateListIndex()
        
{
            
if (!(CurrentListIndex >=0 && CurrentListIndex < ListCount))
                CurrentListIndex 
= -1;
            
return;
        }

        
// ***********************************************************************

        
// ***********************************************************************
        
// PRIVATE FetchAllData
        
// Runs the query for all data to be paged and caches the resulting data
        private void FetchAllData()
        
{
            
// Looks for data in the ASP.NET Cache
            DataTable data;
            data 
= (DataTable) Page.Cache[CacheKeyName];
            
if (data == null)
            
{
                
// Fix SelectCommand with order-by info
                AdjustSelectCommand(true);

                data 
= DBHelper.ExecuteDataTable(this.SelectCommand,false);
                Page.Cache.Insert(CacheKeyName, data, 
null
                    DateTime.Now.AddSeconds(CacheDuration), 
                    System.Web.Caching.Cache.NoSlidingExpiration);
            }

        
            
// Configures the paged data source component
            if (_dataSource == null)
                _dataSource 
= new PagedDataSource(); 
            _dataSource.DataSource 
= data.DefaultView; // must be IEnumerable!
            _dataSource.AllowPaging = true;
            _dataSource.PageSize 
= ItemsPerPage;
            TotalPages 
= _dataSource.PageCount; 
            RecordCount 
= data.Rows.Count;
            ListCount
=(PageCount%10==0)?PageCount/10:PageCount/10+1;

            
// Ensures the page index is valid 
            ValidatePageIndex();
            
if (CurrentPageIndex == -1)
            
{
                _dataSource 
= null;
                
return;
            }


            ValidateListIndex();
            
if (CurrentListIndex == -1)
                
return;

            
// Selects the page to view
            _dataSource.CurrentPageIndex = CurrentPageIndex;
        }

        
// ***********************************************************************

        
// ***********************************************************************
        
// PRIVATE FetchPageData
        
// Runs the query to get only the data that fit into the current page
        private void FetchPageData()
        
{
            
// Need a validated page index to fetch data.
            
// Also need the virtual page count to validate the page index
            AdjustSelectCommand(false);
            VirtualRecordCount countInfo 
= CalculateVirtualRecordCount();
            TotalPages 
= countInfo.PageCount;
            RecordCount 
= countInfo.RecordCount;
            ListCount
=(PageCount%10==0)?PageCount/10:PageCount/10+1;

            
// Validate the page number (ensures CurrentPageIndex is valid or -1)
            ValidatePageIndex();
            
if (CurrentPageIndex == -1)
                
return;

            ValidateListIndex();
            
if (CurrentListIndex == -1)
                
return;

            DataTable data 
=DBHelper.ExecuteDataTable(PrepareCommand(countInfo),false);

            
// Configures the paged data source component
            if (_dataSource == null)
                _dataSource 
= new PagedDataSource(); 
            _dataSource.AllowCustomPaging 
= true;
            _dataSource.AllowPaging 
= true;
            _dataSource.CurrentPageIndex 
= 0;
            _dataSource.PageSize 
= ItemsPerPage;
            _dataSource.VirtualCount 
= countInfo.RecordCount;
            _dataSource.DataSource 
= data.DefaultView;    
        }

        
// ***********************************************************************

        
// ***********************************************************************
        
// PRIVATE AdjustSelectCommand
        
// Strips ORDER-BY clauses from SelectCommand and adds a new one based
        
// on SortKeyField
        private void AdjustSelectCommand(bool addCustomSortInfo)
        
{
            
// Truncate where ORDER BY is found
            string temp = SelectCommand.ToLower();
            
int pos = temp.IndexOf("order by"); 
            
if (pos > -1)
                SelectCommand 
= SelectCommand.Substring(0, pos);

            
// Add new ORDER BY info if SortKeyField is specified
            if (SortField != "" && addCustomSortInfo)
                SelectCommand 
+= " ORDER BY " + SortField;
        }

        
// ***********************************************************************

        
// ***********************************************************************
        
// PRIVATE CalculateVirtualRecordCount
        
// Calculates record and page count for the specified query
        private VirtualRecordCount CalculateVirtualRecordCount()
        
{
            VirtualRecordCount count 
= new VirtualRecordCount();

            
// Calculate the virtual number of records from the query
            count.RecordCount = GetQueryVirtualCount();
            count.RecordsInLastPage 
= ItemsPerPage;

            
// Calculate the correspondent number of pages
            int lastPage = count.RecordCount/ItemsPerPage;
            
int remainder = count.RecordCount % ItemsPerPage;
            
if (remainder >0)
                lastPage
++;
            count.PageCount 
= lastPage;
            
            
// Calculate the number of items in the last page
            if (remainder >0)
                count.RecordsInLastPage 
= remainder;
            
return count;
        }

        
// ***********************************************************************

        
// ***********************************************************************
        
// PRIVATE PrepareCommand
        
// Prepares and returns the command object for the reader-based query
        private string PrepareCommand(VirtualRecordCount countInfo)
        
{
            
if (SortField == "")
            
{
                
// Get metadata for all columns and choose either the primary key
                
// or the 
                string text = "SET FMTONLY ON;" + SelectCommand + ";SET FMTONLY OFF;";
                DataTable t 
= DBHelper.ExecuteDataTable(text,false);
                DataColumn col 
= null;
                
if (t.PrimaryKey.Length >0)
                    col 
= t.PrimaryKey[0];
                
else
                    col 
= t.Columns[0];
                SortField 
= col.ColumnName;
            }


            
// Determines how many records are to be retrieved.
            
// The last page could require less than other pages
            int recsToRetrieve = ItemsPerPage;
            
if (CurrentPageIndex == countInfo.PageCount-1)
                recsToRetrieve 
= countInfo.RecordsInLastPage;

            
string cmdText = String.Format(QueryPageCommandText, 
                recsToRetrieve,                        
// {0} --> page size
                ItemsPerPage*(CurrentPageIndex+1),    // {1} --> size * index
                SelectCommand,                        // {2} --> base query
                SortField,                            // {3} --> key field in the query
                "ASC",                                // Default to ascending order
                "DESC");

            
return cmdText;
        }


        
// ***********************************************************************

        
// ***********************************************************************
        
// PRIVATE GetQueryVirtualCount
        
// Run a query to get the record count
        private int GetQueryVirtualCount()
        
{
            
string cmdText = String.Format(QueryCountCommandText, SelectCommand);
            
return Function.getInt(DBHelper.ExecuteDataTable(cmdText,false).Rows[0][0]);
        }

        
// ***********************************************************************

        
// ***********************************************************************
        
// PRIVATE GoToPage
        
// Sets the current page index
        private void GoToPage(int pageIndex)
        
{
            
// Prepares event data
            PageChangedEventArgs e = new PageChangedEventArgs();
            e.OldPageIndex 
= CurrentPageIndex;
            e.NewPageIndex 
= pageIndex;

            
// Updates the current index
            CurrentPageIndex = pageIndex;

            
// Fires the page changed event
            OnPageIndexChanged(e);

            
// Binds new data
            DataBind();
        }

        
// ***********************************************************************
        private void GoToList(int listIndex)
        
{
            
// Prepares event data
            ListChangedEventArgs e = new ListChangedEventArgs();
            e.OldListIndex 
= CurrentListIndex;
            e.NewListIndex 
= listIndex;

            
if(e.NewListIndex>e.OldListIndex)
            
{
                CurrentPageIndex
=(e.NewListIndex)*10;
            }

            
else
            
{
                CurrentPageIndex
=(e.NewListIndex+1)*10-1;
            }


            
// Updates the current index
            CurrentListIndex = listIndex;


            
// Fires the page changed event
            OnListIndexChanged(e);


            
// Binds new data
            DataBind();
        }

        
// ***********************************************************************
        
// PRIVATE first_Click
        
// Event handler for the << button
        private void first_Click(object sender, EventArgs e)
        
{
            GoToPage(
0);
        }

        
// ***********************************************************************
        private void lbtn_Click(object sender, EventArgs e)
        
{
            CurrentPageIndex
=int.Parse((sender as LinkButton).Text)-1;
            GoToPage(CurrentPageIndex);
        }


        
// ***********************************************************************
        
// PRIVATE prev_Click
        
// Event handler for the < button
        private void prev_Click(object sender, EventArgs e)
        
{
            GoToPage(CurrentPageIndex
-1);
        }

        
// ***********************************************************************
        private void prevList_Click(object sender, EventArgs e)
        
{
            GoToList(CurrentListIndex
-1);
        }

        
private void nextList_Click(object sender, EventArgs e)
        
{
            GoToList(CurrentListIndex
+1);
        }


        
private void firstList_Click(object sender, EventArgs e)
        
{
            GoToList(
0);
        }

        
private void lastList_Click(object sender, EventArgs e)
        
{
            GoToList(ListCount
-1);
        }

        
// ***********************************************************************
        
// PRIVATE next_Click
        
// Event handler for the > button
        private void next_Click(object sender, EventArgs e)
        
{
            GoToPage(CurrentPageIndex
+1);
        }

        
// ***********************************************************************

        
// ***********************************************************************
        
// PRIVATE last_Click
        
// Event handler for the >> button
        private void last_Click(object sender, EventArgs e)
        
{
            GoToPage(TotalPages
-1);
        }

        
// ***********************************************************************

        
// ***********************************************************************
        
// PRIVATE PageList_Click
        
// Event handler for any page selected from the drop-down page list 
        private void PageList_Click(object sender, EventArgs e)
        
{
            DropDownList pageList 
= (DropDownList) sender;
            
int pageIndex = Convert.ToInt32(pageList.SelectedItem.Value);
            GoToPage(pageIndex);
        }

        
// ***********************************************************************
        #endregion

    }

    
#endregion

}

http://www.cnblogs.com/jianphu/articles/741712.html

<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    
<title>无标题页</title>
</head>
<body>
    
<form id="form1" runat="server">
    
<div>
        
<asp:DataList ID="DataList1" runat="server">
            
<ItemTemplate>
                ProductName:
                
<asp:Label ID="ProductNameLabel" runat="server" Text='<%# Eval("ProductName") %>'>
                
</asp:Label><br />
                
<br />
            
</ItemTemplate>
        
</asp:DataList>
        
<webdiyer:aspnetpager id="pager1" runat="server" onpagechanged="ChangePage"></webdiyer:aspnetpager>    
    
</div>
    
</form>
</body>
</html>后置代码:default.aspx.cs

using System;
using System.Data;
using System.Configuration;
using System.Collections;
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 cpp114.tools.oledb;
using System.Data.OleDb;
using Wuqi.Webdiyer;

public partial class test_Default : System.Web.UI.Page
{
    
protected OleDbConnection conn = new OleDbConnection();
    
protected OleDbCommand cmd = new OleDbCommand();

    
protected void Page_Load(object sender, EventArgs e)
    
{
        
if (!IsPostBack) {
            initdb();
            conn.Open();
            cmd.CommandText 
= "select count(*) from t_product";
            pager1.RecordCount 
= (int)cmd.ExecuteScalar();
            conn.Close();
            BindData();
                       
        }


    }

 
 
//初始化连接对象
    protected void initdb(){
        conn.ConnectionString 
= oledbtool.myConnStr + Server.MapPath(oledbtool.mydbName);
        cmd.Connection 
= conn;        
    }


 
//数据绑定
    protected void BindData() {
        initdb();
        OleDbDataAdapter sda 
= new OleDbDataAdapter("select * from t_product",conn);       
        DataSet ds 
= new DataSet();
        
//sda.Fill(ds, 10, 10, "temptbl");
        sda.Fill(ds, pager1.PageSize * (pager1.CurrentPageIndex - 1), pager1.PageSize, "temptbl");
        DataList1.DataSource 
= ds.Tables["temptbl"];
        DataList1.DataBind();
    }


 
//翻页事件
    protected void ChangePage(object src, PageChangedEventArgs e)
    
{
        pager1.CurrentPageIndex 
= e.NewPageIndex;
        BindData();
    }
    

}


posted on 2007-05-23 13:35  mbskys  阅读(226)  评论(0编辑  收藏  举报