//------------------------------------------------------------------------------
// <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 C1Mvc {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal C1Mvc() {
        }
        
        /// <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.C1Mvc", 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 The &lt;b&gt;Clipboard&lt;/b&gt; class allows you to customize the
        ///    behavior of the clipboard by modifying its contents using
        ///    the static methods &lt;b&gt;copy&lt;/b&gt; and &lt;b&gt;paste&lt;/b&gt;..
        /// </summary>
        internal static string Clipboard_Text1 {
            get {
                return ResourceManager.GetString("Clipboard_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Note that the &lt;b&gt;Clipboard&lt;/b&gt; class cannot initiate
        ///    clipboard operations; it can only modify the contents of
        ///    the clipboard after an operation has been initiated by a user..
        /// </summary>
        internal static string Clipboard_Text2 {
            get {
                return ResourceManager.GetString("Clipboard_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example customizes &lt;b&gt;copy&lt;/b&gt; operations from a
        ///    FlexGrid by adding column headers to the clipboard content.
        ///    To see how it works, copy a range from the FlexGrid and paste
        ///    into an Excel sheet..
        /// </summary>
        internal static string Clipboard_Text3 {
            get {
                return ResourceManager.GetString("Clipboard_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Include Headers.
        /// </summary>
        internal static string Clipboard_Text4 {
            get {
                return ResourceManager.GetString("Clipboard_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Clipboard.
        /// </summary>
        internal static string Clipboard_Title {
            get {
                return ResourceManager.GetString("Clipboard_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &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 is the core data provider for our MVC controls.
        ///    It takes a &lt;b&gt;sourceCollection&lt;/b&gt; array and provides
        ///    data views with sorting, filtering, grouping, paging,
        ///    notifications, change tracking, currency management,
        ///    and more..
        /// </summary>
        internal static string CollectionView_Text1 {
            get {
                return ResourceManager.GetString("CollectionView_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The views created by the &lt;b&gt;CollectionView&lt;/b&gt; are exposed
        ///    through the &lt;b&gt;items&lt;/b&gt; property, which contains an
        ///    array with sorted/filtered/grouped/paged items from the
        ///    &lt;b&gt;sourceCollection&lt;/b&gt; array..
        /// </summary>
        internal static string CollectionView_Text2 {
            get {
                return ResourceManager.GetString("CollectionView_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Controls that have an &lt;b&gt;itemsSource&lt;/b&gt; property
        ///    accept &lt;b&gt;CollectionView&lt;/b&gt; objects as well as regular
        ///    arrays. If regular arrays are used, the control automatically
        ///    creates an internal &lt;b&gt;CollectionView&lt;/b&gt; to wrap the original
        ///    data. This internal &lt;b&gt;CollectionView&lt;/b&gt; is exposed by the
        ///    control&apos;s &lt;b&gt;collectionView&lt;/b&gt; property..
        /// </summary>
        internal static string CollectionView_Text3 {
            get {
                return ResourceManager.GetString("CollectionView_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;CollectionView&lt;/b&gt; class provides extensive functionality
        ///    and a consistent way for controls to deal with data..
        /// </summary>
        internal static string CollectionView_Text4 {
            get {
                return ResourceManager.GetString("CollectionView_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to C1 MVC includes classes that extend &lt;b&gt;CollectionView&lt;/b&gt; to
        ///    provide additional services. The best example is
        ///    &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/webframe.html#wijmo.odata.ODataCollectionView.Class.html&quot; target=&quot;_blank&quot;&gt;ODataCollectionView&lt;/a&gt;,
        ///    which provides access to
        ///    &lt;a href=&quot;http://www.odata.org/&quot; target=&quot;_blank&quot;&gt;OData&lt;/a&gt; sources..
        /// </summary>
        internal static string CollectionView_Text5 {
            get {
                return ResourceManager.GetString("CollectionView_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to CollectionView.
        /// </summary>
        internal static string CollectionView_Title {
            get {
                return ResourceManager.GetString("CollectionView_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;Color&lt;/b&gt; class parses colors specified as CSS strings
        ///    and exposes their red, green, blue, and alpha channels as read-write
        ///    properties..
        /// </summary>
        internal static string Color_Text1 {
            get {
                return ResourceManager.GetString("Color_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to It also provides &lt;b&gt;fromHsb&lt;/b&gt; and &lt;b&gt;fromHsl&lt;/b&gt; methods for creating
        ///    colors using the HSB and HSL color models instead of RGB, as well as
        ///    &lt;b&gt;getHsb&lt;/b&gt; and &lt;b&gt;getHsl&lt;/b&gt; methods for retrieving the color
        ///    components using those color models..
        /// </summary>
        internal static string Color_Text2 {
            get {
                return ResourceManager.GetString("Color_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;Color&lt;/b&gt; class also has an &lt;b&gt;interpolate&lt;/b&gt; method that creates
        ///    colors by interpolating between two colors using the HSL model. This
        ///    method is especially useful for creating color animations with the
        ///    &lt;b&gt;animate&lt;/b&gt; method..
        /// </summary>
        internal static string Color_Text3 {
            get {
                return ResourceManager.GetString("Color_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The example below illustrates:.
        /// </summary>
        internal static string Color_Text4 {
            get {
                return ResourceManager.GetString("Color_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Color.
        /// </summary>
        internal static string Color_Title {
            get {
                return ResourceManager.GetString("Color_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Every MVC control is associated with an HTML element that
        ///    hosts it on the page..
        /// </summary>
        internal static string ControlsElements_Text1 {
            get {
                return ResourceManager.GetString("ControlsElements_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To get a reference to the element hosting the control, use the
        ///    &lt;b&gt;hostElement&lt;/b&gt; property (available in every C1 MVC control).
        ///    Use the static method &lt;b&gt;wijmo.Control.getControl(element)&lt;/b&gt;
        ///    to get a reference to the control being hosted by an element..
        /// </summary>
        internal static string ControlsElements_Text2 {
            get {
                return ResourceManager.GetString("ControlsElements_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In applications having tab controls or dynamic views, the control
        ///   layout often becomes invalid if the size or visibility of the host
        ///    element is changed and the control is not notified about the same..
        /// </summary>
        internal static string ControlsElements_Text3 {
            get {
                return ResourceManager.GetString("ControlsElements_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to However, in case of MVC controls, layout of all the controls is
        ///    updated according to the size of their host elements. MVC controls
        ///    provide &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/wijmo.Control.Class.html#invalidateAll&quot;&gt;
        ///        wijmo.Control.invalidateAll
        ///    &lt;/a&gt; method to notify the controls about change in their host element, 
        ///    so that the controls update their layout accordingly..
        /// </summary>
        internal static string ControlsElements_Text4 {
            get {
                return ResourceManager.GetString("ControlsElements_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, use the buttons below to observe resizing in the grid in
        ///    two cases; without using &lt;b&gt;invalidateAll&lt;/b&gt; method (WRONG way) and the case 
        ///    using &lt;b&gt;invalidateAll&lt;/b&gt; method (RIGHT way):.
        /// </summary>
        internal static string ControlsElements_Text5 {
            get {
                return ResourceManager.GetString("ControlsElements_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Toggle Font.
        /// </summary>
        internal static string ControlsElements_Text6 {
            get {
                return ResourceManager.GetString("ControlsElements_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Toggle Size (WRONG).
        /// </summary>
        internal static string ControlsElements_Text7 {
            get {
                return ResourceManager.GetString("ControlsElements_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Toggle Size (RIGHT).
        /// </summary>
        internal static string ControlsElements_Text8 {
            get {
                return ResourceManager.GetString("ControlsElements_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Controls and Elements.
        /// </summary>
        internal static string ControlsElements_Title {
            get {
                return ResourceManager.GetString("ControlsElements_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;p&gt;
        ///    Every MVC control is associated with an HTML element that hosts
        ///    it on the page. There are three ways to create a control:
        ///&lt;/p&gt;
        ///&lt;ul&gt;
        ///    &lt;li&gt;Add the control htmlhelper in the view directly.&lt;/li&gt;
        ///    &lt;li&gt;Start by adding a div element to the view, then add the control htmlhelper to bind it.&lt;/li&gt;
        ///    &lt;li&gt;Start by adding a div element to the view, then use JavaScript code to instantiate the
        ///    control and bind it to the host element.&lt;/li&gt;
        ///&lt;/ul&gt;.
        /// </summary>
        internal static string CreateControls_Description {
            get {
                return ResourceManager.GetString("CreateControls_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;p&gt;This is a FlexChart created using the second method:&lt;/p&gt;.
        /// </summary>
        internal static string CreateControls_FlexChart {
            get {
                return ResourceManager.GetString("CreateControls_FlexChart", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;p&gt;This is a FlexGrid created using the first method:&lt;/p&gt;.
        /// </summary>
        internal static string CreateControls_FlexGrid {
            get {
                return ResourceManager.GetString("CreateControls_FlexGrid", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;p&gt;And, this is an InputDate created using the third method:&lt;/p&gt;.
        /// </summary>
        internal static string CreateControls_InputDate {
            get {
                return ResourceManager.GetString("CreateControls_InputDate", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Creating C1 MVC Controls.
        /// </summary>
        internal static string CreateControls_Title {
            get {
                return ResourceManager.GetString("CreateControls_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to @Resources.C1Mvc.CreateControls_Title.
        /// </summary>
        internal static string CreateControls_Title1 {
            get {
                return ResourceManager.GetString("CreateControls_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Many C1 MVC controls include small images called &apos;glyphs&apos;.
        ///    For example, the &lt;b&gt;ComboBox&lt;/b&gt; uses a glyph in the button
        ///    used to show the item list. The &lt;b&gt;FlexGrid&lt;/b&gt; uses glyphs
        ///    to show various state indicators, including sort, editing,
        ///    expanded/collapsed nodes, etc..
        /// </summary>
        internal static string CustomGlyphs_Text1 {
            get {
                return ResourceManager.GetString("CustomGlyphs_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to All glyphs used in C1 MVC controls are CSS-based, which means
        ///    you can override them on all or specific controls using CSS
        ///    rules and no code..
        /// </summary>
        internal static string CustomGlyphs_Text2 {
            get {
                return ResourceManager.GetString("CustomGlyphs_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example shows how you can replace the &lt;b&gt;FlexGrid&lt;/b&gt;
        ///    glyphs with Bootstrap icons and with regular images..
        /// </summary>
        internal static string CustomGlyphs_Text3 {
            get {
                return ResourceManager.GetString("CustomGlyphs_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Glyphs.
        /// </summary>
        internal static string CustomGlyphs_Title {
            get {
                return ResourceManager.GetString("CustomGlyphs_Title", 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 this feature for modifying the 
        ///    UI strings and also the lists of conditions and operators..
        /// </summary>
        internal static string Customization_Text1 {
            get {
                return ResourceManager.GetString("Customization_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;..
        /// </summary>
        internal static string Customization_Text2 {
            get {
                return ResourceManager.GetString("Customization_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Globalization and Custom UIs.
        /// </summary>
        internal static string Customization_Title {
            get {
                return ResourceManager.GetString("Customization_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;CollectionView&lt;/b&gt; provides support for adding
        ///    items with the methods &lt;b&gt;addNew&lt;/b&gt;, &lt;b&gt;commitNew&lt;/b&gt;,
        ///    and &lt;b&gt;cancelNew&lt;/b&gt;. Items are removed using the
        ///    &lt;b&gt;remove&lt;/b&gt; method..
        /// </summary>
        internal static string CVAddingRemoving_Text1 {
            get {
                return ResourceManager.GetString("CVAddingRemoving_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;addNew&lt;/b&gt; method adds an empty item to the
        ///    collection and returns a reference to the new item.
        ///    The caller can use this return value to initialize
        ///    the new item. Alternatively, you can provide a
        ///    &lt;b&gt;CollectionView.newItemCreator&lt;/b&gt; function to
        ///    create and initialize the new items..
        /// </summary>
        internal static string CVAddingRemoving_Text2 {
            get {
                return ResourceManager.GetString("CVAddingRemoving_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;addNew&lt;/b&gt; method also puts the collection in
        ///    &apos;add&apos; mode, suspending sorting and filtering to keep
        ///    the new item in place until it is committed..
        /// </summary>
        internal static string CVAddingRemoving_Text3 {
            get {
                return ResourceManager.GetString("CVAddingRemoving_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;commitNew&lt;/b&gt; method causes the collection
        ///    to exit &apos;add mode&apos;, refreshes the collection and 
        ///    restores sorting and filtering..
        /// </summary>
        internal static string CVAddingRemoving_Text4 {
            get {
                return ResourceManager.GetString("CVAddingRemoving_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;cancelNew&lt;/b&gt; method removes the new item from
        ///    the collection and exits &apos;add mode&apos;..
        /// </summary>
        internal static string CVAddingRemoving_Text5 {
            get {
                return ResourceManager.GetString("CVAddingRemoving_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Add items in the grid below to observe how this works..
        /// </summary>
        internal static string CVAddingRemoving_Text6 {
            get {
                return ResourceManager.GetString("CVAddingRemoving_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To add an item, move the selection to the last
        ///    row, the &quot;New Item Template&quot; (having an asterisk on
        ///    the row header). Edit the new item as usual, and
        ///    press Enter or move the selection to a different row
        ///    to commit the new row..
        /// </summary>
        internal static string CVAddingRemoving_Text7 {
            get {
                return ResourceManager.GetString("CVAddingRemoving_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To cancel the addition, press the Escape key while editing
        ///    the new row. The row will be removed from the collection..
        /// </summary>
        internal static string CVAddingRemoving_Text8 {
            get {
                return ResourceManager.GetString("CVAddingRemoving_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To remove items, select an entire row by clicking
        ///    the row header, and then press the Delete key. The grid
        ///    will call the collection&apos;s &lt;b&gt;remove&lt;/b&gt; method
        ///    and the item will be removed from the collection..
        /// </summary>
        internal static string CVAddingRemoving_Text9 {
            get {
                return ResourceManager.GetString("CVAddingRemoving_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to CollectionView Adding and Removing Items.
        /// </summary>
        internal static string CVAddingRemoving_Title {
            get {
                return ResourceManager.GetString("CVAddingRemoving_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;CollectionView.filter&lt;/b&gt; property allows you
        ///    to specify one filtering function for each collection..
        /// </summary>
        internal static string CVChaining_Text1 {
            get {
                return ResourceManager.GetString("CVChaining_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In some cases, you may want to use two or more independent
        ///    filter functions. For example, you may want to apply a filter
        ///    on the incoming data and let the &lt;b&gt;FlexGridFilter&lt;/b&gt;
        ///    apply a second level of filtering to the data..
        /// </summary>
        internal static string CVChaining_Text2 {
            get {
                return ResourceManager.GetString("CVChaining_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To achieve this, you can chain multiple &lt;b&gt;CollectionView&lt;/b&gt;
        ///    objects so the output of one collection serves as input for
        ///    the next..
        /// </summary>
        internal static string CVChaining_Text3 {
            get {
                return ResourceManager.GetString("CVChaining_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example creates a &lt;b&gt;view&lt;/b&gt; collection with a filter
        ///    based on an input field, and a second &lt;b&gt;view2&lt;/b&gt; collection
        ///    based on the first collection&apos;s output. It binds a grid to
        ///    second collection which has an additional, independent
        ///    filter:.
        /// </summary>
        internal static string CVChaining_Text4 {
            get {
                return ResourceManager.GetString("CVChaining_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to country filter.
        /// </summary>
        internal static string CVChaining_Text5 {
            get {
                return ResourceManager.GetString("CVChaining_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Result (&lt;span id=&quot;cnt&quot;&gt;&lt;/span&gt; items):.
        /// </summary>
        internal static string CVChaining_Text6 {
            get {
                return ResourceManager.GetString("CVChaining_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Chaining Filters.
        /// </summary>
        internal static string CVChaining_Title {
            get {
                return ResourceManager.GetString("CVChaining_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;CollectionView&lt;/b&gt; class represents a view for
        ///    grouping, sorting, filtering, and navigating data
        ///    collections..
        /// </summary>
        internal static string CVCreatingViews_Text1 {
            get {
                return ResourceManager.GetString("CVCreatingViews_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use the &lt;b&gt;items&lt;/b&gt; array to get the output view..
        /// </summary>
        internal static string CVCreatingViews_Text10 {
            get {
                return ResourceManager.GetString("CVCreatingViews_Text10", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use the &lt;b&gt;currentItem&lt;/b&gt; property to get a reference
        ///        to the item that is currently selected, and use the
        ///        &lt;b&gt;currentChanged&lt;/b&gt; event to detect a change in selection..
        /// </summary>
        internal static string CVCreatingViews_Text11 {
            get {
                return ResourceManager.GetString("CVCreatingViews_Text11", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The object model used in the &lt;b&gt;CollectionView&lt;/b&gt;
        ///    class is similar to the one defined by .NET&apos;s
        ///    &lt;b&gt;ICollectionView&lt;/b&gt; and &lt;b&gt;IPagedCollectionView&lt;/b&gt;
        ///    interfaces..
        /// </summary>
        internal static string CVCreatingViews_Text2 {
            get {
                return ResourceManager.GetString("CVCreatingViews_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To create data views, follow these steps:.
        /// </summary>
        internal static string CVCreatingViews_Text3 {
            get {
                return ResourceManager.GetString("CVCreatingViews_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Create a new &lt;b&gt;CollectionView&lt;/b&gt;..
        /// </summary>
        internal static string CVCreatingViews_Text4 {
            get {
                return ResourceManager.GetString("CVCreatingViews_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set the &lt;b&gt;sourceCollection&lt;/b&gt; to an array containing
        ///        the raw data..
        /// </summary>
        internal static string CVCreatingViews_Text5 {
            get {
                return ResourceManager.GetString("CVCreatingViews_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to (Optional) Add items to the &lt;b&gt;sortDescriptions&lt;/b&gt; array
        ///        to define how the data should be sorted..
        /// </summary>
        internal static string CVCreatingViews_Text6 {
            get {
                return ResourceManager.GetString("CVCreatingViews_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to (Optional) Add items to the &lt;b&gt;groupDescriptions&lt;/b&gt; array
        ///        to define how the data should be grouped..
        /// </summary>
        internal static string CVCreatingViews_Text7 {
            get {
                return ResourceManager.GetString("CVCreatingViews_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to (Optional) Set the &lt;b&gt;filter&lt;/b&gt; property to a predicate
        ///        function that selects the items that should be included
        ///        in the view..
        /// </summary>
        internal static string CVCreatingViews_Text8 {
            get {
                return ResourceManager.GetString("CVCreatingViews_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to (Optional) Set the &lt;b&gt;pageSize&lt;/b&gt; property to define the
        ///        number of items in the view, and use the &lt;b&gt;moveToPage&lt;/b&gt;
        ///        method to select the current page..
        /// </summary>
        internal static string CVCreatingViews_Text9 {
            get {
                return ResourceManager.GetString("CVCreatingViews_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Data Views.
        /// </summary>
        internal static string CVCreatingViews_Title {
            get {
                return ResourceManager.GetString("CVCreatingViews_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;CollectionView&lt;/b&gt; has a &lt;b&gt;currentItem&lt;/b&gt; property that
        ///    identifies the item that is currently active..
        /// </summary>
        internal static string CVCurrency_Text1 {
            get {
                return ResourceManager.GetString("CVCurrency_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This property is used by controls that support binding
        ///    to lists and selection (including FlexGrid, FlexChart, ListBox,
        ///    ComboBox, etc)..
        /// </summary>
        internal static string CVCurrency_Text2 {
            get {
                return ResourceManager.GetString("CVCurrency_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The example below implements a simple master/detail screen.
        ///    Select a country from the &lt;b&gt;ComboBox&lt;/b&gt; to change the current
        ///    item. This raises the &lt;b&gt;currentChanged&lt;/b&gt; event which is used to
        ///    update the elements that show details of the current item..
        /// </summary>
        internal static string CVCurrency_Text3 {
            get {
                return ResourceManager.GetString("CVCurrency_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Country.
        /// </summary>
        internal static string CVCurrency_Text4 {
            get {
                return ResourceManager.GetString("CVCurrency_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Downloads.
        /// </summary>
        internal static string CVCurrency_Text5 {
            get {
                return ResourceManager.GetString("CVCurrency_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sales.
        /// </summary>
        internal static string CVCurrency_Text6 {
            get {
                return ResourceManager.GetString("CVCurrency_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Expenses.
        /// </summary>
        internal static string CVCurrency_Text7 {
            get {
                return ResourceManager.GetString("CVCurrency_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to CollectionView Currency.
        /// </summary>
        internal static string CVCurrency_Title {
            get {
                return ResourceManager.GetString("CVCurrency_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;CollectionView&lt;/b&gt; class relies on a &lt;b&gt;sourceCollection&lt;/b&gt;
        ///    that contains an array of data items. This collection is typically
        ///    populated with http requests that retrieve data from a server..
        /// </summary>
        internal static string CVDataProviders_Text1 {
            get {
                return ResourceManager.GetString("CVDataProviders_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In some cases, it may be advantageous to extend the &lt;b&gt;CollectionView&lt;/b&gt;
        ///    class in order to take advantage of functionality exposed by the
        ///    server. For example, C1 MVC includes a &lt;b&gt;RemoteCollectionView&lt;/b&gt;
        ///    that can use the result objects from the data service as data sources,
        ///    and in addition to full CRUD support and real-time updates you automatically get
        ///    CollectionView features including sorting, filtering, paging, grouping, and editing..
        /// </summary>
        internal static string CVDataProviders_Text2 {
            get {
                return ResourceManager.GetString("CVDataProviders_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Data Providers.
        /// </summary>
        internal static string CVDataProviders_Title {
            get {
                return ResourceManager.GetString("CVDataProviders_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;CollectionView&lt;/b&gt; provides support for editing items
        ///    with the help of methods similar to those found in .NET&apos;s
        ///    &lt;b&gt;IEditableCollectionView&lt;/b&gt; interface:
        ///    &lt;b&gt;editItem&lt;/b&gt;, &lt;b&gt;commitEdit&lt;/b&gt;, and &lt;b&gt;cancelEdit&lt;/b&gt;..
        /// </summary>
        internal static string CVEditingViews_Text1 {
            get {
                return ResourceManager.GetString("CVEditingViews_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;editItem&lt;/b&gt; method saves a copy of the item and
        ///    puts the collection in &apos;edit mode&apos;. While in edit mode,
        ///    the view is not refreshed, so items are not sorted
        ///    or filtered out of view during the edit process..
        /// </summary>
        internal static string CVEditingViews_Text2 {
            get {
                return ResourceManager.GetString("CVEditingViews_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;commitEdit&lt;/b&gt; method exits the edit mode so that sorting
        ///    and filtering become active again. If the item has changed,
        ///    the &lt;b&gt;collectionChanged&lt;/b&gt; event is fired to reflect the 
        ///    changes in the bound controls..
        /// </summary>
        internal static string CVEditingViews_Text3 {
            get {
                return ResourceManager.GetString("CVEditingViews_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;cancelEdit&lt;/b&gt; method restores the original data
        ///    and exits the edit mode..
        /// </summary>
        internal static string CVEditingViews_Text4 {
            get {
                return ResourceManager.GetString("CVEditingViews_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Edit the grid below to observe how this works..
        /// </summary>
        internal static string CVEditingViews_Text5 {
            get {
                return ResourceManager.GetString("CVEditingViews_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To edit the grid, double click a cell. When editing 
        ///	starts, a pencil icon appears on the
        ///    row header to indicate that the collection is in edit
        ///    mode..
        /// </summary>
        internal static string CVEditingViews_Text6 {
            get {
                return ResourceManager.GetString("CVEditingViews_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To cancel the editing process, press the Escape key
        ///    while editing and restore the original data..
        /// </summary>
        internal static string CVEditingViews_Text7 {
            get {
                return ResourceManager.GetString("CVEditingViews_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To commit the edits, move the selection to 
        ///    a different row, or move the focus away from the grid. 
        ///    At this point, the collection is refreshed and any
        ///    active filtering/sorting is applied again using the
        ///    new values..
        /// </summary>
        internal static string CVEditingViews_Text8 {
            get {
                return ResourceManager.GetString("CVEditingViews_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to CollectionView Editing.
        /// </summary>
        internal static string CVEditingViews_Title {
            get {
                return ResourceManager.GetString("CVEditingViews_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use the &lt;b&gt;CollectionView.filter&lt;/b&gt; property to specify
        ///    a filter function that defines which items should be
        ///    included in the view..
        /// </summary>
        internal static string CVFiltering_Text1 {
            get {
                return ResourceManager.GetString("CVFiltering_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Choose one of the options to see it in action:.
        /// </summary>
        internal static string CVFiltering_Text2 {
            get {
                return ResourceManager.GetString("CVFiltering_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No Filter.
        /// </summary>
        internal static string CVFiltering_Text3 {
            get {
                return ResourceManager.GetString("CVFiltering_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to US only.
        /// </summary>
        internal static string CVFiltering_Text4 {
            get {
                return ResourceManager.GetString("CVFiltering_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sales &gt; 50,000.
        /// </summary>
        internal static string CVFiltering_Text5 {
            get {
                return ResourceManager.GetString("CVFiltering_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Downloads &gt; 150,000.
        /// </summary>
        internal static string CVFiltering_Text6 {
            get {
                return ResourceManager.GetString("CVFiltering_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Result (&lt;span id=&quot;cnt&quot;&gt;&lt;/span&gt; items):.
        /// </summary>
        internal static string CVFiltering_Text7 {
            get {
                return ResourceManager.GetString("CVFiltering_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to CollectionView Filtering.
        /// </summary>
        internal static string CVFiltering_Title {
            get {
                return ResourceManager.GetString("CVFiltering_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This sample shows how you can add spinners to the FlexGrid control
        ///    to indicate the process of loading data. The basic idea is to add a spinner
        ///    element to the grid when you start loading the data, and remove the
        ///    spinner when you get the data displayed on the grid..
        /// </summary>
        internal static string CVFlexGridSpinners_Text1 {
            get {
                return ResourceManager.GetString("CVFlexGridSpinners_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example shows an animated GIF while the grid is loading:.
        /// </summary>
        internal static string CVFlexGridSpinners_Text2 {
            get {
                return ResourceManager.GetString("CVFlexGridSpinners_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Load Grid Using GIF Spinner.
        /// </summary>
        internal static string CVFlexGridSpinners_Text3 {
            get {
                return ResourceManager.GetString("CVFlexGridSpinners_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;img src=&quot;https://preloaders.net/preloaders/159/Rounded%20blocks.gif&quot;&gt;.
        /// </summary>
        internal static string CVFlexGridSpinners_Text4 {
            get {
                return ResourceManager.GetString("CVFlexGridSpinners_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example shows an animated RadialGauge while the grid is loading:.
        /// </summary>
        internal static string CVFlexGridSpinners_Text5 {
            get {
                return ResourceManager.GetString("CVFlexGridSpinners_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Load Grid Using Gauge Spinner.
        /// </summary>
        internal static string CVFlexGridSpinners_Text6 {
            get {
                return ResourceManager.GetString("CVFlexGridSpinners_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to When FlexGrid binds to a CollectionViewService which uses remote bind mode,
        ///    it shows a mask with text &quot;Loading...&quot; while loading data from the remote server.
        ///    You can customize the mask by overriding the c1-grid-mask CSS class..
        /// </summary>
        internal static string CVFlexGridSpinners_Text7 {
            get {
                return ResourceManager.GetString("CVFlexGridSpinners_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid Spinners.
        /// </summary>
        internal static string CVFlexGridSpinners_Title {
            get {
                return ResourceManager.GetString("CVFlexGridSpinners_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to GIF Spinners.
        /// </summary>
        internal static string CVFlexGridSpinners_Title1 {
            get {
                return ResourceManager.GetString("CVFlexGridSpinners_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Gauge Spinners.
        /// </summary>
        internal static string CVFlexGridSpinners_Title2 {
            get {
                return ResourceManager.GetString("CVFlexGridSpinners_Title2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Loading Mask.
        /// </summary>
        internal static string CVFlexGridSpinners_Title3 {
            get {
                return ResourceManager.GetString("CVFlexGridSpinners_Title3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use the &lt;b&gt;CollectionView.groupDescriptions&lt;/b&gt; property to specify
        ///    which fields should be grouped..
        /// </summary>
        internal static string CVGrouping_Text1 {
            get {
                return ResourceManager.GetString("CVGrouping_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Choose one of the options to see it in action:.
        /// </summary>
        internal static string CVGrouping_Text2 {
            get {
                return ResourceManager.GetString("CVGrouping_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No Grouping.
        /// </summary>
        internal static string CVGrouping_Text3 {
            get {
                return ResourceManager.GetString("CVGrouping_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By Country.
        /// </summary>
        internal static string CVGrouping_Text4 {
            get {
                return ResourceManager.GetString("CVGrouping_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By Country and by Product.
        /// </summary>
        internal static string CVGrouping_Text5 {
            get {
                return ResourceManager.GetString("CVGrouping_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By Country, Product, and Sales.
        /// </summary>
        internal static string CVGrouping_Text6 {
            get {
                return ResourceManager.GetString("CVGrouping_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Result:.
        /// </summary>
        internal static string CVGrouping_Text7 {
            get {
                return ResourceManager.GetString("CVGrouping_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Show on Console.
        /// </summary>
        internal static string CVGrouping_Text8 {
            get {
                return ResourceManager.GetString("CVGrouping_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to CollectionView Grouping.
        /// </summary>
        internal static string CVGrouping_Title {
            get {
                return ResourceManager.GetString("CVGrouping_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Loading data into a &lt;b&gt;CollectionView&lt;/b&gt; is straightforward..
        /// </summary>
        internal static string CVLoadingData_Text1 {
            get {
                return ResourceManager.GetString("CVLoadingData_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you already have the data in an array, you can use that
        ///    array as a constructor parameter, or set the &lt;b&gt;sourceCollection&lt;/b&gt;
        ///    property to that array:.
        /// </summary>
        internal static string CVLoadingData_Text2 {
            get {
                return ResourceManager.GetString("CVLoadingData_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If the data is on a server, you can retrieve it by using the
        ///    &lt;b&gt;httpRequest&lt;/b&gt; method. When you get a response from
        ///    the server, set the &lt;b&gt;sourceCollection&lt;/b&gt; array to the
        ///    response value or append new data to the
        ///    &lt;b&gt;sourceCollection&lt;/b&gt; array:.
        /// </summary>
        internal static string CVLoadingData_Text3 {
            get {
                return ResourceManager.GetString("CVLoadingData_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The server side CollectionViewService control constructs
        ///    a client side CollectionView instance. You can get the
        ///    instance by
        ///    &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/c1.Module.html#getService&quot; target=&quot;_blank&quot;&gt;c1.getService&lt;/a&gt;
        ///    method..
        /// </summary>
        internal static string CVLoadingData_Text4 {
            get {
                return ResourceManager.GetString("CVLoadingData_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If your data service API supports commands such as filtering,
        ///    sorting, and paging, you can add parameters to your
        ///    &lt;b&gt;httpRequest&lt;/b&gt; calls to support these features. You can even
        ///    encapsulate the server API into a custom class that extends
        ///    &lt;b&gt;CollectionView&lt;/b&gt;..
        /// </summary>
        internal static string CVLoadingData_Text5 {
            get {
                return ResourceManager.GetString("CVLoadingData_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Loading Data.
        /// </summary>
        internal static string CVLoadingData_Title {
            get {
                return ResourceManager.GetString("CVLoadingData_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Loading on the Client.
        /// </summary>
        internal static string CVLoadingData_Title1 {
            get {
                return ResourceManager.GetString("CVLoadingData_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Loading from the Server.
        /// </summary>
        internal static string CVLoadingData_Title2 {
            get {
                return ResourceManager.GetString("CVLoadingData_Title2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Construct in Server.
        /// </summary>
        internal static string CVLoadingData_Title3 {
            get {
                return ResourceManager.GetString("CVLoadingData_Title3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to JSON is a great format for serializing data, but unfortunately
        ///    it does not support dates..
        /// </summary>
        internal static string CVLoadingJsonDates_Text1 {
            get {
                return ResourceManager.GetString("CVLoadingJsonDates_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you serialize an object that contains date fields using
        ///    JSON.stringify, the dates will be converted to strings.
        ///    If you then parse the same object back using JSON.parse,
        ///    they will remain strings..
        /// </summary>
        internal static string CVLoadingJsonDates_Text2 {
            get {
                return ResourceManager.GetString("CVLoadingJsonDates_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Note how the &quot;Date&quot; column contains strings in the example below:.
        /// </summary>
        internal static string CVLoadingJsonDates_Text3 {
            get {
                return ResourceManager.GetString("CVLoadingJsonDates_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The solution for this problem is to use a &apos;reviver&apos; function
        ///    in the call to JSON.parse that will inspect the strings
        ///    and convert those that look like dates into date objects..
        /// </summary>
        internal static string CVLoadingJsonDates_Text4 {
            get {
                return ResourceManager.GetString("CVLoadingJsonDates_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Following is a grid showing the same data, this time parsed
        ///    with a date reviver function:.
        /// </summary>
        internal static string CVLoadingJsonDates_Text5 {
            get {
                return ResourceManager.GetString("CVLoadingJsonDates_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Loading JSON Dates.
        /// </summary>
        internal static string CVLoadingJsonDates_Title {
            get {
                return ResourceManager.GetString("CVLoadingJsonDates_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The Problem.
        /// </summary>
        internal static string CVLoadingJsonDates_Title1 {
            get {
                return ResourceManager.GetString("CVLoadingJsonDates_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The Solution.
        /// </summary>
        internal static string CVLoadingJsonDates_Title2 {
            get {
                return ResourceManager.GetString("CVLoadingJsonDates_Title2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Paging is a common technique for dealing with large collections
        ///    of data..
        /// </summary>
        internal static string CVPaging_Text1 {
            get {
                return ResourceManager.GetString("CVPaging_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;CollectionView&lt;/b&gt; class supports client-side paging
        ///    by default. This enables you to generate grids and tables that contain
        ///    only a reasonable amount of data. To enable paging, set the
        ///    &lt;b&gt;pageSize&lt;/b&gt; property and to select the page you want to display, 
        ///    use the &lt;b&gt;moveToPage&lt;/b&gt; method..
        /// </summary>
        internal static string CVPaging_Text2 {
            get {
                return ResourceManager.GetString("CVPaging_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example:.
        /// </summary>
        internal static string CVPaging_Text3 {
            get {
                return ResourceManager.GetString("CVPaging_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Server-side paging consists of making requests that bring in
        ///    one page of data at a time. The actual commands used to retrieve
        ///    the data depend on the API exposed by the server..
        /// </summary>
        internal static string CVPaging_Text4 {
            get {
                return ResourceManager.GetString("CVPaging_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to MVC Edition includes &lt;b&gt;CollectionViewService&lt;/b&gt; that implements
        ///    server-based paging (as well as sorting and filtering)..
        /// </summary>
        internal static string CVPaging_Text5 {
            get {
                return ResourceManager.GetString("CVPaging_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example:.
        /// </summary>
        internal static string CVPaging_Text6 {
            get {
                return ResourceManager.GetString("CVPaging_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to CollectionView Paging.
        /// </summary>
        internal static string CVPaging_Title {
            get {
                return ResourceManager.GetString("CVPaging_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Client-Side Paging.
        /// </summary>
        internal static string CVPaging_Title1 {
            get {
                return ResourceManager.GetString("CVPaging_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Server-Side Paging.
        /// </summary>
        internal static string CVPaging_Title2 {
            get {
                return ResourceManager.GetString("CVPaging_Title2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;CollectionView&lt;/b&gt; class is highly optimized.
        ///    It sorts, filters, groups, and paginates large data
        ///    sets efficiently in virtually every situation..
        /// </summary>
        internal static string CVPerformance_Text1 {
            get {
                return ResourceManager.GetString("CVPerformance_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In some cases, you may be able to improve performance
        ///    even more by using the &lt;b&gt;deferUpdate&lt;/b&gt; method to
        ///    suspend refreshes while performing batch operations..
        /// </summary>
        internal static string CVPerformance_Text2 {
            get {
                return ResourceManager.GetString("CVPerformance_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This is especially important when adding items to collections
        ///    that are sorted, grouped, or filtered. Without deferred
        ///    updates, each addition causes a refresh..
        /// </summary>
        internal static string CVPerformance_Text3 {
            get {
                return ResourceManager.GetString("CVPerformance_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, click the buttons below to add 1,000
        ///    items to a &lt;b&gt;CollectionView&lt;/b&gt; using three
        ///    different methods:.
        /// </summary>
        internal static string CVPerformance_Text4 {
            get {
                return ResourceManager.GetString("CVPerformance_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to addNew.
        /// </summary>
        internal static string CVPerformance_Text5 {
            get {
                return ResourceManager.GetString("CVPerformance_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to push.
        /// </summary>
        internal static string CVPerformance_Text6 {
            get {
                return ResourceManager.GetString("CVPerformance_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to push + defer updates.
        /// </summary>
        internal static string CVPerformance_Text7 {
            get {
                return ResourceManager.GetString("CVPerformance_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to CollectionView Notifications and Performance.
        /// </summary>
        internal static string CVPerformance_Title {
            get {
                return ResourceManager.GetString("CVPerformance_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use the &lt;b&gt;CollectionView.sortDescriptions&lt;/b&gt; property to specify
        ///    which fields should be sorted and in which direction..
        /// </summary>
        internal static string CVSorting_Text1 {
            get {
                return ResourceManager.GetString("CVSorting_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Choose one of the options to see it in action:.
        /// </summary>
        internal static string CVSorting_Text2 {
            get {
                return ResourceManager.GetString("CVSorting_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to No Sort.
        /// </summary>
        internal static string CVSorting_Text3 {
            get {
                return ResourceManager.GetString("CVSorting_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sort by Country.
        /// </summary>
        internal static string CVSorting_Text4 {
            get {
                return ResourceManager.GetString("CVSorting_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sort by Country and Sales.
        /// </summary>
        internal static string CVSorting_Text5 {
            get {
                return ResourceManager.GetString("CVSorting_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sort by Country, Sales, and Downloads.
        /// </summary>
        internal static string CVSorting_Text6 {
            get {
                return ResourceManager.GetString("CVSorting_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Result:.
        /// </summary>
        internal static string CVSorting_Text7 {
            get {
                return ResourceManager.GetString("CVSorting_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to CollectionView Sorting.
        /// </summary>
        internal static string CVSorting_Title {
            get {
                return ResourceManager.GetString("CVSorting_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The CollectionView class has a &quot;stableSort&quot; property that allows
        ///    you to keep the original sequence of items when sorting by
        ///    any fields in the data objects..
        /// </summary>
        internal static string CVStableSort_Text1 {
            get {
                return ResourceManager.GetString("CVStableSort_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, this sample creates a CollectionView based on
        ///    a list of items sorted by Country and ID. If you sort the
        ///    grid by any property (e.g. Active), items with the same
        ///    sort property value will be sorted according to the original
        ///    order (sorted by Country and ID):.
        /// </summary>
        internal static string CVStableSort_Text2 {
            get {
                return ResourceManager.GetString("CVStableSort_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &quot;stableSort&quot; property does have a performance cost. 
        ///    Therefore, it is set to &quot;false&quot; by default and should be
        ///    set to &quot;true&quot; only when needed..
        /// </summary>
        internal static string CVStableSort_Text3 {
            get {
                return ResourceManager.GetString("CVStableSort_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Stable Sort.
        /// </summary>
        internal static string CVStableSort_Title {
            get {
                return ResourceManager.GetString("CVStableSort_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Web applications often use a pattern of downloading
        ///    some data from the server, making changes locally,
        ///    and updating the server with the changes later..
        /// </summary>
        internal static string CVTrackingChanges_Text1 {
            get {
                return ResourceManager.GetString("CVTrackingChanges_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;CollectionView&lt;/b&gt; can help by keeping track
        ///    of items that have been added, removed, or modified..
        /// </summary>
        internal static string CVTrackingChanges_Text2 {
            get {
                return ResourceManager.GetString("CVTrackingChanges_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To use this feature, set the
        ///    &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/wijmo.collections.CollectionView.Class.html#trackChanges&quot; target=&quot;_blank&quot;&gt;trackChanges&lt;/a&gt;
        ///    property to true. Once you do that, the &lt;b&gt;CollectionView&lt;/b&gt;
        ///    will add items to its &lt;b&gt;itemsAdded&lt;/b&gt;, &lt;b&gt;itemsRemoved&lt;/b&gt;,
        ///    and &lt;b&gt;itemsEdited&lt;/b&gt; collections. When you are ready, send
        ///    the changes to the server and call the &lt;b&gt;clearChanges&lt;/b&gt;
        ///    method to reset the change-tracking collections..
        /// </summary>
        internal static string CVTrackingChanges_Text3 {
            get {
                return ResourceManager.GetString("CVTrackingChanges_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Edit/add/remove items in the grid below to observe how it works:.
        /// </summary>
        internal static string CVTrackingChanges_Text4 {
            get {
                return ResourceManager.GetString("CVTrackingChanges_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to CollectionView Change Tracking.
        /// </summary>
        internal static string CVTrackingChanges_Title {
            get {
                return ResourceManager.GetString("CVTrackingChanges_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Edited Items:.
        /// </summary>
        internal static string CVTrackingChanges_Title1 {
            get {
                return ResourceManager.GetString("CVTrackingChanges_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Added Items:.
        /// </summary>
        internal static string CVTrackingChanges_Title2 {
            get {
                return ResourceManager.GetString("CVTrackingChanges_Title2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Removed Items:.
        /// </summary>
        internal static string CVTrackingChanges_Title3 {
            get {
                return ResourceManager.GetString("CVTrackingChanges_Title3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;CollectionView&lt;/b&gt; has a &lt;b&gt;getError&lt;/b&gt; property
        ///    that provides validation support.
        ///    To use it, 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 CVValidation_Text1 {
            get {
                return ResourceManager.GetString("CVValidation_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;getError&lt;/b&gt; property goes beyond basic HTML5 validation
        ///    based only on the value itself (such as min, max, required,
        ///    pattern, etc). It allows you to specify conditions that involve
        ///    multiple properties..
        /// </summary>
        internal static string CVValidation_Text2 {
            get {
                return ResourceManager.GetString("CVValidation_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;getError&lt;/b&gt; property allows you to include the
        ///    validation logic in the collection itself, rather than
        ///    in the UI used for editing items.
        ///    The same method can then be used by input forms or by
        ///    controls such as &lt;b&gt;FlexGrid&lt;/b&gt;..
        /// </summary>
        internal static string CVValidation_Text3 {
            get {
                return ResourceManager.GetString("CVValidation_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;FlexGrid&lt;/b&gt; uses the &lt;b&gt;CollectionView.getError&lt;/b&gt;
        ///    property by default. Try entering an invalid country or a
        ///    negative number to see how the grid identifies the error
        ///    and prevents the invalid entry from being committed:.
        /// </summary>
        internal static string CVValidation_Text4 {
            get {
                return ResourceManager.GetString("CVValidation_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can use the the &lt;b&gt;CollectionView.getError&lt;/b&gt; property
        ///    to validate forms as well. Simply call the function and
        ///    apply the result to the appropriate input element using the
        ///    &lt;b&gt;setCustomValidity&lt;/b&gt; method that is part of the HTML5
        ///    validation API..
        /// </summary>
        internal static string CVValidation_Text5 {
            get {
                return ResourceManager.GetString("CVValidation_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Country.
        /// </summary>
        internal static string CVValidation_Text6 {
            get {
                return ResourceManager.GetString("CVValidation_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Downloads.
        /// </summary>
        internal static string CVValidation_Text7 {
            get {
                return ResourceManager.GetString("CVValidation_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sales.
        /// </summary>
        internal static string CVValidation_Text8 {
            get {
                return ResourceManager.GetString("CVValidation_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to CollectionView Validation.
        /// </summary>
        internal static string CVValidation_Title {
            get {
                return ResourceManager.GetString("CVValidation_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid Validation.
        /// </summary>
        internal static string CVValidation_Title1 {
            get {
                return ResourceManager.GetString("CVValidation_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Forms Validation.
        /// </summary>
        internal static string CVValidation_Title2 {
            get {
                return ResourceManager.GetString("CVValidation_Title2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to HTML5 has an eventing mechanism that works for HTML elements.
        ///    But, it cannot be used to add events to arbitrary objects,
        ///    such as controls and collections..
        /// </summary>
        internal static string Events_Text1 {
            get {
                return ResourceManager.GetString("Events_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To handle this, we defined an &lt;b&gt;Event&lt;/b&gt; class. Any class
        ///    may define events by declaring them as fields, and any class may
        ///    add or remove event handlers using the event&apos;s &lt;b&gt;addHandler&lt;/b&gt;
        ///    and &lt;b&gt;removeHandler&lt;/b&gt; methods..
        /// </summary>
        internal static string Events_Text2 {
            get {
                return ResourceManager.GetString("Events_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You may also declare event handlers as &lt;b&gt;options&lt;/b&gt; in the 
        ///    &lt;b&gt;initialize&lt;/b&gt; method of any MVC control..
        /// </summary>
        internal static string Events_Text3 {
            get {
                return ResourceManager.GetString("Events_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to These event handlers take two parameters: &lt;b&gt;sender&lt;/b&gt;
        ///    and &lt;b&gt;args&lt;/b&gt;.
        ///    &lt;b&gt;Sender&lt;/b&gt; is an object that raised the event, and &lt;b&gt;args&lt;/b&gt;
        ///    is an object that contains the event parameters..
        /// </summary>
        internal static string Events_Text4 {
            get {
                return ResourceManager.GetString("Events_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Below are some input controls with the event handlers
        ///    attached to them:.
        /// </summary>
        internal static string Events_Text5 {
            get {
                return ResourceManager.GetString("Events_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For more details on C1 MVC and HTML events, please refer to
        ///        our blog on
        ///        &lt;a href=&quot;http://wijmo.com/blog/html-and-wijmo-events/&quot; target=&quot;_blank&quot;&gt;HTML and Wijmo Events&lt;/a&gt;..
        /// </summary>
        internal static string Events_Text6 {
            get {
                return ResourceManager.GetString("Events_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Events.
        /// </summary>
        internal static string Events_Title {
            get {
                return ResourceManager.GetString("Events_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Extenders are used to extend the funtionality of a control. Following is the list of some extenders provided with ASP.NET MVC Edition and the controls they can be used with..
        /// </summary>
        internal static string Extenders_Text1 {
            get {
                return ResourceManager.GetString("Extenders_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to AnnotationLayer.
        /// </summary>
        internal static string Extenders_Text10 {
            get {
                return ResourceManager.GetString("Extenders_Text10", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ChartAnimation.
        /// </summary>
        internal static string Extenders_Text11 {
            get {
                return ResourceManager.GetString("Extenders_Text11", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ChartGestures.
        /// </summary>
        internal static string Extenders_Text12 {
            get {
                return ResourceManager.GetString("Extenders_Text12", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to LineMarker.
        /// </summary>
        internal static string Extenders_Text13 {
            get {
                return ResourceManager.GetString("Extenders_Text13", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to RangeSelector.
        /// </summary>
        internal static string Extenders_Text14 {
            get {
                return ResourceManager.GetString("Extenders_Text14", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The following extender can be used with the FlexSheet control..
        /// </summary>
        internal static string Extenders_Text15 {
            get {
                return ResourceManager.GetString("Extenders_Text15", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FormulaBar.
        /// </summary>
        internal static string Extenders_Text16 {
            get {
                return ResourceManager.GetString("Extenders_Text16", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There are two ways to use the extenders..
        /// </summary>
        internal static string Extenders_Text17 {
            get {
                return ResourceManager.GetString("Extenders_Text17", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Create extender using control extender builder.
        /// </summary>
        internal static string Extenders_Text18 {
            get {
                return ResourceManager.GetString("Extenders_Text18", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Create extender using client extender constructor.
        /// </summary>
        internal static string Extenders_Text19 {
            get {
                return ResourceManager.GetString("Extenders_Text19", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The following extenders can be used with the FlexGrid control..
        /// </summary>
        internal static string Extenders_Text2 {
            get {
                return ResourceManager.GetString("Extenders_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If the extender is created using control extender builder, we can get the same in following ways:.
        /// </summary>
        internal static string Extenders_Text20 {
            get {
                return ResourceManager.GetString("Extenders_Text20", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;code&gt;c1.getExtenders(control, extenderType?)&lt;/code&gt;&lt;br/&gt;
        ///        Gets the extenders with specified owner and type..
        /// </summary>
        internal static string Extenders_Text21 {
            get {
                return ResourceManager.GetString("Extenders_Text21", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;code&gt;c1.getExtender(control, id)&lt;/code&gt; &lt;br/&gt;
        ///        Gets the extender with specified owner and id..
        /// </summary>
        internal static string Extenders_Text22 {
            get {
                return ResourceManager.GetString("Extenders_Text22", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The samples below show how to create, get and customize an extender..
        /// </summary>
        internal static string Extenders_Text23 {
            get {
                return ResourceManager.GetString("Extenders_Text23", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use the control builder to add an extender directly.&lt;br/&gt;.
        /// </summary>
        internal static string Extenders_Text24 {
            get {
                return ResourceManager.GetString("Extenders_Text24", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use javascript code to add an extender in the client.&lt;br/&gt;.
        /// </summary>
        internal static string Extenders_Text25 {
            get {
                return ResourceManager.GetString("Extenders_Text25", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGridDetailProvider.
        /// </summary>
        internal static string Extenders_Text3 {
            get {
                return ResourceManager.GetString("Extenders_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGridFilter.
        /// </summary>
        internal static string Extenders_Text4 {
            get {
                return ResourceManager.GetString("Extenders_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGridGroupPanel.
        /// </summary>
        internal static string Extenders_Text5 {
            get {
                return ResourceManager.GetString("Extenders_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The following extenders can be used with the MultiRow control..
        /// </summary>
        internal static string Extenders_Text6 {
            get {
                return ResourceManager.GetString("Extenders_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGridFilter.
        /// </summary>
        internal static string Extenders_Text7 {
            get {
                return ResourceManager.GetString("Extenders_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGridGroupPanel.
        /// </summary>
        internal static string Extenders_Text8 {
            get {
                return ResourceManager.GetString("Extenders_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The following extenders can be used with charts..
        /// </summary>
        internal static string Extenders_Text9 {
            get {
                return ResourceManager.GetString("Extenders_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to C1 MVC Extenders.
        /// </summary>
        internal static string Extenders_Title {
            get {
                return ResourceManager.GetString("Extenders_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid adds a &quot;wj-state-selected&quot; class to the selected cells..
        /// </summary>
        internal static string FlexGridFocus_Text1 {
            get {
                return ResourceManager.GetString("FlexGridFocus_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can combine this with the &quot;wj-state-focused&quot; class added to
        ///    the grid to create styles for highlighting
        ///    the selection when grid has the focus:.
        /// </summary>
        internal static string FlexGridFocus_Text2 {
            get {
                return ResourceManager.GetString("FlexGridFocus_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexGrid Focus.
        /// </summary>
        internal static string FlexGridFocus_Title {
            get {
                return ResourceManager.GetString("FlexGridFocus_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To globalize your application, register the appropriate culture
        ///    while registering the C1 MVC scripts.
        ///    &lt;a href=&quot;http://wijmo.com/5/docs/static/globalization.html&quot; target=&quot;_blank&quot;&gt;
        ///        MVC includes over 40 culture files you can choose from.
        ///    &lt;/a&gt;.
        /// </summary>
        internal static string Formatting_Text1 {
            get {
                return ResourceManager.GetString("Formatting_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Full Date/Time Pattern (long time).
        /// </summary>
        internal static string Formatting_Text10 {
            get {
                return ResourceManager.GetString("Formatting_Text10", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Short Time Pattern.
        /// </summary>
        internal static string Formatting_Text11 {
            get {
                return ResourceManager.GetString("Formatting_Text11", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Long Time Pattern.
        /// </summary>
        internal static string Formatting_Text12 {
            get {
                return ResourceManager.GetString("Formatting_Text12", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Quarter/Year.
        /// </summary>
        internal static string Formatting_Text13 {
            get {
                return ResourceManager.GetString("Formatting_Text13", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom format.
        /// </summary>
        internal static string Formatting_Text14 {
            get {
                return ResourceManager.GetString("Formatting_Text14", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In addition to the standard .NET format specifiers, our MVC controls support
        ///        a few additional specifiers including &apos;Q/q&apos; for quarter, &apos;U/u&apos; for
        ///        fiscal quarter, and &apos;EEEE/eeee&apos; for fiscal year..
        /// </summary>
        internal static string Formatting_Text15 {
            get {
                return ResourceManager.GetString("Formatting_Text15", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Numbers are formatted using the &lt;b&gt;Globalize.formatNumber&lt;/b&gt;
        ///    function.
        ///    For details regarding format strings, please refer the
        ///    &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/wijmo.Globalize.Class.html#formatNumber&quot; target=&quot;_blank&quot;&gt;
        ///        online documentation&lt;/a&gt;..
        /// </summary>
        internal static string Formatting_Text16 {
            get {
                return ResourceManager.GetString("Formatting_Text16", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Value.
        /// </summary>
        internal static string Formatting_Text17 {
            get {
                return ResourceManager.GetString("Formatting_Text17", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Precision.
        /// </summary>
        internal static string Formatting_Text18 {
            get {
                return ResourceManager.GetString("Formatting_Text18", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specifier.
        /// </summary>
        internal static string Formatting_Text19 {
            get {
                return ResourceManager.GetString("Formatting_Text19", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Please select a culture.
        /// </summary>
        internal static string Formatting_Text2 {
            get {
                return ResourceManager.GetString("Formatting_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Number.
        /// </summary>
        internal static string Formatting_Text20 {
            get {
                return ResourceManager.GetString("Formatting_Text20", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Number (thousands).
        /// </summary>
        internal static string Formatting_Text21 {
            get {
                return ResourceManager.GetString("Formatting_Text21", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Number (millions).
        /// </summary>
        internal static string Formatting_Text22 {
            get {
                return ResourceManager.GetString("Formatting_Text22", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Fixed-point.
        /// </summary>
        internal static string Formatting_Text23 {
            get {
                return ResourceManager.GetString("Formatting_Text23", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to General (no trailing zeros).
        /// </summary>
        internal static string Formatting_Text24 {
            get {
                return ResourceManager.GetString("Formatting_Text24", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Decimal (integers).
        /// </summary>
        internal static string Formatting_Text25 {
            get {
                return ResourceManager.GetString("Formatting_Text25", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Hexadecimal (integers).
        /// </summary>
        internal static string Formatting_Text26 {
            get {
                return ResourceManager.GetString("Formatting_Text26", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Currency.
        /// </summary>
        internal static string Formatting_Text27 {
            get {
                return ResourceManager.GetString("Formatting_Text27", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Currency (explicit currency symbol).
        /// </summary>
        internal static string Formatting_Text28 {
            get {
                return ResourceManager.GetString("Formatting_Text28", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Currency (no currency symbol).
        /// </summary>
        internal static string Formatting_Text29 {
            get {
                return ResourceManager.GetString("Formatting_Text29", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Dates are formatted using the
        ///    &lt;b&gt;Globalize.formatDate&lt;/b&gt; function.
        ///    For details regarding format strings, please refer the
        ///    &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/wijmo.Globalize.Class.html#formatDate&quot; target=&quot;_blank&quot;&gt;
        ///        online documentation&lt;/a&gt;..
        /// </summary>
        internal static string Formatting_Text3 {
            get {
                return ResourceManager.GetString("Formatting_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Percent.
        /// </summary>
        internal static string Formatting_Text30 {
            get {
                return ResourceManager.GetString("Formatting_Text30", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Our numeric formats allow you to include an explicit currency symbol
        ///        instead of the symbol of current culture.
        ///        For example, an English application may need to generate lists with
        ///        amounts in Dollars, Euros, and Yens..
        /// </summary>
        internal static string Formatting_Text31 {
            get {
                return ResourceManager.GetString("Formatting_Text31", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Format.
        /// </summary>
        internal static string Formatting_Text4 {
            get {
                return ResourceManager.GetString("Formatting_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Description.
        /// </summary>
        internal static string Formatting_Text5 {
            get {
                return ResourceManager.GetString("Formatting_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Result.
        /// </summary>
        internal static string Formatting_Text6 {
            get {
                return ResourceManager.GetString("Formatting_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Short Date Pattern.
        /// </summary>
        internal static string Formatting_Text7 {
            get {
                return ResourceManager.GetString("Formatting_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Long Date Pattern.
        /// </summary>
        internal static string Formatting_Text8 {
            get {
                return ResourceManager.GetString("Formatting_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Full Date/Time Pattern (short time).
        /// </summary>
        internal static string Formatting_Text9 {
            get {
                return ResourceManager.GetString("Formatting_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Formatting Dates and Numbers.
        /// </summary>
        internal static string Formatting_Title {
            get {
                return ResourceManager.GetString("Formatting_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Dates.
        /// </summary>
        internal static string Formatting_Title1 {
            get {
                return ResourceManager.GetString("Formatting_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Numbers.
        /// </summary>
        internal static string Formatting_Title2 {
            get {
                return ResourceManager.GetString("Formatting_Title2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, MVC controls format and parse the data using
        ///    American English culture. The decimal symbol is a period,
        ///    the thousand separator is a comma, and the days of the week
        ///    are &quot;Sunday&quot; through &quot;Saturday&quot;..
        /// </summary>
        internal static string Globalization_Text1 {
            get {
                return ResourceManager.GetString("Globalization_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If your application targets other cultures, register the appropriate culture
        ///    by registering the MVC scripts in your HTML pages.
        ///    MVC edition includes over 40 cultures (see
        ///    &lt;a href=&quot;http://wijmo.com/5/docs/static/globalization.html&quot; target=&quot;_blank&quot;&gt;
        ///        the complete list
        ///    &lt;/a&gt;
        ///    )..
        /// </summary>
        internal static string Globalization_Text2 {
            get {
                return ResourceManager.GetString("Globalization_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, to localize an application for the German culture,
        ///    register the &quot;de&quot; culture while registering the scripts:.
        /// </summary>
        internal static string Globalization_Text3 {
            get {
                return ResourceManager.GetString("Globalization_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Globalizing Applications.
        /// </summary>
        internal static string Globalization_Title {
            get {
                return ResourceManager.GetString("Globalization_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The C1 MVC CSS includes several glyphs defined
        ///    as pure CSS.
        ///    The glyphs are used by the C1 MVC controls and extensions,
        ///    and your applications may also use them..
        /// </summary>
        internal static string Glyphs_Text1 {
            get {
                return ResourceManager.GetString("Glyphs_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Using CSS to define glyphs eliminates the need to deploy
        ///    extra font or image files, and ensures the images are
        ///    rendered using the foreground color and font size defined
        ///    by the current theme..
        /// </summary>
        internal static string Glyphs_Text2 {
            get {
                return ResourceManager.GetString("Glyphs_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To use C1 MVC glyphs in your applications, add a span
        ///    element to your markup and set its class to the glyph
        ///    name. For example:.
        /// </summary>
        internal static string Glyphs_Text3 {
            get {
                return ResourceManager.GetString("Glyphs_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can use CSS to customize the appearance of the glyphs
        ///    used in the C1 MVC controls.
        ///    For example, you could use the CSS below to hide or
        ///    modify the appearance of the pencil glyph used by
        ///    the &lt;b&gt;FlexGrid&lt;/b&gt; to indicate rows in edit mode:.
        /// </summary>
        internal static string Glyphs_Text4 {
            get {
                return ResourceManager.GetString("Glyphs_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The table below shows the glyphs defined in the
        ///    C1 MVC CSS:.
        /// </summary>
        internal static string Glyphs_Text5 {
            get {
                return ResourceManager.GetString("Glyphs_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Glyphs.
        /// </summary>
        internal static string Glyphs_Title {
            get {
                return ResourceManager.GetString("Glyphs_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to C1 MVC events do not replace HTML events. For example,
        ///    mouse and keyboard events must be detected and handled
        ///    using regular HTML handlers attached to the control&apos;s
        ///    &lt;b&gt;hostElement&lt;/b&gt;..
        /// </summary>
        internal static string HtmlEvents_Text1 {
            get {
                return ResourceManager.GetString("HtmlEvents_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Control&lt;/b&gt; class of MVC makes HTML event easier to
        ///    use by providing &lt;b&gt;addEventListener&lt;/b&gt; and
        ///    &lt;b&gt;removeEventListener&lt;/b&gt; methods that automatically
        ///    clean up when a control is destroyed, which helps in avoiding
        ///    memory leaks..
        /// </summary>
        internal static string HtmlEvents_Text2 {
            get {
                return ResourceManager.GetString("HtmlEvents_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Below are some input controls with the HTML event handlers
        ///    attached to them:.
        /// </summary>
        internal static string HtmlEvents_Text3 {
            get {
                return ResourceManager.GetString("HtmlEvents_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Please move the mouse over the controls..
        /// </summary>
        internal static string HtmlEvents_Text4 {
            get {
                return ResourceManager.GetString("HtmlEvents_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For more details on C1 MVC and HTML events, please refer to
        ///        our blog on
        ///        &lt;a href=&quot;http://wijmo.com/blog/html-and-wijmo-events/&quot;&gt;HTML and Wijmo Events&lt;/a&gt;..
        /// </summary>
        internal static string HtmlEvents_Text5 {
            get {
                return ResourceManager.GetString("HtmlEvents_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to MVC and HTML Events.
        /// </summary>
        internal static string HtmlEvents_Title {
            get {
                return ResourceManager.GetString("HtmlEvents_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;p&gt;
        ///    This application demonstrates main features of C1 MVC
        ///    controls with the help of a series of samples.
        ///&lt;/p&gt;
        ///&lt;p&gt;
        ///    Browse the topics in the left pane to see various features
        ///    in action and learn by browsing the code and markup.
        ///    After navigating through a few samples, you should be able
        ///    to understand MVC client basics and eventually become 
        ///    an expert as you dig in further.
        ///&lt;/p&gt;
        ///&lt;p&gt;
        ///    For more details on a specific control or property, please refer the
        ///    &lt;a href=&quot;htt [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string Index_Description {
            get {
                return ResourceManager.GetString("Index_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Learn C1 MVC Client.
        /// </summary>
        internal static string Index_Title {
            get {
                return ResourceManager.GetString("Index_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to @Resources.C1Mvc.Index_Title.
        /// </summary>
        internal static string Index_Title1 {
            get {
                return ResourceManager.GetString("Index_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In addition to implementing fundamental classes such as
        ///    &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/webframe.html#wijmo.Control.Class.html&quot; target=&quot;_blank&quot;&gt;Control&lt;/a&gt;,
        ///    &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/webframe.html#wijmo.Event.Class.html&quot; target=&quot;_blank&quot;&gt;Event&lt;/a&gt;, and
        ///    &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 [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string OtherServices_Text1 {
            get {
                return ResourceManager.GetString("OtherServices_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/webframe.html#wijmo.Tooltip.Class.html&quot; target=&quot;_blank&quot;&gt;Tooltip&lt;/a&gt;:
        ///        Class that provides pop-up windows that display additional information about elements on the page..
        /// </summary>
        internal static string OtherServices_Text2 {
            get {
                return ResourceManager.GetString("OtherServices_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/webframe.html#wijmo.Clipboard.Class.html&quot; target=&quot;_blank&quot;&gt;Clipboard&lt;/a&gt;:
        ///        Class that provides static &lt;b&gt;copy&lt;/b&gt; and &lt;b&gt;paste&lt;/b&gt; methods that can be used by applications
        ///        and controls to customize the clipboard content during clipboard operations..
        /// </summary>
        internal static string OtherServices_Text3 {
            get {
                return ResourceManager.GetString("OtherServices_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/webframe.html#wijmo.PrintDocument.Class.html&quot; target=&quot;_blank&quot;&gt;PrintDocument&lt;/a&gt;:
        ///        Class that makes it easy to create documents for printing or exporting to PDF.
        ///        Most browsers allow you to select the paper size, orientation, margins,
        ///        and whether to include page headers and footers..
        /// </summary>
        internal static string OtherServices_Text4 {
            get {
                return ResourceManager.GetString("OtherServices_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/wijmo.Color.Class.html&quot; target=&quot;_blank&quot;&gt;Color&lt;/a&gt;:
        ///        Class that parses colors specified as CSS strings and exposes their red, green, blue,
        ///        and alpha channels as read-write properties. Also provides methods for converting
        ///        color spaces and interpolating..
        /// </summary>
        internal static string OtherServices_Text5 {
            get {
                return ResourceManager.GetString("OtherServices_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Glyphs.
        /// </summary>
        internal static string OtherServices_Text6 {
            get {
                return ResourceManager.GetString("OtherServices_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The C1 MVC CSS includes several glyphs used by the Wijmo controls. These glyphs
        ///        do not depend on any font files or external images, and you may use them in your
        ///        applications as well..
        /// </summary>
        internal static string OtherServices_Text7 {
            get {
                return ResourceManager.GetString("OtherServices_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/wijmo.Module.html#httpRequest&quot; target=&quot;_blank&quot;&gt;httpRequest&lt;/a&gt;:
        ///        Static method used to submit http requests to the server..
        /// </summary>
        internal static string OtherServices_Text8 {
            get {
                return ResourceManager.GetString("OtherServices_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/wijmo.Module.html#animate&quot; target=&quot;_blank&quot;&gt;animate&lt;/a&gt;:
        ///        Static method used to create animations by setting properties on a timer..
        /// </summary>
        internal static string OtherServices_Text9 {
            get {
                return ResourceManager.GetString("OtherServices_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Other Classes and Services.
        /// </summary>
        internal static string OtherServices_Title {
            get {
                return ResourceManager.GetString("OtherServices_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To globalize your application, register the appropriate culture
        ///    while registering the C1 MVC scripts.
        ///    &lt;a href=&quot;http://wijmo.com/5/docs/static/globalization.html&quot; target=&quot;_blank&quot;&gt;
        ///        Wijmo includes over 40 culture files you can choose from.
        ///    &lt;/a&gt;.
        /// </summary>
        internal static string Parsing_Text1 {
            get {
                return ResourceManager.GetString("Parsing_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Input format.
        /// </summary>
        internal static string Parsing_Text10 {
            get {
                return ResourceManager.GetString("Parsing_Text10", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Input string.
        /// </summary>
        internal static string Parsing_Text11 {
            get {
                return ResourceManager.GetString("Parsing_Text11", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parse Number.
        /// </summary>
        internal static string Parsing_Text12 {
            get {
                return ResourceManager.GetString("Parsing_Text12", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Please select a culture.
        /// </summary>
        internal static string Parsing_Text2 {
            get {
                return ResourceManager.GetString("Parsing_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Dates are parsed using the
        ///    &lt;b&gt;Globalize.parseDate&lt;/b&gt; function.
        ///    The format strings are the same used to format dates. For details regarding format strings, please refer the
        ///    &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/wijmo.Globalize.Class.html#formatDate&quot; target=&quot;_blank&quot;&gt;
        ///        online documentation&lt;/a&gt;..
        /// </summary>
        internal static string Parsing_Text3 {
            get {
                return ResourceManager.GetString("Parsing_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Try it yourself with the help of the sample below:.
        /// </summary>
        internal static string Parsing_Text4 {
            get {
                return ResourceManager.GetString("Parsing_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Input format.
        /// </summary>
        internal static string Parsing_Text5 {
            get {
                return ResourceManager.GetString("Parsing_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Input string.
        /// </summary>
        internal static string Parsing_Text6 {
            get {
                return ResourceManager.GetString("Parsing_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parse Date.
        /// </summary>
        internal static string Parsing_Text7 {
            get {
                return ResourceManager.GetString("Parsing_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Numbers are parsed using the &lt;b&gt;Globalize.parseFloat&lt;/b&gt; function.
        ///    The format strings are the same used to format numbers. For details regarding format strings, please refer the
        ///    &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/wijmo.Globalize.Class.html#formatNumber&quot; target=&quot;_blank&quot;&gt;
        ///        online documentation&lt;/a&gt;..
        /// </summary>
        internal static string Parsing_Text8 {
            get {
                return ResourceManager.GetString("Parsing_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Try it yourself with the help of the sample below:.
        /// </summary>
        internal static string Parsing_Text9 {
            get {
                return ResourceManager.GetString("Parsing_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Parsing Dates and Numbers.
        /// </summary>
        internal static string Parsing_Title {
            get {
                return ResourceManager.GetString("Parsing_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Dates.
        /// </summary>
        internal static string Parsing_Title1 {
            get {
                return ResourceManager.GetString("Parsing_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Numbers.
        /// </summary>
        internal static string Parsing_Title2 {
            get {
                return ResourceManager.GetString("Parsing_Title2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There may be cases where you want to display custom messages
        ///    based on the item count. This is especially important
        ///    in certain cultures such as Polish..
        /// </summary>
        internal static string Pluralization_Text1 {
            get {
                return ResourceManager.GetString("Pluralization_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;format&lt;/b&gt; method supports that by accepting format
        ///    strings that contain pluralization rules encoded as JSON
        ///    objects..
        /// </summary>
        internal static string Pluralization_Text2 {
            get {
                return ResourceManager.GetString("Pluralization_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, choose the number of items and see the
        ///    formatted output below:.
        /// </summary>
        internal static string Pluralization_Text3 {
            get {
                return ResourceManager.GetString("Pluralization_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Pluralization.
        /// </summary>
        internal static string Pluralization_Title {
            get {
                return ResourceManager.GetString("Pluralization_Title", 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 or exporting to PDF. Most browsers allow you to select
        ///    the paper size, orientation, margins, and whether to include page
        ///    headers and footers..
        /// </summary>
        internal static string PrintDocument_Text1 {
            get {
                return ResourceManager.GetString("PrintDocument_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Print with PrintDocument.
        /// </summary>
        internal static string PrintDocument_Text2 {
            get {
                return ResourceManager.GetString("PrintDocument_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Print directly.
        /// </summary>
        internal static string PrintDocument_Text3 {
            get {
                return ResourceManager.GetString("PrintDocument_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Here is a table with some radial gauges. The table will be included
        ///    in the &lt;b&gt;PrintDocument&lt;/b&gt;..
        /// </summary>
        internal static string PrintDocument_Text4 {
            get {
                return ResourceManager.GetString("PrintDocument_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to And here is a &lt;b&gt;FlexGrid&lt;/b&gt; control. Printing it directly would show
        ///    the scrollbars and the part of the content that is visible.
        ///    The &lt;b&gt;PrintDocument&lt;/b&gt; class allows us to replace that with a
        ///    printer-friendly version of the grid..
        /// </summary>
        internal static string PrintDocument_Text5 {
            get {
                return ResourceManager.GetString("PrintDocument_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to PrintDocument.
        /// </summary>
        internal static string PrintDocument_Title {
            get {
                return ResourceManager.GetString("PrintDocument_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A number of MVC controls have properties that take enumeration values..
        /// </summary>
        internal static string PropertiesEnums_Text1 {
            get {
                return ResourceManager.GetString("PropertiesEnums_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the FlexChart&apos;s &lt;b&gt;chartType&lt;/b&gt; property takes
        ///    values of type
        ///    &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/webframe.html#wijmo.chart.ChartType.Enum.html&quot; target=&quot;_blank&quot;&gt;wijmo.chart.ChartType&lt;/a&gt;..
        /// </summary>
        internal static string PropertiesEnums_Text2 {
            get {
                return ResourceManager.GetString("PropertiesEnums_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can set enumeration properties using the enum symbol,
        ///    numeric value, or name. For example, following three ways are 
        ///    equivalent:.
        /// </summary>
        internal static string PropertiesEnums_Text3 {
            get {
                return ResourceManager.GetString("PropertiesEnums_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Regardless of the method used, when you make the assignment
        ///    MVC will convert the values into proper enumeration and 
        ///    store the converted value. If the conversion fails, an exception
        ///    will be thrown. For example:.
        /// </summary>
        internal static string PropertiesEnums_Text4 {
            get {
                return ResourceManager.GetString("PropertiesEnums_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The current chart type is &lt;b&gt;&lt;span id=&quot;currentType&quot;&gt;&lt;/span&gt;&lt;/b&gt;.
        ///    Use the following combobox to switch to other chart type..
        /// </summary>
        internal static string PropertiesEnums_Text5 {
            get {
                return ResourceManager.GetString("PropertiesEnums_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Chart Type:.
        /// </summary>
        internal static string PropertiesEnums_Text6 {
            get {
                return ResourceManager.GetString("PropertiesEnums_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Properties and Enums.
        /// </summary>
        internal static string PropertiesEnums_Title {
            get {
                return ResourceManager.GetString("PropertiesEnums_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Live example:.
        /// </summary>
        internal static string PropertiesEnums_Title1 {
            get {
                return ResourceManager.GetString("PropertiesEnums_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to CSS pseudo-classes are keywords added to selectors that
        ///    specify special states of the element to be selected.
        ///    For example, pseudo-class :hover will apply a style when user
        ///    hovers over the element specified by the selector..
        /// </summary>
        internal static string PseudoClasses_Text1 {
            get {
                return ResourceManager.GetString("PseudoClasses_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Click the gauges below to change the current value and watch how
        ///    their respective thumbs change:.
        /// </summary>
        internal static string PseudoClasses_Text10 {
            get {
                return ResourceManager.GetString("PseudoClasses_Text10", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Some standard pseudo-classes have limited use 
        ///    because they get applied to specific elements only,
        ///    and not to their ancestors. For example,
        ///    a number of MVC input controls contain input elements.
        ///    When input elements have the focus, they get the pseudo-class :focus,
        ///    but the control host that contains it does not get the same..
        /// </summary>
        internal static string PseudoClasses_Text2 {
            get {
                return ResourceManager.GetString("PseudoClasses_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To handle this, we added some pseudo-classes of our
        ///    own to make it easier to build effective forms:.
        /// </summary>
        internal static string PseudoClasses_Text3 {
            get {
                return ResourceManager.GetString("PseudoClasses_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;wj-state-focused&lt;/b&gt;:
        ///        Added to control host elements when control contains
        ///        the active element (not necessarily when the host element
        ///        is the active element)..
        /// </summary>
        internal static string PseudoClasses_Text4 {
            get {
                return ResourceManager.GetString("PseudoClasses_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;wj-state-invalid&lt;/b&gt;:
        ///        Added to control host elements when control contains
        ///        input elements in an invalid state..
        /// </summary>
        internal static string PseudoClasses_Text5 {
            get {
                return ResourceManager.GetString("PseudoClasses_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;wj-state-empty&lt;/b&gt;:
        ///        Added to control host elements when control contains
        ///        an input element with no content (this is different from
        ///        the :empty pseudo-class which is applied to elements that
        ///        have no children..
        /// </summary>
        internal static string PseudoClasses_Text6 {
            get {
                return ResourceManager.GetString("PseudoClasses_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;wj-state-readonly&lt;/b&gt;:
        ///        Added to control host elements when &lt;b&gt;isReadOnly&lt;/b&gt;
        ///        property of control is set to true..
        /// </summary>
        internal static string PseudoClasses_Text7 {
            get {
                return ResourceManager.GetString("PseudoClasses_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;wj-state-disabled&lt;/b&gt;:
        ///        Added to control host elements when &lt;b&gt;isDisabled&lt;/b&gt; property
        ///        of control is set to true (which corresponds to adding 
        ///        a &quot;disabled&quot; attribute to the control&apos;s host element)..
        /// </summary>
        internal static string PseudoClasses_Text8 {
            get {
                return ResourceManager.GetString("PseudoClasses_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example shows how you can use the &lt;b&gt;wj-state-focused&lt;/b&gt;
        ///    pseudo-class to apply CSS animations to the thumb element of
        ///    linear and radial gauges when they get the focus..
        /// </summary>
        internal static string PseudoClasses_Text9 {
            get {
                return ResourceManager.GetString("PseudoClasses_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Pseudo Classes.
        /// </summary>
        internal static string PseudoClasses_Title {
            get {
                return ResourceManager.GetString("PseudoClasses_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;p&gt;
        ///    To use C1 MVC controls in your MVC application, follow these steps:
        ///&lt;/p&gt;
        ///&lt;ol&gt;
        ///    &lt;li&gt;
        ///        &lt;b&gt;Install ASP.NET MVC Edition&lt;/b&gt;&lt;br /&gt;
        ///        Download the installer(&lt;a href=&quot;https://www.grapecity.com/en/download&quot;&gt;C1StudioInstaller.exe&lt;/a&gt;) in your machine. 
        ///        Follow the steps through the installation wizard to install the
        ///        .NET DLLs and packages for ASP.NET MVC Edition. The installer 
        ///        also installs C1 ASP.NET MVC Web Application templates which 
        ///        can be used i [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string Reference_Description {
            get {
                return ResourceManager.GetString("Reference_Description", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Referencing MVC Controls in your Application.
        /// </summary>
        internal static string Reference_Title {
            get {
                return ResourceManager.GetString("Reference_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to @Resources.C1Mvc.Reference_Title.
        /// </summary>
        internal static string Reference_Title1 {
            get {
                return ResourceManager.GetString("Reference_Title1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Service is an object defined to provide additional functionality. 
        ///    Currently, ASP.NET MVC Edition provides following two services:.
        /// </summary>
        internal static string Services_Text1 {
            get {
                return ResourceManager.GetString("Services_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;code&gt;c1.mvc.collections.RemoteCollectionView&lt;/code&gt;.
        /// </summary>
        internal static string Services_Text2 {
            get {
                return ResourceManager.GetString("Services_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;code&gt;c1.mvc.olap.PivotEngine&lt;/code&gt;.
        /// </summary>
        internal static string Services_Text3 {
            get {
                return ResourceManager.GetString("Services_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The service object can be obtained using &lt;code&gt;c1.getService(serviceId)&lt;/code&gt;..
        /// </summary>
        internal static string Services_Text4 {
            get {
                return ResourceManager.GetString("Services_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The sample shows how to create a RemoteCollectionView service and customize it..
        /// </summary>
        internal static string Services_Text5 {
            get {
                return ResourceManager.GetString("Services_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Previous Page.
        /// </summary>
        internal static string Services_Text6 {
            get {
                return ResourceManager.GetString("Services_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Next Page.
        /// </summary>
        internal static string Services_Text7 {
            get {
                return ResourceManager.GetString("Services_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to C1 MVC Services.
        /// </summary>
        internal static string Services_Title {
            get {
                return ResourceManager.GetString("Services_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to MVC controls are styled using CSS.
        ///    The default look is provided by registering the styles,
        ///    and over 20 beautiful themes that can be registered as follows:.
        /// </summary>
        internal static string Themes_Text1 {
            get {
                return ResourceManager.GetString("Themes_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In addition to the CSS included in the MVC edition, you can use
        ///    standard CSS selectors to customize the look of any control..
        /// </summary>
        internal static string Themes_Text2 {
            get {
                return ResourceManager.GetString("Themes_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Please select a theme:.
        /// </summary>
        internal static string Themes_Text3 {
            get {
                return ResourceManager.GetString("Themes_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Below are some input controls:.
        /// </summary>
        internal static string Themes_Text4 {
            get {
                return ResourceManager.GetString("Themes_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This is a FlexGrid:.
        /// </summary>
        internal static string Themes_Text5 {
            get {
                return ResourceManager.GetString("Themes_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Themes.
        /// </summary>
        internal static string Themes_Title {
            get {
                return ResourceManager.GetString("Themes_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tooltips are provided by the C1 MVC core. They are not controls,
        ///    but popups containing HTML that appear when the mouse hovers
        ///    over designated elements..
        /// </summary>
        internal static string Tooltip_Text1 {
            get {
                return ResourceManager.GetString("Tooltip_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can associate a tooltip with one or more elements on the
        ///    page using the &lt;b id=&quot;setTooltip&quot;&gt;Tooltip.setTooltip&lt;/b&gt; method..
        /// </summary>
        internal static string Tooltip_Text2 {
            get {
                return ResourceManager.GetString("Tooltip_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to And this paragraph has a &lt;b id=&quot;theSpan&quot;&gt;span with a tooltip&lt;/b&gt;
        ///    and another &lt;i id=&quot;theOtherSpan&quot;&gt;span with a different tooltip&lt;/i&gt;..
        /// </summary>
        internal static string Tooltip_Text3 {
            get {
                return ResourceManager.GetString("Tooltip_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The buttons below also have tooltips:.
        /// </summary>
        internal static string Tooltip_Text4 {
            get {
                return ResourceManager.GetString("Tooltip_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to addNew.
        /// </summary>
        internal static string Tooltip_Text5 {
            get {
                return ResourceManager.GetString("Tooltip_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to push.
        /// </summary>
        internal static string Tooltip_Text6 {
            get {
                return ResourceManager.GetString("Tooltip_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to push + defer updates.
        /// </summary>
        internal static string Tooltip_Text7 {
            get {
                return ResourceManager.GetString("Tooltip_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;setTooltip&lt;/b&gt; method a ssigns tooltip content to given elements on the page..
        /// </summary>
        internal static string Tooltip_Text8 {
            get {
                return ResourceManager.GetString("Tooltip_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The same tooltip may be used to display information for any number
        ///            of elements on the page. To remove the tooltip from an element,
        ///            call the &lt;b&gt;setTooltip&lt;/b&gt; method and specify null for the content..
        /// </summary>
        internal static string Tooltip_Text9 {
            get {
                return ResourceManager.GetString("Tooltip_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tooltips.
        /// </summary>
        internal static string Tooltip_Title {
            get {
                return ResourceManager.GetString("Tooltip_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Animations can make web applications more attractive and intuitive.
        ///    For example, removing an item from the page by making it shrink
        ///    away lets the user see which item is being removed more easily
        ///    that if it was simply hidden..
        /// </summary>
        internal static string WijmoAnimate_Text1 {
            get {
                return ResourceManager.GetString("WijmoAnimate_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Many JavaScript toolkits and frameworks have their own wrappers
        ///    for creating animations. For example, Angular has an
        ///    &lt;a href=&quot;https://docs.angularjs.org/api/ng/service/$animate&quot; target=&quot;_blank&quot;&gt;$animate&lt;/a&gt; service,
        ///    and jQuery has an
        ///    &lt;a href=&quot;http://api.jquery.com/animate/&quot;&gt;animate()&lt;/a&gt; method.
        ///    If you have a favorite you can use that with C1 MVC..
        /// </summary>
        internal static string WijmoAnimate_Text2 {
            get {
                return ResourceManager.GetString("WijmoAnimate_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you want to reduce dependencies on external toolkits and
        ///    frameworks, you can use Wijmo&apos;s simple and flexible
        ///    &lt;b&gt;animate&lt;/b&gt; method instead..
        /// </summary>
        internal static string WijmoAnimate_Text3 {
            get {
                return ResourceManager.GetString("WijmoAnimate_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The example below illustrates by rotating a FlexGrid like
        ///    a flip card. The &lt;b&gt;animate&lt;/b&gt; method has a single callback
        ///    that controls the entire animation:.
        /// </summary>
        internal static string WijmoAnimate_Text4 {
            get {
                return ResourceManager.GetString("WijmoAnimate_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Flip the Grid.
        /// </summary>
        internal static string WijmoAnimate_Text5 {
            get {
                return ResourceManager.GetString("WijmoAnimate_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The wijmo.animate Method.
        /// </summary>
        internal static string WijmoAnimate_Title {
            get {
                return ResourceManager.GetString("WijmoAnimate_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Creating strings based on formatted data can be challenging in JavaScript.
        ///    ES2016 addressed that limitation by introducing
        ///    &lt;a href=&quot;https://developers.google.com/web/updates/2015/01/ES6-Template-Strings&quot; target=&quot;_blank&quot;&gt;Template Strings&lt;/a&gt;..
        /// </summary>
        internal static string WijmoFormat_Text1 {
            get {
                return ResourceManager.GetString("WijmoFormat_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unfortunately, browser support is still limited for that solution. Hence,
        ///    we provide the
        ///    &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/wijmo.Module.html#format&quot; target=&quot;_blank&quot;&gt;format&lt;/a&gt;
        ///    function that works regardless of browser. The &lt;b&gt;format&lt;/b&gt; function takes a
        ///    format string with placeholders that contain variable names and format
        ///    specifiers, and a data object that supplies the variables..
        /// </summary>
        internal static string WijmoFormat_Text2 {
            get {
                return ResourceManager.GetString("WijmoFormat_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example:.
        /// </summary>
        internal static string WijmoFormat_Text3 {
            get {
                return ResourceManager.GetString("WijmoFormat_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Show Result.
        /// </summary>
        internal static string WijmoFormat_Text4 {
            get {
                return ResourceManager.GetString("WijmoFormat_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Another example:.
        /// </summary>
        internal static string WijmoFormat_Text5 {
            get {
                return ResourceManager.GetString("WijmoFormat_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The wijmo.format Method.
        /// </summary>
        internal static string WijmoFormat_Title {
            get {
                return ResourceManager.GetString("WijmoFormat_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to HTTP requests are the basic mechanism used by web applications
        ///    to exchange data with the server..
        /// </summary>
        internal static string WijmoHttpRequest_Text1 {
            get {
                return ResourceManager.GetString("WijmoHttpRequest_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Many JavaScript toolkits and frameworks have their own wrappers
        ///    for making HTTP requests. For example, Angular has an
        ///    &lt;a href=&quot;https://docs.angularjs.org/api/ng/service/$http&quot; target=&quot;_blank&quot;&gt;$http&lt;/a&gt; service,
        ///    and jQuery has an
        ///    &lt;a href=&quot;http://api.jquery.com/jquery.ajax/&quot;&gt;ajax()&lt;/a&gt; method.
        ///    If you have a favorite you can use that with C1 MVC..
        /// </summary>
        internal static string WijmoHttpRequest_Text2 {
            get {
                return ResourceManager.GetString("WijmoHttpRequest_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you want to reduce dependencies on external toolkits and
        ///    frameworks, you can use C1 MVC&apos;s simple and flexible
        ///    &lt;b&gt;httpRequest&lt;/b&gt; method instead..
        /// </summary>
        internal static string WijmoHttpRequest_Text3 {
            get {
                return ResourceManager.GetString("WijmoHttpRequest_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The example below illustrates by retrieving some data from
        ///    Microsoft&apos;s Northwind OData sample service and using that
        ///    to populate a FlexGrid:.
        /// </summary>
        internal static string WijmoHttpRequest_Text4 {
            get {
                return ResourceManager.GetString("WijmoHttpRequest_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The wijmo.httpRequest Method.
        /// </summary>
        internal static string WijmoHttpRequest_Title {
            get {
                return ResourceManager.GetString("WijmoHttpRequest_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can easily implement a column-picker UI by using the
        ///    grid&apos;s &lt;b&gt;columns&lt;/b&gt; property, a &lt;b&gt;ListBox&lt;/b&gt; control,
        ///    and C1 MVC&apos;s &lt;b&gt;showPopup&lt;/b&gt; and &lt;b&gt;hidePopup&lt;/b&gt;
        ///    methods..
        /// </summary>
        internal static string WijmoShowPopup_Text1 {
            get {
                return ResourceManager.GetString("WijmoShowPopup_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the grid below loads with an auto-generated
        ///    set of columns. Click the gear icon at the top-left cell to
        ///    show a &lt;b&gt;ListBox&lt;/b&gt; where you can select the columns
        ///    you want to display..
        /// </summary>
        internal static string WijmoShowPopup_Text2 {
            get {
                return ResourceManager.GetString("WijmoShowPopup_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 WijmoShowPopup_Text3 {
            get {
                return ResourceManager.GetString("WijmoShowPopup_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Save Layout.
        /// </summary>
        internal static string WijmoShowPopup_Text4 {
            get {
                return ResourceManager.GetString("WijmoShowPopup_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Restore Layout.
        /// </summary>
        internal static string WijmoShowPopup_Text5 {
            get {
                return ResourceManager.GetString("WijmoShowPopup_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Popup Column Picker.
        /// </summary>
        internal static string WijmoShowPopup_Title {
            get {
                return ResourceManager.GetString("WijmoShowPopup_Title", resourceCulture);
            }
        }
    }
}
