//------------------------------------------------------------------------------
// <auto-generated>
//     This code was generated by a tool.
//     Runtime Version:4.0.30319.42000
//
//     Changes to this file may cause incorrect behavior and will be lost if
//     the code is regenerated.
// </auto-generated>
//------------------------------------------------------------------------------

namespace Resources {
    using System;
    
    
    /// <summary>
    ///   A strongly-typed resource class, for looking up localized strings, etc.
    /// </summary>
    // This class was auto-generated by the StronglyTypedResourceBuilder
    // class via a tool like ResGen or Visual Studio.
    // To add or remove a member, edit your .ResX file then rerun ResGen
    // with the /str option or rebuild the Visual Studio project.
    [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Web.Application.StronglyTypedResourceProxyBuilder", "14.0.0.0")]
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    internal class C1Nav {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal C1Nav() {
        }
        
        /// <summary>
        ///   Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("Resources.C1Nav", global::System.Reflection.Assembly.Load("App_GlobalResources"));
                    resourceMan = temp;
                }
                return resourceMan;
            }
        }
        
        /// <summary>
        ///   Overrides the current thread's CurrentUICulture property for all
        ///   resource lookups using this strongly typed resource class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        internal static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Accordions are multi-pane panels that keep only one panel expanded
        ///    at a time. They are commonly used for navigation..
        /// </summary>
        internal static string AccordionTrees_Text1 {
            get {
                return ResourceManager.GetString("AccordionTrees_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can use the &lt;b&gt;TreeView&lt;/b&gt; control to implement accordions..
        /// </summary>
        internal static string AccordionTrees_Text2 {
            get {
                return ResourceManager.GetString("AccordionTrees_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use CSS to customize the header display and to hide the
        ///    collapse/expand glyphs, and make sure the &lt;b&gt;autoCollapse&lt;/b&gt;
        ///    property is set to true (the default), so non-active panels
        ///    are automatically collapsed..
        /// </summary>
        internal static string AccordionTrees_Text3 {
            get {
                return ResourceManager.GetString("AccordionTrees_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use Custom CSS.
        /// </summary>
        internal static string AccordionTrees_Text4 {
            get {
                return ResourceManager.GetString("AccordionTrees_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Ready.
        /// </summary>
        internal static string AccordionTrees_Text5 {
            get {
                return ResourceManager.GetString("AccordionTrees_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Accordion Trees.
        /// </summary>
        internal static string AccordionTrees_Title {
            get {
                return ResourceManager.GetString("AccordionTrees_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To add nodes to a &lt;b&gt;TreeView&lt;/b&gt; control, add a new data item
        ///    to the tree&apos;s &lt;b&gt;itemsSource&lt;/b&gt; array (at the proper position),
        ///    then refresh the tree by calling the &lt;b&gt;loadTree&lt;/b&gt; method:.
        /// </summary>
        internal static string Adding_Text1 {
            get {
                return ResourceManager.GetString("Adding_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to New Node:.
        /// </summary>
        internal static string Adding_Text2 {
            get {
                return ResourceManager.GetString("Adding_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Add Node:.
        /// </summary>
        internal static string Adding_Text3 {
            get {
                return ResourceManager.GetString("Adding_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Before.
        /// </summary>
        internal static string Adding_Text4 {
            get {
                return ResourceManager.GetString("Adding_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to After.
        /// </summary>
        internal static string Adding_Text5 {
            get {
                return ResourceManager.GetString("Adding_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Child.
        /// </summary>
        internal static string Adding_Text6 {
            get {
                return ResourceManager.GetString("Adding_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Adding Nodes.
        /// </summary>
        internal static string Adding_Title {
            get {
                return ResourceManager.GetString("Adding_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The control below looks like an Accordion but is really
        ///    a TreeView with some CSS and a &lt;b&gt;formatItem&lt;/b&gt;
        ///    event handler..
        /// </summary>
        internal static string AnotherAccordion_Text1 {
            get {
                return ResourceManager.GetString("AnotherAccordion_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The tree automatically expands the selected item
        ///    and collapses all others, and ensures only top-level
        ///    nodes can be selected:.
        /// </summary>
        internal static string AnotherAccordion_Text2 {
            get {
                return ResourceManager.GetString("AnotherAccordion_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Selected item: &lt;b&gt;&lt;span id=&quot;selected&quot;&gt;&lt;/span&gt;&lt;/b&gt;.
        /// </summary>
        internal static string AnotherAccordion_Text3 {
            get {
                return ResourceManager.GetString("AnotherAccordion_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to TreeView Accordion.
        /// </summary>
        internal static string AnotherAccordion_Title {
            get {
                return ResourceManager.GetString("AnotherAccordion_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The TreeView architecture is very simple, because it
        ///    delegates a lot of the work to the browser&apos;s DOM..
        /// </summary>
        internal static string Architecture_Text1 {
            get {
                return ResourceManager.GetString("Architecture_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The control is 100% data-bound. The &lt;b&gt;itemsSource&lt;/b&gt; property
        ///    defines an array of data items that represent nodes and may
        ///    contain child elements (as defined by the &lt;b&gt;childItemsPath&lt;/b&gt;
        ///    property).
        ///    When one of the binding properties change, the control populates
        ///    its DOM by scanning the itemsSource array and creating DOM elements
        ///    to represent the nodes..
        /// </summary>
        internal static string Architecture_Text2 {
            get {
                return ResourceManager.GetString("Architecture_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There is no virtualization, so the number of DOM elements remains
        ///    constant as the user scrolls the control, collapses or expands nodes.
        ///    This is not a significant limitation since the TreeView supports
        ///    lazy-loading, which allows you to load data as the user requests it
        ///    (by expanding the nodes)..
        /// </summary>
        internal static string Architecture_Text3 {
            get {
                return ResourceManager.GetString("Architecture_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The TreeView has a &lt;b&gt;selectedItem&lt;/b&gt; property that gets or sets
        ///    the data item in the &lt;b&gt;itemsSource&lt;/b&gt; array that is currently selected.
        ///    It also has a &lt;b&gt;selectedNode&lt;/b&gt; property that gets or sets the tree
        ///    node that wraps the current item. You can use the &lt;b&gt;selectedNode&lt;/b&gt;
        ///    property to collapse, expand, or move the selection.
        ///    You use the TreeView&apos;s &lt;b&gt;getNode&lt;/b&gt; method to get a reference to
        ///    the node that represents a given data item..
        /// </summary>
        internal static string Architecture_Text4 {
            get {
                return ResourceManager.GetString("Architecture_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To change the tree, you will normally change the &lt;b&gt;itemsSource&lt;/b&gt;
        ///    array and call the &lt;b&gt;loadTree&lt;/b&gt; method to re-generate the nodes.
        ///    The example below shows the performance of the TreeView when binding
        ///    to sources of different sizes:.
        /// </summary>
        internal static string Architecture_Text5 {
            get {
                return ResourceManager.GetString("Architecture_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Levels:.
        /// </summary>
        internal static string Architecture_Text6 {
            get {
                return ResourceManager.GetString("Architecture_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Nodes/Level:.
        /// </summary>
        internal static string Architecture_Text7 {
            get {
                return ResourceManager.GetString("Architecture_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Bind Tree.
        /// </summary>
        internal static string Architecture_Text8 {
            get {
                return ResourceManager.GetString("Architecture_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to TreeView Architecture.
        /// </summary>
        internal static string Architecture_Title {
            get {
                return ResourceManager.GetString("Architecture_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Setting the &lt;b&gt;allowDrag&lt;/b&gt; property to true allows users
        ///    to drag and drop nodes within the same &lt;b&gt;TreeView&lt;/b&gt;..
        /// </summary>
        internal static string BetweenTrees_Text1 {
            get {
                return ResourceManager.GetString("BetweenTrees_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To allow dragging and dropping nodes between different
        ///    &lt;b&gt;TreeView&lt;/b&gt; controls, you must handle the &lt;b&gt;dragOver&lt;/b&gt;
        ///    event and set the &lt;b&gt;cancel&lt;/b&gt; parameter to true if
        ///    the operation is invalid, or to false if it is valid..
        /// </summary>
        internal static string BetweenTrees_Text2 {
            get {
                return ResourceManager.GetString("BetweenTrees_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to allow dragging within trees.
        /// </summary>
        internal static string BetweenTrees_Text3 {
            get {
                return ResourceManager.GetString("BetweenTrees_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to allow dragging between trees.
        /// </summary>
        internal static string BetweenTrees_Text4 {
            get {
                return ResourceManager.GetString("BetweenTrees_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Drag and Drop Between Trees.
        /// </summary>
        internal static string BetweenTrees_Title {
            get {
                return ResourceManager.GetString("BetweenTrees_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To refresh nodes after making changes to the items in the
        ///    &lt;b&gt;itemsSource&lt;/b&gt; array, you may call the TreeView&apos;s
        ///    &lt;b&gt;loadTree&lt;/b&gt; method. This will update the tree and
        ///    will ensure the currently selected node is visible..
        /// </summary>
        internal static string Changing_Text1 {
            get {
                return ResourceManager.GetString("Changing_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you want to refresh the content of a single node,
        ///    however, it may be more efficient to change the node
        ///    element directly without reloading the whole tree..
        /// </summary>
        internal static string Changing_Text2 {
            get {
                return ResourceManager.GetString("Changing_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The buttons below show both approaches:.
        /// </summary>
        internal static string Changing_Text3 {
            get {
                return ResourceManager.GetString("Changing_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Change and reload the TreeView.
        /// </summary>
        internal static string Changing_Text4 {
            get {
                return ResourceManager.GetString("Changing_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Change and update the TreeNode.
        /// </summary>
        internal static string Changing_Text5 {
            get {
                return ResourceManager.GetString("Changing_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Refreshing Nodes.
        /// </summary>
        internal static string Changing_Title {
            get {
                return ResourceManager.GetString("Changing_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set the &lt;b&gt;showCheckboxes&lt;/b&gt; property to true and the TreeView will
        ///    add checkboxes to each node..
        /// </summary>
        internal static string Checkboxes_Text1 {
            get {
                return ResourceManager.GetString("Checkboxes_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When checkboxes are displayed, the TreeView manages their
        ///    hierarchy so that when a checkbox is checked or cleared, the new
        ///    value is automatically applied to all child nodes, and reflected
        ///    on the state of the parent nodes..
        /// </summary>
        internal static string Checkboxes_Text2 {
            get {
                return ResourceManager.GetString("Checkboxes_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When items are checked or unchecked, the &lt;b&gt;checkedItemsChanged&lt;/b&gt;
        ///    event is raised, and the &lt;b&gt;checkedItems&lt;/b&gt; property is updated
        ///    with a list of the items that are currently checked:.
        /// </summary>
        internal static string Checkboxes_Text3 {
            get {
                return ResourceManager.GetString("Checkboxes_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Check All.
        /// </summary>
        internal static string Checkboxes_Text4 {
            get {
                return ResourceManager.GetString("Checkboxes_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Uncheck All.
        /// </summary>
        internal static string Checkboxes_Text5 {
            get {
                return ResourceManager.GetString("Checkboxes_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Save State.
        /// </summary>
        internal static string Checkboxes_Text6 {
            get {
                return ResourceManager.GetString("Checkboxes_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Restore State.
        /// </summary>
        internal static string Checkboxes_Text7 {
            get {
                return ResourceManager.GetString("Checkboxes_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Node Checkboxes.
        /// </summary>
        internal static string Checkboxes_Title {
            get {
                return ResourceManager.GetString("Checkboxes_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The TreeView below has a custom context menu.
        ///    Right-click the tree to see it:.
        /// </summary>
        internal static string ContextMenus_Text1 {
            get {
                return ResourceManager.GetString("ContextMenus_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Option 1.
        /// </summary>
        internal static string ContextMenus_Text2 {
            get {
                return ResourceManager.GetString("ContextMenus_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Option 2.
        /// </summary>
        internal static string ContextMenus_Text3 {
            get {
                return ResourceManager.GetString("ContextMenus_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Option 3.
        /// </summary>
        internal static string ContextMenus_Text4 {
            get {
                return ResourceManager.GetString("ContextMenus_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Option 4.
        /// </summary>
        internal static string ContextMenus_Text5 {
            get {
                return ResourceManager.GetString("ContextMenus_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to TreeView with Context Menu.
        /// </summary>
        internal static string ContextMenus_Title {
            get {
                return ResourceManager.GetString("ContextMenus_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can customize the content of the TreeView nodes using the &lt;b&gt;formatItem&lt;/b&gt;
        ///    event. The event handler parameters include the element that represents the node
        ///    and the data item being rendered..
        /// </summary>
        internal static string CustomContent_Text1 {
            get {
                return ResourceManager.GetString("CustomContent_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The example below uses the &lt;b&gt;formatItem&lt;/b&gt; event to add a &quot;new&quot; badge to the
        ///    right of new items on the tree..
        /// </summary>
        internal static string CustomContent_Text2 {
            get {
                return ResourceManager.GetString("CustomContent_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Node Content.
        /// </summary>
        internal static string CustomContent_Title {
            get {
                return ResourceManager.GetString("CustomContent_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can disable nodes using the &lt;b&gt;TreeNode&lt;/b&gt;&apos;s &lt;b&gt;isDisabled&lt;/b&gt;
        ///    property..
        /// </summary>
        internal static string Disabling_Text1 {
            get {
                return ResourceManager.GetString("Disabling_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Disabled nodes cannot be selected using the mouse or keyboard..
        /// </summary>
        internal static string Disabling_Text2 {
            get {
                return ResourceManager.GetString("Disabling_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Disable Selected Node.
        /// </summary>
        internal static string Disabling_Text3 {
            get {
                return ResourceManager.GetString("Disabling_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enable All Nodes.
        /// </summary>
        internal static string Disabling_Text4 {
            get {
                return ResourceManager.GetString("Disabling_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Disabled Nodes.
        /// </summary>
        internal static string Disabling_Title {
            get {
                return ResourceManager.GetString("Disabling_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set the &lt;b&gt;allowDragging&lt;/b&gt; property to true to allow users
        ///    to drag nodes to new positions within the &lt;b&gt;TreeView&lt;/b&gt;..
        /// </summary>
        internal static string DragDrop_Text1 {
            get {
                return ResourceManager.GetString("DragDrop_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to allow dropping into empty nodes.
        /// </summary>
        internal static string DragDrop_Text10 {
            get {
                return ResourceManager.GetString("DragDrop_Text10", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When dragging is allowed, users may drag any node to any position
        ///    within the tree. Specifically, nodes can be dragged to a position
        ///    above, below, or into (as a child of) other nodes..
        /// </summary>
        internal static string DragDrop_Text2 {
            get {
                return ResourceManager.GetString("DragDrop_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can customize this behavior by handling the &lt;b&gt;TreeView&lt;/b&gt;
        ///    drag/drop events:.
        /// </summary>
        internal static string DragDrop_Text3 {
            get {
                return ResourceManager.GetString("DragDrop_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;dragStart:&lt;/b&gt; Occurs when a drag/drop operation is about to start.
        ///        You may examine the node about to be dragged and cancel the operation
        ///        by setting the event&apos;s &lt;b&gt;cancel&lt;/b&gt; parameter to true..
        /// </summary>
        internal static string DragDrop_Text4 {
            get {
                return ResourceManager.GetString("DragDrop_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;dragOver:&lt;/b&gt; Occurs while the user drags the node over other nodes
        ///        on the tree. You may examine the current target node and drop position
        ///        and prevent the drop or modify its location setting the event&apos;s
        ///        &lt;b&gt;cancel&lt;/b&gt; and &lt;b&gt;position&lt;/b&gt; parameters..
        /// </summary>
        internal static string DragDrop_Text5 {
            get {
                return ResourceManager.GetString("DragDrop_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;drop:&lt;/b&gt; Occurs when the user drops the node into its new location.
        ///        You may examine the current target node and drop position and
        ///        prevent the drop or modify its location setting the event&apos;s
        ///        &lt;b&gt;cancel&lt;/b&gt; and &lt;b&gt;position&lt;/b&gt; parameters..
        /// </summary>
        internal static string DragDrop_Text6 {
            get {
                return ResourceManager.GetString("DragDrop_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;dragEnd:&lt;/b&gt; Occurs after the drag/drop operation is finished,
        ///        even if it was canceled and the source node was not moved..
        /// </summary>
        internal static string DragDrop_Text7 {
            get {
                return ResourceManager.GetString("DragDrop_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to allow dragging.
        /// </summary>
        internal static string DragDrop_Text8 {
            get {
                return ResourceManager.GetString("DragDrop_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to allow dragging parent nodes.
        /// </summary>
        internal static string DragDrop_Text9 {
            get {
                return ResourceManager.GetString("DragDrop_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Drag and Drop.
        /// </summary>
        internal static string DragDrop_Title {
            get {
                return ResourceManager.GetString("DragDrop_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;TreeView&lt;/b&gt; control provides editing support. Set the
        ///    &lt;b&gt;isReadOnly&lt;/b&gt; property to false and users will be able to
        ///    edit the content of the nodes by pressing the F2 key..
        /// </summary>
        internal static string Editing_Text1 {
            get {
                return ResourceManager.GetString("Editing_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Edits made to node contents are automatically applied to the
        ///    items in the &lt;b&gt;itemsSource&lt;/b&gt; array using the properties
        ///    specified by the &lt;b&gt;displayMemberPath&lt;/b&gt; property..
        /// </summary>
        internal static string Editing_Text2 {
            get {
                return ResourceManager.GetString("Editing_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You may customize the editing behavior using the following events:
        ///    &lt;b&gt;nodeEditStarting&lt;/b&gt;, &lt;b&gt;nodeEditStarted&lt;/b&gt;,
        ///    &lt;b&gt;nodeEditEnding&lt;/b&gt;, and &lt;b&gt;nodeEditEnded&lt;/b&gt;..
        /// </summary>
        internal static string Editing_Text3 {
            get {
                return ResourceManager.GetString("Editing_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In the example below, we enable editing only for nodes that
        ///    contain no children. To edit, select a node and press F2:.
        /// </summary>
        internal static string Editing_Text4 {
            get {
                return ResourceManager.GetString("Editing_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Editing Nodes.
        /// </summary>
        internal static string Editing_Title {
            get {
                return ResourceManager.GetString("Editing_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In most TreeView applications, the &lt;b&gt;displayMemberPath&lt;/b&gt;
        ///    and &lt;b&gt;childItemsPath&lt;/b&gt; properties are set to strings that
        ///    define the name of the property that should be displayed on
        ///    the nodes and the name of the property that contains child
        ///    items (the default values for these properties are &apos;header&apos;
        ///    and &apos;items&apos;)..
        /// </summary>
        internal static string HeterogeneousData_Text1 {
            get {
                return ResourceManager.GetString("HeterogeneousData_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In some applications, however, the names of these binding
        ///    properties depends on the hierarchical level of the data.
        ///    In these cases, you can use an array of names for either
        ///    property..
        /// </summary>
        internal static string HeterogeneousData_Text2 {
            get {
                return ResourceManager.GetString("HeterogeneousData_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The tree below is bound to a list of &apos;continent&apos; items,
        ///    each with a &apos;countries&apos; member that contains a list of
        ///    &apos;country&apos; items with a &apos;cities&apos; member:.
        /// </summary>
        internal static string HeterogeneousData_Text3 {
            get {
                return ResourceManager.GetString("HeterogeneousData_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Heterogeneous Data.
        /// </summary>
        internal static string HeterogeneousData_Title {
            get {
                return ResourceManager.GetString("HeterogeneousData_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use the &lt;b&gt;imageMemberPath&lt;/b&gt; property to add images to nodes
        ///    by specifying the name of a property on the data items that
        ///    contains an image URL..
        /// </summary>
        internal static string Images_Text1 {
            get {
                return ResourceManager.GetString("Images_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, some our sample items array have an &quot;Image&quot; property
        ///    set to image URLs:.
        /// </summary>
        internal static string Images_Text2 {
            get {
                return ResourceManager.GetString("Images_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Node Images.
        /// </summary>
        internal static string Images_Title {
            get {
                return ResourceManager.GetString("Images_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;TreeView&lt;/b&gt; control shows hierarchical data. It enables
        ///    users to collapse or expand nodes, select items, load, search,
        ///    and edit data, and to use drag and drop gestures to re-organize
        ///    the items if needed..
        /// </summary>
        internal static string Index_Text1 {
            get {
                return ResourceManager.GetString("Index_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To use the &lt;b&gt;TreeView&lt;/b&gt; control, you will normally use the
        ///    following three properties:.
        /// </summary>
        internal static string Index_Text2 {
            get {
                return ResourceManager.GetString("Index_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;itemsSource&lt;/b&gt; defines the array that contains the hierarchical data.
        ///        Each item in the array contains information about a node and (optionally)
        ///        an array of child nodes..
        /// </summary>
        internal static string Index_Text3 {
            get {
                return ResourceManager.GetString("Index_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;displayMemberPath&lt;/b&gt; defines the name of the property in the items
        ///        that contains the text to be displayed in the tree nodes. By default,
        ///        this property is set to the string &apos;header&apos;..
        /// </summary>
        internal static string Index_Text4 {
            get {
                return ResourceManager.GetString("Index_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;childItemsPath&lt;/b&gt; defines the name of the property in the items that
        ///        contains the array of child nodes. By default, this property is set to the
        ///        string &apos;items&apos;..
        /// </summary>
        internal static string Index_Text5 {
            get {
                return ResourceManager.GetString("Index_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Once the tree is set up, use the &lt;b&gt;itemClicked&lt;/b&gt; or
        ///    &lt;b&gt;selectedItemChanged&lt;/b&gt; events to track user actions and handle them
        ///    with the &lt;b&gt;selectedItem&lt;/b&gt; property..
        /// </summary>
        internal static string Index_Text6 {
            get {
                return ResourceManager.GetString("Index_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the &lt;b&gt;TreeView&lt;/b&gt; below shows a hierarchical list of
        ///    products. Users may expand nodes by clicking the collapsed icons,
        ///    or by pressing the right-arrow key when a node is selected..
        /// </summary>
        internal static string Index_Text7 {
            get {
                return ResourceManager.GetString("Index_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to C1 MVC TreeView.
        /// </summary>
        internal static string Index_Title {
            get {
                return ResourceManager.GetString("Index_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, the TreeView expands the first node at each
        ///    level and collapsed all others when it is bound to some
        ///    data:.
        /// </summary>
        internal static string InitialState_Text1 {
            get {
                return ResourceManager.GetString("InitialState_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you select an item when the tree loads, it will
        ///    automatically ensure the selected node is visible,
        ///    expanding the tree and scrolling as needed.
        ///    In this case, we selected the &apos;Solar Panel&apos; item:.
        /// </summary>
        internal static string InitialState_Text2 {
            get {
                return ResourceManager.GetString("InitialState_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use the &lt;b&gt;collapseToLevel&lt;/b&gt; method to collapse or expand
        ///    the tree to a given level when it loads. For example, the
        ///    trees below start totally collapsed and totally expanded:.
        /// </summary>
        internal static string InitialState_Text3 {
            get {
                return ResourceManager.GetString("InitialState_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Initial State.
        /// </summary>
        internal static string InitialState_Title {
            get {
                return ResourceManager.GetString("InitialState_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Selecting a default item.
        /// </summary>
        internal static string InitialState_Title1 {
            get {
                return ResourceManager.GetString("InitialState_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Collapsing to a given Level.
        /// </summary>
        internal static string InitialState_Title2 {
            get {
                return ResourceManager.GetString("InitialState_Title2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lazy loading is useful when you are dealing with large hierarchical
        ///    data sources and would like to avoid the delays involved in loading
        ///    the entire data set at once..
        /// </summary>
        internal static string LazyLoading_Text1 {
            get {
                return ResourceManager.GetString("LazyLoading_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;TreeView&lt;/b&gt; control makes lazy-loading super easy. Only two
        ///    steps are required:.
        /// </summary>
        internal static string LazyLoading_Text2 {
            get {
                return ResourceManager.GetString("LazyLoading_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set the &lt;b&gt;items&lt;/b&gt; property in the parent node data item to an
        ///        empty array..
        /// </summary>
        internal static string LazyLoading_Text3 {
            get {
                return ResourceManager.GetString("LazyLoading_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set the &lt;b&gt;TreeView&apos;s&lt;/b&gt; &lt;b&gt;lazyLoadFunction&lt;/b&gt; property to a
        ///        function to be called when the user expands the node. This function
        ///        takes two parameters: the parent node and a callback function to be
        ///        invoked when the data becomes available..
        /// </summary>
        internal static string LazyLoading_Text4 {
            get {
                return ResourceManager.GetString("LazyLoading_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The tree in example below starts with three lazy-loaded nodes.
        ///    When you expand them, the &lt;b&gt;lazyLoadFunction&lt;/b&gt; is invoked.
        ///    The function uses a timeout to simulate an http delay and
        ///    returns data for three child nodes, one of which is also a
        ///    lazy-loaded node..
        /// </summary>
        internal static string LazyLoading_Text5 {
            get {
                return ResourceManager.GetString("LazyLoading_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lazy-Loading Nodes.
        /// </summary>
        internal static string LazyLoading_Title {
            get {
                return ResourceManager.GetString("LazyLoading_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example shows how you can use the &lt;b&gt;TreeView&lt;/b&gt; control to
        ///    display hierarchical data from OData sources..
        /// </summary>
        internal static string LazyOdata_Text1 {
            get {
                return ResourceManager.GetString("LazyOdata_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The sample starts by loading the Northwind employees table. When the
        ///    data is loaded, the code adds an &quot;Orders&quot; empty array to each employee.
        ///    The &lt;b&gt;lazyLoadFunction&lt;/b&gt; is used to load the orders when an employee
        ///    node is expanded..
        /// </summary>
        internal static string LazyOdata_Text2 {
            get {
                return ResourceManager.GetString("LazyOdata_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The orders table also adds an &quot;Order_Details&quot; empty array to each
        ///    order. The &lt;b&gt;lazyLoadFunction&lt;/b&gt; is used to load the order details
        ///    when an order node is expanded..
        /// </summary>
        internal static string LazyOdata_Text3 {
            get {
                return ResourceManager.GetString("LazyOdata_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lazy-Loading and OData.
        /// </summary>
        internal static string LazyOdata_Title {
            get {
                return ResourceManager.GetString("LazyOdata_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In addition to the data-binding properties that define the
        ///    TreeView content, the control provides several properties that
        ///    customize its behavior..
        /// </summary>
        internal static string MainProperties_Text1 {
            get {
                return ResourceManager.GetString("MainProperties_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows the effect of some of these properties:.
        /// </summary>
        internal static string MainProperties_Text2 {
            get {
                return ResourceManager.GetString("MainProperties_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Collapse All.
        /// </summary>
        internal static string MainProperties_Text3 {
            get {
                return ResourceManager.GetString("MainProperties_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Expand All.
        /// </summary>
        internal static string MainProperties_Text4 {
            get {
                return ResourceManager.GetString("MainProperties_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to TreeView Properties.
        /// </summary>
        internal static string MainProperties_Title {
            get {
                return ResourceManager.GetString("MainProperties_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The simplest and most common use for the TreeView control is navigation.
        ///    The &lt;b&gt;TreeView&lt;/b&gt;&apos;s hierarchical structure and auto-search functionality
        ///    make it easy for users to drill-down and find the items they are
        ///    interested in..
        /// </summary>
        internal static string NavigationTrees_Text1 {
            get {
                return ResourceManager.GetString("NavigationTrees_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can use the &lt;b&gt;selectedItemChanged&lt;/b&gt; or &lt;b&gt;itemClicked&lt;/b&gt; events
        ///    for navigation. The difference is that &lt;b&gt;selectedItemChanged&lt;/b&gt; occurs
        ///    when the user moves the selection with the keyboard, and &lt;b&gt;itemClicked&lt;/b&gt;
        ///    occurs when the user clicks an item or presses the Enter key..
        /// </summary>
        internal static string NavigationTrees_Text2 {
            get {
                return ResourceManager.GetString("NavigationTrees_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example uses the &lt;b&gt;itemClicked&lt;/b&gt; event:.
        /// </summary>
        internal static string NavigationTrees_Text3 {
            get {
                return ResourceManager.GetString("NavigationTrees_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Ready.
        /// </summary>
        internal static string NavigationTrees_Text4 {
            get {
                return ResourceManager.GetString("NavigationTrees_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Navigation Trees.
        /// </summary>
        internal static string NavigationTrees_Title {
            get {
                return ResourceManager.GetString("NavigationTrees_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In most cases, you can work with a TreeView using only its
        ///    data-binding and selection properties, and the original
        ///    data items bound to the tree..
        /// </summary>
        internal static string Nodes_Text1 {
            get {
                return ResourceManager.GetString("Nodes_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;index&lt;/b&gt;: Gets the index of this node in the node collection
        ///        that contains it..
        /// </summary>
        internal static string Nodes_Text10 {
            get {
                return ResourceManager.GetString("Nodes_Text10", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;level&lt;/b&gt;: Gets the node&apos;s level in the outline structure.
        ///        Top level nodes have level zero..
        /// </summary>
        internal static string Nodes_Text11 {
            get {
                return ResourceManager.GetString("Nodes_Text11", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;nodes&lt;/b&gt;: Gets an array containing the node&apos;s child nodes..
        /// </summary>
        internal static string Nodes_Text12 {
            get {
                return ResourceManager.GetString("Nodes_Text12", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;previous, next, previousSibling, nextSibling&lt;/b&gt;:
        ///        Get references to adjacent nodes on the tree, optionally excluding
        ///        collapsed or non-sibling nodes..
        /// </summary>
        internal static string Nodes_Text13 {
            get {
                return ResourceManager.GetString("Nodes_Text13", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;isChecked, isCollapsed, isDisabled:&lt;/b&gt; Get or set values that
        ///        change the state of the node..
        /// </summary>
        internal static string Nodes_Text14 {
            get {
                return ResourceManager.GetString("Nodes_Text14", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, click the button below to scan the &lt;i&gt;visible&lt;/i&gt;
        ///    nodes on the TreeView. Try expanding and collapsing some
        ///    nodes to see the difference when you click the button:.
        /// </summary>
        internal static string Nodes_Text15 {
            get {
                return ResourceManager.GetString("Nodes_Text15", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Scan Visible Nodes.
        /// </summary>
        internal static string Nodes_Text16 {
            get {
                return ResourceManager.GetString("Nodes_Text16", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Visible Nodes:.
        /// </summary>
        internal static string Nodes_Text17 {
            get {
                return ResourceManager.GetString("Nodes_Text17", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There are a few scenarios where you may need access to
        ///    properties of the &lt;b&gt;TreeNode&lt;/b&gt; objects that make up
        ///    the actual tree..
        /// </summary>
        internal static string Nodes_Text2 {
            get {
                return ResourceManager.GetString("Nodes_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can get the &lt;b&gt;TreeNode&lt;/b&gt; that corresponds to a given
        ///    data item by calling the TreeView&apos;s &lt;b&gt;getNode&lt;/b&gt; method,
        ///    or use the &lt;b&gt;nodes&lt;/b&gt; property to get the collection of
        ///    root nodes on the TreeView..
        /// </summary>
        internal static string Nodes_Text3 {
            get {
                return ResourceManager.GetString("Nodes_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Once you have a node, you can use its properties and methods
        ///    to inspect or modify the tree. These properties and methods
        ///    include:.
        /// </summary>
        internal static string Nodes_Text4 {
            get {
                return ResourceManager.GetString("Nodes_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;dataItem&lt;/b&gt;: Gets the item in the data source that is
        ///        bound to this node..
        /// </summary>
        internal static string Nodes_Text5 {
            get {
                return ResourceManager.GetString("Nodes_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;element&lt;/b&gt;: Gets the HTML element that represents this
        ///        node..
        /// </summary>
        internal static string Nodes_Text6 {
            get {
                return ResourceManager.GetString("Nodes_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;ensureVisible&lt;/b&gt;: Expands parent nodes and scrolls the
        ///        TreeView as needed to ensure the node is currently visible..
        /// </summary>
        internal static string Nodes_Text7 {
            get {
                return ResourceManager.GetString("Nodes_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;select&lt;/b&gt;: Selects the node and ensures it is visible..
        /// </summary>
        internal static string Nodes_Text8 {
            get {
                return ResourceManager.GetString("Nodes_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;parentNode&lt;/b&gt;: Gets a reference to the node&apos;s parent node..
        /// </summary>
        internal static string Nodes_Text9 {
            get {
                return ResourceManager.GetString("Nodes_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to TreeView Nodes.
        /// </summary>
        internal static string Nodes_Title {
            get {
                return ResourceManager.GetString("Nodes_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The TreeView&apos;s &lt;b&gt;lazyLoadFunction&lt;/b&gt; property allows you to
        ///    create nodes that are loaded only when the node is expanded..
        /// </summary>
        internal static string Reloading_Text1 {
            get {
                return ResourceManager.GetString("Reloading_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This can be used to improve performance in cases where data is
        ///    loaded asynchronously..
        /// </summary>
        internal static string Reloading_Text2 {
            get {
                return ResourceManager.GetString("Reloading_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, lazy nodes load their data only once, when the node
        ///    is expanded for the first time. This sample shows how you can
        ///    change that behavior for selected nodes causing them to re-load
        ///    their data whenever they are expanded. The sample does this by:.
        /// </summary>
        internal static string Reloading_Text3 {
            get {
                return ResourceManager.GetString("Reloading_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Clearing the node&apos;s lazy-loaded data when the node is
        ///        collapsed, and.
        /// </summary>
        internal static string Reloading_Text4 {
            get {
                return ResourceManager.GetString("Reloading_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Re-binding the tree to remove the old nodes..
        /// </summary>
        internal static string Reloading_Text5 {
            get {
                return ResourceManager.GetString("Reloading_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Re-loading Lazy-Loaded Nodes.
        /// </summary>
        internal static string Reloading_Title {
            get {
                return ResourceManager.GetString("Reloading_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To remove nodes from a &lt;b&gt;TreeView&lt;/b&gt; control, remove the data
        ///    item from the tree&apos;s &lt;b&gt;itemsSource&lt;/b&gt; array, then refresh the
        ///    tree by calling the &lt;b&gt;loadTree&lt;/b&gt; method:.
        /// </summary>
        internal static string Removing_Text1 {
            get {
                return ResourceManager.GetString("Removing_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Remove Selected Node.
        /// </summary>
        internal static string Removing_Text2 {
            get {
                return ResourceManager.GetString("Removing_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Removing Nodes.
        /// </summary>
        internal static string Removing_Title {
            get {
                return ResourceManager.GetString("Removing_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Some languages render content from the right to the left of the page
        ///    (Arabic and Hebrew are typical examples) . HTML accommodates this
        ///    with the &apos;dir&apos; attribute. Setting &apos;dir&apos; to &apos;rtl&apos; on any element
        ///    causes the element&apos;s content to flow from right to left..
        /// </summary>
        internal static string Rtl_Text1 {
            get {
                return ResourceManager.GetString("Rtl_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;TreeView&lt;/b&gt; supports this automatically. If the element hosting
        ///    the tree has the &apos;dir&apos; attribute set to &apos;rtl&apos;, the tree will render with
        ///    nodes extending from right to left. You don&apos;t have to set any properties
        ///    on the control..
        /// </summary>
        internal static string Rtl_Text2 {
            get {
                return ResourceManager.GetString("Rtl_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Note that the &apos;dir&apos; attribute value is inherited, so if you set it on the
        ///    body tag for example, the entire page will be rendered from right to left,
        ///    including the tree..
        /// </summary>
        internal static string Rtl_Text3 {
            get {
                return ResourceManager.GetString("Rtl_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Note also that CSS has a &apos;direction&apos; attribute that performs the same
        ///    function as the &apos;dir&apos; element attribute. The &apos;dir&apos; attribute is generally
        ///    considered more appropriate for several reasons, including the fact that
        ///    it can be used in CSS rules..
        /// </summary>
        internal static string Rtl_Text4 {
            get {
                return ResourceManager.GetString("Rtl_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Right to Left Layout.
        /// </summary>
        internal static string Rtl_Text5 {
            get {
                return ResourceManager.GetString("Rtl_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This is some regular content, followed by a &lt;b&gt;TreeView&lt;/b&gt;:.
        /// </summary>
        internal static string Rtl_Text6 {
            get {
                return ResourceManager.GetString("Rtl_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to RTL Support.
        /// </summary>
        internal static string Rtl_Title {
            get {
                return ResourceManager.GetString("Rtl_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Searching TreeViews is not trivial because of their hierarchical nature.
        ///    Nodes typically reflect a context defined by in part by their parent
        ///    nodes but also by additional content associated with the node..
        /// </summary>
        internal static string Searching_Text1 {
            get {
                return ResourceManager.GetString("Searching_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, if a user searched the TreeView below for &quot;Electronics&quot;,
        ///    you may or may not want to include the child nodes in the results.
        ///    Furthermore, if items contained detailed descriptions, you might want
        ///    to add keywords to help in the search. So if a user typed for example
        ///    &quot;beard&quot;, you would probably want the &quot;Trimmers/Shavers&quot; node to be
        ///    selected..
        /// </summary>
        internal static string Searching_Text2 {
            get {
                return ResourceManager.GetString("Searching_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The AutoComplete control provides a good way to implement a search
        ///    box to be used with the TreeView. In this sample, we build a flat
        ///    searchArray with the full node paths and keywords and use that as
        ///    an itemsSource for searching through the TreeView..
        /// </summary>
        internal static string Searching_Text3 {
            get {
                return ResourceManager.GetString("Searching_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In addition to the &apos;itemsSource&apos;and &apos;displayMemberPath&apos; properties,
        ///    we use the &apos;searchMemberPath&apos; property to specify the name of the
        ///    field that contains the keywords to include in the search.
        ///    For example, try typing &apos;collect&apos; or &apos;food&apos; in the search box:.
        /// </summary>
        internal static string Searching_Text4 {
            get {
                return ResourceManager.GetString("Searching_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Search:.
        /// </summary>
        internal static string Searching_Text5 {
            get {
                return ResourceManager.GetString("Searching_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Searching TreeViews.
        /// </summary>
        internal static string Searching_Title {
            get {
                return ResourceManager.GetString("Searching_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can customize the appearance of the TreeView using CSS..
        /// </summary>
        internal static string StylingCSS_Text1 {
            get {
                return ResourceManager.GetString("StylingCSS_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example changes the collapse/expand icons, uses different
        ///    font sizes depending on node level, and adds a vertical bar to
        ///    the left of the level one nodes..
        /// </summary>
        internal static string StylingCSS_Text2 {
            get {
                return ResourceManager.GetString("StylingCSS_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use Custom CSS.
        /// </summary>
        internal static string StylingCSS_Text3 {
            get {
                return ResourceManager.GetString("StylingCSS_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Styling and CSS.
        /// </summary>
        internal static string StylingCSS_Title {
            get {
                return ResourceManager.GetString("StylingCSS_Title", resourceCulture);
            }
        }
    }
}
