//------------------------------------------------------------------------------
// <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 Auto grid layout, as the name suggests, arranges the tiles in the tabular form automatically. An auto grid layout consists of groups which are rendered in the direction specified by the &lt;b&gt;orientation&lt;/b&gt; property. The property also defines the direction in which each group expands. You can also define the maximum number of rows or columns that each group can have in horizontal or vertical orientation respectively using &lt;b&gt;maxRowsOrCols&lt;/b&gt; property..
        /// </summary>
        internal static string AutoGridLayout_Text1 {
            get {
                return ResourceManager.GetString("AutoGridLayout_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For instance, when orientation is set to horizontal, tiles are added row-wise until the maximum row count is reached. Once that limit is reached, the layout starts expanding horizontally by adding new columns one after the other. There is no limit to the number of columns that can be added in the horizontal orientation..
        /// </summary>
        internal static string AutoGridLayout_Text2 {
            get {
                return ResourceManager.GetString("AutoGridLayout_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The auto grid layout also supports cell merging by spanning rows or columns through &lt;b&gt;rowSpan&lt;/b&gt; and &lt;b&gt;columnSpan&lt;/b&gt; properties of the tile  available in the designer..
        /// </summary>
        internal static string AutoGridLayout_Text3 {
            get {
                return ResourceManager.GetString("AutoGridLayout_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The layout automatically positions the tiles in the DashboardLayout control. Each cell in the table can contain multiple controls, and these controls can be grouped together with the help of the group object..
        /// </summary>
        internal static string AutoGridLayout_Text4 {
            get {
                return ResourceManager.GetString("AutoGridLayout_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Auto Grid Layout.
        /// </summary>
        internal static string AutoGridLayout_Title {
            get {
                return ResourceManager.GetString("AutoGridLayout_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 Cost Budgeting for {0}.
        /// </summary>
        internal static string CostBudget {
            get {
                return ResourceManager.GetString("CostBudget", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Countrywise Sales for {0}.
        /// </summary>
        internal static string Countrywise {
            get {
                return ResourceManager.GetString("Countrywise", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In some cases, you may want to add tabs to a TabPanel control programmatically rather than using HTML markup..
        /// </summary>
        internal static string CreatingProgrammatically_Text1 {
            get {
                return ResourceManager.GetString("CreatingProgrammatically_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can do this using the &lt;b&gt;tabs&lt;/b&gt; property, which provides access to the collection of tabs in the TabPanel..
        /// </summary>
        internal static string CreatingProgrammatically_Text2 {
            get {
                return ResourceManager.GetString("CreatingProgrammatically_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can also use the &lt;b&gt;tabs&lt;/b&gt; property to remove, modify, or reorder the tabs within the TabPanel..
        /// </summary>
        internal static string CreatingProgrammatically_Text3 {
            get {
                return ResourceManager.GetString("CreatingProgrammatically_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Creating TabPanels In Code.
        /// </summary>
        internal static string CreatingProgrammatically_Title {
            get {
                return ResourceManager.GetString("CreatingProgrammatically_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 Cancel.
        /// </summary>
        internal static string CustomTile_Cancel {
            get {
                return ResourceManager.GetString("CustomTile_Cancel", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ChartType.
        /// </summary>
        internal static string CustomTile_ChartType {
            get {
                return ResourceManager.GetString("CustomTile_ChartType", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to OK.
        /// </summary>
        internal static string CustomTile_OK {
            get {
                return ResourceManager.GetString("CustomTile_OK", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The tile could be customized in the DashboardLayout control. For a tile, there are three areas: Header, Toolbar and Content. All these areas can be customized via this event. The related dom elements or objects can be obtained in the event argument: headerElement, toolbar and contentElement. You can customize these areas by the &lt;b&gt;formatTile&lt;/b&gt; event..
        /// </summary>
        internal static string CustomTile_Text1 {
            get {
                return ResourceManager.GetString("CustomTile_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Tile.
        /// </summary>
        internal static string CustomTile_Title {
            get {
                return ResourceManager.GetString("CustomTile_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;DashboardLayout&lt;/b&gt; provides four types of layouts, namely Flow, AutoGrid, ManualGrid and Split. These layouts specify the arrangement of the tiles in different ways on the DashboardLayout control. Being able to choose layouts that fits screen requirements is the core feature of the control..
        /// </summary>
        internal static string DashboardLayouts_Text1 {
            get {
                return ResourceManager.GetString("DashboardLayouts_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Different layouts.
        /// </summary>
        internal static string DashboardLayouts_Title {
            get {
                return ResourceManager.GetString("DashboardLayouts_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;DashboardLayout&lt;/b&gt; is a layout control that allows you to create dynamic dashboards for interactive data visualization. It allows you to organize and present data in a consolidated form with the help of images, grids, charts, maps, etc in different layouts. This makes it easy for you to monitor the presented information..
        /// </summary>
        internal static string DashboardLayout_Text1 {
            get {
                return ResourceManager.GetString("DashboardLayout_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;DashboardLayout&lt;/b&gt; control acts as a container which lets you dynamically place controls within tiles also called child containers. These child containers can be arranged in four different types of layouts supported by the DashboardLayout control i.e. Flow, AutoGrid, ManualGrid and Split. The appropriate layout is attached to the DashboardLayout control to achieve the specific layout. The control lets you resize and rearrange these child containers at runtime to create an ideal workspace..
        /// </summary>
        internal static string DashboardLayout_Text2 {
            get {
                return ResourceManager.GetString("DashboardLayout_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Being able to choose layouts that fits screen requirements is the core feature of the control. Other built-in features include drag and drop, maximize and restore, and save and load layouts..
        /// </summary>
        internal static string DashboardLayout_Text3 {
            get {
                return ResourceManager.GetString("DashboardLayout_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to DashboardLayout Concepts.
        /// </summary>
        internal static string DashboardLayout_Title {
            get {
                return ResourceManager.GetString("DashboardLayout_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 Export.
        /// </summary>
        internal static string Export {
            get {
                return ResourceManager.GetString("Export", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When the flow layout is applied in the DashboardLayout control, it arranges child containers into either rows or columns, per the direction property. By default, the flow of items is wrapped at the control&apos;s edge, so when one column/row ends, another one automatically starts..
        /// </summary>
        internal static string FlowLayout_Text1 {
            get {
                return ResourceManager.GetString("FlowLayout_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Flow Layout.
        /// </summary>
        internal static string FlowLayout_Title {
            get {
                return ResourceManager.GetString("FlowLayout_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 KPIs for {0}.
        /// </summary>
        internal static string KPIs {
            get {
                return ResourceManager.GetString("KPIs", 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 Manual grid layout, as the name suggests, arranges the tiles in the tabular form in the specified manner. The layout is similar to auto grid layout except the fact that you can specify the row and column numbers where a particular tile should be positioned..
        /// </summary>
        internal static string ManualGridLayout_Text1 {
            get {
                return ResourceManager.GetString("ManualGridLayout_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Position of the tiles in the manual grid layout is specified using the Row and Column properties. Each cell in the manual grid layout can contain multiple controls, and these controls can be grouped together..
        /// </summary>
        internal static string ManualGridLayout_Text2 {
            get {
                return ResourceManager.GetString("ManualGridLayout_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Manual Grid Layout.
        /// </summary>
        internal static string ManualGridLayout_Title {
            get {
                return ResourceManager.GetString("ManualGridLayout_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 Sales Dashboard for {0}.
        /// </summary>
        internal static string SalesDashboard {
            get {
                return ResourceManager.GetString("SalesDashboard", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The DashboardLayout control provides a public API to save and load the layout to local storage in JSON format through the &lt;b&gt;saveLayout&lt;/b&gt; and &lt;b&gt;loadLayout&lt;/b&gt; methods. This feature is helpful if you need to save a particular layout and load, or to provide an option to users that may need to change layout and save it to load later..
        /// </summary>
        internal static string SaveLoadLayout_Text1 {
            get {
                return ResourceManager.GetString("SaveLoadLayout_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Save and Load Layout.
        /// </summary>
        internal static string SaveLoadLayout_Title {
            get {
                return ResourceManager.GetString("SaveLoadLayout_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 Settings.
        /// </summary>
        internal static string Settings {
            get {
                return ResourceManager.GetString("Settings", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Country.
        /// </summary>
        internal static string Share_Header1 {
            get {
                return ResourceManager.GetString("Share_Header1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Last 12 Months.
        /// </summary>
        internal static string Share_Header2 {
            get {
                return ResourceManager.GetString("Share_Header2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Current Year(mil.).
        /// </summary>
        internal static string Share_Header3 {
            get {
                return ResourceManager.GetString("Share_Header3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Status.
        /// </summary>
        internal static string Share_Header4 {
            get {
                return ResourceManager.GetString("Share_Header4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sales.
        /// </summary>
        internal static string Share_Text1 {
            get {
                return ResourceManager.GetString("Share_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Expenses.
        /// </summary>
        internal static string Share_Text2 {
            get {
                return ResourceManager.GetString("Share_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Profit.
        /// </summary>
        internal static string Share_Text3 {
            get {
                return ResourceManager.GetString("Share_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sales Trend Line.
        /// </summary>
        internal static string Share_Text4 {
            get {
                return ResourceManager.GetString("Share_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Budget.
        /// </summary>
        internal static string Share_Text5 {
            get {
                return ResourceManager.GetString("Share_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to in millions.
        /// </summary>
        internal static string Share_Text6 {
            get {
                return ResourceManager.GetString("Share_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Quarter Sales ({0}).
        /// </summary>
        internal static string SplitLayout_Text0 {
            get {
                return ResourceManager.GetString("SplitLayout_Text0", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The split layout is helpful when we want to add the tiles in different orientations for different groups. It enables the users to have nested groups where in each group can have a different orientation. The group can either consist of another or a tile. Each tile can render any MVC or HTML control. The order in which the groups are rendered is determined by the &lt;b&gt;orientation&lt;/b&gt; property. When the orientation is set to Horizontal, the groups or tiles are rendered horizontally and when the orientation is se [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string SplitLayout_Text1 {
            get {
                return ResourceManager.GetString("SplitLayout_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The split layout divides the dashboard into multiple section where in you can add multiple tiles to the layout..
        /// </summary>
        internal static string SplitLayout_Text2 {
            get {
                return ResourceManager.GetString("SplitLayout_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Split Layout.
        /// </summary>
        internal static string SplitLayout_Title {
            get {
                return ResourceManager.GetString("SplitLayout_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);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The TabPanel implements WAI-ARIA accessibility guidelines. All tab elements have the proper role attributes as well as all applicable ARIA attributes..
        /// </summary>
        internal static string TabPanelAccessibility_Text1 {
            get {
                return ResourceManager.GetString("TabPanelAccessibility_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The example below assigns unique IDs to the tab headers and panes, which the TabPanel automatically uses to generate &quot;aria-controls&quot; and &quot;aria-labelledby&quot; attributes..
        /// </summary>
        internal static string TabPanelAccessibility_Text2 {
            get {
                return ResourceManager.GetString("TabPanelAccessibility_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The example also adds a &quot;wj-state-active&quot; class to the &quot;America&quot; pane in markup to define the tab that is initially selected. Without that, the first tab would have been selected by default..
        /// </summary>
        internal static string TabPanelAccessibility_Text3 {
            get {
                return ResourceManager.GetString("TabPanelAccessibility_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Finally, the example shows the effect of the &lt;b&gt;autoSwitch&lt;/b&gt; property, which affects how the control handles the tab and cursor keys. For a detailed discussion of this topic, please see the &lt;a href=&quot;https://www.w3.org/TR/wai-aria-practices/#kbd_selection_follows_focus&quot; target=&quot;_blank&quot;&gt;W3C ARIA practices&lt;/a&gt; and &lt;a href=&quot;https://simplyaccessible.com/article/danger-aria-tabs/&quot; target=&quot;_blank&quot;&gt;SimplyAccessible articles.&lt;/a&gt;.
        /// </summary>
        internal static string TabPanelAccessibility_Text4 {
            get {
                return ResourceManager.GetString("TabPanelAccessibility_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to TabPanel Accessibility.
        /// </summary>
        internal static string TabPanelAccessibility_Title {
            get {
                return ResourceManager.GetString("TabPanelAccessibility_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The TabPanel has a built-in panel that shows the content of the selected tab. In some cases, you may want to display the content in a different element..
        /// </summary>
        internal static string TabPanelDetachedPanels_Text1 {
            get {
                return ResourceManager.GetString("TabPanelDetachedPanels_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To do that, hide the built-in content element and use the &lt;b&gt;OnClientSelectedIndexChanged&lt;/b&gt; event to update the content..
        /// </summary>
        internal static string TabPanelDetachedPanels_Text2 {
            get {
                return ResourceManager.GetString("TabPanelDetachedPanels_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Detached Panels.
        /// </summary>
        internal static string TabPanelDetachedPanels_Title {
            get {
                return ResourceManager.GetString("TabPanelDetachedPanels_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can disable or hide individual tabs using the Tab&apos;s &lt;b&gt;isDisabled&lt;/b&gt; and &lt;b&gt;isVisible&lt;/b&gt; properties..
        /// </summary>
        internal static string TabPanelDisabledInvisibleTabs_Text1 {
            get {
                return ResourceManager.GetString("TabPanelDisabledInvisibleTabs_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Invisible and disabled tabs cannot be selected by the user..
        /// </summary>
        internal static string TabPanelDisabledInvisibleTabs_Text2 {
            get {
                return ResourceManager.GetString("TabPanelDisabledInvisibleTabs_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Disabled and Invisible Tabs.
        /// </summary>
        internal static string TabPanelDisabledInvisibleTabs_Title {
            get {
                return ResourceManager.GetString("TabPanelDisabledInvisibleTabs_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to One of the main benefits of the TabPanel control is that it automatically updates any C1 controls it contains when a new tab is selected..
        /// </summary>
        internal static string TabPanelHostC1Controls_Text1 {
            get {
                return ResourceManager.GetString("TabPanelHostC1Controls_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When using other tab controls, you must add code to refresh any C1 controls contained in the tabs..
        /// </summary>
        internal static string TabPanelHostC1Controls_Text2 {
            get {
                return ResourceManager.GetString("TabPanelHostC1Controls_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Hosting C1 Controls.
        /// </summary>
        internal static string TabPanelHostC1Controls_Title {
            get {
                return ResourceManager.GetString("TabPanelHostC1Controls_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The markup used to initialize TabPanel controls consists of one element per tab, each with two children: the tab header and the tab content..
        /// </summary>
        internal static string TabPanelMarkup_Text1 {
            get {
                return ResourceManager.GetString("TabPanelMarkup_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to We suggest you use anchor elements (tag a) for the tab headers because they are semantically more meaningful than plain div elements..
        /// </summary>
        internal static string TabPanelMarkup_Text2 {
            get {
                return ResourceManager.GetString("TabPanelMarkup_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In this example, we added a &quot;wj-state-active&quot; class to the &quot;America&quot; pane markup. That defines the tab that is initially selected. Alternatively, we could have set the TabPanel&apos;s &lt;b&gt;selectedIndex&lt;/b&gt; property..
        /// </summary>
        internal static string TabPanelMarkup_Text3 {
            get {
                return ResourceManager.GetString("TabPanelMarkup_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to TabPanel Markup.
        /// </summary>
        internal static string TabPanelMarkup_Title {
            get {
                return ResourceManager.GetString("TabPanelMarkup_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 TabPanelRightToLeft_Text1 {
            get {
                return ResourceManager.GetString("TabPanelRightToLeft_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The TabPanel supports this automatically. If the element hosting the control has the &apos;dir&apos; attribute set to &apos;rtl&apos;, the panel will render with tabs aligned from right to left. You don&apos;t have to set any properties on the control..
        /// </summary>
        internal static string TabPanelRightToLeft_Text2 {
            get {
                return ResourceManager.GetString("TabPanelRightToLeft_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 TabPanel..
        /// </summary>
        internal static string TabPanelRightToLeft_Text3 {
            get {
                return ResourceManager.GetString("TabPanelRightToLeft_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 TabPanelRightToLeft_Text4 {
            get {
                return ResourceManager.GetString("TabPanelRightToLeft_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to TabPanel Right to Left.
        /// </summary>
        internal static string TabPanelRightToLeft_Title {
            get {
                return ResourceManager.GetString("TabPanelRightToLeft_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The TabPanel control has a simple layout, which makes it easy to style using CSS. For example, tabs appear above the content by default, but you can use CSS to change their position and show the below or vertically stacked, to the left or to the right of the content..
        /// </summary>
        internal static string TabPanelStyling_Text1 {
            get {
                return ResourceManager.GetString("TabPanelStyling_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can also choose whether or not to use animation when switching tabs..
        /// </summary>
        internal static string TabPanelStyling_Text2 {
            get {
                return ResourceManager.GetString("TabPanelStyling_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Styling and CSS.
        /// </summary>
        internal static string TabPanelStyling_Title {
            get {
                return ResourceManager.GetString("TabPanelStyling_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The TabPanel control enables content organization at a high level, such as switching between views, data sets, or functional aspects of an application..
        /// </summary>
        internal static string TabPanel_Text1 {
            get {
                return ResourceManager.GetString("TabPanel_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tabs are presented as a single row above their associated content. Tab headers succinctly describe the content within..
        /// </summary>
        internal static string TabPanel_Text2 {
            get {
                return ResourceManager.GetString("TabPanel_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tabs can be selected with the mouse or keyboard, and automatically update the content to reflect the current selection..
        /// </summary>
        internal static string TabPanel_Text3 {
            get {
                return ResourceManager.GetString("TabPanel_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Each tab consists of a header element (always visible) and a pane element that contains the tab content. The pane element is visible when the corresponding header is selected with the mouse or keyboard..
        /// </summary>
        internal static string TabPanel_Text4 {
            get {
                return ResourceManager.GetString("TabPanel_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to TabPanel Concepts.
        /// </summary>
        internal static string TabPanel_Title {
            get {
                return ResourceManager.GetString("TabPanel_Title", resourceCulture);
            }
        }
    }
}
