public HtmlRange( IHtmlNode node1, IHtmlNode node2, bool inclusiveNode1, bool inclusiveNode2 )
        {
            if ( node1 == null )
            throw new ArgumentNullException( "node1" );

              if ( node2 == null )
            throw new ArgumentNullException( "node2" );

              container = node1.Container;

              if ( container == null || !container.Equals( node2.Container ) || node1.Equals( node2 ) )
            throw new InvalidOperationException();

              if ( node1.NodesIndexOfSelf() <= node2.NodesIndexOfSelf() )
              {
            beginNode = node1;
            endNode = node2;
            inclusiveBegin = inclusiveNode1;
            inclusiveEnd = inclusiveNode2;
              }
              else
              {
            beginNode = node2;
            endNode = node1;
            inclusiveBegin = inclusiveNode2;
            inclusiveEnd = inclusiveNode1;
              }
        }

 private void ApplyDecorators(IHtmlNode table)
 {
     foreach (var decorator in Decorators)
     {
         decorator.Decorate(table);
     }
 }

        protected object GetData( IHtmlNode node, bool asContainer )
        {
            if ( node == null )
            return null;

              lock ( _dataItems.SyncRoot )
              {

            if ( asContainer )
            {
              var _container = node as IHtmlContainer;

              if ( _container != null && _dataItems.Contains( _container ) )
            return _dataItems[_container];
            }

            var container = node.Container;

            if ( _dataItems.Contains( container ) )
              return _dataItems[container];

            else
              return GetData( container as IHtmlNode, false );
              }
        }

        private void AppendPageInput(IHtmlNode container, GridPagerStyles style, GridPagerData section)
        {
            if ((style & GridPagerStyles.PageInput) != GridPagerStyles.PageInput)
                return;

            inputSectionBuilder.Create(section).AppendTo(container);
        }

    bool IHtmlRenderAdapter.Render( IHtmlNode node, IHtmlRenderContext context )
    {
      var element = node as IHtmlElement;

      if ( element == null )
        return false;

      if ( element.Name.EqualsIgnoreCase( "content" ) )
      {
        GetContentBody( element ).RenderChilds( context.Writer, RenderAdapters );
        return true;
      }
      else if ( element.Name.EqualsIgnoreCase( "head" ) )
      {

        View.ViewContext.HttpContext.Trace.Write( "ContentView", "Begin Merge Head" );
        var head = MergeHead( element, Document.FindSingle( "head" ) );
        View.ViewContext.HttpContext.Trace.Write( "ContentView", "End Merge Head" );

        head.Render( context.Writer, RenderAdapters );

        return true;
      }
      else
        return false;
    }

        public void ApplyTo(IHtmlNode target)
        {
            var hierarchyCell = new HtmlTag("th")
                .AddClass(UIPrimitives.Header, UIPrimitives.Grid.HierarchyCell);

            target.Children.Insert(0, hierarchyCell);
        }

 private static string AsString(IHtmlNode node)
 {
     var sb = new StringBuilder();
     using (var writer = new HtmlTextWriter(new StringWriter(sb)))
         node.Write(writer);
     return sb.ToString();
 }

        public void ApplyTo(IHtmlNode target)
        {
            var filtered = column.Grid.DataProcessor.FilterDescriptors.SelectRecursive(filter =>
            {
                CompositeFilterDescriptor compositeDescriptor = filter as CompositeFilterDescriptor;

                if (compositeDescriptor != null)
                {
                    return compositeDescriptor.FilterDescriptors;
                }

                return null;
            })
            .Where(filter => filter is FilterDescriptor)
            .OfType<FilterDescriptor>()
            .Any(filter => filter.Member.IsCaseInsensitiveEqual(column.Member));

            var wrapper = new HtmlTag("div")
                .AddClass("t-grid-filter", "t-state-default")
                .ToggleClass("t-active-filter", filtered);

            wrapper.AppendTo(target);

            var icon = new HtmlTag("span").AddClass("t-icon", "t-filter");
            icon.AppendTo(wrapper);
        }

        private void AppendPageSizeDropDown(IHtmlNode container, GridPagerStyles style, GridPagerData section)
        {
            if ((style & GridPagerStyles.PageSizeDropDown) != GridPagerStyles.PageSizeDropDown)
                return;

            gridPagerPageSizeSection.Create(section).AppendTo(container);
        }

 protected override void AppendCellContent(IHtmlNode td, object dataItem)
 {
     foreach (var builder in builders)
     {
         builder(dataItem).AppendTo(td);
     }
 }

 protected void Decorate(IHtmlNode td)
 {
     foreach (var decorator in Decorators)
     {
         decorator.Decorate(td);
     }
 }

 private void AppendNumericSection(IHtmlNode container, GridPagerStyles style, IGridUrlBuilder urlBuilder, int currentPage, int pageCount)
 {
     if ((style & GridPagerStyles.Numeric) == GridPagerStyles.Numeric)
     {
         numericSectionBuilder.Create(urlBuilder, currentPage, pageCount).AppendTo(container);
     }
 }

 private void AppendPageInput(IHtmlNode container, GridPagerData section)
 {
     if (section.Input)
     {
         inputSectionBuilder.Create(section).AppendTo(container);
     }
 }

 private void AppendPrevButtonsLink(int numericStart, IHtmlNode numericDiv, IGridUrlBuilder urlBuilder)
 {
     if (numericStart > 1)
     {
         buttonFactory.CreateButton(GridPagerButtonType.NumericLink, "...", true,
                                    GetUrl(urlBuilder, numericStart - 1)).AppendTo(numericDiv);
     }
 }

        public void Apply(IHtmlNode parent)
        {
            var span = new HtmlElement("span");

            span.Attributes(button.ImageHtmlAttributes).AddClass(UIPrimitives.Icon, button.SpriteCssClass);

            span.AppendTo(parent);
        }

 private void AppendNumericButtons(IGridUrlBuilder urlBuilder, int currentPage, int numericStart, IHtmlNode numericDiv, int numericEnd)
 {
     for (var page = numericStart; page <= numericEnd; page++)
     {
         buttonFactory.CreateButton(GridPagerButtonType.NumericLink, page.ToString(), page != currentPage,
                                    GetUrl(urlBuilder, page)).AppendTo(numericDiv);
     }
 }

 private void AppendNextButtonsLink(int pageCount, IHtmlNode numericDiv, int numericEnd, IGridUrlBuilder urlBuilder)
 {
     if (numericEnd < pageCount)
     {
         buttonFactory.CreateButton(GridPagerButtonType.NumericLink, "...", true,
                                    GetUrl(urlBuilder, numericEnd + 1)).AppendTo(numericDiv);
     }
 }

 protected void AppendFooter(IHtmlNode table, GridRenderingData renderingData)
 {
     if (renderingData.ShowFooter)
     {
         var tfoot = CreateFooter(renderingData);
         tfoot.AppendTo(table);
     }
 }

 private void AppendNumericSection(IHtmlNode container, IGridUrlBuilder urlBuilder, GridPagerData section)
 {
     if (section.Numeric)
     {
         numericSectionBuilder.Create(urlBuilder, section.Page, section.TotalPages, section.ButtonCount)
                              .AppendTo(container);
     }
 }

        public override void WriteHtml(IHtmlNode parent)
        {
            var li = CreateElement();

            li.Children.Add(CreateLink());

            parent.Children.Add(li);
        }