public static MvcHtmlString AjaxPager(this HtmlHelper html, IPagedList pagedList, PagerOptions pagerOptions, AjaxOptions ajaxOptions, object htmlAttributes)
 {
     if (pagedList == null)
         return AjaxPager(html, pagerOptions, new RouteValueDictionary(htmlAttributes));
     return AjaxPager(html, pagedList.TotalItemCount, pagedList.PageSize, pagedList.CurrentPageIndex, null, null, null, pagerOptions, null,
                      ajaxOptions, htmlAttributes);
 }

 public GalleryViewModel(Photoset set, IPagedList<FlickrNet.Photo> collection, int post, string id)
 {
     this.Photoset = set;
     this.Photos = collection;
     this.PostID = post;
     this.PhotosetID = id;
 }

 /// <summary>
 /// Generates a digg-like pager - div with page numbers as links, previous and next links(or spans)
 /// </summary>
 /// <param name="htmlHelper">Instance of html helper</param>
 /// <param name="collection">Paged collection to render pager for</param>
 /// <param name="actionName">Action name for links generation (optional: default = null)</param>
 /// <param name="controllerName">Controller name for links generation (optional: default = null)</param>
 /// <param name="pagerHtmlAttributes">Object with html attributes for pager container</param>
 /// <param name="pagerContainer">Pager container (optional: default = "div")</param>
 /// <param name="previousLabel">Caption for previous label (optinoal: default = '« Previous')</param>
 /// <param name="nextLabel">Caption for next label (optional: default = 'Next »')</param>
 /// <param name="innerWindow">How many links are shown around current page (optional: default = 4)</param>
 /// <param name="outerWindow">How many links are shown around the first and the last pages (optional: default = 1)</param>
 /// <param name="separator">String separator between page links or spans (optional: default ' ' - space)</param>
 /// <param name="windowLinks">
 /// When true, 'next', 'previous' and page numbers should be rendered,
 /// when false, only 'next' and 'previous' should be rendered.
 /// Optional: default = true
 /// </param>
 /// <returns>System.Web.Mvc.MvcHtmlString</returns>
 public static MvcHtmlString Pager(
     this HtmlHelper htmlHelper,
     IPagedList collection,
     string actionName = null,
     string controllerName = null,
     object pagerHtmlAttributes = null,
     string pagerContainer = "div",
     string previousLabel = "&larr;",
     string nextLabel = "&rarr;",
     int innerWindow = 4,
     int outerWindow = 1,
     string separator = " ",
     bool windowLinks = true
     )
 {
     IRenderer renderer = new DiggStyleLinkRenderer {
         HtmlHelper = htmlHelper,
         Collection = collection,
         ActionName = actionName,
         ControllerName = controllerName,
         PagerContainer = pagerContainer,
         InnerWindow = innerWindow,
         NextLabel = nextLabel,
         OuterWindow = outerWindow,
         PreviousLabel = previousLabel,
         Separator = separator,
         WindowLinks = windowLinks
     };
     renderer.PagerHtmlAttributes = new RouteValueDictionary(pagerHtmlAttributes);
     return MvcHtmlString.Create(renderer.GenerateHtml());
 }

        /// <summary>
        /// Creates a new instance of the Pager class.
        /// </summary>
        /// <param name="pagination">The IPagination datasource</param>
        /// <param name="context">The view context</param>
        public Pager(IPagedList pagination, ViewContext context)
        {
            _pagination = pagination;
            _viewContext = context;

            _urlBuilder = CreateDefaultUrl;
        }

        ///<summary>
        /// Displays a configurable "Go To Page:" form for instances of PagedList.
        ///</summary>
        ///<param name="html">This method is meant to hook off HtmlHelper as an extension method.</param>
        ///<param name="list">The PagedList to use as the data source.</param>
        ///<param name="formAction">The URL this form should submit the GET request to.</param>
        ///<param name="options">Formatting options.</param>
        ///<returns>Outputs the "Go To Page:" form HTML.</returns>
        public static MvcHtmlString PagedListGoToPageForm(this System.Web.Mvc.HtmlHelper html,
		                                         IPagedList list,
		                                         string formAction,
		                                         GoToFormRenderOptions options)
        {
            var form = new TagBuilder("form");
            form.AddCssClass("PagedList-goToPage");
            form.Attributes.Add("action", formAction);
            form.Attributes.Add("method", "get");

            var fieldset = new TagBuilder("fieldset");

            var label = new TagBuilder("label");
            label.Attributes.Add("for", options.InputFieldName);
            label.SetInnerText(options.LabelFormat);

            var input = new TagBuilder("input");
            input.Attributes.Add("type", options.InputFieldType);
            input.Attributes.Add("name", options.InputFieldName);
            input.Attributes.Add("value", list.PageNumber.ToString());

            var submit = new TagBuilder("input");
            submit.Attributes.Add("type", "submit");
            submit.Attributes.Add("value", options.SubmitButtonFormat);

            fieldset.InnerHtml = label.ToString();
            fieldset.InnerHtml += input.ToString(TagRenderMode.SelfClosing);
            fieldset.InnerHtml += submit.ToString(TagRenderMode.SelfClosing);
            form.InnerHtml = fieldset.ToString();
            return new MvcHtmlString(form.ToString());
        }

        public static MvcHtmlString SeoPager(this HtmlHelper helper, IPagedList pagedList, string pageIndexParameterName = "id", int sectionSize = 20)
        {
            var sb = new StringBuilder();

            int pageCount = pagedList.TotalItemCount / pagedList.PageSize + (pagedList.TotalItemCount % pagedList.PageSize == 0 ? 0 : 1);

            if (pageCount > 1)
            {
                var pages = new List<int>();
                for (int i = 1; i <= pageCount; i++)
                    pages.Add(i);
                var sections = pages.GroupBy(p => (p - 1) / sectionSize);
                var currentSection = sections.Single(s => s.Key == (pagedList.CurrentPageIndex - 1) / sectionSize);
                foreach (var p in currentSection)
                {
                    if (p == pagedList.CurrentPageIndex)
                        sb.AppendFormat("<span>{0}</span>", p);
                    else
                        sb.AppendFormat("<a href=\"{1}\">{0}</a>", p, PrepearRouteUrl(helper, pageIndexParameterName, p));
                }
                if (sections.Count() > 1)
                {
                    sb.Append("<br/>");

                    foreach (var s in sections)
                    {
                        if (s.Key == currentSection.Key)
                            sb.AppendFormat("<span>{0}-{1}</span>", s.First(), s.Last());
                        else
                            sb.AppendFormat("<a href=\"{2}\">{0}-{1}</a>", s.First(), s.Last(), PrepearRouteUrl(helper, pageIndexParameterName, s.First()));
                    }
                }
            }
            return MvcHtmlString.Create(sb.ToString());
        }

		public static AccountMyAuctionsViewModel FromAuctions(IPagedList<Auction> auctions,
		                                                      string titleFilter,
		                                                      int createdInDays,
		                                                      AuctionStatusFilter currentStatusFilter)
		{
			Contract.Requires(auctions != null);

			var items = auctions.Select(x => new AccountMyAuctionsViewModel.Item
			{
				Id           = x.Id,
				Title        = x.Title,
				CategoryName = x.Category.Name,
				CategoryId   = x.Category.Id,
				Status       = x.Status,
				TimeTillEnd  = x.EndDate - DateTime.Now,
				BuyoutPrice  = x.BuyoutPrice,
				BestOffer    = x.BestOffer != null ? x.BestOffer.Money : null
			});

			return new AccountMyAuctionsViewModel
			{
				Auctions            = new StaticPagedList<AccountMyAuctionsViewModel.Item>(items, auctions),
				TitleFilter         = titleFilter,
				CreatedIn           = TimeSpan.FromDays(createdInDays),
				CurrentStatusFilter = currentStatusFilter
			};
		}

        private IEnumerable<SaleProductModel> Convert(IPagedList<productDto> sources)
        {
            if (sources == null) return null;

            return sources.Select(t =>
                     {
                         var data = new SaleProductModel()
                         {
                             brandname = t.brand.name,
                             categoryname = t.category.name,
                             gendername = t.gender.name,
                             unitprice = t.unitprice,
                             code = t.code,
                             name = t.name,
                             imgpath = t.imagemain,
                             productid = t.key
                         };
                         data.details.AddRange(t.v_stocks.Select(o => new SaleProductDetailModel()
                         {
                             productid = t.key,
                             size = o.size.code,
                             displaysize = o.size.displaycode,
                             sizeid = o.sizeid,
                             stockquantity = o.stockquantity
                         }));
                         return data;
                     });
        }

        public static string BlogPager(this HtmlHelper helper, IPagedList pager)
        {
            // Don't display anything if not multiple pages
            if (pager.TotalPageCount == 1)
                return string.Empty;

            // Build route data
            var routeData = new RouteValueDictionary(helper.ViewContext.RouteData.Values);

            // Build string
            var sb = new StringBuilder();

            // Render Newer Entries
            if (pager.PageIndex > 0)
            {
                routeData["page"] = pager.PageIndex - 1;
                sb.Append(helper.ActionLink("Newer Entries", "Index", routeData));
            }

            // Render divider
            if (pager.PageIndex > 0 && pager.PageIndex < pager.TotalPageCount - 1)
                sb.Append(" | ");

            // Render Older Entries
            if (pager.PageIndex < pager.TotalPageCount - 1)
            {
                routeData["page"] = pager.PageIndex + 1;
                sb.Append(helper.ActionLink("Older Entries", "Index", routeData));
            }

            return sb.ToString();
        }

 public QuestionsModel(IPagedList<Question> questions, SiteState state)
 {
     SiteState = state;
     Questions = questions;
     state.Page = Convert.ToInt32(questions.CurrentPage);
     state.ItemCount = questions.TotalItems;
     state.MaxPages = Convert.ToInt32(Math.Ceiling(Convert.ToDouble(questions.TotalItems) / Convert.ToDouble(questions.PageSize)));
 }

 ///<include file='MvcPagerDocs.xml' path='MvcPagerDocs/PagerExtensions/Method[@name="HtmlPager4"]/*'/>
 public static HtmlPager Pager(this HtmlHelper helper, IPagedList pagedList, PagerOptions pagerOptions)
 {
     if (pagedList == null)
     {
         throw new ArgumentNullException("pagedList");
     }
     return Pager(helper, pagedList.TotalItemCount, pagedList.PageSize, pagedList.CurrentPageIndex, pagerOptions);
 }

 public static MvcHtmlString AjaxPager(this HtmlHelper html, IPagedList pagedList, string actionName, string controllerName, PagerOptions pagerOptions, AjaxOptions ajaxOptions)
 {
     if (pagedList == null)
     {
         return AjaxPager(html, pagerOptions, null);
     }
     return html.AjaxPager(pagedList.TotalItemCount, pagedList.PageSize, pagedList.CurrentPageIndex, actionName, controllerName, null, pagerOptions, ((RouteValueDictionary)null), ajaxOptions, ((IDictionary<string, object>)null));
 }

 public static MvcHtmlString Pager(this HtmlHelper html, IPagedList list, string action, string controller)
 {
     var urlHelper = new UrlHelper(html.ViewContext.RequestContext);
     return html.PagedListPager(list,
                                page =>
                                urlHelper.Action(action, controller,
                                                 html.ViewContext.GetCombinedRouteValues(new {page = page})),
                                PagedListRenderOptions.DefaultPlusFirstAndLast);
 }

 public static string GeneratePager(this HtmlHelper helper, IPagedList<object> data, string controller, string action, string pageParameter,params KeyValuePair<string, object>[] Parameters )
 {
     string url = "";
     foreach (var item in Parameters)
     {
         if(item.Value!= null)
         url += string.Format("&{0}={1}", item.Key, item.Value.ToString());
     }
     return helper.GeneratePager(data, controller, action, pageParameter, url, true);
 }

        public DiscussionViewModel(Board board, IPagedList<PostViewModel> posts, int focusPostId, Competitor viewer)
        {
            Board = board;
            FocusPostId = focusPostId;
            Viewer = viewer != null && viewer.Status == CompetitorStatus.Active
                         ? new CompetitorViewModel(viewer)
                         : new CompetitorViewModel();

            Posts = posts;
        }

            internal CmsPagerBuilder(IFrontHtmlHelper html, IPagedList pageList,
                PagerOptions pagerOptions, RouteValueDictionary routeValues, IDictionary<string, object> htmlAttributes)
                : base(html.Html, null, null, pageList, pagerOptions, null, routeValues, htmlAttributes)
            {
                frontHtml = html;
                this.routeValues = routeValues ?? new RouteValueDictionary();

                _pageList = pageList;
                this._pagerOptions = pagerOptions;
            }

        private static TagBuilder First(IPagedList list, Func<int, string> generatePageUrl, string format)
        {
            const int targetPageIndex = 0;
            var first = new TagBuilder("a");
            first.SetInnerText(string.Format(format, targetPageIndex + 1));

            if (list.IsFirstPage)
                return WrapInListItem(first, "PagedList-skipToFirst", "PagedList-disabled");

            first.Attributes["href"] = generatePageUrl(targetPageIndex);
            return WrapInListItem(first, "PagedList-skipToFirst");
        }

 public RegistryItemsPage(IPagedList<Gift> gifts, IEnumerable<Category> categories, int pageSize,int selectedCategory)
 {
     Gifts =gifts.Select((gift, i) => new GiftRow {Item = gift, IsFirst = i == 0});
     Categories = categories.ToList();
     TotalNumberOfItems = gifts.TotalItemCount;
     PageNumber = gifts.PageNumber;
     PageCount = gifts.PageCount;
     FirstItemIndex = gifts.FirstItemIndex;
     LastItemIndex = gifts.LastItemIndex;
     PageSize = pageSize;
     SelectedCategoryId = selectedCategory;
 }

        public async Task GetHubsCallReturnsAnObjectResult(
            Mock<IRepository<HubDataModel>> hubRepository,
            IPagedList<HubDataModel> hubs,
            string hubSlug)
        {
            hubRepository.Setup(mock => mock.GetPaged(1, 100, null)).Returns(Task.FromResult(hubs));

            var controllerUnderTest = new HubController(hubRepository.Object);

            var result = await controllerUnderTest.GetPagedHubs(1, 100);

            Assert.IsAssignableFrom<IPagedList<HubDataModel>>(result);
        }

 ///<summary>
 /// Non-enumerable version of the PagedList class.
 ///</summary>
 ///<param name="pagedList">A PagedList (likely enumerable) to copy metadata from.</param>
 public PagedListMetaData(IPagedList pagedList)
 {
     PageCount = pagedList.PageCount;
     TotalItemCount = pagedList.TotalItemCount;
     PageNumber = pagedList.PageNumber;
     PageSize = pagedList.PageSize;
     HasPreviousPage = pagedList.HasPreviousPage;
     HasNextPage = pagedList.HasNextPage;
     IsFirstPage = pagedList.IsFirstPage;
     IsLastPage = pagedList.IsLastPage;
     FirstItemOnPage = pagedList.FirstItemOnPage;
     LastItemOnPage = pagedList.LastItemOnPage;
 }