//------------------------------------------------------------------------------
// <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 MvcExplorer.Localization {
    using System;
    using System.Reflection;
    
    
    /// <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 your VS project.
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute()]
    [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()]
    public class TreeViewRes {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        internal TreeViewRes() {
        }
        
        /// <summary>
        ///    Returns the cached ResourceManager instance used by this class.
        /// </summary>
        [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)]
        public static global::System.Resources.ResourceManager ResourceManager {
            get {
                if (object.ReferenceEquals(resourceMan, null)) {
                    global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("MvcExplorer.Localization.TreeViewRes", typeof(TreeViewRes).GetTypeInfo().Assembly);
                    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)]
        public static global::System.Globalization.CultureInfo Culture {
            get {
                return resourceCulture;
            }
            set {
                resourceCulture = value;
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to This view shows how to make an Accordion control using TreeView control..
        /// </summary>
        public static string Accordion_Text0 {
            get {
                return ResourceManager.GetString("Accordion_Text0", resourceCulture);
            }
        }
        
        /// <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>
        public static string Accordion_Text1 {
            get {
                return ResourceManager.GetString("Accordion_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to You can use the TreeView control to implement accordions..
        /// </summary>
        public static string Accordion_Text2 {
            get {
                return ResourceManager.GetString("Accordion_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 &quot;&lt;b&gt;auto-collapse&lt;/b&gt;&quot; attribute is set to true (the default), so non-active panels are automatically collapsed..
        /// </summary>
        public static string Accordion_Text3 {
            get {
                return ResourceManager.GetString("Accordion_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to Checked Items:.
        /// </summary>
        public static string Checkboxes_Text0 {
            get {
                return ResourceManager.GetString("Checkboxes_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to This view shows how to show checkboxes in a TreeView control..
        /// </summary>
        public static string Checkboxes_Text1 {
            get {
                return ResourceManager.GetString("Checkboxes_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to Set the &quot;&lt;b&gt;show-checkboxes&lt;/b&gt;&quot; attribute to true and the TreeView will add checkboxes to each node..
        /// </summary>
        public static string Checkboxes_Text2 {
            get {
                return ResourceManager.GetString("Checkboxes_Text2", 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>
        public static string Checkboxes_Text3 {
            get {
                return ResourceManager.GetString("Checkboxes_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to When items are checked or unchecked, the &quot;&lt;b&gt;checked-items-changed&lt;/b&gt;&quot; event is raised, 
        ///        and the checkedItems property of the client TreeView object is updated with a list of the items that are currently checked..
        /// </summary>
        public static string Checkboxes_Text4 {
            get {
                return ResourceManager.GetString("Checkboxes_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to The checkboxes are only shown when TreeView works without lazy nodes.
        ///        That&apos;s to say, the &quot;&lt;b&gt;lazy-load-action-url&lt;/b&gt;&quot; attribute and the &quot;&lt;b&gt;lazy-load-function&lt;/b&gt;&quot; attribute are not set..
        /// </summary>
        public static string Checkboxes_Text5 {
            get {
                return ResourceManager.GetString("Checkboxes_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to This view shows how to customize the node content in a TreeView control..
        /// </summary>
        public static string CustomNodeContent_Text0 {
            get {
                return ResourceManager.GetString("CustomNodeContent_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to You can customize the content of the TreeView nodes using the formatItem event. The event handler parameters include the element that represents the node and the data item being rendered..
        /// </summary>
        public static string CustomNodeContent_Text1 {
            get {
                return ResourceManager.GetString("CustomNodeContent_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to The example uses the &quot;&lt;b&gt;format-item&lt;/b&gt;&quot; event to add a &quot;new&quot; badge to the right of new items on the tree..
        /// </summary>
        public static string CustomNodeContent_Text2 {
            get {
                return ResourceManager.GetString("CustomNodeContent_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to This view shows how to drag and drop the nodes in a TreeView control..
        /// </summary>
        public static string DragDrop_Text0 {
            get {
                return ResourceManager.GetString("DragDrop_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to Set the &quot;&lt;b&gt;allow-dragging&lt;/b&gt;&quot; attribute to true to allow users to drag nodes to new positions within the TreeView..
        /// </summary>
        public static string DragDrop_Text1 {
            get {
                return ResourceManager.GetString("DragDrop_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to  When dragging is allowed, users may drag any node to any position within the tree. You can customize this behavior by handling the TreeView drag/drop events:
        ///        &lt;ul class=&quot;normal&quot;&gt;
        ///            &lt;li&gt;&lt;b&gt;drag-start&lt;/b&gt;:&lt;/li&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 cancel parameter to true.
        ///            &lt;li&gt;&lt;b&gt;drag-over&lt;/b&gt;:&lt;/li&gt;
        ///            Occurs while the user drags the node over othe [rest of string was truncated]&quot;;.
        /// </summary>
        public static string DragDrop_Text2 {
            get {
                return ResourceManager.GetString("DragDrop_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to The example shows how to provide standard and customized drag/drop operations on a TreeView control..
        /// </summary>
        public static string DragDrop_Text3 {
            get {
                return ResourceManager.GetString("DragDrop_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to Allow dragging parent nodes.
        /// </summary>
        public static string DragDrop_Text4 {
            get {
                return ResourceManager.GetString("DragDrop_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to Allow dropping into empty nodes.
        /// </summary>
        public static string DragDrop_Text5 {
            get {
                return ResourceManager.GetString("DragDrop_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to This view shows how to edit the nodes in a TreeView control..
        /// </summary>
        public static string EditingNodes_Text0 {
            get {
                return ResourceManager.GetString("EditingNodes_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to The TreeView control provides editing support. Set the &quot;&lt;b&gt;is-read-only&lt;/b&gt;&quot; attribute to false and users will be able to edit the content of the nodes by pressing the F2 key..
        /// </summary>
        public static string EditingNodes_Text1 {
            get {
                return ResourceManager.GetString("EditingNodes_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to Edits made to node contents are automatically applied to the items in the &quot;&lt;b&gt;source&lt;/b&gt;&quot; attribute using the properties specified by the &quot;&lt;b&gt;display-member-path&lt;/b&gt;&quot; attribute..
        /// </summary>
        public static string EditingNodes_Text2 {
            get {
                return ResourceManager.GetString("EditingNodes_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to You may customize the editing behavior using the following events: &quot;&lt;b&gt;node-edit-starting&lt;/b&gt;&quot;, &quot;&lt;b&gt;node-edit-started&lt;/b&gt;&quot;, &quot;&lt;b&gt;node-edit-ending&lt;/b&gt;&quot;, and &quot;&lt;b&gt;node-edit-ended&lt;/b&gt;&quot;..
        /// </summary>
        public static string EditingNodes_Text3 {
            get {
                return ResourceManager.GetString("EditingNodes_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>
        public static string EditingNodes_Text4 {
            get {
                return ResourceManager.GetString("EditingNodes_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to This view shows how to add images to the nodes in a TreeView control..
        /// </summary>
        public static string Images_Text0 {
            get {
                return ResourceManager.GetString("Images_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to Use the &quot;&lt;b&gt;image-member-path&lt;/b&gt;&quot; attribute to add images to nodes by specifying the name of a property on the data items that contains an image URL..
        /// </summary>
        public static string Images_Text1 {
            get {
                return ResourceManager.GetString("Images_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to In this sample, the source contains the Image field, which value is an image url.
        ///        &quot;Image&quot; is set to the &quot;&lt;b&gt;image-member-path&lt;/b&gt;&quot; attribute..
        /// </summary>
        public static string Images_Text2 {
            get {
                return ResourceManager.GetString("Images_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to This view shows basic features of TreeView for ASP.NET MVC..
        /// </summary>
        public static string Index_Text0 {
            get {
                return ResourceManager.GetString("Index_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to The TreeView control displays a hierarchical list which may contain text, checkboxes, images, or arbitrary HTML content.
        ///        A TreeView is typically used to display the headings in a document,
        ///        the entries in an index, the files and directories on a disk,
        ///        or any other kind of information that might usefully be displayed as a hierarchy..
        /// </summary>
        public static string Index_Text1 {
            get {
                return ResourceManager.GetString("Index_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to  To create trees, you will normally have to set three attributes:
        ///        &lt;ul class=&quot;normal&quot;&gt;
        ///            &lt;li&gt;&lt;b&gt;source&lt;/b&gt;&lt;/li&gt;
        ///            It is an array that contains the hierarchical data. Each item in the array contains information about a node and (optionally) an array of child nodes.
        ///            &lt;li&gt;&lt;b&gt;display-member-path&lt;/b&gt;&lt;/li&gt;
        ///            It 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;h [rest of string was truncated]&quot;;.
        /// </summary>
        public static string Index_Text2 {
            get {
                return ResourceManager.GetString("Index_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to Set the &quot;&lt;b&gt;lazy-load-action-url&lt;/b&gt;&quot; attribute to a url where you can get the lazy nodes data..
        /// </summary>
        public static string LazyLoading_Li1 {
            get {
                return ResourceManager.GetString("LazyLoading_Li1", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to This view shows how to load the child nodes dynamically in TreeView..
        /// </summary>
        public static string LazyLoading_Text0 {
            get {
                return ResourceManager.GetString("LazyLoading_Text0", 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>
        public static string LazyLoading_Text1 {
            get {
                return ResourceManager.GetString("LazyLoading_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to The TreeView control makes lazy-loading super easy. Only one step is required:.
        /// </summary>
        public static string LazyLoading_Text2 {
            get {
                return ResourceManager.GetString("LazyLoading_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to If you wants to use lazy-loading with javascript, you can set the TreeView&apos;s &lt;b&gt;lazy-load-function&lt;/b&gt; attribute 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>
        public static string LazyLoading_Text3 {
            get {
                return ResourceManager.GetString("LazyLoading_Text3", 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;lazy-load-function&lt;/b&gt; is invoked. The function
        ///        uses a setTimeout to simulate an http delay and returns data for three child nodes,
        ///        one of which is also a lazy-loaded node..
        /// </summary>
        public static string LazyLoading_Text4 {
            get {
                return ResourceManager.GetString("LazyLoading_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to The example also uses some CSS to animate the node icons while they are being
        ///        loaded..
        /// </summary>
        public static string LazyLoading_Text5 {
            get {
                return ResourceManager.GetString("LazyLoading_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to If the child node has children, you can set an empty array to the field which name is what the &quot;&lt;b&gt;child-items-path&lt;/b&gt;&quot; attribute stands for.
        ///        Otherwise, let it to be null..
        /// </summary>
        public static string LazyLoading_Text6 {
            get {
                return ResourceManager.GetString("LazyLoading_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to Navigating to &lt;b&gt;*** {0} ***&lt;/b&gt;.
        /// </summary>
        public static string Navigation_NavigatingInfo {
            get {
                return ResourceManager.GetString("Navigation_NavigatingInfo", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to This view shows how to do navigation in TreeView for ASP.NET MVC..
        /// </summary>
        public static string Navigation_Text0 {
            get {
                return ResourceManager.GetString("Navigation_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to The simplest and most common use for the TreeView control is navigation. The TreeView&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>
        public static string Navigation_Text1 {
            get {
                return ResourceManager.GetString("Navigation_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to You can use the &lt;b&gt;selected-item-changed&lt;/b&gt; or &lt;b&gt;item-clicked&lt;/b&gt; events for navigation. The difference is that &lt;b&gt;selected-item-changed&lt;/b&gt; occurs when the user moves the selection with the keyboard, and &lt;b&gt;item-clicked&lt;/b&gt; occurs when the user clicks an item or presses the Enter key..
        /// </summary>
        public static string Navigation_Text2 {
            get {
                return ResourceManager.GetString("Navigation_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to This example uses the &lt;b&gt;item-clicked&lt;/b&gt; event..
        /// </summary>
        public static string Navigation_Text3 {
            get {
                return ResourceManager.GetString("Navigation_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to This view shows how to load the node items from a remote url in TreeView for ASP.NET MVC..
        /// </summary>
        public static string RemoteLoading_Text0 {
            get {
                return ResourceManager.GetString("RemoteLoading_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to You can load the node items from a remote url using the &quot;&lt;b&gt;load-action-url&lt;/b&gt;&quot; attribute..
        /// </summary>
        public static string RemoteLoading_Text1 {
            get {
                return ResourceManager.GetString("RemoteLoading_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to This view shows how to customize the appearance of TreeView for ASP.NET MVC using CSS..
        /// </summary>
        public static string Styling_Text0 {
            get {
                return ResourceManager.GetString("Styling_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///    Looks up a localized string similar to You can customize the appearance of the TreeView using CSS..
        /// </summary>
        public static string Styling_Text1 {
            get {
                return ResourceManager.GetString("Styling_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>
        public static string Styling_Text2 {
            get {
                return ResourceManager.GetString("Styling_Text2", resourceCulture);
            }
        }
    }
}
