//------------------------------------------------------------------------------
// <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 C1FlexGrid {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal C1FlexGrid() {
        }
        
        /// <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.C1FlexGrid", 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 To show aggregates above the data, follow these steps:.
        /// </summary>
        internal static string AggregatesAboveData_Text1 {
            get {
                return ResourceManager.GetString("AggregatesAboveData_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set the &lt;b&gt;aggregate&lt;/b&gt; property on the columns that you want to aggregate..
        /// </summary>
        internal static string AggregatesAboveData_Text2 {
            get {
                return ResourceManager.GetString("AggregatesAboveData_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Create a single &lt;b&gt;GroupDescription&lt;/b&gt; based on a dummy property..
        /// </summary>
        internal static string AggregatesAboveData_Text3 {
            get {
                return ResourceManager.GetString("AggregatesAboveData_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Optionally, freeze the top row to keep the aggregates in view..
        /// </summary>
        internal static string AggregatesAboveData_Text4 {
            get {
                return ResourceManager.GetString("AggregatesAboveData_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Aggregates Above the Data.
        /// </summary>
        internal static string AggregatesAboveData_Title {
            get {
                return ResourceManager.GetString("AggregatesAboveData_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To show aggregates below the data, set the &lt;b&gt;aggregate&lt;/b&gt;
        ///    property on the columns that you want to aggregate, and
        ///    add a &lt;b&gt;GroupRow&lt;/b&gt; to the grid&apos;s &lt;b&gt;columnFooter&lt;/b&gt;
        ///    panel..
        /// </summary>
        internal static string AggregatesBelowData_Text1 {
            get {
                return ResourceManager.GetString("AggregatesBelowData_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Aggregates Below the Data.
        /// </summary>
        internal static string AggregatesBelowData_Title {
            get {
                return ResourceManager.GetString("AggregatesBelowData_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid columns have an &lt;b&gt;aggregate&lt;/b&gt; property that
        ///    allows you to show data summaries for the whole grid or
        ///    for each group..
        /// </summary>
        internal static string AggregatesCustom_Text1 {
            get {
                return ResourceManager.GetString("AggregatesCustom_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to However, in some cases, the &lt;b&gt;aggregate&lt;/b&gt; property is
        ///    not flexible enough. So, you may need to calculate
        ///    aggregates using custom code..
        /// </summary>
        internal static string AggregatesCustom_Text2 {
            get {
                return ResourceManager.GetString("AggregatesCustom_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below includes a &apos;Profit&apos; column that shows
        ///    the difference between &apos;Sales&apos; and &apos;Expenses&apos;..
        /// </summary>
        internal static string AggregatesCustom_Text3 {
            get {
                return ResourceManager.GetString("AggregatesCustom_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;Profit&apos; column is calculated in the &lt;b&gt;formatItem&lt;/b&gt;
        ///    event. The profit for regular data items is based on
        ///    the actual data items. The profit for groups is calculated
        ///    using the group&apos;s &lt;b&gt;getAggregate&lt;/b&gt; method..
        /// </summary>
        internal static string AggregatesCustom_Text4 {
            get {
                return ResourceManager.GetString("AggregatesCustom_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Aggregates.
        /// </summary>
        internal static string AggregatesCustom_Title {
            get {
                return ResourceManager.GetString("AggregatesCustom_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Although FlexGrid provides efficient, Excel-style
        ///    editing by default, you may want to customize the
        ///    editing behavior in some cases..
        /// </summary>
        internal static string AlwaysEditing_Text1 {
            get {
                return ResourceManager.GetString("AlwaysEditing_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The simplest customization is to keep the grid
        ///    always in edit mode. This does not save any 
        ///    effort of the user, because anyways, FlexGrid allows
        ///    editing cells by typing at any time. But, it does 
        ///    show users that the grid is editable..
        /// </summary>
        internal static string AlwaysEditing_Text2 {
            get {
                return ResourceManager.GetString("AlwaysEditing_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The easiest way to keep the grid in edit mode at
        ///    all times is to call the &lt;b&gt;startEditing&lt;/b&gt;
        ///    method when the grid gets the focus and when the
        ///    selection changes..
        /// </summary>
        internal static string AlwaysEditing_Text3 {
            get {
                return ResourceManager.GetString("AlwaysEditing_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Editing.
        /// </summary>
        internal static string AlwaysEditing_Title {
            get {
                return ResourceManager.GetString("AlwaysEditing_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid displays data in a tabular form and allows
        ///    users to edit it or modify the views by sorting,
        ///    filtering, and grouping it..
        /// </summary>
        internal static string Architecture_Text1 {
            get {
                return ResourceManager.GetString("Architecture_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Like all other CMVC controls, the grid delegates all
        ///    data-related tasks to the
        ///    &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/webframe.html#wijmo.collections.CollectionView.Class.html&quot; target=&quot;_blank&quot;&gt;CollectionView&lt;/a&gt;
        ///    class..
        /// </summary>
        internal static string Architecture_Text2 {
            get {
                return ResourceManager.GetString("Architecture_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When you set the &lt;b&gt;itemsSource&lt;/b&gt; property of grid to an array,
        ///    or
        ///    &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/webframe.html#wijmo.collections.ObservableArray.Class.html&quot; target=&quot;_blank&quot;&gt;ObservableArray&lt;/a&gt;,
        ///    the grid automatically creates a CollectionView instance
        ///    to wrap the original array. This CollectionView can be 
        ///    accessed through the &lt;b&gt;collectionView&lt;/b&gt; property..
        /// </summary>
        internal static string Architecture_Text3 {
            get {
                return ResourceManager.GetString("Architecture_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the grids below are bound to the same data array.
        ///    Each one has its own internal CollectionView, so they can be sorted,
        ///    filtered, and grouped independently. The current item
        ///    (associated with the grid selection) is also independent:.
        /// </summary>
        internal static string Architecture_Text4 {
            get {
                return ResourceManager.GetString("Architecture_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By contrast, the two grids below are bound to the same CollectionView.
        ///    Because of this, they show the same view. Sorting, filtering, or
        ///    selecting on one grid affects the other..
        /// </summary>
        internal static string Architecture_Text5 {
            get {
                return ResourceManager.GetString("Architecture_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Observe how sorting, filtering, and selection applied
        ///    to the common view is also reflected on other
        ///    controls such as &lt;b&gt;ListBox&lt;/b&gt;:.
        /// </summary>
        internal static string Architecture_Text6 {
            get {
                return ResourceManager.GetString("Architecture_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid Architecture.
        /// </summary>
        internal static string Architecture_Title {
            get {
                return ResourceManager.GetString("Architecture_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This grid automatically resizes columns to fit their content.
        ///    It does this by calling the &lt;b&gt;autoSizeColumns&lt;/b&gt; method
        ///    in response to events that affect the content size..
        /// </summary>
        internal static string AutoColumnWidths_Text1 {
            get {
                return ResourceManager.GetString("AutoColumnWidths_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Auto-Size Columns.
        /// </summary>
        internal static string AutoColumnWidths_Title {
            get {
                return ResourceManager.GetString("AutoColumnWidths_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This grid automatically resizes rows to fit their content.
        ///    It does this by calling the &lt;b&gt;autoSizeRows&lt;/b&gt; method
        ///    in response to events that affect the content size..
        /// </summary>
        internal static string AutoRowHeights_Text1 {
            get {
                return ResourceManager.GetString("AutoRowHeights_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Auto-Size Rows.
        /// </summary>
        internal static string AutoRowHeights_Title {
            get {
                return ResourceManager.GetString("AutoRowHeights_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In most scenarios, the FlexGrid shows data that is loaded from a
        ///    server or generated in code. This data is represented as an
        ///    array of objects, and the grid is bound to this array via
        ///    its &lt;b&gt;itemsSource&lt;/b&gt; property..
        /// </summary>
        internal static string Binding_Text1 {
            get {
                return ResourceManager.GetString("Binding_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, when you set the &lt;b&gt;itemsSource&lt;/b&gt; property
        ///    the grid will scan the data objects and automatically
        ///    generate columns for each property in the data items.
        ///    For example:.
        /// </summary>
        internal static string Binding_Text2 {
            get {
                return ResourceManager.GetString("Binding_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Auto-generating columns works well for simple data sources
        ///    or while testing/developing applications. But in most scenarios,
        ///    you will want to turn off the automatic column generation and
        ///    specify the columns in code. This way you get complete control
        ///    over which columns are displayed, in what order, their widths,
        ///    format, headers, etc..
        /// </summary>
        internal static string Binding_Text3 {
            get {
                return ResourceManager.GetString("Binding_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Each column has a &lt;b&gt;binding&lt;/b&gt; property that determines which
        ///    property of the data item that should be displayed in the cell.
        ///    For example:.
        /// </summary>
        internal static string Binding_Text4 {
            get {
                return ResourceManager.GetString("Binding_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Binding.
        /// </summary>
        internal static string Binding_Title {
            get {
                return ResourceManager.GetString("Binding_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid supports content-driven cell merging..
        /// </summary>
        internal static string CellMerging_Text1 {
            get {
                return ResourceManager.GetString("CellMerging_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To enable cell merging, set the &lt;b&gt;allowMerging&lt;/b&gt; property to
        ///    indicate what part or parts of the grid you want to merge, and
        ///    set the &lt;b&gt;allowMerging&lt;/b&gt; property on specific rows and
        ///    columns to true. Once you do that, the grid will merges cells
        ///    that have the same content, grouping the data visually..
        /// </summary>
        internal static string CellMerging_Text2 {
            get {
                return ResourceManager.GetString("CellMerging_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In the example below, the &lt;b&gt;allowMerging&lt;/b&gt; property is set to
        ///    true on the &quot;Country&quot; and &quot;Active&quot; columns..
        /// </summary>
        internal static string CellMerging_Text3 {
            get {
                return ResourceManager.GetString("CellMerging_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Try sorting the grid to see how that affects merging..
        /// </summary>
        internal static string CellMerging_Text4 {
            get {
                return ResourceManager.GetString("CellMerging_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Notice how cells with the same content are merged down
        ///    the columns, regardless of the content of other cells.
        ///    You can customize this behavior using the &lt;b&gt;mergeManager&lt;/b&gt;
        ///    property..
        /// </summary>
        internal static string CellMerging_Text5 {
            get {
                return ResourceManager.GetString("CellMerging_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cell Merging.
        /// </summary>
        internal static string CellMerging_Title {
            get {
                return ResourceManager.GetString("CellMerging_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexGrid module defines &lt;b&gt;Row&lt;/b&gt; and &lt;b&gt;Column&lt;/b&gt;
        ///    classes, but no &lt;b&gt;Cell&lt;/b&gt; class. That is because cells
        ///    are just DOM elements created to represent the intersection
        ///    of a &lt;b&gt;Row&lt;/b&gt; and a &lt;b&gt;Column&lt;/b&gt;..
        /// </summary>
        internal static string Cells_Text1 {
            get {
                return ResourceManager.GetString("Cells_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When rendering, FlexGrid scans the rows and columns in
        ///    the &lt;b&gt;viewRange&lt;/b&gt; and generates a cell element for
        ///    each combination. Cell elements are created based on a
        ///    &lt;b&gt;dataItem&lt;/b&gt; provided by the row and a &lt;b&gt;binding&lt;/b&gt;
        ///    provided by the column (along with some other properties)..
        /// </summary>
        internal static string Cells_Text2 {
            get {
                return ResourceManager.GetString("Cells_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In some situations, you may want to customize the cell
        ///    element based on the data (dynamic formatting), to create
        ///    custom cell elements (templating), or not to use bindings
        ///    at all (calculated columns, unbound grids)..
        /// </summary>
        internal static string Cells_Text3 {
            get {
                return ResourceManager.GetString("Cells_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In these cases, use the &lt;b&gt;formatItem&lt;/b&gt; event to create or
        ///    modify the cell elements. For example, the
        ///    grid below shows sales below 1,000 in red and sales
        ///    over 5,000 in green:.
        /// </summary>
        internal static string Cells_Text4 {
            get {
                return ResourceManager.GetString("Cells_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In most of the cases, you modify the data directly in the
        ///    binding source object, and let the grid show the results.
        ///    But in a few cases, you may want to get or set the
        ///    data through the grid instead..
        /// </summary>
        internal static string Cells_Text5 {
            get {
                return ResourceManager.GetString("Cells_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can do this using the &lt;b&gt;getCellData&lt;/b&gt; and
        ///    &lt;b&gt;setCellData&lt;/b&gt; methods in the &lt;b&gt;GridPanel&lt;/b&gt;
        ///    class. These methods offer options for getting raw
        ///    or formatted data, coercing data types when setting
        ///    data, and getting or setting data on unbound grids..
        /// </summary>
        internal static string Cells_Text6 {
            get {
                return ResourceManager.GetString("Cells_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Get the data for the currently selected cell.
        /// </summary>
        internal static string Cells_Text7 {
            get {
                return ResourceManager.GetString("Cells_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cells.
        /// </summary>
        internal static string Cells_Title {
            get {
                return ResourceManager.GetString("Cells_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The formatItem event.
        /// </summary>
        internal static string Cells_Title1 {
            get {
                return ResourceManager.GetString("Cells_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Getting and setting cell data.
        /// </summary>
        internal static string Cells_Title2 {
            get {
                return ResourceManager.GetString("Cells_Title2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexGrid control has built-in clipboard support..
        /// </summary>
        internal static string Clipboard_Text1 {
            get {
                return ResourceManager.GetString("Clipboard_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, pressing the Ctrl+C or Ctrl+Insert keys
        ///    copies the current selection to the clipboard.
        ///    Pressing Ctrl+V or Shift+Insert pastes the clipboard
        ///    content into the grid..
        /// </summary>
        internal static string Clipboard_Text2 {
            get {
                return ResourceManager.GetString("Clipboard_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can disable the automatic clipboard feature by setting
        ///    the &lt;b&gt;autoClipboard&lt;/b&gt; property to false..
        /// </summary>
        internal static string Clipboard_Text3 {
            get {
                return ResourceManager.GetString("Clipboard_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can customize the clipboard actions using the
        ///    &lt;b&gt;copying&lt;/b&gt;, &lt;b&gt;copied&lt;/b&gt;, &lt;b&gt;pasting&lt;/b&gt;, &lt;b&gt;pasted&lt;/b&gt;,
        ///    &lt;b&gt;pastingCell&lt;/b&gt;, and &lt;b&gt;pastedCell&lt;/b&gt; events..
        /// </summary>
        internal static string Clipboard_Text4 {
            get {
                return ResourceManager.GetString("Clipboard_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, when you copy a range from the grid below, it will
        ///    add the column headers to the clipboard content..
        /// </summary>
        internal static string Clipboard_Text5 {
            get {
                return ResourceManager.GetString("Clipboard_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Note that the FlexGrid implements an Excel-style &apos;smart pasting&apos;
        ///    feature that replicates the clipboard data when pasting.
        ///    For example, if you select a single cell and press Ctrl+C to
        ///    copy it to the clipboard, then extend the selection and press
        ///    Ctrl+V to paste, the cell will be pasted over the entire
        ///    selection..
        /// </summary>
        internal static string Clipboard_Text6 {
            get {
                return ResourceManager.GetString("Clipboard_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Clipboard Support.
        /// </summary>
        internal static string Clipboard_Title {
            get {
                return ResourceManager.GetString("Clipboard_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Behaviors.
        /// </summary>
        internal static string Clipboard_Title1 {
            get {
                return ResourceManager.GetString("Clipboard_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Smart Pasting.
        /// </summary>
        internal static string Clipboard_Title2 {
            get {
                return ResourceManager.GetString("Clipboard_Title2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid works with the &lt;b&gt;CollectionView&lt;/b&gt; class to
        ///    provide item and collection-level validation..
        /// </summary>
        internal static string CollectionViewValidation_Text1 {
            get {
                return ResourceManager.GetString("CollectionViewValidation_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To use this feature, set &lt;b&gt;getError&lt;/b&gt; to a function that
        ///    takes two parameters containing the data item being validated
        ///    and the property to validate, and returns a string describing
        ///    the error condition (or null if there are no errors)..
        /// </summary>
        internal static string CollectionViewValidation_Text2 {
            get {
                return ResourceManager.GetString("CollectionViewValidation_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below has a data source that implements a &lt;b&gt;getError&lt;/b&gt;
        ///    function that ensures the &apos;Sales&apos; and &apos;Expenses&apos; properties of the
        ///    items contain positive values. To see how validation works,
        ///    try entering negative values in either column:.
        /// </summary>
        internal static string CollectionViewValidation_Text3 {
            get {
                return ResourceManager.GetString("CollectionViewValidation_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid has two properties that allow you to customize its
        ///    validation behavior:.
        /// </summary>
        internal static string CollectionViewValidation_Text4 {
            get {
                return ResourceManager.GetString("CollectionViewValidation_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;showErrors:&lt;/b&gt;
        ///        Whether the grid should add the &apos;wj-state-invalid&apos; class
        ///        to cells that contain validation errors, and tooltips
        ///        with error descriptions..
        /// </summary>
        internal static string CollectionViewValidation_Text5 {
            get {
                return ResourceManager.GetString("CollectionViewValidation_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;validateEdits:&lt;/b&gt;
        ///        Whether the grid should remain in edit mode when the user
        ///        tries to commit edits that fail validation.
        /// </summary>
        internal static string CollectionViewValidation_Text6 {
            get {
                return ResourceManager.GetString("CollectionViewValidation_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to CollectionView Validation.
        /// </summary>
        internal static string CollectionViewValidation_Title {
            get {
                return ResourceManager.GetString("CollectionViewValidation_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When you set the grid&apos;s &lt;b&gt;itemsSource&lt;/b&gt; property to a
        ///    regular JavaScript array, it automatically creates an
        ///    internal &lt;b&gt;CollectionView&lt;/b&gt; and uses that as a
        ///    data source so that it can provide sorting and editing features
        ///    without forcing you to create a &lt;b&gt;CollectionView&lt;/b&gt; yourself..
        /// </summary>
        internal static string CollectionView_Text1 {
            get {
                return ResourceManager.GetString("CollectionView_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This internal view is exposed by the grid&apos;s
        ///    &lt;b&gt;collectionView&lt;/b&gt; property, and you can use it
        ///    in case you need the extra functionality yourself..
        /// </summary>
        internal static string CollectionView_Text2 {
            get {
                return ResourceManager.GetString("CollectionView_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the grid below is bound to a regular array,
        ///    and the grid&apos;s &lt;b&gt;collectionView&lt;/b&gt; property is used
        ///    to show the currently selected item:.
        /// </summary>
        internal static string CollectionView_Text3 {
            get {
                return ResourceManager.GetString("CollectionView_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Arrays and CollectionViews.
        /// </summary>
        internal static string CollectionView_Title {
            get {
                return ResourceManager.GetString("CollectionView_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid columns have an &lt;b&gt;aggregate&lt;/b&gt; property that
        ///    allows you to show data summaries for the whole grid or
        ///    for each group..
        /// </summary>
        internal static string ColumnsAggregates_Text1 {
            get {
                return ResourceManager.GetString("ColumnsAggregates_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To show group aggregates, set the &lt;b&gt;aggregate&lt;/b&gt; property
        ///    on the columns that you want to aggregate, and create groups
        ///    by dragging the column headers into the group panel above
        ///    the grid..
        /// </summary>
        internal static string ColumnsAggregates_Text2 {
            get {
                return ResourceManager.GetString("ColumnsAggregates_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Notice how the group rows contain the sum of the &apos;Sales&apos; and
        ///    &apos;Expenses&apos; columns for each group. The aggregates are
        ///    updated automatically when you edit the data..
        /// </summary>
        internal static string ColumnsAggregates_Text3 {
            get {
                return ResourceManager.GetString("ColumnsAggregates_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Drag columns here to create groups.
        /// </summary>
        internal static string ColumnsAggregates_Text4 {
            get {
                return ResourceManager.GetString("ColumnsAggregates_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Aggregates.
        /// </summary>
        internal static string ColumnsAggregates_Title {
            get {
                return ResourceManager.GetString("ColumnsAggregates_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid has &lt;b&gt;autoSizeColumns&lt;/b&gt; and &lt;b&gt;autoSizeRows&lt;/b&gt;
        ///    methods to automatically size rows and columns to fit their content..
        /// </summary>
        internal static string ColumnsAutoSizing_Text1 {
            get {
                return ResourceManager.GetString("ColumnsAutoSizing_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The auto-size methods take special styles and formats
        ///    applied to the cells into account..
        /// </summary>
        internal static string ColumnsAutoSizing_Text2 {
            get {
                return ResourceManager.GetString("ColumnsAutoSizing_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, click this button to size the columns of the
        ///    grid below to fit their content..
        /// </summary>
        internal static string ColumnsAutoSizing_Text3 {
            get {
                return ResourceManager.GetString("ColumnsAutoSizing_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to autoSizeColumns.
        /// </summary>
        internal static string ColumnsAutoSizing_Text4 {
            get {
                return ResourceManager.GetString("ColumnsAutoSizing_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Automatically resizing rows and columns is one of the
        ///        most time-consuming grid operations. If your grid has
        ///        more than a few hundred rows, avoid auto-sizing and
        ///        consider setting the column sizes to explicit numeric
        ///        values instead..
        /// </summary>
        internal static string ColumnsAutoSizing_Text5 {
            get {
                return ResourceManager.GetString("ColumnsAutoSizing_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Auto-Sizing.
        /// </summary>
        internal static string ColumnsAutoSizing_Title {
            get {
                return ResourceManager.GetString("ColumnsAutoSizing_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, FlexGrid allows users to resize and reorder
        ///    columns..
        /// </summary>
        internal static string ColumnsColumnLayout_Text1 {
            get {
                return ResourceManager.GetString("ColumnsColumnLayout_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to It is easy to extend this and allow users to select columns as well.
        ///    For example, you can use the &lt;b&gt;MultiSelect&lt;/b&gt; control below
        ///    to select the columns to be displayed on the grid:.
        /// </summary>
        internal static string ColumnsColumnLayout_Text2 {
            get {
                return ResourceManager.GetString("ColumnsColumnLayout_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can use the grid&apos;s &lt;b&gt;columnLayout&lt;/b&gt; property to allow users
        ///    to save and restore column layouts. Click the buttons below
        ///    to see how this works..
        /// </summary>
        internal static string ColumnsColumnLayout_Text3 {
            get {
                return ResourceManager.GetString("ColumnsColumnLayout_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Save Layout.
        /// </summary>
        internal static string ColumnsColumnLayout_Text4 {
            get {
                return ResourceManager.GetString("ColumnsColumnLayout_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Restore Layout.
        /// </summary>
        internal static string ColumnsColumnLayout_Text5 {
            get {
                return ResourceManager.GetString("ColumnsColumnLayout_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Persisting Layout.
        /// </summary>
        internal static string ColumnsColumnLayout_Title {
            get {
                return ResourceManager.GetString("ColumnsColumnLayout_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid provides a powerful infrastructure for binding cells
        ///    to data and formatting the cells using CSS..
        /// </summary>
        internal static string ColumnsCustomCells_Text1 {
            get {
                return ResourceManager.GetString("ColumnsCustomCells_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to But in some cases that may not be enough. In those situations,
        ///    use the &lt;b&gt;formatItem&lt;/b&gt; event to customize the style or
        ///    the content present in each cell..
        /// </summary>
        internal static string ColumnsCustomCells_Text2 {
            get {
                return ResourceManager.GetString("ColumnsCustomCells_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below uses &lt;b&gt;formatItem&lt;/b&gt; to format cells
        ///    with star ratings and sparklines..
        /// </summary>
        internal static string ColumnsCustomCells_Text3 {
            get {
                return ResourceManager.GetString("ColumnsCustomCells_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Cell Content.
        /// </summary>
        internal static string ColumnsCustomCells_Title {
            get {
                return ResourceManager.GetString("ColumnsCustomCells_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In many situations, you may want columns to map values so
        ///    that cells display a value that is different from what is
        ///    actually stored in the grid..
        /// </summary>
        internal static string ColumnsDataMaps_Text1 {
            get {
                return ResourceManager.GetString("ColumnsDataMaps_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, you may have a &apos;rating&apos; column with values
        ///    ranging from one to three, and you would like to display
        ///    the strings &apos;Low&apos;, &apos;Medium&apos;, or &apos;High&apos; instead..
        /// </summary>
        internal static string ColumnsDataMaps_Text2 {
            get {
                return ResourceManager.GetString("ColumnsDataMaps_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Or maybe you have a &apos;customer&apos; column that contains the
        ///    customer ID, and you would like to display the customer
        ///    name instead..
        /// </summary>
        internal static string ColumnsDataMaps_Text3 {
            get {
                return ResourceManager.GetString("ColumnsDataMaps_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You could accomplish such tasks using the &lt;b&gt;formatItem&lt;/b&gt;
        ///    event, but &lt;b&gt;FlexGrid&lt;/b&gt; provides a better alternative:
        ///    &lt;b&gt;DataMaps&lt;/b&gt;. If you set a column&apos;s &lt;b&gt;dataMap&lt;/b&gt; property
        ///    to an instance of a &lt;b&gt;DataMap&lt;/b&gt;, the grid will use it to:.
        /// </summary>
        internal static string ColumnsDataMaps_Text4 {
            get {
                return ResourceManager.GetString("ColumnsDataMaps_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Look up display values for each data item, and.
        /// </summary>
        internal static string ColumnsDataMaps_Text5 {
            get {
                return ResourceManager.GetString("ColumnsDataMaps_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Provide a drop-down list with valid items when editing
        ///        the cells..
        /// </summary>
        internal static string ColumnsDataMaps_Text6 {
            get {
                return ResourceManager.GetString("ColumnsDataMaps_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the grid below has a &apos;Customer&apos; column with a
        ///    &lt;b&gt;DataMap&lt;/b&gt; that associates customer names and IDs.
        ///    The data source contains customer IDs, but the grid shows
        ///    their names instead, and provides a drop-down list for
        ///    selecting the customer for each item..
        /// </summary>
        internal static string ColumnsDataMaps_Text7 {
            get {
                return ResourceManager.GetString("ColumnsDataMaps_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid also assigns a &lt;b&gt;dataMap&lt;/b&gt; to the &apos;Country&apos;
        ///    column. In this case, the map is just a string array
        ///    with the country names. There is no real mapping, but
        ///    you still get the drop-down list to pick from. Users
        ///    will not be able to enter any countries that are not
        ///    on the list..
        /// </summary>
        internal static string ColumnsDataMaps_Text8 {
            get {
                return ResourceManager.GetString("ColumnsDataMaps_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to And here is another grid showing all the customers.
        ///    If you edit their names, you will see the change in the
        ///    top grid:.
        /// </summary>
        internal static string ColumnsDataMaps_Text9 {
            get {
                return ResourceManager.GetString("ColumnsDataMaps_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to DataMaps.
        /// </summary>
        internal static string ColumnsDataMaps_Title {
            get {
                return ResourceManager.GetString("ColumnsDataMaps_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Column&apos;s &lt;b&gt;allowDragging&lt;/b&gt; property provides
        ///    control over the drag source (which columns may be
        ///    dragged into new positions)..
        /// </summary>
        internal static string ColumnsDropTargetControl_Text1 {
            get {
                return ResourceManager.GetString("ColumnsDropTargetControl_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can get control over the drop target (column&apos;s
        ///    new position) by handling the &lt;b&gt;dragingColumnOver&lt;/b&gt;
        ///    event and setting the event&apos;s &lt;b&gt;cancel&lt;/b&gt; parameter
        ///    to true if the current source/target combination is
        ///    invalid..
        /// </summary>
        internal static string ColumnsDropTargetControl_Text2 {
            get {
                return ResourceManager.GetString("ColumnsDropTargetControl_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the grid below does not allow dragging
        ///    the &apos;country&apos; column to the last or the first positions:.
        /// </summary>
        internal static string ColumnsDropTargetControl_Text3 {
            get {
                return ResourceManager.GetString("ColumnsDropTargetControl_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Drop Target Control.
        /// </summary>
        internal static string ColumnsDropTargetControl_Title {
            get {
                return ResourceManager.GetString("ColumnsDropTargetControl_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can freeze rows and columns by setting the grid&apos;s
        ///    &lt;b&gt;frozenRows&lt;/b&gt; and &lt;b&gt;frozenColumns&lt;/b&gt; properties..
        /// </summary>
        internal static string ColumnsFreezing_Text1 {
            get {
                return ResourceManager.GetString("ColumnsFreezing_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Frozen cells do not scroll but are selectable/editable
        ///    like regular cells:.
        /// </summary>
        internal static string ColumnsFreezing_Text2 {
            get {
                return ResourceManager.GetString("ColumnsFreezing_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Toggle Frozen Rows.
        /// </summary>
        internal static string ColumnsFreezing_Text3 {
            get {
                return ResourceManager.GetString("ColumnsFreezing_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Toggle Frozen Columns.
        /// </summary>
        internal static string ColumnsFreezing_Text4 {
            get {
                return ResourceManager.GetString("ColumnsFreezing_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Frozen Rows and Columns.
        /// </summary>
        internal static string ColumnsFreezing_Title {
            get {
                return ResourceManager.GetString("ColumnsFreezing_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Although FlexGrid does not allow you to freeze columns on the right
        ///    of the grid, or rows along the bottom. But this example shows
        ///    how you can implement something similar using two grids
        ///    bound to the same data source..
        /// </summary>
        internal static string ColumnsMultiPaneGrids_Text1 {
            get {
                return ResourceManager.GetString("ColumnsMultiPaneGrids_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Multi-Pane Grid.
        /// </summary>
        internal static string ColumnsMultiPaneGrids_Title {
            get {
                return ResourceManager.GetString("ColumnsMultiPaneGrids_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;wijmo.grid.Column&lt;/b&gt; class has
        ///    &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/webframe.html#wijmo.grid.Column.Class.html&quot; target=&quot;_blank&quot;&gt;
        ///        almost 40 properties
        ///    &lt;/a&gt; which you can use to configure each column&apos;s appearance and behavior..
        /// </summary>
        internal static string ColumnsProperties_Text1 {
            get {
                return ResourceManager.GetString("ColumnsProperties_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the grid below has a custom set of columns with the main
        ///    properties set in code:.
        /// </summary>
        internal static string ColumnsProperties_Text10 {
            get {
                return ResourceManager.GetString("ColumnsProperties_Text10", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to These properties are set automatically for auto-generated
        ///    columns, but when creating columns in code you will normally
        ///    set a few of these:.
        /// </summary>
        internal static string ColumnsProperties_Text2 {
            get {
                return ResourceManager.GetString("ColumnsProperties_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;binding&lt;/b&gt;:
        ///        Defines property of the data item to be shown in
        ///        the column..
        /// </summary>
        internal static string ColumnsProperties_Text3 {
            get {
                return ResourceManager.GetString("ColumnsProperties_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;header&lt;/b&gt;:
        ///        Defines the content of column&apos;s header cell..
        /// </summary>
        internal static string ColumnsProperties_Text4 {
            get {
                return ResourceManager.GetString("ColumnsProperties_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;format&lt;/b&gt;:
        ///        Specifies format string used to convert numbers and dates into display
        ///        strings for the column..
        /// </summary>
        internal static string ColumnsProperties_Text5 {
            get {
                return ResourceManager.GetString("ColumnsProperties_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;width&lt;/b&gt;:
        ///        Specifies width of the column in pixels. You may also use &apos;star&apos; sizing
        ///        to specify the column width in relative units (e.g. &apos;2*&apos; is
        ///        twice as wide as &apos;*&apos;)..
        /// </summary>
        internal static string ColumnsProperties_Text6 {
            get {
                return ResourceManager.GetString("ColumnsProperties_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;align&lt;/b&gt;:
        ///        Defines the horizontal alignment of items in the column.
        ///        This is set to null by default, which aligns data based
        ///        on the column&apos;s data type. You can override the default
        ///        by setting this property to &apos;left&apos;, &apos;right&apos;, or &apos;center&apos;..
        /// </summary>
        internal static string ColumnsProperties_Text7 {
            get {
                return ResourceManager.GetString("ColumnsProperties_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;isReadOnly&lt;/b&gt;:
        ///        Determines whether the column can be edited by the user.
        ///        You can disable editing altogether by setting the grid&apos;s
        ///        &lt;b&gt;isReadOnly&lt;/b&gt; property to false..
        /// </summary>
        internal static string ColumnsProperties_Text8 {
            get {
                return ResourceManager.GetString("ColumnsProperties_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;isRequired&lt;/b&gt;:
        ///        Determines whether users should be able to set values
        ///        in the column to empty strings or null values..
        /// </summary>
        internal static string ColumnsProperties_Text9 {
            get {
                return ResourceManager.GetString("ColumnsProperties_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Column Properties.
        /// </summary>
        internal static string ColumnsProperties_Title {
            get {
                return ResourceManager.GetString("ColumnsProperties_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, FlexGrid allows reordering columns by dragging their
        ///    headers into new positions..
        /// </summary>
        internal static string ColumnsReordering_Text1 {
            get {
                return ResourceManager.GetString("ColumnsReordering_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You may prevent users from reordering columns by setting
        ///    the grid&apos;s &lt;b&gt;allowDragging&lt;/b&gt; property to &apos;None&apos;.
        ///    You may also prevent dragging specific columns by
        ///    setting the columns &lt;b&gt;allowDragging&lt;/b&gt; property
        ///    to &apos;false&apos;..
        /// </summary>
        internal static string ColumnsReordering_Text2 {
            get {
                return ResourceManager.GetString("ColumnsReordering_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the grid below allows reordering
        ///    all columns except &apos;ID&apos;..
        /// </summary>
        internal static string ColumnsReordering_Text3 {
            get {
                return ResourceManager.GetString("ColumnsReordering_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to C1 MVC uses the HTML5 drag/drop API for column reordering.
        ///        Unfortunately, most of the mobile devices do not support this API.
        ///        If you want to support column reordering on mobile devices,
        ///        we suggest to use the
        ///        &lt;a href=&quot;https://github.com/Bernardo-Castilho/dragdroptouch&quot; target=&quot;_blank&quot;&gt;
        ///            DragDropTouch polyfill
        ///        &lt;/a&gt;..
        /// </summary>
        internal static string ColumnsReordering_Text4 {
            get {
                return ResourceManager.GetString("ColumnsReordering_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Reordering.
        /// </summary>
        internal static string ColumnsReordering_Title {
            get {
                return ResourceManager.GetString("ColumnsReordering_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexGrid below shows all columns on large devices,
        ///    and only one summary column on devices with
        ///    narrow screens..
        /// </summary>
        internal static string ColumnsResponsiveLayouts_Text1 {
            get {
                return ResourceManager.GetString("ColumnsResponsiveLayouts_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Responsive Layouts.
        /// </summary>
        internal static string ColumnsResponsiveLayouts_Title {
            get {
                return ResourceManager.GetString("ColumnsResponsiveLayouts_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can specify the column widths when creating them.
        ///    Ater that, users may resize the FlexGrid columns using
        ///    mouse. As in the case of Excel, users may either drag
        ///    the column header&apos;s right edge to adjust the width, or 
        ///    they may double-click the edge to auto-size the column
        ///    to fits its content..
        /// </summary>
        internal static string ColumnsSizing_Text1 {
            get {
                return ResourceManager.GetString("ColumnsSizing_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you want to prevent users from resizing the columns,
        ///    you can either set the grid&apos;s &lt;b&gt;allowResizing&lt;/b&gt; property
        ///    to &apos;None&apos;, or prevent them from resizing specific columns
        ///    by setting the column&apos;s &lt;b&gt;allowResizing&lt;/b&gt; property to
        ///    &apos;false&apos;..
        /// </summary>
        internal static string ColumnsSizing_Text2 {
            get {
                return ResourceManager.GetString("ColumnsSizing_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the grid below does not allow resizing the &apos;ID&apos;
        ///    column. Other columns may be resized and auto-sized:.
        /// </summary>
        internal static string ColumnsSizing_Text3 {
            get {
                return ResourceManager.GetString("ColumnsSizing_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid also allows you to resize multiple columns
        ///        at once. Select a range of columns and press the &apos;control&apos;
        ///        key while resizing them with the mouse, and all selected
        ///        columns will be resized at once..
        /// </summary>
        internal static string ColumnsSizing_Text4 {
            get {
                return ResourceManager.GetString("ColumnsSizing_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to C1 MVC uses the HTML5 drag/drop API for column resizing.
        ///        Unfortunately, most of the mobile devices do not support this API.
        ///        If you want to support column resizing on mobile devices,
        ///        we suggest to use the
        ///        &lt;a href=&quot;https://github.com/Bernardo-Castilho/dragdroptouch&quot; target=&quot;_blank&quot;&gt;
        ///            DragDropTouch polyfill
        ///        &lt;/a&gt;..
        /// </summary>
        internal static string ColumnsSizing_Text5 {
            get {
                return ResourceManager.GetString("ColumnsSizing_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Column Sizing.
        /// </summary>
        internal static string ColumnsSizing_Title {
            get {
                return ResourceManager.GetString("ColumnsSizing_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can use the &lt;b&gt;stickyHeaders&lt;/b&gt; property to ensure
        ///    column headers remain visible when you scroll
        ///    the page, so the grid is easier to read..
        /// </summary>
        internal static string ColumnsStickyHeaders_Text1 {
            get {
                return ResourceManager.GetString("ColumnsStickyHeaders_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Headers in sticky state behave like regular headers.
        ///    You can click them to sort, drag to reorder or resize
        ///    columns, etc..
        /// </summary>
        internal static string ColumnsStickyHeaders_Text2 {
            get {
                return ResourceManager.GetString("ColumnsStickyHeaders_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To observe how sticky headers work, scroll this page
        ///    down until the top of the grid scrolls off the window..
        /// </summary>
        internal static string ColumnsStickyHeaders_Text3 {
            get {
                return ResourceManager.GetString("ColumnsStickyHeaders_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sticky Headers.
        /// </summary>
        internal static string ColumnsStickyHeaders_Title {
            get {
                return ResourceManager.GetString("ColumnsStickyHeaders_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid columns have a few properties that affect styling:.
        /// </summary>
        internal static string ColumnsStyling_Text1 {
            get {
                return ResourceManager.GetString("ColumnsStyling_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;cssClass&lt;/b&gt;: Specifies a class name to be added to cells
        ///        in the column. The class name can be used in CSS rules to
        ///        modify the style of cells in the column..
        /// </summary>
        internal static string ColumnsStyling_Text2 {
            get {
                return ResourceManager.GetString("ColumnsStyling_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;align&lt;/b&gt;: Specifies the horizontal alignment of text
        ///        in the cells. This property is set to null by default, which
        ///        causes the grid to select the alignment based on the column&apos;s
        ///        &lt;b&gt;dataType&lt;/b&gt; (numbers are right-aligned, Boolean values
        ///        are centered, and other types are left-aligned).
        ///        If you want to override the default alignment, set this property
        ///        to &apos;left&apos; &apos;right&apos;, or &apos;center&apos;..
        /// </summary>
        internal static string ColumnsStyling_Text3 {
            get {
                return ResourceManager.GetString("ColumnsStyling_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;wordWrap&lt;/b&gt;: Specifies whether text in the cells should be
        ///        allowed to wrap within the cell. Note that the grid will not
        ///        adjust the row heights to fit the cell content unless you call
        ///        the &lt;b&gt;autoSizeRows&lt;/b&gt; method..
        /// </summary>
        internal static string ColumnsStyling_Text4 {
            get {
                return ResourceManager.GetString("ColumnsStyling_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;cssClass&lt;/b&gt; is the most powerful and flexible of the
        ///    three properties, but &lt;b&gt;align&lt;/b&gt; and &lt;b&gt;wordWrap&lt;/b&gt; are
        ///    simple and convenient. Also, &lt;b&gt;align&lt;/b&gt; and &lt;b&gt;wordWrap&lt;/b&gt;
        ///    apply to all cells, including headers, while &lt;b&gt;cssClass&lt;/b&gt;
        ///    applies only to the scrollable cells..
        /// </summary>
        internal static string ColumnsStyling_Text5 {
            get {
                return ResourceManager.GetString("ColumnsStyling_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below shows the effect of these properties..
        /// </summary>
        internal static string ColumnsStyling_Text6 {
            get {
                return ResourceManager.GetString("ColumnsStyling_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;cssClass&lt;/b&gt; property is useful for formatting
        ///    entire columns. If you have to format specific cells,
        ///    perhaps based on their content or some other criteria,
        ///    use the &lt;b&gt;formatItem&lt;/b&gt; event instead..
        /// </summary>
        internal static string ColumnsStyling_Text7 {
            get {
                return ResourceManager.GetString("ColumnsStyling_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below uses &lt;b&gt;formatItem&lt;/b&gt; to add class
        ///    names to numeric cells so that their style depends on
        ///    their values..
        /// </summary>
        internal static string ColumnsStyling_Text8 {
            get {
                return ResourceManager.GetString("ColumnsStyling_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Column Styling.
        /// </summary>
        internal static string ColumnsStyling_Title {
            get {
                return ResourceManager.GetString("ColumnsStyling_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Formatting cells.
        /// </summary>
        internal static string ColumnsStyling_Title1 {
            get {
                return ResourceManager.GetString("ColumnsStyling_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexGrid control has two sets of columns:.
        /// </summary>
        internal static string Columns_Text1 {
            get {
                return ResourceManager.GetString("Columns_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Fixed Columns&lt;/b&gt;
        ///        This collection contains the columns on the left
        ///        of the grid. It is used by the &lt;b&gt;topLeftCells&lt;/b&gt;
        ///        and &lt;b&gt;rowHeaders&lt;/b&gt; panels.
        ///        By default, this collection contains only one column..
        /// </summary>
        internal static string Columns_Text2 {
            get {
                return ResourceManager.GetString("Columns_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Scrollable Columns&lt;/b&gt;
        ///        This collection contains the main set of columns.
        ///        It is used by the &lt;b&gt;cells&lt;/b&gt;, &lt;b&gt;columnHeaders&lt;/b&gt;,
        ///        and &lt;b&gt;columnFooters&lt;/b&gt; panels..
        /// </summary>
        internal static string Columns_Text3 {
            get {
                return ResourceManager.GetString("Columns_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Both of these collections are objects of &lt;b&gt;ColumnCollection&lt;/b&gt;
        ///    class, which extend regular arrays.
        ///    You may add or remove columns by adding or removing
        ///    &lt;b&gt;Column&lt;/b&gt; objects from these arrays..
        /// </summary>
        internal static string Columns_Text4 {
            get {
                return ResourceManager.GetString("Columns_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the grid below has an extra fixed column and
        ///    automatically-generated scrollable columns:.
        /// </summary>
        internal static string Columns_Text5 {
            get {
                return ResourceManager.GetString("Columns_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to And this grid has no fixed columns and a custom set of
        ///    scrollable columns:.
        /// </summary>
        internal static string Columns_Text6 {
            get {
                return ResourceManager.GetString("Columns_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Column Collections.
        /// </summary>
        internal static string Columns_Title {
            get {
                return ResourceManager.GetString("Columns_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid provides a powerful infrastructure for binding cells
        ///    to data and formatting the cells using CSS..
        /// </summary>
        internal static string CustomCells_Text1 {
            get {
                return ResourceManager.GetString("CustomCells_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to But in some cases that may not be enough. In those situations,
        ///    use the &lt;b&gt;formatItem&lt;/b&gt; event to customize the style or
        ///    content present in each cell..
        /// </summary>
        internal static string CustomCells_Text2 {
            get {
                return ResourceManager.GetString("CustomCells_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below uses &lt;b&gt;formatItem&lt;/b&gt; to calculate and format
        ///    cells that show difference between values in the current
        ///    and previous items..
        /// </summary>
        internal static string CustomCells_Text3 {
            get {
                return ResourceManager.GetString("CustomCells_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Cells.
        /// </summary>
        internal static string CustomCells_Title {
            get {
                return ResourceManager.GetString("CustomCells_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid has several events related to editing..
        /// </summary>
        internal static string CustomEditing_Text1 {
            get {
                return ResourceManager.GetString("CustomEditing_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example shows how you can use two of them:.
        /// </summary>
        internal static string CustomEditing_Text2 {
            get {
                return ResourceManager.GetString("CustomEditing_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;beginningEdit&lt;/b&gt;:
        ///        Prevent editing overdue items by setting the &lt;b&gt;cancel&lt;/b&gt;
        ///        parameter to true..
        /// </summary>
        internal static string CustomEditing_Text3 {
            get {
                return ResourceManager.GetString("CustomEditing_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;cellEditEnding&lt;/b&gt;:
        ///        Prevent entering negative amounts for the &apos;sales&apos; and
        ///        &apos;expenses&apos; columns..
        /// </summary>
        internal static string CustomEditing_Text4 {
            get {
                return ResourceManager.GetString("CustomEditing_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &amp;nbsp;.
        /// </summary>
        internal static string CustomEditing_Text5 {
            get {
                return ResourceManager.GetString("CustomEditing_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Editing Events.
        /// </summary>
        internal static string CustomEditing_Title {
            get {
                return ResourceManager.GetString("CustomEditing_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Although FlexGrid provides efficient, Excel-style
        ///    editing by default, you may want to customize the
        ///    editing behavior..
        /// </summary>
        internal static string CustomEditors_Text1 {
            get {
                return ResourceManager.GetString("CustomEditors_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example defines a &lt;b&gt;CustomGridEditor&lt;/b&gt; class
        ///    that allows any Wijmo control to be used as a grid
        ///    editor:.
        /// </summary>
        internal static string CustomEditors_Text2 {
            get {
                return ResourceManager.GetString("CustomEditors_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Editors.
        /// </summary>
        internal static string CustomEditors_Title {
            get {
                return ResourceManager.GetString("CustomEditors_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can customize the icons shown by the FlexGridFilter using
        ///    CSS..
        /// </summary>
        internal static string CustomFilterIcons_Text1 {
            get {
                return ResourceManager.GetString("CustomFilterIcons_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Filter Icons.
        /// </summary>
        internal static string CustomFilterIcons_Title {
            get {
                return ResourceManager.GetString("CustomFilterIcons_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Icons.
        /// </summary>
        internal static string CustomFilterIcons_Title1 {
            get {
                return ResourceManager.GetString("CustomFilterIcons_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Colors.
        /// </summary>
        internal static string CustomFilterIcons_Title2 {
            get {
                return ResourceManager.GetString("CustomFilterIcons_Title2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;FlexGridFilter&lt;/b&gt; class is localizable, and you can take
        ///    advantage of that not only to customize the strings displayed in
        ///    the UI, but also which filter conditions to show for each data
        ///    type..
        /// </summary>
        internal static string CustomFilterOperators_Text1 {
            get {
                return ResourceManager.GetString("CustomFilterOperators_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In this sample, we customized the list of operators by assigning
        ///    custom arrays to the filter&apos;s &lt;b&gt;stringOperators&lt;/b&gt;, &lt;b&gt;numberOperators&lt;/b&gt;,
        ///    &lt;b&gt;dateOperators&lt;/b&gt;, and &lt;b&gt;booleanOperators&lt;/b&gt;. Open the filter
        ///    drop-downs to see the effect..
        /// </summary>
        internal static string CustomFilterOperators_Text2 {
            get {
                return ResourceManager.GetString("CustomFilterOperators_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This technique allows you to re-order, remove, and include operators
        ///    for each data type. It does not allow you to create new, custom
        ///    operators. For that, you would have to fork the source code and
        ///    customize it..
        /// </summary>
        internal static string CustomFilterOperators_Text3 {
            get {
                return ResourceManager.GetString("CustomFilterOperators_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Filter Operators.
        /// </summary>
        internal static string CustomFilterOperators_Title {
            get {
                return ResourceManager.GetString("CustomFilterOperators_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use the &lt;b&gt;defaultFilterType&lt;/b&gt; property of FlexGridFilter to
        ///    determine whether the filter should be based on conditions,
        ///    values, or both..
        /// </summary>
        internal static string CustomFilterTypes_Text1 {
            get {
                return ResourceManager.GetString("CustomFilterTypes_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use the &lt;b&gt;showFilterButtons&lt;/b&gt; property to set whether
        ///    the filter editor should include buttons for sorting the
        ///    columns..
        /// </summary>
        internal static string CustomFilterTypes_Text2 {
            get {
                return ResourceManager.GetString("CustomFilterTypes_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Filter Types.
        /// </summary>
        internal static string CustomFilterTypes_Title {
            get {
                return ResourceManager.GetString("CustomFilterTypes_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, FlexGrid applies merging to cells based on
        ///    their content. In some cases, you may want to use different
        ///    strategies for merging..
        /// </summary>
        internal static string CustomMerging_Text1 {
            get {
                return ResourceManager.GetString("CustomMerging_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can achieve this by defining a class that extends the
        ///    &lt;b&gt;wijmo.grid.MergeManager&lt;/b&gt; class and assigning an object
        ///    of that type to the grid&apos;s &lt;b&gt;mergeManager&lt;/b&gt; property..
        /// </summary>
        internal static string CustomMerging_Text2 {
            get {
                return ResourceManager.GetString("CustomMerging_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Below example illustrates this by creating a grid that looks like
        ///    a TV guide:.
        /// </summary>
        internal static string CustomMerging_Text3 {
            get {
                return ResourceManager.GetString("CustomMerging_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Notice how the custom merge manager creates merged ranges
        ///    that span both rows and columns. This is something the
        ///    default merge manager does not do..
        /// </summary>
        internal static string CustomMerging_Text4 {
            get {
                return ResourceManager.GetString("CustomMerging_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Merging.
        /// </summary>
        internal static string CustomMerging_Title {
            get {
                return ResourceManager.GetString("CustomMerging_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Data binding is the process of connecting the FlexGrid to
        ///    a data source so you can use it to see and edit collection
        ///    of items..
        /// </summary>
        internal static string DataBinding_Text1 {
            get {
                return ResourceManager.GetString("DataBinding_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Although generally grids are used in bound mode, FlexGrid
        ///    can also be used as an unbound control. You can add rows
        ///    and columns to a grid and use the &lt;b&gt;setCellData&lt;/b&gt; and
        ///    &lt;b&gt;getCellData&lt;/b&gt; methods to get or set the data in each
        ///    cell:.
        /// </summary>
        internal static string DataBinding_Text2 {
            get {
                return ResourceManager.GetString("DataBinding_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To use FlexGrid in bound mode, set its &lt;b&gt;itemsSource&lt;/b&gt;
        ///    property to an array or &lt;b&gt;CollectionView&lt;/b&gt; containing the
        ///    data. The grid will automatically create columns for each
        ///    property in the data items:.
        /// </summary>
        internal static string DataBinding_Text3 {
            get {
                return ResourceManager.GetString("DataBinding_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Automatically generating columns is convenient in some
        ///    scenarios, but in most common cases it is required to
        ///    explicitly tell the grid which columns to show and how
        ///    to format them. You can do this by setting the
        ///    &lt;b&gt;autoGenerateColumns&lt;/b&gt; property to false and
        ///    populating the grid&apos;s &lt;b&gt;columns&lt;/b&gt; collection:.
        /// </summary>
        internal static string DataBinding_Text4 {
            get {
                return ResourceManager.GetString("DataBinding_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Data Binding.
        /// </summary>
        internal static string DataBinding_Title {
            get {
                return ResourceManager.GetString("DataBinding_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unbound Grids.
        /// </summary>
        internal static string DataBinding_Title1 {
            get {
                return ResourceManager.GetString("DataBinding_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Auto-Generating Columns.
        /// </summary>
        internal static string DataBinding_Title2 {
            get {
                return ResourceManager.GetString("DataBinding_Title2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Defining Columns in Code.
        /// </summary>
        internal static string DataBinding_Title3 {
            get {
                return ResourceManager.GetString("DataBinding_Title3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Each grid column has a &lt;b&gt;binding&lt;/b&gt; property that determines
        ///    which property of the data item should be displayed in the cell. 
        ///    In most of the cases, this property is a regular identifier
        ///    such as &apos;name&apos; or &apos;value&apos;..
        /// </summary>
        internal static string DeepBinding_Text1 {
            get {
                return ResourceManager.GetString("DeepBinding_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to But the grid also supports &apos;deep-binding&apos;, where the binding
        ///    string contains a binding path composed of identifiers separated
        ///    by periods. The syntax is similar to what you would use in
        ///    regular JavaScript expressions..
        /// </summary>
        internal static string DeepBinding_Text2 {
            get {
                return ResourceManager.GetString("DeepBinding_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, if the data objects in the &lt;b&gt;itemsSource&lt;/b&gt; array
        ///    have a &apos;customer&apos; property that contains a reference to a
        ///    &apos;Customer&apos; object, you could use a &apos;customer.name&apos; binding
        ///    to show the customer&apos;s name on the grid:.
        /// </summary>
        internal static string DeepBinding_Text3 {
            get {
                return ResourceManager.GetString("DeepBinding_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Deep binding can be very useful in a number of scenarios, but
        ///    you have to be aware of how binding works. In this example,
        ///    editing the customer&apos;s first or last name will affect all
        ///    rows that are bound to the same customer..
        /// </summary>
        internal static string DeepBinding_Text4 {
            get {
                return ResourceManager.GetString("DeepBinding_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Also, unlike regular bindings, deep bindings are not &apos;un-doable&apos;
        ///    by default. To enable undo for deep bindings, you should use
        ///    the grid&apos;s &lt;b&gt;rowEditStarted&lt;/b&gt; event to record the original
        ///    deep-bound values, and the &lt;b&gt;rowEditEnding&lt;/b&gt; event to
        ///    restore those values if the edits are being canceled..
        /// </summary>
        internal static string DeepBinding_Text5 {
            get {
                return ResourceManager.GetString("DeepBinding_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Enable deep binding undos.
        /// </summary>
        internal static string DeepBinding_Text6 {
            get {
                return ResourceManager.GetString("DeepBinding_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Deep Binding.
        /// </summary>
        internal static string DeepBinding_Title {
            get {
                return ResourceManager.GetString("DeepBinding_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, FlexGrid resizes rows and columns along with the 
        ///    mouse drag..
        /// </summary>
        internal static string DefferedResizing_Text1 {
            get {
                return ResourceManager.GetString("DefferedResizing_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to However, setting the &lt;b&gt;deferResizing&lt;/b&gt; property to true 
        ///    causes the grid to show a marker instead, and resize the row
        ///    or column only after the mouse button is released. This may 
        ///    improve performance of the grids having large number of columns..
        /// </summary>
        internal static string DefferedResizing_Text2 {
            get {
                return ResourceManager.GetString("DefferedResizing_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Defer Resizing.
        /// </summary>
        internal static string DefferedResizing_Text3 {
            get {
                return ResourceManager.GetString("DefferedResizing_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Deferred Resizing.
        /// </summary>
        internal static string DefferedResizing_Title {
            get {
                return ResourceManager.GetString("DefferedResizing_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In some situations, you may want to change the data map used
        ///    with a column depending on the value of another column.
        ///    For example, you may want the drop-down in the &apos;City&apos; column
        ///    to show only cities in the country that is selected for the
        ///    current row..
        /// </summary>
        internal static string DynamicDataMapsCustomize_Text1 {
            get {
                return ResourceManager.GetString("DynamicDataMapsCustomize_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below does this by customizing the DataMap used for
        ///    the &quot;cities&quot; column. The code overrides the city map&apos;s
        ///    &lt;b&gt;getDisplayValues&lt;/b&gt; method to return only cities that
        ///    belong to the current country:.
        /// </summary>
        internal static string DynamicDataMapsCustomize_Text2 {
            get {
                return ResourceManager.GetString("DynamicDataMapsCustomize_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Dynamic DataMaps (customize).
        /// </summary>
        internal static string DynamicDataMapsCustomize_Title {
            get {
                return ResourceManager.GetString("DynamicDataMapsCustomize_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In some situations, you may want to change the data map used
        ///    with a column depending on the value of another column.
        ///    For example, you may want the drop-down in the &apos;City&apos; column
        ///    to show only cities in the country that is selected for the
        ///    current row..
        /// </summary>
        internal static string DynamicDataMapsSwitch_Text1 {
            get {
                return ResourceManager.GetString("DynamicDataMapsSwitch_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If your data maps contain only array strings, then it is not
        ///    used as a real map. The cells actually contain the strings
        ///    stored in the grid, and in this case it is safe to switch
        ///    data maps before editing cells..
        /// </summary>
        internal static string DynamicDataMapsSwitch_Text2 {
            get {
                return ResourceManager.GetString("DynamicDataMapsSwitch_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In the grid below, the data map used for selecting cities is
        ///    a string array that is updated before editing the cells to
        ///    include only cities that belong to the current country:.
        /// </summary>
        internal static string DynamicDataMapsSwitch_Text3 {
            get {
                return ResourceManager.GetString("DynamicDataMapsSwitch_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Dynamic DataMaps (switch).
        /// </summary>
        internal static string DynamicDataMapsSwitch_Title {
            get {
                return ResourceManager.GetString("DynamicDataMapsSwitch_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In some situations, you may want to change the data map used
        ///    with a column depending on the value of another column.
        ///    For example, you may want the drop-down in the &apos;City&apos; column
        ///    to show only cities in the country that is selected in the
        ///    current row..
        /// </summary>
        internal static string DynamicDataMaps_Text1 {
            get {
                return ResourceManager.GetString("DynamicDataMaps_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This is not as simple as it may seem, because the maps are
        ///    used by all cells, not just by the ones being edited. So
        ///    changing the map values will change the whole grid..
        /// </summary>
        internal static string DynamicDataMaps_Text2 {
            get {
                return ResourceManager.GetString("DynamicDataMaps_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There are two ways to handle this:.
        /// </summary>
        internal static string DynamicDataMaps_Text3 {
            get {
                return ResourceManager.GetString("DynamicDataMaps_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Customized DataMaps&lt;/b&gt;: You can override the DataMap&apos;s
        ///            &lt;b&gt;getDisplayValues&lt;/b&gt; method to get only values that
        ///            apply to the current context..
        /// </summary>
        internal static string DynamicDataMaps_Text4 {
            get {
                return ResourceManager.GetString("DynamicDataMaps_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example:.
        /// </summary>
        internal static string DynamicDataMaps_Text5 {
            get {
                return ResourceManager.GetString("DynamicDataMaps_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;String-Only DataMaps&lt;/b&gt;: If your data maps contain only
        ///            array strings, then it is not used as a real map. The cells
        ///            actually contain the strings stored in the grid, and in
        ///            this case it is safe to switch data maps before editing
        ///            cells..
        /// </summary>
        internal static string DynamicDataMaps_Text6 {
            get {
                return ResourceManager.GetString("DynamicDataMaps_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Dynamic DataMaps.
        /// </summary>
        internal static string DynamicDataMaps_Title {
            get {
                return ResourceManager.GetString("DynamicDataMaps_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid updates all cells automatically when there
        ///    are changes in its data source..
        /// </summary>
        internal static string DynamicUpdates_Text1 {
            get {
                return ResourceManager.GetString("DynamicUpdates_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you have a data source where only a few items change
        ///    frequently, it is more efficient to update only
        ///    the cells bound to items that have actually changed..
        /// </summary>
        internal static string DynamicUpdates_Text2 {
            get {
                return ResourceManager.GetString("DynamicUpdates_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below uses the &lt;b&gt;formatItem&lt;/b&gt; event to keep
        ///    track of the cell elements for each data item. When the
        ///    data changes, it updates only the affected cells rather
        ///    than the whole grid..
        /// </summary>
        internal static string DynamicUpdates_Text3 {
            get {
                return ResourceManager.GetString("DynamicUpdates_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Cells.
        /// </summary>
        internal static string DynamicUpdates_Text4 {
            get {
                return ResourceManager.GetString("DynamicUpdates_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Auto Update.
        /// </summary>
        internal static string DynamicUpdates_Text5 {
            get {
                return ResourceManager.GetString("DynamicUpdates_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Update Interval (ms).
        /// </summary>
        internal static string DynamicUpdates_Text6 {
            get {
                return ResourceManager.GetString("DynamicUpdates_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Batch Size (# items).
        /// </summary>
        internal static string DynamicUpdates_Text7 {
            get {
                return ResourceManager.GetString("DynamicUpdates_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Dynamic Updates.
        /// </summary>
        internal static string DynamicUpdates_Title {
            get {
                return ResourceManager.GetString("DynamicUpdates_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you use FlexGrid&apos;s &lt;b&gt;childItemsPath&lt;/b&gt; property to
        ///    show the data as a tree, the resulting grid will
        ///    be read-only by default. This happens because every
        ///    row in a tree is a &lt;b&gt;GroupRow&lt;/b&gt;, and group rows
        ///    are read-only by default..
        /// </summary>
        internal static string EditableTreeGrids_Text1 {
            get {
                return ResourceManager.GetString("EditableTreeGrids_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you want your tree to be editable, handle the
        ///    &lt;b&gt;loadedRows&lt;/b&gt; event to set the &lt;b&gt;isReadOnly&lt;/b&gt;
        ///    property of every row to false..
        /// </summary>
        internal static string EditableTreeGrids_Text2 {
            get {
                return ResourceManager.GetString("EditableTreeGrids_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can still control which columns are editable
        ///    using the column&apos;s &lt;b&gt;isReadOnly&lt;/b&gt; property or
        ///    the &lt;b&gt;beginningEdit&lt;/b&gt; event..
        /// </summary>
        internal static string EditableTreeGrids_Text3 {
            get {
                return ResourceManager.GetString("EditableTreeGrids_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the grid below allows users to edit
        ///    cells in the &apos;hours&apos; and &apos;rate&apos; columns:.
        /// </summary>
        internal static string EditableTreeGrids_Text4 {
            get {
                return ResourceManager.GetString("EditableTreeGrids_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Editable Tree Grids.
        /// </summary>
        internal static string EditableTreeGrids_Title {
            get {
                return ResourceManager.GetString("EditableTreeGrids_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexGrid has built-in support for Excel-like, efficient,
        ///    in-cell editing. There is no need to add extra columns with
        ///    &apos;Edit&apos; buttons that switch between display and edit modes..
        /// </summary>
        internal static string Editing_Text1 {
            get {
                return ResourceManager.GetString("Editing_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Users can start editing simply by typing into any cell.
        ///    This is called &apos;quick-edit&apos; mode. In this mode, the cursor keys
        ///    finish the editing and the grid moves the selection. Users may
        ///    also start editing by pressing F2 or by clicking a cell twice.
        ///    This is called &apos;full-edit&apos; mode. In this mode, the cursor
        ///    keys move the caret within the editor and the user must press
        ///    the Enter, Tab, or Escape keys to finish editing..
        /// </summary>
        internal static string Editing_Text2 {
            get {
                return ResourceManager.GetString("Editing_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid automatically parses the input and coerces it into
        ///    the proper data type for the column. If the coercion fails,
        ///    the original value is restored..
        /// </summary>
        internal static string Editing_Text3 {
            get {
                return ResourceManager.GetString("Editing_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Editing.
        /// </summary>
        internal static string Editing_Title {
            get {
                return ResourceManager.GetString("Editing_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can use the HTML5 drag/drop API to implement row dragging
        ///    from, into, or between the FlexGrid controls..
        /// </summary>
        internal static string EventsDragDrop_Text1 {
            get {
                return ResourceManager.GetString("EventsDragDrop_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This simple example shows how you can drag rows from the
        ///    grid into arbitrary elements. You can easily extend this
        ///    to support move operations (by removing the row from the
        ///    source grid when the operation is completed) or dropping
        ///    into grids (by detecting the drop position and inserting
        ///    new rows into the target grid)..
        /// </summary>
        internal static string EventsDragDrop_Text2 {
            get {
                return ResourceManager.GetString("EventsDragDrop_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Drag rows from the grid by the row header:.
        /// </summary>
        internal static string EventsDragDrop_Text3 {
            get {
                return ResourceManager.GetString("EventsDragDrop_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to And drop them here:.
        /// </summary>
        internal static string EventsDragDrop_Text4 {
            get {
                return ResourceManager.GetString("EventsDragDrop_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Drop rows here....
        /// </summary>
        internal static string EventsDragDrop_Text5 {
            get {
                return ResourceManager.GetString("EventsDragDrop_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Dragging Rows from the FlexGrid.
        /// </summary>
        internal static string EventsDragDrop_Title {
            get {
                return ResourceManager.GetString("EventsDragDrop_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To handle mouse events, add a listener to &lt;b&gt;hostElement&lt;/b&gt; 
        ///    of the grid and use the &lt;b&gt;hitTest&lt;/b&gt; method
        ///    to determine which grid panel and cell were clicked..
        /// </summary>
        internal static string EventsMouse_Text1 {
            get {
                return ResourceManager.GetString("EventsMouse_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below has a handler attached to the &apos;mousemove&apos;
        ///    event, and shows information about the element that is 
        ///    hovered by the mouse..
        /// </summary>
        internal static string EventsMouse_Text2 {
            get {
                return ResourceManager.GetString("EventsMouse_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to please move the mouse over the grid.
        /// </summary>
        internal static string EventsMouse_Text3 {
            get {
                return ResourceManager.GetString("EventsMouse_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Mouse Events.
        /// </summary>
        internal static string EventsMouse_Title {
            get {
                return ResourceManager.GetString("EventsMouse_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid raises &lt;b&gt;resizingColumn&lt;/b&gt; and
        ///    &lt;b&gt;resizedColumn&lt;/b&gt; events as the user resizes
        ///    the columns..
        /// </summary>
        internal static string EventsResizing_Text1 {
            get {
                return ResourceManager.GetString("EventsResizing_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The example below handles the &lt;b&gt;resizingColumn&lt;/b&gt;
        ///    event to show a tooltip with the column&apos;s new width:.
        /// </summary>
        internal static string EventsResizing_Text2 {
            get {
                return ResourceManager.GetString("EventsResizing_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Column Sizing Events.
        /// </summary>
        internal static string EventsResizing_Title {
            get {
                return ResourceManager.GetString("EventsResizing_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid&apos;s &lt;b&gt;selection&lt;/b&gt; property returns a
        ///    &lt;b&gt;CellRange&lt;/b&gt; object that contains the range of
        ///    selected cells..
        /// </summary>
        internal static string EventsSelection_Text1 {
            get {
                return ResourceManager.GetString("EventsSelection_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When the selection changes, the grid raises the
        ///    &lt;b&gt;selectionChanging&lt;/b&gt; and &lt;b&gt;selectionChanged&lt;/b&gt;
        ///    events..
        /// </summary>
        internal static string EventsSelection_Text2 {
            get {
                return ResourceManager.GetString("EventsSelection_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below uses the &lt;b&gt;selectionChanged&lt;/b&gt;
        ///    event to show a summary of the data selected..
        /// </summary>
        internal static string EventsSelection_Text3 {
            get {
                return ResourceManager.GetString("EventsSelection_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to please select a range on the grid.
        /// </summary>
        internal static string EventsSelection_Text4 {
            get {
                return ResourceManager.GetString("EventsSelection_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Selection Events.
        /// </summary>
        internal static string EventsSelection_Title {
            get {
                return ResourceManager.GetString("EventsSelection_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid provides many events which you can use to
        ///    customize almost every aspect of the control&apos;s
        ///    behavior. You can see a complete list in the
        ///    &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/webframe.html#wijmo.grid.FlexGrid.Class.html&quot; target=&quot;_blank&quot;&gt;Online Documentation&lt;/a&gt;..
        /// </summary>
        internal static string Events_Text1 {
            get {
                return ResourceManager.GetString("Events_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to These events can be grouped into categories that include:.
        /// </summary>
        internal static string Events_Text2 {
            get {
                return ResourceManager.GetString("Events_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Mouse&lt;/b&gt;:
        ///        FlexGrid relies on HTML events for mouse handling,
        ///        and includes a &lt;b&gt;hitTest&lt;/b&gt; method that can be used
        ///        to determine which part of the grid the event refers to..
        /// </summary>
        internal static string Events_Text3 {
            get {
                return ResourceManager.GetString("Events_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Selection&lt;/b&gt;:
        ///        The &lt;b&gt;selectionChanging&lt;/b&gt; and &lt;b&gt;selectionChanged&lt;/b&gt;
        ///        events can be used to prevent users from selecting parts
        ///        of the grid or to display information relative to the
        ///        current &lt;b&gt;selection&lt;/b&gt;..
        /// </summary>
        internal static string Events_Text4 {
            get {
                return ResourceManager.GetString("Events_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Editing&lt;/b&gt;:
        ///        FlexGrid provides events that can be used for
        ///        preventing certain cells from being edited
        ///        (&lt;b&gt;beginningEdit&lt;/b&gt;), for customizing the editor
        ///        element (&lt;b&gt;prepareCellForEdit&lt;/b&gt;), for
        ///        validation (&lt;b&gt;cellEditEnding&lt;/b&gt;), and more..
        /// </summary>
        internal static string Events_Text5 {
            get {
                return ResourceManager.GetString("Events_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Resizing Rows and Columns:&lt;/b&gt;
        ///        FlexGrid raises events when rows and columns
        ///        are being resized so that you can validate or
        ///        persist the grid layout..
        /// </summary>
        internal static string Events_Text6 {
            get {
                return ResourceManager.GetString("Events_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Reordering Columns:&lt;/b&gt;
        ///        FlexGrid raises events when rows and columns
        ///        are being dragged into new positions so that you can
        ///        validate or persist the grid layout..
        /// </summary>
        internal static string Events_Text7 {
            get {
                return ResourceManager.GetString("Events_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Drag and Drop:&lt;/b&gt;
        ///        FlexGrid uses HTML drag/drop events for reordering
        ///        rows and columns, and you can extend that support to
        ///        provide cell drag and drop functionality as well..
        /// </summary>
        internal static string Events_Text8 {
            get {
                return ResourceManager.GetString("Events_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Grid Events.
        /// </summary>
        internal static string Events_Title {
            get {
                return ResourceManager.GetString("Events_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To export FlexGrid controls to the XLSX format, you
        ///    should include following extra modules in your application:.
        /// </summary>
        internal static string Excel_Text1 {
            get {
                return ResourceManager.GetString("Excel_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;&lt;a href=&quot;https://stuk.github.io/jszip/&quot; target=&quot;_blank&quot;&gt;jszip.js&lt;/a&gt;&lt;/b&gt;:
        ///        Javascript library for creating, reading and editing ZIP files..
        /// </summary>
        internal static string Excel_Text2 {
            get {
                return ResourceManager.GetString("Excel_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To export FlexGrid to XLSX, call the
        ///    &lt;b&gt;FlexGridXlsxConverter.save&lt;/b&gt; method to obtain a &apos;book&apos;
        ///    object. You may modify the book object before saving it. For example,
        ///    you may add or rename sheets. Once the &apos;book&apos; is ready, 
        ///    call its &lt;b&gt;save&lt;/b&gt; method to create the XLSX file..
        /// </summary>
        internal static string Excel_Text3 {
            get {
                return ResourceManager.GetString("Excel_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Export to XLSX.
        /// </summary>
        internal static string Excel_Text4 {
            get {
                return ResourceManager.GetString("Excel_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Export to XLSX.
        /// </summary>
        internal static string Excel_Title {
            get {
                return ResourceManager.GetString("Excel_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The iPad contact list uses a fast scroller to make it easier
        ///    to look up people by clicking their initials..
        /// </summary>
        internal static string FastScroller_Text1 {
            get {
                return ResourceManager.GetString("FastScroller_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample implements something similar by adding a vertical
        ///    list of initials near the right edge of the grid. When user
        ///    clicks or types an initial, the grid scrolls to show the first
        ///    contact that matches the request..
        /// </summary>
        internal static string FastScroller_Text2 {
            get {
                return ResourceManager.GetString("FastScroller_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Fast Scroller (iOS-style).
        /// </summary>
        internal static string FastScroller_Title {
            get {
                return ResourceManager.GetString("FastScroller_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can use the grid&apos;s &lt;b&gt;collectionView.filter&lt;/b&gt;
        ///    property directly. This is easy to use and very flexible, 
        ///    but you have to implement the filter UI yourself..
        /// </summary>
        internal static string Filtering_Text1 {
            get {
                return ResourceManager.GetString("Filtering_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, this grid filters the data by country:.
        /// </summary>
        internal static string Filtering_Text2 {
            get {
                return ResourceManager.GetString("Filtering_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Country Filter.
        /// </summary>
        internal static string Filtering_Text3 {
            get {
                return ResourceManager.GetString("Filtering_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Filtering.
        /// </summary>
        internal static string Filtering_Title {
            get {
                return ResourceManager.GetString("Filtering_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;wijmo.grid.filter&lt;/b&gt; module provides a &lt;b&gt;FlexGridFilter&lt;/b&gt;
        ///    class that adds an Excel-style filtering UI to each column.
        ///    The &lt;b&gt;FlexGridFilter&lt;/b&gt; provides two types of filters:
        ///    &lt;b&gt;value&lt;/b&gt; filter and &lt;b&gt;condition&lt;/b&gt; filter..
        /// </summary>
        internal static string FilterOptimizations_Text1 {
            get {
                return ResourceManager.GetString("FilterOptimizations_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;value&lt;/b&gt; filter editor contains a list of unique values
        ///    for the user to choose from. If the grid contains a lot of data,
        ///    this list of unique values may take a while to generate.
        ///    Furthermore, if the list contains too many values, it is not
        ///    very useful. A condition filter may be more appropriate
        ///    in such cases..
        /// </summary>
        internal static string FilterOptimizations_Text2 {
            get {
                return ResourceManager.GetString("FilterOptimizations_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how you can optimize the &lt;b&gt;value&lt;/b&gt; filters
        ///    in three ways:.
        /// </summary>
        internal static string FilterOptimizations_Text3 {
            get {
                return ResourceManager.GetString("FilterOptimizations_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;uniqueValues&lt;/b&gt;: The &apos;Rating&apos; column filter specifies
        ///        the list of possible unique values in the column, so the
        ///        filter does not have to scan the data to build the list..
        /// </summary>
        internal static string FilterOptimizations_Text4 {
            get {
                return ResourceManager.GetString("FilterOptimizations_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;maxValues&lt;/b&gt;: The &apos;Sales&apos; column filter specifies
        ///        that the list should show up to 20 values only. You may
        ///        use the filter field in the editor to select which
        ///        values you are interested in..
        /// </summary>
        internal static string FilterOptimizations_Text5 {
            get {
                return ResourceManager.GetString("FilterOptimizations_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;filterType&lt;/b&gt;: The &apos;Expenses&apos; column filter specifies
        ///        that the only filter type to be used is &lt;b&gt;condition&lt;/b&gt;.
        ///        A value filter is not even displayed for this column..
        /// </summary>
        internal static string FilterOptimizations_Text6 {
            get {
                return ResourceManager.GetString("FilterOptimizations_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGridFilter Optimizations.
        /// </summary>
        internal static string FilterOptimizations_Title {
            get {
                return ResourceManager.GetString("FilterOptimizations_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;wijmo.grid.filter&lt;/b&gt; module provides a &lt;b&gt;FlexGridFilter&lt;/b&gt;
        ///    class that adds an Excel-style filtering UI to each column..
        /// </summary>
        internal static string FlexGridFilter_Text1 {
            get {
                return ResourceManager.GetString("FlexGridFilter_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;FlexGridFilter&lt;/b&gt; adds filter icons to the column headers.
        ///    Users may click the icons to see a drop-down where they can apply
        ///    filters by value or by condition:.
        /// </summary>
        internal static string FlexGridFilter_Text2 {
            get {
                return ResourceManager.GetString("FlexGridFilter_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGridFilter.
        /// </summary>
        internal static string FlexGridFilter_Title {
            get {
                return ResourceManager.GetString("FlexGridFilter_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexGrid control is made up of six
        ///    &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/webframe.html#wijmo.grid.GridPanel.Class.html&quot; target=&quot;_blank&quot;&gt;GridPanel&lt;/a&gt;
        ///    elements:.
        /// </summary>
        internal static string GridPanels_Text1 {
            get {
                return ResourceManager.GetString("GridPanels_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Notice the &lt;b&gt;columnFooters&lt;/b&gt; panel at the bottom of the grid.
        ///    This panel is empty by default, but we have added a &lt;b&gt;GroupRow&lt;/b&gt;
        ///    to the same. The &lt;b&gt;GroupRow&lt;/b&gt; automatically shows aggregate 
        ///    values for each cell calculated based on the value of the column&apos;s 
        ///    &lt;b&gt;aggregate&lt;/b&gt; property, which in this example is set to &apos;Sum&apos;..
        /// </summary>
        internal static string GridPanels_Text10 {
            get {
                return ResourceManager.GetString("GridPanels_Text10", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can use the &lt;b&gt;headersVisibility&lt;/b&gt; property to select
        ///    which header panels should be visible:.
        /// </summary>
        internal static string GridPanels_Text11 {
            get {
                return ResourceManager.GetString("GridPanels_Text11", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;topLeftCells&lt;/b&gt;:
        ///        Panel on the left of the column headers, typically containing
        ///        a single empty cell that can be clicked to select the whole grid
        ///        content. This panel does not scroll..
        /// </summary>
        internal static string GridPanels_Text2 {
            get {
                return ResourceManager.GetString("GridPanels_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;columnHeaders&lt;/b&gt;:
        ///        Panel above the data cells, typically containing a single row
        ///        with cells that can be clicked to sort the grid or dragged
        ///        to resize or re-arrange the columns. This panel scrolls
        ///        horizontally..
        /// </summary>
        internal static string GridPanels_Text3 {
            get {
                return ResourceManager.GetString("GridPanels_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;rowHeaders&lt;/b&gt;:
        ///        Panel on the left of the data cells, typically containing a
        ///        single column that can be clicked to select rows and that
        ///        displays icons for rows being edited or added. This panel
        ///        scrolls vertically..
        /// </summary>
        internal static string GridPanels_Text4 {
            get {
                return ResourceManager.GetString("GridPanels_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;cells&lt;/b&gt;:
        ///        Panel that contains the data cells. Users can select cells
        ///        by clicking and dragging on this panel or by using the
        ///        keyboard. This panel scrolls horizontally and vertically..
        /// </summary>
        internal static string GridPanels_Text5 {
            get {
                return ResourceManager.GetString("GridPanels_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;bottomLeftCells:&lt;/b&gt;
        ///        Panel to the left of the column footers. By default, this
        ///        panel contains no rows and therefore is not visible..
        /// </summary>
        internal static string GridPanels_Text6 {
            get {
                return ResourceManager.GetString("GridPanels_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;columnFooters&lt;/b&gt;:
        ///        Panel below the data cells, typically used to show column
        ///        summary information. By default, this panel contains no
        ///        rows and therefore is not visible..
        /// </summary>
        internal static string GridPanels_Text7 {
            get {
                return ResourceManager.GetString("GridPanels_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Although these panels are synchronized so that they remain aligned with
        ///    each other when the grid scrolls, each one has its own set of 
        ///    properties that can be used to customize the specific areas of the grid..
        /// </summary>
        internal static string GridPanels_Text8 {
            get {
                return ResourceManager.GetString("GridPanels_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Move the mouse over the grid below to see each panel and
        ///    hit-test information of the cell being hovered:.
        /// </summary>
        internal static string GridPanels_Text9 {
            get {
                return ResourceManager.GetString("GridPanels_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Grid Panels.
        /// </summary>
        internal static string GridPanels_Title {
            get {
                return ResourceManager.GetString("GridPanels_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid supports grouping via source &lt;b&gt;CollectionView&lt;/b&gt;..
        /// </summary>
        internal static string Grouping_Text1 {
            get {
                return ResourceManager.GetString("Grouping_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Group the data by one or more properties by adding &lt;b&gt;GroupDescription&lt;/b&gt;
        ///    objects to the grid&apos;s &lt;b&gt;collectionView.groupDescriptions&lt;/b&gt;..
        /// </summary>
        internal static string Grouping_Text2 {
            get {
                return ResourceManager.GetString("Grouping_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below groups the data by country and by product:.
        /// </summary>
        internal static string Grouping_Text3 {
            get {
                return ResourceManager.GetString("Grouping_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You may also want to hide the columns that are being grouped
        ///    on in order to avoid showing redundant data..
        /// </summary>
        internal static string Grouping_Text4 {
            get {
                return ResourceManager.GetString("Grouping_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below groups the data by country and product, and
        ///    hides those columns to achieve a compact grid..
        /// </summary>
        internal static string Grouping_Text5 {
            get {
                return ResourceManager.GetString("Grouping_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Grouping.
        /// </summary>
        internal static string Grouping_Title {
            get {
                return ResourceManager.GetString("Grouping_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;wijmo.grid.grouppanel&lt;/b&gt; module provides a &lt;b&gt;GroupPanel&lt;/b&gt;
        ///    control that adds an Outlook-style grouping UI to the grid..
        /// </summary>
        internal static string GroupPanel_Text1 {
            get {
                return ResourceManager.GetString("GroupPanel_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To use the &lt;b&gt;GroupPanel&lt;/b&gt; control, drag column headers into
        ///    the panel to create the groups. You may also remove or change 
        ///    the order of groups by dragging them to a new position..
        /// </summary>
        internal static string GroupPanel_Text2 {
            get {
                return ResourceManager.GetString("GroupPanel_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to GroupPanel control.
        /// </summary>
        internal static string GroupPanel_Title {
            get {
                return ResourceManager.GetString("GroupPanel_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid supports content-driven cell merging
        ///    in column header cells..
        /// </summary>
        internal static string HeaderMerging_Text1 {
            get {
                return ResourceManager.GetString("HeaderMerging_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Header Merging.
        /// </summary>
        internal static string HeaderMerging_Title {
            get {
                return ResourceManager.GetString("HeaderMerging_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The CollectionView class supports filtering only for items
        ///    that are direct children of the collection. In most of the cases,
        ///    it does not work well for hierarchical data..
        /// </summary>
        internal static string HierarchicalDataFiltering_Text1 {
            get {
                return ResourceManager.GetString("HierarchicalDataFiltering_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Filtering hierarchical data is not a trivial exercise because
        ///    when a child element is visible, all its ancestors should
        ///    also be visible..
        /// </summary>
        internal static string HierarchicalDataFiltering_Text2 {
            get {
                return ResourceManager.GetString("HierarchicalDataFiltering_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below shows how you can implement a simple hierarchical
        ///    binding method that will show cities that match the filter and
        ///    states that match the filter or contain cities that do.
        ///    For example, try typing &apos;San&apos; in the filter box below:.
        /// </summary>
        internal static string HierarchicalDataFiltering_Text3 {
            get {
                return ResourceManager.GetString("HierarchicalDataFiltering_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Filter.
        /// </summary>
        internal static string HierarchicalDataFiltering_Text4 {
            get {
                return ResourceManager.GetString("HierarchicalDataFiltering_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For more details on hierarchical filtering, please see our
        ///    &lt;a href=&quot;http://wijmo.com/blog/filter-hierarchical-data-flexgrid/&quot; target=&quot;_blank&quot;&gt;How to Filter Hierarchical Data in FlexGrid and Angular&lt;/a&gt;
        ///    blog..
        /// </summary>
        internal static string HierarchicalDataFiltering_Text5 {
            get {
                return ResourceManager.GetString("HierarchicalDataFiltering_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Filtering Hierarchical Data.
        /// </summary>
        internal static string HierarchicalDataFiltering_Title {
            get {
                return ResourceManager.GetString("HierarchicalDataFiltering_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Regular grids and &lt;b&gt;CollectionView&lt;/b&gt; objects are
        ///    great for dealing with flat data but not with data
        ///    structures having hierarchical structure. However,
        ///    FlexGrid provides a few properties and extensions
        ///    to help you deal with such data structures as well..
        /// </summary>
        internal static string HierarchicalData_Text1 {
            get {
                return ResourceManager.GetString("HierarchicalData_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The next topics show different ways to handle hierarchical
        ///    data with FlexGrid, including Master-Detail, Tree Grids,
        ///    and Row Details..
        /// </summary>
        internal static string HierarchicalData_Text2 {
            get {
                return ResourceManager.GetString("HierarchicalData_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Hierarchical Data.
        /// </summary>
        internal static string HierarchicalData_Title {
            get {
                return ResourceManager.GetString("HierarchicalData_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to IME is an abbreviation of
        ///    &lt;a href=&quot;https://en.wikipedia.org/wiki/Input_method&quot; target=&quot;_blank&quot;&gt;
        ///        Input Method Editor
        ///    &lt;/a&gt;..
        /// </summary>
        internal static string Ime_Text1 {
            get {
                return ResourceManager.GetString("Ime_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to IME allows any data, such as keyboard strokes or mouse movements,
        ///    to be received as input. In this way, users can enter characters and
        ///    symbols that are not found on their input devices. IME is obligatory for
        ///    languages such as Japanese, Chinese, Korean, and Taiwanese..
        /// </summary>
        internal static string Ime_Text2 {
            get {
                return ResourceManager.GetString("Ime_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid supports IME through its &lt;b&gt;imeEnabled&lt;/b&gt;
        ///    property. For example, the grid below has &lt;b&gt;imeEnabled&lt;/b&gt;
        ///    set to true..
        /// </summary>
        internal static string Ime_Text3 {
            get {
                return ResourceManager.GetString("Ime_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you set the keyboard language to Japanese or Chinese and
        ///    enable IME, the grid honors that setting and allows
        ///    you to edit cells using the selected IME mode by typing
        ///    directly into the cells:.
        /// </summary>
        internal static string Ime_Text4 {
            get {
                return ResourceManager.GetString("Ime_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Input Method Editor (IME).
        /// </summary>
        internal static string Ime_Title {
            get {
                return ResourceManager.GetString("Ime_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Printer can also be seen as an export option, especially
        ///    since most modern browsers allow users to redirect the output
        ///    to PDF files, cloud storage, etc..
        /// </summary>
        internal static string ImportExport_Text1 {
            get {
                return ResourceManager.GetString("ImportExport_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;PrintDocument&lt;/b&gt; class makes it easy to create
        ///    documents for printing. This sample shows how you can
        ///    convert a FlexGrid into a &lt;b&gt;table&lt;/b&gt; element suitable
        ///    for printing with the &lt;b&gt;PrintDocument&lt;/b&gt; class..
        /// </summary>
        internal static string ImportExport_Text2 {
            get {
                return ResourceManager.GetString("ImportExport_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Print with PrintDocument.
        /// </summary>
        internal static string ImportExport_Text3 {
            get {
                return ResourceManager.GetString("ImportExport_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Printer.
        /// </summary>
        internal static string ImportExport_Title {
            get {
                return ResourceManager.GetString("ImportExport_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid allows you to visualize and edit tabular data.
        ///    It provides a variety of options about how to present and
        ///    perform operations over the data, including selection,
        ///    sorting, filtering, grouping, paging, editing, formatting,
        ///    etc..
        /// </summary>
        internal static string Index_Text1 {
            get {
                return ResourceManager.GetString("Index_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Populate the FlexGrid by setting its &lt;b&gt;itemsSource&lt;/b&gt;
        ///    property to an array containing regular JavaScript objects.
        ///    The grid will automatically generate columns to display
        ///    the data items, and will allow users to select, sort, and
        ///    edit the data..
        /// </summary>
        internal static string Index_Text2 {
            get {
                return ResourceManager.GetString("Index_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can customize the grid columns by setting the
        ///    &lt;b&gt;autoGenerateColumns&lt;/b&gt; property to false and populating
        ///    the columns property in code..
        /// </summary>
        internal static string Index_Text3 {
            get {
                return ResourceManager.GetString("Index_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can customize the default features of grid by setting
        ///    the properties such as &lt;b&gt;selectionMode&lt;/b&gt;, &lt;b&gt;allowSorting&lt;/b&gt;, 
        ///    &lt;b&gt;allowDragging&lt;/b&gt;, &lt;b&gt;isReadOnly&lt;/b&gt; and &lt;b&gt;headersVisibility&lt;/b&gt;..
        /// </summary>
        internal static string Index_Text4 {
            get {
                return ResourceManager.GetString("Index_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to selectionMode:.
        /// </summary>
        internal static string Index_Text5 {
            get {
                return ResourceManager.GetString("Index_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to allowSorting:.
        /// </summary>
        internal static string Index_Text6 {
            get {
                return ResourceManager.GetString("Index_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to allowDragging:.
        /// </summary>
        internal static string Index_Text7 {
            get {
                return ResourceManager.GetString("Index_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to isReadOnly:.
        /// </summary>
        internal static string Index_Text8 {
            get {
                return ResourceManager.GetString("Index_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to headersVisibility:.
        /// </summary>
        internal static string Index_Text9 {
            get {
                return ResourceManager.GetString("Index_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid.
        /// </summary>
        internal static string Index_Title {
            get {
                return ResourceManager.GetString("Index_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Although FlexGrid provides efficient, Excel-style
        ///    editing by default, you may want to customize the
        ///    editing behavior..
        /// </summary>
        internal static string InlineEditing_Text1 {
            get {
                return ResourceManager.GetString("InlineEditing_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If for some reason you don&apos;t like the Excel-style
        ///    editing and prefer to add editing buttons to every
        ///    row (typical of editable HTML tables), you can
        ///    accomplish that using the &lt;b&gt;formatItem&lt;/b&gt; event
        ///    and a little code..
        /// </summary>
        internal static string InlineEditing_Text2 {
            get {
                return ResourceManager.GetString("InlineEditing_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below demonstrates this approach:.
        /// </summary>
        internal static string InlineEditing_Text3 {
            get {
                return ResourceManager.GetString("InlineEditing_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Inline Editing.
        /// </summary>
        internal static string InlineEditing_Title {
            get {
                return ResourceManager.GetString("InlineEditing_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The simplest way to deal with hierarchical data is
        ///    the master-detail model. Use a control to select the
        ///    main item and one or more additional controls to show
        ///    the main item&apos;s details..
        /// </summary>
        internal static string MasterDetail_Text1 {
            get {
                return ResourceManager.GetString("MasterDetail_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the ComboBox below is used as a master
        ///    control. Select a country from the combo and the
        ///    grid below will show the items in that country:.
        /// </summary>
        internal static string MasterDetail_Text2 {
            get {
                return ResourceManager.GetString("MasterDetail_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Select a country:.
        /// </summary>
        internal static string MasterDetail_Text3 {
            get {
                return ResourceManager.GetString("MasterDetail_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In the next example, FlexGrid is used as the master
        ///    control. Select an item on the grid and see the details
        ///    in the controls below:.
        /// </summary>
        internal static string MasterDetail_Text4 {
            get {
                return ResourceManager.GetString("MasterDetail_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Country:.
        /// </summary>
        internal static string MasterDetail_Text5 {
            get {
                return ResourceManager.GetString("MasterDetail_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Product:.
        /// </summary>
        internal static string MasterDetail_Text6 {
            get {
                return ResourceManager.GetString("MasterDetail_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Date:.
        /// </summary>
        internal static string MasterDetail_Text7 {
            get {
                return ResourceManager.GetString("MasterDetail_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sales:.
        /// </summary>
        internal static string MasterDetail_Text8 {
            get {
                return ResourceManager.GetString("MasterDetail_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Expenses:.
        /// </summary>
        internal static string MasterDetail_Text9 {
            get {
                return ResourceManager.GetString("MasterDetail_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Master Detail.
        /// </summary>
        internal static string MasterDetail_Title {
            get {
                return ResourceManager.GetString("MasterDetail_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Master.
        /// </summary>
        internal static string MasterDetail_Title1 {
            get {
                return ResourceManager.GetString("MasterDetail_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Detail.
        /// </summary>
        internal static string MasterDetail_Title2 {
            get {
                return ResourceManager.GetString("MasterDetail_Title2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid has a &lt;b&gt;ListBox&lt;/b&gt; selection mode that
        ///    allows users to select non-contiguous ranges of rows.
        ///    But, it does not have a built-in selection mode that
        ///    allows user to select multiple, non-contiguous ranges
        ///    of cells..
        /// </summary>
        internal static string MultiRangeSelection_Text1 {
            get {
                return ResourceManager.GetString("MultiRangeSelection_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can add multi-range selection support by handling
        ///    a few events. For example, press the Control key while
        ///    selecting ranges with the mouse on the grid below
        ///    (the console shows the list of selected ranges
        ///    as the selection changes):.
        /// </summary>
        internal static string MultiRangeSelection_Text2 {
            get {
                return ResourceManager.GetString("MultiRangeSelection_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Multi-Range Selection.
        /// </summary>
        internal static string MultiRangeSelection_Title {
            get {
                return ResourceManager.GetString("MultiRangeSelection_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid shows scrollbars automatically, when the
        ///    width or height of the grid content exceeds the 
        ///    dimensions of the grid..
        /// </summary>
        internal static string NoScrollbars_Text1 {
            get {
                return ResourceManager.GetString("NoScrollbars_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you want to keep the grid scrollable without 
        ///    displaying the scroll bars, you can use CSS to 
        ///    set the &lt;b&gt;overflow&lt;/b&gt; property of the grid&apos;s
        ///    root element to &apos;hidden&apos;..
        /// </summary>
        internal static string NoScrollbars_Text2 {
            get {
                return ResourceManager.GetString("NoScrollbars_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you want to support scrolling with the mouse wheel
        ///    even without scrollbars, add a handler to the &quot;wheel&quot;
        ///    event and update the &lt;b&gt;scrollTop&lt;/b&gt; value of root element:.
        /// </summary>
        internal static string NoScrollbars_Text3 {
            get {
                return ResourceManager.GetString("NoScrollbars_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No Scrollbars.
        /// </summary>
        internal static string NoScrollbars_Title {
            get {
                return ResourceManager.GetString("NoScrollbars_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To export FlexGrid to PDF, call the
        ///    &lt;b&gt;FlexGridPdfConverter.export&lt;/b&gt; method and
        ///    provide a reference to the grid that will be exported,
        ///    the file name, and extra options to define the
        ///    page format, headers and footers, and styles..
        /// </summary>
        internal static string Pdf_Text1 {
            get {
                return ResourceManager.GetString("Pdf_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Export to PDF.
        /// </summary>
        internal static string Pdf_Text2 {
            get {
                return ResourceManager.GetString("Pdf_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Create PDF Document.
        /// </summary>
        internal static string Pdf_Text3 {
            get {
                return ResourceManager.GetString("Pdf_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Export to PDF.
        /// </summary>
        internal static string Pdf_Title {
            get {
                return ResourceManager.GetString("Pdf_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example shows how you can save and restore the grid
        ///    state, including column layout, sort descriptions, and
        ///    filter definitions..
        /// </summary>
        internal static string PersistingState_Text1 {
            get {
                return ResourceManager.GetString("PersistingState_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Try reordering, resizing, sorting, and filtering the columns
        ///    on the grid below. Then press the &quot;Save State&quot; button to save the
        ///    state to local storage. Run the sample again and press the
        ///    &quot;Restore State&quot; button to restore the layout that you saved..
        /// </summary>
        internal static string PersistingState_Text2 {
            get {
                return ResourceManager.GetString("PersistingState_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Save State.
        /// </summary>
        internal static string PersistingState_Text3 {
            get {
                return ResourceManager.GetString("PersistingState_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Restore State.
        /// </summary>
        internal static string PersistingState_Text4 {
            get {
                return ResourceManager.GetString("PersistingState_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Persisting the Grid State.
        /// </summary>
        internal static string PersistingState_Title {
            get {
                return ResourceManager.GetString("PersistingState_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;FlexGrid&lt;/b&gt; supports quick editing by default.
        ///    If you select a cell and start typing, the grid will
        ///    automatically switch to the edit mode so that you can
        ///    edit cells as you would do in Excel..
        /// </summary>
        internal static string QuickEditing_Text1 {
            get {
                return ResourceManager.GetString("QuickEditing_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &apos;quick-edit&apos; mode also allows users to finish
        ///    editing using the arrow keys to move on to the next
        ///    cell. Please note that in the full-edit mode, the
        ///    arrow keys move the cursor within the editor. The 
        ///    F2 key toggles the edit mode between quick and full modes..
        /// </summary>
        internal static string QuickEditing_Text2 {
            get {
                return ResourceManager.GetString("QuickEditing_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you want to disable quick editing, the easiest way
        ///    is to handle the &lt;b&gt;beginninEdit&lt;/b&gt; event and set the
        ///    cancel parameter to true if the source event was a
        ///    &apos;keypress&apos;. The grid below demonstrates this behavior..
        /// </summary>
        internal static string QuickEditing_Text3 {
            get {
                return ResourceManager.GetString("QuickEditing_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Allow Quick-Editing.
        /// </summary>
        internal static string QuickEditing_Text4 {
            get {
                return ResourceManager.GetString("QuickEditing_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Excel-Style Quick-Editing.
        /// </summary>
        internal static string QuickEditing_Title {
            get {
                return ResourceManager.GetString("QuickEditing_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can disable editing at the grid, column, or row levels
        ///    using the &lt;b&gt;isReadOnly&lt;/b&gt; property of the grid, column,
        ///    or row objects respectively. You can also disable editing 
        ///    for specific cells using the &lt;b&gt;cellEditStarting&lt;/b&gt; event..
        /// </summary>
        internal static string ReadOnlyRequiredColumns_Text1 {
            get {
                return ResourceManager.GetString("ReadOnlyRequiredColumns_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can use the column&apos;s &lt;b&gt;isRequired&lt;/b&gt; property to
        ///    determine whether empty/null values should be allowed
        ///    for that column..
        /// </summary>
        internal static string ReadOnlyRequiredColumns_Text2 {
            get {
                return ResourceManager.GetString("ReadOnlyRequiredColumns_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below prevents users from entering empty
        ///    values for the &apos;Country&apos; column, and allows them to delete
        ///    the content of the numeric columns..
        /// </summary>
        internal static string ReadOnlyRequiredColumns_Text3 {
            get {
                return ResourceManager.GetString("ReadOnlyRequiredColumns_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid also uses the &lt;b&gt;beginningEdit&lt;/b&gt; event to
        ///    prevent users from editing items that are overdue:.
        /// </summary>
        internal static string ReadOnlyRequiredColumns_Text4 {
            get {
                return ResourceManager.GetString("ReadOnlyRequiredColumns_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Read-Only, Required Columns.
        /// </summary>
        internal static string ReadOnlyRequiredColumns_Title {
            get {
                return ResourceManager.GetString("ReadOnlyRequiredColumns_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, FlexGrid merges cells that have the
        ///    same content, regardless of the content of neighboring
        ///    cells..
        /// </summary>
        internal static string RestrictedMerging_Text1 {
            get {
                return ResourceManager.GetString("RestrictedMerging_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In this example, we use a custom merge manager that
        ///    merges cells vertically only if the cells in the
        ///    previous column contain the same value..
        /// </summary>
        internal static string RestrictedMerging_Text2 {
            get {
                return ResourceManager.GetString("RestrictedMerging_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Restricted Merging.
        /// </summary>
        internal static string RestrictedMerging_Title {
            get {
                return ResourceManager.GetString("RestrictedMerging_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In most of the cases, you do not need to write code to add or
        ///    remove rows from the grid. By default, it has
        ///    one row of column headers and one row per bound item
        ///    which is added automatically when you set the grid&apos;s
        ///    &lt;b&gt;itemsSource&lt;/b&gt; property..
        /// </summary>
        internal static string RowsAddingRemoving_Text1 {
            get {
                return ResourceManager.GetString("RowsAddingRemoving_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you want to allow users to add or remove rows at
        ///    runtime, use the following properties:.
        /// </summary>
        internal static string RowsAddingRemoving_Text2 {
            get {
                return ResourceManager.GetString("RowsAddingRemoving_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;allowAddNew&lt;/b&gt;:
        ///        Setting this property to true causes the grid to show
        ///        a new row &apos;template&apos; at the bottom of the grid. Users
        ///        may add new rows to the &lt;b&gt;itemsSource&lt;/b&gt; array by
        ///        filling out the cells in the new row template..
        /// </summary>
        internal static string RowsAddingRemoving_Text3 {
            get {
                return ResourceManager.GetString("RowsAddingRemoving_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;allowRemove&lt;/b&gt;:
        ///        Setting this property to true causes the grid to handle
        ///        the &apos;Delete&apos; key and remove selected rows. Users may
        ///        click row headers to select the row, then press &apos;Delete&apos;
        ///        to remove the bound items from the &lt;b&gt;itemsSource&lt;/b&gt;
        ///        array..
        /// </summary>
        internal static string RowsAddingRemoving_Text4 {
            get {
                return ResourceManager.GetString("RowsAddingRemoving_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;newRowAtTop&lt;/b&gt;:
        ///        Setting this property to true causes the grid to show the
        ///        new row template at the top of the grid rather than at
        ///        the bottom..
        /// </summary>
        internal static string RowsAddingRemoving_Text5 {
            get {
                return ResourceManager.GetString("RowsAddingRemoving_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below shows how this works:.
        /// </summary>
        internal static string RowsAddingRemoving_Text6 {
            get {
                return ResourceManager.GetString("RowsAddingRemoving_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to newRowAtTop.
        /// </summary>
        internal static string RowsAddingRemoving_Text7 {
            get {
                return ResourceManager.GetString("RowsAddingRemoving_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Adding and Removing Rows.
        /// </summary>
        internal static string RowsAddingRemoving_Title {
            get {
                return ResourceManager.GetString("RowsAddingRemoving_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexGrid control is made up of six
        ///    &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/webframe.html#wijmo.grid.GridPanel.Class.html&quot; target=&quot;_blank&quot;&gt;GridPanel&lt;/a&gt;
        ///    elements..
        /// </summary>
        internal static string RowsColumns_Text1 {
            get {
                return ResourceManager.GetString("RowsColumns_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Scrollable Rows:&lt;/b&gt;
        ///    The two panels along the middle of the grid share a collection
        ///    of &apos;scrollable&apos; rows:.
        /// </summary>
        internal static string RowsColumns_Text10 {
            get {
                return ResourceManager.GetString("RowsColumns_Text10", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Footer Rows:&lt;/b&gt;
        ///    The two panels along the bottom of the grid share a collection
        ///    of &apos;footer&apos; rows:.
        /// </summary>
        internal static string RowsColumns_Text11 {
            get {
                return ResourceManager.GetString("RowsColumns_Text11", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Each panel has a collection of &lt;b&gt;rows&lt;/b&gt; and &lt;b&gt;columns&lt;/b&gt;.
        ///    Rows and columns have properties that define what should be
        ///    displayed in each cell of each panel..
        /// </summary>
        internal static string RowsColumns_Text2 {
            get {
                return ResourceManager.GetString("RowsColumns_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifically, &lt;b&gt;Row&lt;/b&gt; objects have a &lt;b&gt;dataItem&lt;/b&gt; property
        ///    that determines the object the row is bound to, and &lt;b&gt;Column&lt;/b&gt;
        ///    objects have a &lt;b&gt;binding&lt;/b&gt; property that determines which property
        ///    of the data item should be displayed in the cell..
        /// </summary>
        internal static string RowsColumns_Text3 {
            get {
                return ResourceManager.GetString("RowsColumns_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In most of the situations, you can simply use &lt;b&gt;rows&lt;/b&gt; and 
        ///    &lt;b&gt;columns&lt;/b&gt; properties of the grid, which refer to the row and
        ///    column collections of the &lt;b&gt;cells&lt;/b&gt; panel..
        /// </summary>
        internal static string RowsColumns_Text4 {
            get {
                return ResourceManager.GetString("RowsColumns_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to But there are situations where you will need the properties
        ///    of specific panels. For example, to create a multi-row column
        ///    header, multi-column row header, or to add rows to the
        ///    group footer panel..
        /// </summary>
        internal static string RowsColumns_Text5 {
            get {
                return ResourceManager.GetString("RowsColumns_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The collections of rows and columns are shared by the panels as
        ///    follows:.
        /// </summary>
        internal static string RowsColumns_Text6 {
            get {
                return ResourceManager.GetString("RowsColumns_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Header Columns:&lt;/b&gt;
        ///    The three panels on the left of the grid share a collection
        ///    of &apos;header&apos; columns:.
        /// </summary>
        internal static string RowsColumns_Text7 {
            get {
                return ResourceManager.GetString("RowsColumns_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Scrollable Columns:&lt;/b&gt;
        ///    The three panels on the right of the grid share a collection
        ///    of &apos;scrollable&apos; columns:.
        /// </summary>
        internal static string RowsColumns_Text8 {
            get {
                return ResourceManager.GetString("RowsColumns_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Header Rows:&lt;/b&gt;
        ///    The two panels along the top of the grid share a collection
        ///    of &apos;header&apos; rows:.
        /// </summary>
        internal static string RowsColumns_Text9 {
            get {
                return ResourceManager.GetString("RowsColumns_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Rows and Columns.
        /// </summary>
        internal static string RowsColumns_Title {
            get {
                return ResourceManager.GetString("RowsColumns_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sometimes rows are bound to data objects that contain
        ///    more information than what would fit easily on a regular grid..
        /// </summary>
        internal static string RowsDetails_Text1 {
            get {
                return ResourceManager.GetString("RowsDetails_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In these scenarios, you may want to use the
        ///    &lt;b&gt;FlexGridDetailProvider&lt;/b&gt; class that is included with
        ///    the &lt;b&gt;wijmo.grid.detail&lt;/b&gt; module..
        /// </summary>
        internal static string RowsDetails_Text2 {
            get {
                return ResourceManager.GetString("RowsDetails_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;FlexGridDetailProvider&lt;/b&gt; extends the &lt;b&gt;FlexGrid&lt;/b&gt;
        ///    class by adding collapse/expand buttons to row headers, and a
        ///    &lt;b&gt;createDetailCell&lt;/b&gt; method that can be used to provide
        ///    additional details about an item. The detail information
        ///    is shown in a &apos;detail row&apos; added to the grid when the
        ///    details are expanded, and removed when they are collapsed..
        /// </summary>
        internal static string RowsDetails_Text3 {
            get {
                return ResourceManager.GetString("RowsDetails_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This grid shows product categories on each row. Expanding
        ///    the rows shows an HTML element with information about
        ///    the products in that category..
        /// </summary>
        internal static string RowsDetails_Text4 {
            get {
                return ResourceManager.GetString("RowsDetails_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can add anything you want to the detail rows,
        ///    including other grids. This example shows the same
        ///    categories, but the detail row uses another grid
        ///    to show the products..
        /// </summary>
        internal static string RowsDetails_Text5 {
            get {
                return ResourceManager.GetString("RowsDetails_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Row Details.
        /// </summary>
        internal static string RowsDetails_Title {
            get {
                return ResourceManager.GetString("RowsDetails_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to HTML in Row Details.
        /// </summary>
        internal static string RowsDetails_Title1 {
            get {
                return ResourceManager.GetString("RowsDetails_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Grids in Row Details.
        /// </summary>
        internal static string RowsDetails_Title2 {
            get {
                return ResourceManager.GetString("RowsDetails_Title2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;wijmo.grid.Row&lt;/b&gt; class has
        ///    &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/webframe.html#wijmo.grid.Row.Class.html&quot; target=&quot;_blank&quot;&gt;
        ///        almost 20 properties
        ///    &lt;/a&gt; which you can use to configure rows&apos;s appearance and behavior..
        /// </summary>
        internal static string RowsProperties_Text1 {
            get {
                return ResourceManager.GetString("RowsProperties_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, click the button below to hide or show every alternate
        ///    row on the grid..
        /// </summary>
        internal static string RowsProperties_Text10 {
            get {
                return ResourceManager.GetString("RowsProperties_Text10", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Toggle Row Visibility.
        /// </summary>
        internal static string RowsProperties_Text11 {
            get {
                return ResourceManager.GetString("RowsProperties_Text11", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Note that when grids refresh, the scrollable rows are re-created
        ///    (so they can be bound to the new data). Because of this, you
        ///    should normally apply row properties in response to the
        ///    &lt;b&gt;loadedRows&lt;/b&gt; event, which fires after the rows have been
        ///    created..
        /// </summary>
        internal static string RowsProperties_Text2 {
            get {
                return ResourceManager.GetString("RowsProperties_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Most rows are instances of the &lt;b&gt;Row&lt;/b&gt; class, but grouped grids
        ///    may also contain &lt;b&gt;GroupRow&lt;/b&gt; objects, which extend the regular
        ///    &lt;b&gt;Row&lt;/b&gt; class..
        /// </summary>
        internal static string RowsProperties_Text3 {
            get {
                return ResourceManager.GetString("RowsProperties_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The most important properties in the &lt;b&gt;Row&lt;/b&gt; class are:.
        /// </summary>
        internal static string RowsProperties_Text4 {
            get {
                return ResourceManager.GetString("RowsProperties_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;dataItem&lt;/b&gt;:
        ///        Contains a reference to the data item that is bound to the row.
        ///        This property is set by the grid when it creates bound rows, and
        ///        is often used in &lt;b&gt;formatItem&lt;/b&gt; event handlers.
        ///        In &lt;b&gt;GroupRow&lt;/b&gt; objects, the &lt;b&gt;dataItem&lt;/b&gt; property
        ///        contains a reference to the row&apos;s &lt;b&gt;Group&lt;/b&gt; rather than
        ///        to a regular data item..
        /// </summary>
        internal static string RowsProperties_Text5 {
            get {
                return ResourceManager.GetString("RowsProperties_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;isReadOnly&lt;/b&gt;:
        ///        Gets or sets whether the row is editable. By default, &lt;b&gt;Row&lt;/b&gt;
        ///        instances are editable and &lt;b&gt;GroupRow&lt;/b&gt; instances are not..
        /// </summary>
        internal static string RowsProperties_Text6 {
            get {
                return ResourceManager.GetString("RowsProperties_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;isSelected&lt;/b&gt;:
        ///        This property is important when the grid&apos;s &lt;b&gt;selectionMode&lt;/b&gt;
        ///        property is set to &lt;b&gt;ListBox&lt;/b&gt;. In this case, users may select
        ///        non-contiguous sets of rows, and the &lt;b&gt;isSelected&lt;/b&gt; property
        ///        allows you to get or set the selected state of individual rows..
        /// </summary>
        internal static string RowsProperties_Text7 {
            get {
                return ResourceManager.GetString("RowsProperties_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;visible&lt;/b&gt;:
        ///        Gets or sets whether the row is visible. You can use this property
        ///        to conditionally hide rows..
        /// </summary>
        internal static string RowsProperties_Text8 {
            get {
                return ResourceManager.GetString("RowsProperties_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;isVisible&lt;/b&gt;:
        ///        Gets a value that indicates whether the row is currently visible.
        ///        Even if the &lt;b&gt;visible&lt;/b&gt; property is set to true, rows may
        ///        be hidden because they are part of collapsed groups..
        /// </summary>
        internal static string RowsProperties_Text9 {
            get {
                return ResourceManager.GetString("RowsProperties_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Row Properties.
        /// </summary>
        internal static string RowsProperties_Title {
            get {
                return ResourceManager.GetString("RowsProperties_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, grid cells have solid backgrounds. This can get
        ///    in the way of styling rows using pseudo selectors such as :hover..
        /// </summary>
        internal static string RowsStylingHover_Text1 {
            get {
                return ResourceManager.GetString("RowsStylingHover_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can simply give a hover style to cells. 
        ///    Just add some CSS based on the &apos;.wj-cell&apos; class and &apos;:hover&apos;
        ///    pseudo-selector:.
        /// </summary>
        internal static string RowsStylingHover_Text2 {
            get {
                return ResourceManager.GetString("RowsStylingHover_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you want to give a hover style to entire row, apply the hover
        ///    pseudo-style to the &apos;.wj-row&apos; element instead, and extend it to
        ///    the row&apos;s non-selected child cells:.
        /// </summary>
        internal static string RowsStylingHover_Text3 {
            get {
                return ResourceManager.GetString("RowsStylingHover_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Hover Styles.
        /// </summary>
        internal static string RowsStylingHover_Title {
            get {
                return ResourceManager.GetString("RowsStylingHover_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Hover on Cells.
        /// </summary>
        internal static string RowsStylingHover_Title1 {
            get {
                return ResourceManager.GetString("RowsStylingHover_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Hover on Rows.
        /// </summary>
        internal static string RowsStylingHover_Title2 {
            get {
                return ResourceManager.GetString("RowsStylingHover_Title2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, the grid computes row heights based on the
        ///    font size and a default cell padding which is set to
        ///    three pixels in the &apos;wijmo.css&apos; file..
        /// </summary>
        internal static string RowsStylingRowHeight_Text1 {
            get {
                return ResourceManager.GetString("RowsStylingRowHeight_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can change this default value easily by specifying a
        ///    different padding for the cells using CSS. This
        ///    is a good approach because it applies to cells in
        ///    all grid panels and does not require any code..
        /// </summary>
        internal static string RowsStylingRowHeight_Text2 {
            get {
                return ResourceManager.GetString("RowsStylingRowHeight_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the first grid below uses the default
        ///    styles. The second increases cell padding to eight
        ///    pixels, which makes it easier to use on devices
        ///    with small screens:.
        /// </summary>
        internal static string RowsStylingRowHeight_Text3 {
            get {
                return ResourceManager.GetString("RowsStylingRowHeight_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Row Height.
        /// </summary>
        internal static string RowsStylingRowHeight_Title {
            get {
                return ResourceManager.GetString("RowsStylingRowHeight_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Default Cell Padding: 3px.
        /// </summary>
        internal static string RowsStylingRowHeight_Title1 {
            get {
                return ResourceManager.GetString("RowsStylingRowHeight_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Cell Padding: 8px.
        /// </summary>
        internal static string RowsStylingRowHeight_Title2 {
            get {
                return ResourceManager.GetString("RowsStylingRowHeight_Title2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In most of the cases, the vertical alignment of content within
        ///    FlexGrid cells doesn&apos;t matter, since cells contain only
        ///    a single row of content. However, in some situations
        ///    you may want to control the vertical alignment of some
        ///    or all cells. For example, when showing wrapping text
        ///    or merging cells vertically..
        /// </summary>
        internal static string RowsStylingVerticalAlignment_Text1 {
            get {
                return ResourceManager.GetString("RowsStylingVerticalAlignment_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To control the vertical alignment of FlexGrid cells,
        ///    you should use the &lt;b&gt;formatItem&lt;/b&gt; event and modify
        ///    the cell&apos;s HTML to achieve the result you want..
        /// </summary>
        internal static string RowsStylingVerticalAlignment_Text2 {
            get {
                return ResourceManager.GetString("RowsStylingVerticalAlignment_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the grid below has cells that are
        ///    vertically aligned using a CSS transform:.
        /// </summary>
        internal static string RowsStylingVerticalAlignment_Text3 {
            get {
                return ResourceManager.GetString("RowsStylingVerticalAlignment_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Vertical Alignment.
        /// </summary>
        internal static string RowsStylingVerticalAlignment_Title {
            get {
                return ResourceManager.GetString("RowsStylingVerticalAlignment_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, the grid adds a &apos;wj-alt&apos; class to every other
        ///    row, and the &apos;wijmo.css&apos; file uses this class to style
        ///    alternating rows. You can disable this using some custom
        ///    CSS, but it is often easier just to set the grid&apos;s
        ///    &lt;b&gt;showAlternatingRows&lt;/b&gt; property to false if you don&apos;t
        ///    want alternating row styles applied at all..
        /// </summary>
        internal static string RowsStyling_Text1 {
            get {
                return ResourceManager.GetString("RowsStyling_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid re-generates rows whenever the data source
        ///    refreshes, which happens when the data is sorted, filtered,
        ///    grouped, or edited. Because of this, you should not expect
        ///    row properties to retain their values in most cases..
        /// </summary>
        internal static string RowsStyling_Text2 {
            get {
                return ResourceManager.GetString("RowsStyling_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you do want to apply custom styles to rows, you should
        ///    do this when handling the &lt;b&gt;loadedRows&lt;/b&gt; event, which
        ///    fires whenever the grid re-generates the rows..
        /// </summary>
        internal static string RowsStyling_Text3 {
            get {
                return ResourceManager.GetString("RowsStyling_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The row properties that affect styling are:.
        /// </summary>
        internal static string RowsStyling_Text4 {
            get {
                return ResourceManager.GetString("RowsStyling_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;cssClass&lt;/b&gt;: Specifies a class name to be added to cells
        ///        in this row. The class name can be used in CSS rules to
        ///        modify the style of cells in this row..
        /// </summary>
        internal static string RowsStyling_Text5 {
            get {
                return ResourceManager.GetString("RowsStyling_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;height&lt;/b&gt;: Specifies height of the row in pixels..
        /// </summary>
        internal static string RowsStyling_Text6 {
            get {
                return ResourceManager.GetString("RowsStyling_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below shows the effect of the grid&apos;s &lt;b&gt;showAlternatingRows&lt;/b&gt;
        ///    and the row&apos;s &lt;b&gt;cssClass&lt;/b&gt; properties..
        /// </summary>
        internal static string RowsStyling_Text7 {
            get {
                return ResourceManager.GetString("RowsStyling_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to showAlternatingRows.
        /// </summary>
        internal static string RowsStyling_Text8 {
            get {
                return ResourceManager.GetString("RowsStyling_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Row Styling.
        /// </summary>
        internal static string RowsStyling_Title {
            get {
                return ResourceManager.GetString("RowsStyling_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexGrid control has three sets of rows:.
        /// </summary>
        internal static string Rows_Text1 {
            get {
                return ResourceManager.GetString("Rows_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Header Rows&lt;/b&gt;
        ///        This collection contains the top set of rows;
        ///        it is used by the &lt;b&gt;topLeftCells&lt;/b&gt; and
        ///        &lt;b&gt;columnHeaders&lt;/b&gt; panels.
        ///        By default, this collection contains one row..
        /// </summary>
        internal static string Rows_Text2 {
            get {
                return ResourceManager.GetString("Rows_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Scrollable Rows&lt;/b&gt;
        ///        This collection contains the main set of rows;
        ///        it is used by the &lt;b&gt;cells&lt;/b&gt; and &lt;b&gt;rowHeaders&lt;/b&gt;
        ///        panels.
        ///        By default, this collection does not contain any row.
        ///        It is populated when you set the grid&apos;s
        ///        &lt;b&gt;itemsSource&lt;/b&gt; property..
        /// </summary>
        internal static string Rows_Text3 {
            get {
                return ResourceManager.GetString("Rows_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Footer Rows&lt;/b&gt;
        ///        This collection contains the bottom set of rows;
        ///        it is used by the &lt;b&gt;bottomLeftCells&lt;/b&gt;
        ///        and &lt;b&gt;columnFooters&lt;/b&gt; panels.
        ///        By default, this collection is empty..
        /// </summary>
        internal static string Rows_Text4 {
            get {
                return ResourceManager.GetString("Rows_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The three row collections are &lt;b&gt;RowCollection&lt;/b&gt;
        ///    objects, which extend regular arrays.
        ///    You may add or remove rows by adding or removing &lt;b&gt;Row&lt;/b&gt;
        ///    objects from these arrays.
        ///    In most cases, however, you won&apos;t add or remove scrollable
        ///    rows, since the grid does that automatically when you set
        ///    the &lt;b&gt;itemsSource&lt;/b&gt; property..
        /// </summary>
        internal static string Rows_Text5 {
            get {
                return ResourceManager.GetString("Rows_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the grid below has an extra fixed row and
        ///    automatically-generated scrollable rows:.
        /// </summary>
        internal static string Rows_Text6 {
            get {
                return ResourceManager.GetString("Rows_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Row Collections.
        /// </summary>
        internal static string Rows_Title {
            get {
                return ResourceManager.GetString("Rows_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When user selects a cell using mouse or keyboard,
        ///    FlexGrid automatically ensures that it is visible by
        ///    calling the &lt;b&gt;scrollIntoView&lt;/b&gt; method..
        /// </summary>
        internal static string ScrollingViewRange_Text1 {
            get {
                return ResourceManager.GetString("ScrollingViewRange_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;scrollIntoView&lt;/b&gt; method causes the grid to
        ///    scroll so that the requested cell is within the
        ///    current &lt;b&gt;viewRange&lt;/b&gt;. The grid will scroll the
        ///    minimum amount needed to show the cell, so it may
        ///    become visible at the top, middle, or bottom of the
        ///    view range..
        /// </summary>
        internal static string ScrollingViewRange_Text2 {
            get {
                return ResourceManager.GetString("ScrollingViewRange_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you want to show a specific row at the top of the view
        ///    range, you need a slightly different approach. Get the
        ///    bounding rectangle of the cell you want to show to the
        ///    top and use the coordinates to set the grid&apos;s
        ///    &lt;b&gt;scrollPosition&lt;/b&gt; property..
        /// </summary>
        internal static string ScrollingViewRange_Text3 {
            get {
                return ResourceManager.GetString("ScrollingViewRange_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example:.
        /// </summary>
        internal static string ScrollingViewRange_Text4 {
            get {
                return ResourceManager.GetString("ScrollingViewRange_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Scroll Row 100 Into View.
        /// </summary>
        internal static string ScrollingViewRange_Text5 {
            get {
                return ResourceManager.GetString("ScrollingViewRange_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set Top Cell to Row 100.
        /// </summary>
        internal static string ScrollingViewRange_Text6 {
            get {
                return ResourceManager.GetString("ScrollingViewRange_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Scrolling and ViewRange.
        /// </summary>
        internal static string ScrollingViewRange_Title {
            get {
                return ResourceManager.GetString("ScrollingViewRange_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can use the &apos;wj-state-focused&apos; pseudo-class to improve
        ///    accessibility of your FlexGrid controls..
        /// </summary>
        internal static string SelectionFocus_Text1 {
            get {
                return ResourceManager.GetString("SelectionFocus_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the grid below shows the selection in grey when
        ///    it does not contain the focus, and adds an orange outline
        ///    to the selected cell when the grid does have the focus..
        /// </summary>
        internal static string SelectionFocus_Text2 {
            get {
                return ResourceManager.GetString("SelectionFocus_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Selection and Focus.
        /// </summary>
        internal static string SelectionFocus_Title {
            get {
                return ResourceManager.GetString("SelectionFocus_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, the &lt;b&gt;FlexGrid&lt;/b&gt; allows you to select a
        ///    range of cells with the mouse or keyboard, just like Excel..
        /// </summary>
        internal static string Selection_Text1 {
            get {
                return ResourceManager.GetString("Selection_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;selectionMode&lt;/b&gt; property allows you to change this behavior
        ///    so that users can be restricted from selecting rows, row ranges,
        ///    non-contiguous rows (like in a list-box), single cells,
        ///    or nothing at all..
        /// </summary>
        internal static string Selection_Text2 {
            get {
                return ResourceManager.GetString("Selection_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to selectionMode.
        /// </summary>
        internal static string Selection_Text3 {
            get {
                return ResourceManager.GetString("Selection_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Regardless of the current &lt;b&gt;selectionMode&lt;/b&gt;, the grid raises
        ///    &lt;b&gt;selectionChanging&lt;/b&gt; and &lt;b&gt;selectionChanged&lt;/b&gt; events
        ///    when the selection changes. And you can use the &lt;b&gt;selection&lt;/b&gt;
        ///    property to get or set the current selection as a
        ///    &lt;b&gt;CellRange&lt;/b&gt; value..
        /// </summary>
        internal static string Selection_Text4 {
            get {
                return ResourceManager.GetString("Selection_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Select the first four cells.
        /// </summary>
        internal static string Selection_Text5 {
            get {
                return ResourceManager.GetString("Selection_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Current selection: &lt;span id=&quot;currSel&quot;&gt;&lt;/span&gt;..
        /// </summary>
        internal static string Selection_Text6 {
            get {
                return ResourceManager.GetString("Selection_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In &lt;b&gt;ListBox&lt;/b&gt; mode, users can select individual rows using
        ///    ctrl+click, and you can check whether rows are selected
        ///    using the row&apos;s &lt;b&gt;isSelected&lt;/b&gt; property..
        /// </summary>
        internal static string Selection_Text7 {
            get {
                return ResourceManager.GetString("Selection_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Select rows 0, 2, and 4.
        /// </summary>
        internal static string Selection_Text8 {
            get {
                return ResourceManager.GetString("Selection_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;FlexGrid&lt;/b&gt; has built-in clipboard support.
        ///    Press ctrl+c to copy the current selection to the
        ///    clipboard..
        /// </summary>
        internal static string Selection_Text9 {
            get {
                return ResourceManager.GetString("Selection_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Selection.
        /// </summary>
        internal static string Selection_Title {
            get {
                return ResourceManager.GetString("Selection_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, FlexGrid provides the resize and auto-size
        ///    feature through column header cells. So, users can drag
        ///    the right edge of the column header cells to resize 
        ///    columns, or double-click the right edge of the cell to 
        ///    auto-size the columns. This default behavior can be 
        ///    observed in the grid below..
        /// </summary>
        internal static string SizingMouse_Text1 {
            get {
                return ResourceManager.GetString("SizingMouse_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can use the &lt;b&gt;allowResizing&lt;/b&gt; property to customize
        ///    this behavior. Either prevent resizing altogether,
        ///    or allow users to resize columns by dragging the right edge
        ///    of ANY cell. This last option is especially useful in grids
        ///    without column headers. For example:.
        /// </summary>
        internal static string SizingMouse_Text2 {
            get {
                return ResourceManager.GetString("SizingMouse_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sizing with the Mouse.
        /// </summary>
        internal static string SizingMouse_Title {
            get {
                return ResourceManager.GetString("SizingMouse_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, the FlexGrid sets its height automatically
        ///    to fit its content..
        /// </summary>
        internal static string SizingScrolling_Text1 {
            get {
                return ResourceManager.GetString("SizingScrolling_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to However, generally, grid height needs to be adjusted 
        ///    using CSS as per the application design. In that case, 
        ///    the grid automatically shows scrollbars as needed and 
        ///    virtualizes the content to improve performance..
        /// </summary>
        internal static string SizingScrolling_Text2 {
            get {
                return ResourceManager.GetString("SizingScrolling_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Below grid has its maximum height set to 150 pixels:.
        /// </summary>
        internal static string SizingScrolling_Text3 {
            get {
                return ResourceManager.GetString("SizingScrolling_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to And this one demonstrates the default behavior of the grid where 
        ///    it automatically takes the height required to show all its
        ///    content without vertical scrollbars:.
        /// </summary>
        internal static string SizingScrolling_Text4 {
            get {
                return ResourceManager.GetString("SizingScrolling_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sizing and Auto Sizing.
        /// </summary>
        internal static string SizingScrolling_Title {
            get {
                return ResourceManager.GetString("SizingScrolling_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FkexGrid supports sorting via source &lt;b&gt;CollectionView&lt;/b&gt;..
        /// </summary>
        internal static string Sorting_Text1 {
            get {
                return ResourceManager.GetString("Sorting_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, clicking on any column header sorts the data
        ///    based on the column that is clicked. Clicking the same column
        ///    header again reverts the sort order. Control-clicking
        ///    the column header removes the sort..
        /// </summary>
        internal static string Sorting_Text2 {
            get {
                return ResourceManager.GetString("Sorting_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You may customize the sorting behavior using the grid&apos;s
        ///    &lt;b&gt;showSort&lt;/b&gt; and &lt;b&gt;allowSorting&lt;/b&gt; properties. You
        ///    can disable sorting on specific columns by setting the
        ///    column&apos;s &lt;b&gt;allowSorting&lt;/b&gt; property to false..
        /// </summary>
        internal static string Sorting_Text3 {
            get {
                return ResourceManager.GetString("Sorting_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below does not allow sorting by &apos;ID&apos;.
        ///    All other columns support sorting..
        /// </summary>
        internal static string Sorting_Text4 {
            get {
                return ResourceManager.GetString("Sorting_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Although the &lt;b&gt;CollectionView&lt;/b&gt; class supports sorting
        ///        on multiple properties, the grid does not provide a UI
        ///        for that. You can build your own Excel-style sort dialogs
        ///        if you need that functionality..
        /// </summary>
        internal static string Sorting_Text5 {
            get {
                return ResourceManager.GetString("Sorting_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sorting.
        /// </summary>
        internal static string Sorting_Title {
            get {
                return ResourceManager.GetString("Sorting_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set the &lt;b&gt;stickyHeaders&lt;/b&gt; property of FlexGrid to true to 
        ///    keep the column headers visible when users scroll the top
        ///    of the grid off the page..
        /// </summary>
        internal static string StickyHeaders_Text1 {
            get {
                return ResourceManager.GetString("StickyHeaders_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sticky headers enable users to see context all the time, and can
        ///    be used to sort and resize columns as usual..
        /// </summary>
        internal static string StickyHeaders_Text2 {
            get {
                return ResourceManager.GetString("StickyHeaders_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To see how sticky headers work, scroll the page until the
        ///    top of the grid scrolls off the top of the page..
        /// </summary>
        internal static string StickyHeaders_Text3 {
            get {
                return ResourceManager.GetString("StickyHeaders_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to And here&apos; a grid without sticky headers:.
        /// </summary>
        internal static string StickyHeaders_Text4 {
            get {
                return ResourceManager.GetString("StickyHeaders_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sticky Headers.
        /// </summary>
        internal static string StickyHeaders_Title {
            get {
                return ResourceManager.GetString("StickyHeaders_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can use &lt;b&gt;format&lt;/b&gt; function to implement a
        ///    basic template handling mechanism..
        /// </summary>
        internal static string Templates_Text1 {
            get {
                return ResourceManager.GetString("Templates_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below handles the &lt;b&gt;formatItem&lt;/b&gt; event to
        ///    generate the content for cells in the &quot;Template&quot; column
        ///    using a template element defined in the markup:.
        /// </summary>
        internal static string Templates_Text2 {
            get {
                return ResourceManager.GetString("Templates_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Cell Templates.
        /// </summary>
        internal static string Templates_Title {
            get {
                return ResourceManager.GetString("Templates_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If your data items contain collections of child items,
        ///    you may use FlexGrid&apos;s &lt;b&gt;childItemsPath&lt;/b&gt; property to
        ///    show the data as a tree..
        /// </summary>
        internal static string TreeGrids_Text1 {
            get {
                return ResourceManager.GetString("TreeGrids_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, consider a list of &apos;person&apos; objects
        ///    which have a &apos;children&apos; property. The &apos;children&apos;
        ///    property contains an array of more person objects.
        ///    This is sometimes called a &lt;i&gt;homogeneous&lt;/i&gt;
        ///    hierarchy..
        /// </summary>
        internal static string TreeGrids_Text2 {
            get {
                return ResourceManager.GetString("TreeGrids_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below was built by binding the grid to
        ///    the top-level persons list and setting the
        ///    &lt;b&gt;childItemsPath&lt;/b&gt; property to &apos;children&apos;:.
        /// </summary>
        internal static string TreeGrids_Text3 {
            get {
                return ResourceManager.GetString("TreeGrids_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Show as Tree:.
        /// </summary>
        internal static string TreeGrids_Text4 {
            get {
                return ResourceManager.GetString("TreeGrids_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There are also &apos;heterogeneous&apos; hierarchies, where
        ///    items at different levels have different types and
        ///    different child item properties..
        /// </summary>
        internal static string TreeGrids_Text5 {
            get {
                return ResourceManager.GetString("TreeGrids_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the grid below is bound to a collection
        ///    of &apos;worker&apos; objects which receive &apos;checks&apos; which list
        ///    &apos;earnings&apos;:.
        /// </summary>
        internal static string TreeGrids_Text6 {
            get {
                return ResourceManager.GetString("TreeGrids_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tree Grids.
        /// </summary>
        internal static string TreeGrids_Title {
            get {
                return ResourceManager.GetString("TreeGrids_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you prefer to work in unbound mode, you can still
        ///    build trees by adding rows and columns in code..
        /// </summary>
        internal static string UnboundTreeGrids_Text1 {
            get {
                return ResourceManager.GetString("UnboundTreeGrids_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unbound Tree Grids.
        /// </summary>
        internal static string UnboundTreeGrids_Title {
            get {
                return ResourceManager.GetString("UnboundTreeGrids_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid helps with validation in several ways:.
        /// </summary>
        internal static string Validation_Text1 {
            get {
                return ResourceManager.GetString("Validation_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Automatic Type Coercion:&lt;/b&gt;
        ///        When cell edits are committed, the grid automatically coerces
        ///        values to match the column&apos;s data type. It also checks for nulls
        ///        and empty values based on the column&apos;s &lt;b&gt;isRequired&lt;/b&gt; property.
        ///        If the data is invalid, the original cell value is restored..
        /// </summary>
        internal static string Validation_Text2 {
            get {
                return ResourceManager.GetString("Validation_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Data Maps:&lt;/b&gt;
        ///        If your grids contain columns that should only allow certain input
        ///        values, add a &lt;b&gt;DataMap&lt;/b&gt; to the column to ensure users will not
        ///        be able to type invalid content into the cells..
        /// </summary>
        internal static string Validation_Text3 {
            get {
                return ResourceManager.GetString("Validation_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Event-Based Validation:&lt;/b&gt;
        ///        The grid raises a &lt;b&gt;cellEditEnding&lt;/b&gt; event that allows you
        ///        to check the editor&apos;s current value and cancels the edit if the
        ///        new value is invalid..
        /// </summary>
        internal static string Validation_Text4 {
            get {
                return ResourceManager.GetString("Validation_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;CollectionView-Based Validation:&lt;/b&gt;
        ///        The grid honors the collection view&apos;s &lt;b&gt;getError&lt;/b&gt; method
        ///        to highlight invalid cells and to prevent users from entering
        ///        invalid information..
        /// </summary>
        internal static string Validation_Text5 {
            get {
                return ResourceManager.GetString("Validation_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid below demonstrates the first three ways of validation.
        ///    It has a Country column with a data map that prevents users
        ///    from entering invalid countries.
        ///    The &lt;b&gt;cellEditEnding&lt;/b&gt; event is used to ensure that the
        ///    &apos;Sales&apos; and &apos;Expenses&apos; columns contain positive values:.
        /// </summary>
        internal static string Validation_Text6 {
            get {
                return ResourceManager.GetString("Validation_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Validation.
        /// </summary>
        internal static string Validation_Title {
            get {
                return ResourceManager.GetString("Validation_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The main job of FlexGrid is to convert JavaScript
        ///    data objects into DOM elements that user can interact
        ///    with. In many cases, the data consists of large arrays with many
        ///    thousands of items. Creating DOM elements for each of these
        ///    items would make for large and slow pages..
        /// </summary>
        internal static string Virtualization_Text1 {
            get {
                return ResourceManager.GetString("Virtualization_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Virtualization is the process of keeping track of visible 
        ///    portions of the data and rendering only those
        ///    parts. This reduces the number of DOM elements in the
        ///    document tree and improves performance dramatically..
        /// </summary>
        internal static string Virtualization_Text2 {
            get {
                return ResourceManager.GetString("Virtualization_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid exposes visible part of the data through
        ///    the &lt;b&gt;viewRange&lt;/b&gt; property. Whenever user resizes
        ///    the screen or scrolls the grid, &lt;b&gt;viewRange&lt;/b&gt; is
        ///    updated which updates the child DOM elements of the grid..
        /// </summary>
        internal static string Virtualization_Text3 {
            get {
                return ResourceManager.GetString("Virtualization_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The sample below uses the &lt;b&gt;viewRange&lt;/b&gt; property to
        ///    implement a simple type of &apos;infinite scrolling&apos;. When the
        ///    user scrolls to the bottom of the grid, the code adds
        ///    items to the grid&apos;s &lt;b&gt;itemsSource&lt;/b&gt;..
        /// </summary>
        internal static string Virtualization_Text4 {
            get {
                return ResourceManager.GetString("Virtualization_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you inspect the DOM, you will notice that no matter how
        ///    large the &lt;b&gt;itemsSource&lt;/b&gt; gets, the number of DOM elements
        ///    remains constant. The data is &apos;virtualized&apos;..
        /// </summary>
        internal static string Virtualization_Text5 {
            get {
                return ResourceManager.GetString("Virtualization_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The grid now has &lt;span id=&apos;rowCount&apos;&gt;&lt;/span&gt; rows and
        ///    &lt;span id=&apos;cellCount&apos;&gt;&lt;/span&gt; cell elements..
        /// </summary>
        internal static string Virtualization_Text6 {
            get {
                return ResourceManager.GetString("Virtualization_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Virtualization.
        /// </summary>
        internal static string Virtualization_Title {
            get {
                return ResourceManager.GetString("Virtualization_Title", resourceCulture);
            }
        }
    }
}
