/// <summary>
        /// This renders out the form for us
        /// </summary>
        /// <param name="htmlHelper"></param>
        /// <param name="formAction"></param>
        /// <param name="method"></param>
        /// <param name="htmlAttributes"></param>
        /// <param name="surfaceController"></param>
        /// <param name="surfaceAction"></param>
        /// <param name="area"></param>		
        /// <param name="additionalRouteVals"></param>
        /// <returns></returns>
        /// <remarks>
        /// This code is pretty much the same as the underlying MVC code that writes out the form
        /// </remarks>
        private static MvcForm RenderForm(this IHtmlHelper htmlHelper,
                                          string formAction,
                                          FormMethod method,
                                          IDictionary<string, object> htmlAttributes,
                                          string surfaceController,
                                          string surfaceAction,
                                          string area,
                                          object additionalRouteVals = null)
        {
            if (htmlAttributes == null)
            {
                htmlAttributes = new Dictionary<string, object>();
            }
            //ensure that the multipart/form-data is added to the html attributes
            if (htmlAttributes.ContainsKey("enctype") == false)
            {
                htmlAttributes.Add("enctype", "multipart/form-data");
            }

            var tagBuilder = new TagBuilder("form");
            tagBuilder.MergeAttributes(htmlAttributes);
            // action is implicitly generated, so htmlAttributes take precedence.
            tagBuilder.MergeAttribute("action", formAction);
            // method is an explicit parameter, so it takes precedence over the htmlAttributes.
            tagBuilder.MergeAttribute("method", HtmlHelper.GetFormMethodString(method), true);

            tagBuilder.TagRenderMode = TagRenderMode.StartTag;
            tagBuilder.WriteTo(htmlHelper.ViewContext.Writer, new HtmlEncoder());

            //new UmbracoForm:
            var theForm = new UmbracoForm(htmlHelper.UrlEncoder, htmlHelper.ViewContext, surfaceController, surfaceAction, area, additionalRouteVals);

            return theForm;
        }

 public Form(ActionResult result)
     : base(null)
 {
     this._result = result;
     this._formMethod = System.Web.Mvc.FormMethod.Post;
     _actionTypePassed = ActionTypePassed.HtmlActionResult;
 }

        public jQueryForm(ViewContext context, string action, FormMethod method, jQueryAjaxOptions ajaxOptions, IDictionary<string, object> htmlAttributes)
            : base("form", TagRenderMode.StartTag)
        {


            MergeAttributes(htmlAttributes);
            Method = method;
            Action = action;
            ViewContext = context;
            OriginalFormContext = context.FormContext;
            context.FormContext = new FormContext();
            AjaxOptions = ajaxOptions ?? new jQueryAjaxOptions();

            if (AjaxOptions != null && AjaxOptions.Metadata)
            {
                AddClass("jquery-ajax-form");
                Attributes.Merge("data-jquery-ajax", AjaxOptions.ToJson());
            }

            if (string.IsNullOrWhiteSpace(Id))
            {
                Attributes.Merge("id", string.Format("form{0}", DateTime.UtcNow.Ticks));
            }
            //context.Writer.Write(f.Html(context));
        }

        /// <summary>
        /// Writes an opening form tag to the response. When the user submits the form,
        /// the request will be processed by the route target.
        /// </summary>
        /// <param name="htmlHelper">The HTML helper.</param>
        /// <param name="routeName">The name of the route to use to obtain the form-post URL.</param>
        /// <param name="method">The HTTP method for processing the form, either GET or POST.</param>
        /// <param name="routeValues">An object that contains the parameters for evaluatedValueString route.</param>
        /// <param name="htmlAttributes">The HTTP method for processing the form, either GET or POST.</param>
        /// <returns>An opening form tag.</returns>
        public static IDisposable BeginRouteForm(this HtmlHelper htmlHelper, string routeName, FormMethod method = FormMethod.Post, object routeValues = null, object htmlAttributes = null)
        {
            var routeDictionary = htmlHelper.AutomaticRouteValuesDictionary(routeValues);
            var attrDictionary = htmlHelper.AutomaticHtmlAttributes(htmlAttributes);

            return BootstrapHelperConfiguration.HtmlRenderer.BeginRouteForm(htmlHelper, routeName, method, routeDictionary, attrDictionary);
        }

        /// <summary>
        /// Sets configuration values for the rendered HTML form.
        /// </summary>
        /// <param name="actionName">The name of the target action.</param>
        /// <param name="controllerName">The name of the target controller.</param>
        /// <param name="routeValues">The route values for the target action.</param>
        /// <param name="formMethod">The method used to submit the form.</param>
        /// <param name="cssClass">The element class.</param>
        /// <param name="cssStyle">The element style.</param>
        /// <returns>The configured <see cref="System.Web.Mvc.Html.MvcForm"/> instance.</returns>
        public MvcForm With(
            string actionName = null, 
            string controllerName = null, 
            object routeValues = null, 
            FormMethod formMethod = FormMethod.Post, 
            string cssClass = null, 
            string cssStyle = null)
        {
            base.With(cssClass, cssStyle);

            if (controllerName.IsNullOrEmpty())
            {
                controllerName = this.HtmlHelper.InnerHelper.ViewContext.RouteData.Values["Controller"] as string;
            }

            if (actionName.IsNullOrEmpty())
            {
                actionName = this.HtmlHelper.InnerHelper.ViewContext.RouteData.Values["Action"] as string;
            }

            var htmlAttributes = this.HtmlAttributes;
            var safeRouteValues = new RouteValueDictionary(routeValues);

            MvcForm form;

            form = this.HtmlHelper
                       .InnerHelper
                            .BeginForm(actionName, controllerName, safeRouteValues, formMethod, htmlAttributes);
            
            return form;
        }

 public static IDisposable FormRoute(this HtmlHelper html, string routeName, FormMethod method, RouteValueDictionary valuesDictionary) {
     VirtualPathData virtualPath = RouteTable.Routes.GetVirtualPath(html.ViewContext, routeName, valuesDictionary);
     string formAction = (virtualPath == null) ? null : virtualPath.VirtualPath;
     SimpleForm form = new SimpleForm(html.ViewContext.HttpContext, formAction, method, null);
     form.WriteStartTag();
     return form;
 }

 /// <summary>
 /// Sets action attribute to a form element by using controller and an action method
 /// </summary>
 /// <param name="action"></param>
 /// <param name="controller"></param>
 public Form(string action, string controller)
     : base(null)
 {
     this._action = action;
     this._controller = controller;
     this._formMethod = System.Web.Mvc.FormMethod.Post;
 }

        public FormContainer(HtmlTextWriter htmlTextWriter,
            string url ,
            BootstrapFormType formType = BootstrapFormType.Horizontal,
            FormMethod method = FormMethod.Post,
            object htmlAttributes = null)
        {
            this.textWriter = htmlTextWriter;
            this.formType = formType;

           // textWriter.AddAttribute("method", method.ToString());

            //textWriter.AddAttribute("action", url ) ;
            var htmlAttributesCollection = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);

            switch (this.formType)
            {
                case BootstrapFormType.Horizontal: htmlAttributesCollection.Merge("class", "form-horizontal"); break;
                case BootstrapFormType.Vertical: htmlAttributesCollection.Merge("class", "form-vertical"); break;
                case BootstrapFormType.Inline: htmlAttributesCollection.Merge("class", "form-inline"); break;
            }

            foreach (var htmlAttribute in htmlAttributesCollection)
            {
                textWriter.AddAttribute(htmlAttribute.Key, htmlAttribute.Value.ToString());
            }
            textWriter.RenderBeginTag(HtmlTextWriterTag.Form);
            
        }

 public Form(Task<ActionResult> taskResult)
     : base(null)
 {
     this._taskResult = taskResult;
     this._formMethod = System.Web.Mvc.FormMethod.Post;
     _actionTypePassed = ActionTypePassed.HtmlTaskResult;
 }

 public static MvcForm BeginForm( this HtmlHelper htmlHelper,
                                  String actionName,
                                  String controllerName,
                                  FormMethod method,
                                  Hash htmlAttributes )
 {
     return htmlHelper.BeginForm(actionName, controllerName, method, HashHelper.ToStringKeyDictinary( htmlAttributes ));
 }

 private void Init(HtmlHelper html, string actionName = null, string controllerName = null, object routeValues = null,
                   FormMethod method = FormMethod.Post, object htmlAttrs = null, FormType? formType = null)
 {
     var attrs = new HtmlAttributes(htmlAttrs);
     if (formType != null) attrs["class"] += "form-" + formType.ToString().ToLower();
     if (html == null) return;
     _form = html.BeginForm(actionName, controllerName, new RouteValueDictionary(routeValues), method, attrs.ToDictionary());
 }

 /// <summary>
 /// Writes an opening &lt;form&gt; tag to the response. When the user submits the form,
 /// the request will be processed by an action method.
 /// </summary>
 /// <param name="htmlHelper">The HTML helper instance that this method extends.</param>
 /// <param name="formClass">CSS class for <c>form</c> element</param>
 /// <param name="method">The HTTP method for processing the form, either GET or POST.</param>
 /// <param name="htmlAttributes">An object that contains the HTML attributes to set for the element.</param>
 /// <returns>An opening <form> tag</returns>
 public static CarcassMvcForm CarcassBeginForm(this HtmlHelper htmlHelper,
     string formClass = CarcassMvcSettings.BootsrapFormClassHorisontal, 
     FormMethod method = FormMethod.Post,
     object htmlAttributes = null)
 {
     var rawUrl = htmlHelper.ViewContext.HttpContext.Request.RawUrl;
     return CarcassBeginFormImpl(htmlHelper, rawUrl, formClass, method, (IDictionary<string, object>)HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes));
 }

 public static MvcForm BeginForm(
     [NotNull] this IHtmlHelper htmlHelper,
     FormMethod method,
     object htmlAttributes)
 {
     return htmlHelper.BeginForm(actionName: null, controllerName: null, routeValues: null,
                                 method: method, htmlAttributes: htmlAttributes);
 }

        public static MvcHtmlString Button(this HtmlHelper helper, 
            string text, string urlAction, FormMethod method, object htmlAttributes)
        {
            var tagBuilder = new TagBuilder("input");
            FillWithAttributes(tagBuilder, new { type = "submit", formaction = urlAction, formmethod = method.ToString(), value = text });
            FillWithAttributes(tagBuilder, htmlAttributes);

            return new MvcHtmlString(tagBuilder.ToString());
        }

        public static MsAspMvc.MvcForm BeginAngularForm(this HtmlHelper htmlHelper, string actionName, string controllerName, FormMethod method, object htmlAttributes)
        {
            RouteValueDictionary routeValues = HtmlHelper.AnonymousObjectToHtmlAttributes(htmlAttributes);
            if (!routeValues.ContainsKey("name"))
                routeValues.Add("name", "form");

            htmlHelper.ViewData.Add("formName", routeValues["name"]);
            return MsAspMvc.FormExtensions.BeginForm(htmlHelper, actionName, controllerName, method, routeValues);
        }

        /// <summary>
        /// Renders a &lt;form&gt; start tag to the response. When the user submits the form, the
        /// current action will process the request.
        /// </summary>
        /// <param name="htmlHelper">The <see cref="IHtmlHelper"/> instance this method extends.</param>
        /// <param name="method">The HTTP method for processing the form, either GET or POST.</param>
        /// <returns>
        /// An <see cref="MvcForm"/> instance which renders the &lt;/form&gt; end tag when disposed.
        /// </returns>
        /// <remarks>
        /// In this context, "renders" means the method writes its output using <see cref="ViewContext.Writer"/>.
        /// </remarks>
        public static MvcForm BeginForm(this IHtmlHelper htmlHelper, FormMethod method)
        {
            if (htmlHelper == null)
            {
                throw new ArgumentNullException(nameof(htmlHelper));
            }

            return htmlHelper.BeginForm(actionName: null, controllerName: null, routeValues: null,
                                        method: method, htmlAttributes: null);
        }

 public static IDisposable MyBeginForm(this HtmlHelper html, string action, string controller, FormMethod method)
 {
     var routeValues = new RouteValueDictionary();
     var query = html.ViewContext.HttpContext.Request.QueryString;
     foreach (string key in query)
     {
         routeValues[key] = query[key];
     }
     return html.BeginForm(action, controller, routeValues, FormMethod.Get);
 }

 /// <summary>
 /// Invokes the private static "FormHelper" method of the <see cref="T:System.Web.Mvc.Html.FormExtensions" /> class via reflection.
 /// </summary>
 /// <param name="htmlHelper">The HTML helper.</param>
 /// <param name="formAction">The form action.</param>
 /// <param name="method">The method.</param>
 /// <param name="htmlAttributes">The HTML attributes.</param>
 /// <returns></returns>
 public static MvcForm FormHelper(HtmlHelper htmlHelper,
                                  string formAction,
                                  FormMethod method,
                                  IDictionary<string, object> htmlAttributes)
 {
     return (MvcForm) typeof (FormExtensions).InvokeMember("FormHelper",
                                                           BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.InvokeMethod,
                                                           null,
                                                           null,
                                                           new object[] {htmlHelper, formAction, method, htmlAttributes});
 }

 public override MvcHtmlString Form(String url, Object routeValues, FormMethod formMethod, Object htmlAttribute, String innerHtml)
 {
     StringBuilder stringBuilder = new StringBuilder();
     stringBuilder.Append("<form ");
     stringBuilder.Append(TagHelper.PackHtmlAttrbute(htmlAttribute));
     stringBuilder.Append(String.Concat(TagHelper.PackFormMethod(formMethod), " "));
     stringBuilder.Append(TagHelper.PackAction(url, routeValues));
     stringBuilder.AppendLine(">");
     stringBuilder.AppendLine(innerHtml);
     stringBuilder.Append("</form>");
     return MvcHtmlString.Create(stringBuilder.ToString());
 }

        public static MvcForm PantherForm(this IHtmlHelper htmlHelper, string Path, FormMethod method = FormMethod.Post, IDictionary<string, object> htmlAttributes = null)
        {
            
            TagBuilder builder = new TagBuilder("form");
            builder.MergeAttributes(htmlAttributes);
            builder.MergeAttribute("action", Path);
            builder.MergeAttribute("method", HtmlHelper.GetFormMethodString(method), true);

            htmlHelper.ViewContext.Writer.Write(builder.ToString(TagRenderMode.StartTag));

            return new MvcForm(htmlHelper.ViewContext);
        }