// using timjames' approach
        public static MvcHtmlString RawActionLink(this AjaxHelper ajaxHelper, string rawHtml, string action, string controller, AjaxOptions ajaxOptions, object routeValues = null, object htmlAttributes = null)
        {
            string linkText = Guid.NewGuid().ToString();
            string originalActionLink = ajaxHelper.ActionLink(linkText, action, controller, routeValues, ajaxOptions, htmlAttributes).ToString();

            return MvcHtmlString.Create(originalActionLink.Replace(linkText, rawHtml));
        }

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

 /// <summary>
 /// Метод создает ссылку, которая с помощью Ajax запроса загружает в контейнер с именем main
 /// требуемый PartialView
 /// </summary>
 public static MvcHtmlString ActionLinkTo(this AjaxHelper ajaxHelper, String linkText, String actionName, String controllerName = null, Object routeValues = null, String areaName = null, String loadMessage = null, Object htmlAttributes = null)
 {
     // Создаем маршрут
     RouteValueDictionary routeValueDictionary = routeValues == null ? new RouteValueDictionary() : (RouteValueDictionary)(routeValues);
     if (!String.IsNullOrEmpty(actionName) && !routeValueDictionary.ContainsKey("action"))
         routeValueDictionary.Add("action", actionName);
     if (!String.IsNullOrEmpty(controllerName) && !routeValueDictionary.ContainsKey("controller"))
         routeValueDictionary.Add("controller", controllerName);
     if (!routeValueDictionary.ContainsKey("area")) {
         if (!String.IsNullOrEmpty(areaName))
             routeValueDictionary.Add("area", areaName);
         else
             routeValueDictionary.Add("area", "");
     }
     // Создаем параметры Ajax
     AjaxOptions ajaxOptions = new AjaxOptions() {
         UpdateTargetId = "main",
         InsertionMode = InsertionMode.Replace,
         HttpMethod = "POST",
         LoadingElementId = "loadLayout",
         OnBegin = "changeLoadMesage('" + loadMessage + "')",
         OnSuccess = "onPageLoaded()"
     };
     RouteValueDictionary htmlatr = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
     htmlatr.Add("onclick", "return ajaxClick(this);");
     // Возвращаем строку
     String ajaxActionName = "Ajax" + actionName;
     return ajaxHelper.ActionLink(linkText, ajaxActionName, null, routeValueDictionary, ajaxOptions, htmlatr);
 }

 public static IHtmlString InputActionLink(this AjaxHelper ajaxHelper, ActionResult result, AjaxOptions ajaxOptions)
 {
     var builder = new TagBuilder("input");
     var link = ajaxHelper.ActionLink("[replaceme]", result, ajaxOptions);
     var mvcLink = new MvcHtmlString(link.ToHtmlString().Replace("[replaceme]", builder.ToString(TagRenderMode.SelfClosing)));
     return mvcLink;
 }

        public static MvcHtmlString PagingNavigator(this AjaxHelper helper, int pageNum, int itemsCount, int pageSize)
        {
            StringBuilder sb = new StringBuilder();
            AjaxOptions ao = new AjaxOptions {UpdateTargetId = "BooksDiv"};

            if (pageNum > 0)
            {
                sb.Append(helper.ActionLink("<", "Index","Books", new { pageNum = pageNum - 1 },ao));
            }
            else
            {
                sb.Append(HttpUtility.HtmlEncode("<"));
            }
            sb.Append(" ");

            int pagesCount = (int)Math.Ceiling((double)itemsCount / pageSize);

            if (pageNum < pagesCount - 1)
            {
                sb.Append(helper.ActionLink(">", "Index","Books", new { pageNum = pageNum + 1 },ao));
            }
            else
            {
                sb.Append(HttpUtility.HtmlEncode(">"));
            }

            return MvcHtmlString.Create(sb.ToString());
        }

        public static string ActionLink(this AjaxHelper ajaxHelper, string linkText, string actionName,
		                                RouteValueDictionary routeValues, AjaxOptions ajaxOptions,
		                                IDictionary<string, object> htmlAttributes)
        {
            return ActionLink(ajaxHelper, linkText, actionName, null /* controllerName */, routeValues, ajaxOptions,
                              htmlAttributes);
        }

        public static string SortableColumnHeader(this AjaxHelper helper, HtmlHelper htmlHelper, TicketCenterListSettings currentDisplayPreferences, string action, string listName, string sortColumn, string linkText, AjaxOptions ajaxOptions)
        {
            var imgContent = string.Empty;
            var linkContent = linkText;
            var indexContent = string.Empty;
            var sortColumns = currentDisplayPreferences.SortColumns;
            var cColumn = sortColumns.SingleOrDefault(sc => sc.ColumnName == sortColumn);
            if (cColumn != null)
            {
                var uh = new UrlHelper(helper.ViewContext.RequestContext);
                string imgSrc = uh.Content((cColumn.SortDirection == ColumnSortDirection.Ascending) ? "~/Content/arrow_top.png" : "~/Content/arrow_down.png");
                imgContent = string.Format("<img src='{0}' alt='{1}' />", imgSrc, cColumn.SortDirection.ToString());

                var idx = sortColumns.IndexOf(cColumn) + 1;
                indexContent = string.Format("<sup>[{0}]</sup>",idx.ToString());
            }

            StringBuilder sb = new StringBuilder();
            sb.AppendLine("<span style='white-space:nowrap;'>");
            var lLine = helper.ActionLink(linkContent, "SortList", new { ListName = listName, ColumnName = sortColumn }, ajaxOptions, new { OnMouseDown = "setShiftStatus(event);", Title = "[shift+click] to add or remove columns from the sort" }).ToString();


            sb.AppendLine(lLine + indexContent);
            sb.AppendLine(imgContent);
            sb.AppendLine("</span>");
            return sb.ToString();
        }

        public static MvcHtmlString ImageActionLink(this AjaxHelper helper, string imageUrl, string altText, string actionName,
		                                            string controllerName, object routeValues, AjaxOptions ajaxOptions,
		                                            object htmlAttributes)
        {
            return ComposeImageActionLink(helper, imageUrl, altText, actionName, controllerName, routeValues, ajaxOptions,
                htmlAttributes);
        }

 public static MvcHtmlString IconActionLink(this AjaxHelper helper, string icon, string linkText, string actionName, string controllerName, object routeValues, AjaxOptions ajaxOptions, object htmlAttributes)
 {
     var builder = new TagBuilder("span");
     builder.MergeAttribute("class", icon);
     var link = helper.ActionLink("[replaceme] " + linkText, actionName, controllerName, routeValues, ajaxOptions, htmlAttributes).ToHtmlString();
     return new MvcHtmlString(link.Replace("[replaceme]", builder.ToString()));
 }

        private static string GenerateAjaxScript(AjaxOptions ajaxOptions, string scriptFormat)
        {
            var ajaxOptionsHelper = new AjaxOptionsHelper(ajaxOptions);
            string optionsString = ajaxOptionsHelper.ToJavascriptString();

            return String.Format(CultureInfo.InvariantCulture, scriptFormat, optionsString);
        }

        internal PagerBuilder(AjaxHelper helper, string actionName, string controllerName, int totalPageCount, int pageIndex, PagerOptions options, AjaxOptions ajaxOptions, object values)
        {
            // Set defaults
            if (String.IsNullOrEmpty(actionName))
                actionName = (string)helper.ViewContext.RouteData.Values["action"];
            if (String.IsNullOrEmpty(controllerName))
                controllerName = (string)helper.ViewContext.RouteData.Values["controller"];
            if (options == null)
                options = new PagerOptions();

            // Assign to fields
            _helper = helper;
            _actionName = actionName;
            _controllerName = controllerName;
            _totalPageCount = totalPageCount;
            _pageIndex = pageIndex;
            _options = options;
            _values = values;
            _ajaxOptions = ajaxOptions;

            // Calculate start page index
            _startPageIndex = pageIndex - (options.MaximumPageNumbers / 2);
            if (_startPageIndex + options.MaximumPageNumbers > _totalPageCount)
                _startPageIndex = _totalPageCount - options.MaximumPageNumbers;
            if (_startPageIndex < 0)
                _startPageIndex = 0;

            // Calculate end page index
            _endPageIndex = _startPageIndex + _options.MaximumPageNumbers;
            if (_endPageIndex > _totalPageCount)
                _endPageIndex = _totalPageCount;

        }

        public static MvcForm BeginPostForm(this AjaxHelper ajaxHelper, 
                                            string url, object routeValues, string beginCallback, 
                                            string successCallback, string failureCallback, string validationCallback, object htmlAttributes)
        {
            MvcForm retVal = null;

            beginCallback = HandledNullOrEmptyCallbacks(beginCallback);
            successCallback = HandledNullOrEmptyCallbacks(successCallback);
            failureCallback = HandledNullOrEmptyCallbacks(failureCallback);
            validationCallback = HandledNullOrEmptyCallbacks(validationCallback);

            AjaxOptions ajaxOptions = new AjaxOptions()
            {
                Url = url,
                HttpMethod = "POST",
                OnBegin = beginCallback,
                OnSuccess = CommonFormSubmitSuccessCallback.Replace(
                            SuccessCallbackPlaceholder, successCallback).Replace(
                            FailureCallbackPlaceholder, failureCallback).Replace(ValidationCallbackPlaceholder, validationCallback),
                OnFailure = CommonFormSubmitFailureCallback
            };

            retVal = ajaxHelper.BeginForm(string.Empty, routeValues, ajaxOptions, htmlAttributes);

            return retVal;
        }

 public static MvcHtmlString RawAjaxActionLink(this AjaxHelper ajaxHelper, string linkText, string actionName, 
     string controllerName, object routeValues, AjaxOptions ajaxOptions, object htmlAttributes)
 {
     var repId = Guid.NewGuid().ToString();
     var lnk = ajaxHelper.ActionLink(repId, actionName, controllerName, routeValues, ajaxOptions, htmlAttributes);
     return MvcHtmlString.Create(lnk.ToString().Replace(repId, linkText));
 }

        public static IHtmlString DisplayNameForSort(this AjaxHelper helper, string displayName, string columName, string actionName, RouteValueDictionary routeValues, AjaxOptions ajaxOptions, string controllerName = null)
        {
            if (!string.IsNullOrWhiteSpace(columName))
            {
                string orderBy;
                string iconName;
                HtmlHelperExtensions.GetListOrderParams(columName, out orderBy, out iconName);
                if (routeValues.ContainsKey("orderBy"))
                {
                    routeValues["orderBy"] = orderBy;
                }
                else
                {
                    routeValues.Add("orderBy", orderBy);
                }

                MvcHtmlString link;
                if (string.IsNullOrEmpty(controllerName))
                {
                    link = helper.ActionLink(displayName, actionName, routeValues, ajaxOptions);
                }
                else
                {
                    link = helper.ActionLink(displayName, actionName, controllerName, routeValues, ajaxOptions);
                }

                string htmlStr = "<div class=\"ap-sortedHeader\">{0}<i class=\"ap-sortedHeader fa {1}\"></i></div>";
                return new MvcHtmlString(string.Format(htmlStr, link.ToString(), iconName));
            }
            else
            {
                return new MvcHtmlString(displayName);
            }
        }

 public PagingRouteValue(string actionName, string controllerName, object optionValues = null, AjaxOptions ajaxOption = null, string prefix = "") : this()
 {
     this.ActionName = actionName;
     this.ControllerName = controllerName;
     this.AjaxOptions = ajaxOption;
     this.OptionValues = optionValues;
     this.RouteValuePrefix = prefix;
 }

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

 public BootstrapActionLink(AjaxHelper ajax, string linkText, ActionResult result, AjaxOptions ajaxOptions)
 {
     this.ajax = ajax;
     this._linkText = linkText;
     this._result = result;
     this._ajaxOptions = ajaxOptions;
     this._actionTypePassed = ActionTypePassed.AjaxActionResult;
 }

 public static IHtmlString IconActionLink(this AjaxHelper helper, string iconClass, string actionName, object routeValues, AjaxOptions ajaxOptions, object htmlAttributes = null)
 {
     var builder = new TagBuilder("i");
     builder.MergeAttribute("class", iconClass);
     builder.MergeAttributes(new RouteValueDictionary(htmlAttributes));
     var link = helper.ActionLink("[replaceme]", actionName, routeValues, ajaxOptions).ToHtmlString();
     return MvcHtmlString.Create(link.Replace("[replaceme]", builder.ToString(TagRenderMode.Normal)));
 }

 public static MvcHtmlString RawActionLink(this AjaxHelper ajaxHelper, string rawHtml, string action, string controller, object routeValues, AjaxOptions ajaxOptions, object htmlAttributes)
 {
     //string anchor = ajaxHelper.ActionLink("##holder##", action, controller, routeValues, ajaxOptions, htmlAttributes).ToString();
     //return MvcHtmlString.Create(anchor.Replace("##holder##", rawHtml));
     string holder = Guid.NewGuid().ToString();
     string anchor = ajaxHelper.ActionLink(holder, action, controller, routeValues, ajaxOptions, htmlAttributes).ToString();
     return MvcHtmlString.Create(anchor.Replace(holder, rawHtml));
 }

        /// <summary>
        /// Builds an ActionLink with the Image as text.
        /// </summary>
        /// <param name="ajaxHelper">The helper.</param>
        /// <param name="imageUri">The image URL.</param>
        /// <param name="title">The title text.</param>
        /// <param name="actionName">Name of the action.</param>
        /// <param name="routeValues">The route values.</param>
        /// <param name="ajaxOptions">The ajax options.</param>
        /// <param name="htmlAttributes">The HTML attributes.</param>
        /// <returns></returns>
        public static IHtmlString ImageActionLink(this AjaxHelper ajaxHelper, Uri imageUri, string title, string actionName, object routeValues, AjaxOptions ajaxOptions, object htmlAttributes)
        {
            Arg.IsNotNull(() => imageUri);

            var builder = BuildImageTag(imageUri, title, htmlAttributes);
            var link = ajaxHelper.ActionLink("[replaceme]", actionName, routeValues, ajaxOptions).ToHtmlString();
            return MvcHtmlString.Create(link.Replace("[replaceme]", builder.ToString(TagRenderMode.SelfClosing)));
        }