//------------------------------------------------------------------------------
// <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 C1FlexChart {
        
        private static global::System.Resources.ResourceManager resourceMan;
        
        private static global::System.Globalization.CultureInfo resourceCulture;
        
        [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")]
        internal C1FlexChart() {
        }
        
        /// <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.C1FlexChart", 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 Box and Whisker series (AKA boxplots) show groups of numerical
        ///    data through their quartiles. They have lines extending
        ///    vertically from the boxes (whiskers) indicating variability
        ///    outside the upper and lower quartiles..
        /// </summary>
        internal static string AnalyticsBoxplot_Text1 {
            get {
                return ResourceManager.GetString("AnalyticsBoxplot_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To create a Box and Whisker chart, follow these steps:.
        /// </summary>
        internal static string AnalyticsBoxplot_Text2 {
            get {
                return ResourceManager.GetString("AnalyticsBoxplot_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Create one or more BoxWhisker series objects,.
        /// </summary>
        internal static string AnalyticsBoxplot_Text3 {
            get {
                return ResourceManager.GetString("AnalyticsBoxplot_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Configure the BoxWhisker series by setting their
        ///        &lt;b&gt;name&lt;/b&gt; and &lt;b&gt;binding&lt;/b&gt; properties (they
        ///        should be bound to properties that contain number
        ///        arrays), and.
        /// </summary>
        internal static string AnalyticsBoxplot_Text4 {
            get {
                return ResourceManager.GetString("AnalyticsBoxplot_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set additional properties such as &lt;b&gt;showOutliers&lt;/b&gt;
        ///        and &lt;b&gt;showInnerPoints&lt;/b&gt; if you want to fine-tune
        ///        the display..
        /// </summary>
        internal static string AnalyticsBoxplot_Text5 {
            get {
                return ResourceManager.GetString("AnalyticsBoxplot_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Show Inner Points:.
        /// </summary>
        internal static string AnalyticsBoxplot_Text6 {
            get {
                return ResourceManager.GetString("AnalyticsBoxplot_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Show Outliers:.
        /// </summary>
        internal static string AnalyticsBoxplot_Text7 {
            get {
                return ResourceManager.GetString("AnalyticsBoxplot_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Randomize Data.
        /// </summary>
        internal static string AnalyticsBoxplot_Text8 {
            get {
                return ResourceManager.GetString("AnalyticsBoxplot_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Box and Whisker Series.
        /// </summary>
        internal static string AnalyticsBoxplot_Title {
            get {
                return ResourceManager.GetString("AnalyticsBoxplot_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;wijmo.chart.analytics&lt;/b&gt; module contains two
        ///    classes that allow you to plot arbitrary functions without
        ///    explicitly generating data points:.
        /// </summary>
        internal static string AnalyticsCustomFunctions_Text1 {
            get {
                return ResourceManager.GetString("AnalyticsCustomFunctions_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;YFunctionSeries&lt;/b&gt;: Series based on a function that
        ///        provides Y values as a function of X values within a
        ///        given range..
        /// </summary>
        internal static string AnalyticsCustomFunctions_Text2 {
            get {
                return ResourceManager.GetString("AnalyticsCustomFunctions_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;ParametricFunctionSeries&lt;/b&gt;: Series based on functions
        ///        that provides X and Y values as a function of domain values
        ///        within a given range..
        /// </summary>
        internal static string AnalyticsCustomFunctions_Text3 {
            get {
                return ResourceManager.GetString("AnalyticsCustomFunctions_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The chart below demonstrates:.
        /// </summary>
        internal static string AnalyticsCustomFunctions_Text4 {
            get {
                return ResourceManager.GetString("AnalyticsCustomFunctions_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Functions.
        /// </summary>
        internal static string AnalyticsCustomFunctions_Title {
            get {
                return ResourceManager.GetString("AnalyticsCustomFunctions_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The ErrorBar class extends the regular Series class
        ///    to provide error bars that can be added on top of the
        ///    regular series data..
        /// </summary>
        internal static string AnalyticsErrorBars_Text1 {
            get {
                return ResourceManager.GetString("AnalyticsErrorBars_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To create a series with error bars, follow these steps:.
        /// </summary>
        internal static string AnalyticsErrorBars_Text2 {
            get {
                return ResourceManager.GetString("AnalyticsErrorBars_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Create an ErrorBar series,.
        /// </summary>
        internal static string AnalyticsErrorBars_Text3 {
            get {
                return ResourceManager.GetString("AnalyticsErrorBars_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Configure the ErrorBar series as you would regular
        ///        series, setting their &lt;b&gt;binding&lt;/b&gt;, &lt;b&gt;chartType&lt;/b&gt;,
        ///        and &lt;b&gt;style&lt;/b&gt; properties for example, and.
        /// </summary>
        internal static string AnalyticsErrorBars_Text4 {
            get {
                return ResourceManager.GetString("AnalyticsErrorBars_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set the ErrorBar&apos;s &lt;b&gt;value&lt;/b&gt; and &lt;b&gt;errorAmount&lt;/b&gt;
        ///        properties to the size of the error bars to be added
        ///        to the data points..
        /// </summary>
        internal static string AnalyticsErrorBars_Text5 {
            get {
                return ResourceManager.GetString("AnalyticsErrorBars_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Chart Type:.
        /// </summary>
        internal static string AnalyticsErrorBars_Text6 {
            get {
                return ResourceManager.GetString("AnalyticsErrorBars_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Error:.
        /// </summary>
        internal static string AnalyticsErrorBars_Text7 {
            get {
                return ResourceManager.GetString("AnalyticsErrorBars_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Randomize Data.
        /// </summary>
        internal static string AnalyticsErrorBars_Text8 {
            get {
                return ResourceManager.GetString("AnalyticsErrorBars_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Error Bars.
        /// </summary>
        internal static string AnalyticsErrorBars_Title {
            get {
                return ResourceManager.GetString("AnalyticsErrorBars_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The MovingAverage class extends the regular Series class
        ///    to provide a series of averages of different subsets of
        ///    the full data set..
        /// </summary>
        internal static string AnalyticsMovingAverages_Text1 {
            get {
                return ResourceManager.GetString("AnalyticsMovingAverages_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To add moving averages to a chart, follow these steps:.
        /// </summary>
        internal static string AnalyticsMovingAverages_Text2 {
            get {
                return ResourceManager.GetString("AnalyticsMovingAverages_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Create one or more MovingAverage series,.
        /// </summary>
        internal static string AnalyticsMovingAverages_Text3 {
            get {
                return ResourceManager.GetString("AnalyticsMovingAverages_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Configure the MovingAverage series as you would regular
        ///        series, setting their &lt;b&gt;binding&lt;/b&gt;, &lt;b&gt;chartType&lt;/b&gt;,
        ///        and &lt;b&gt;style&lt;/b&gt; properties for example, and.
        /// </summary>
        internal static string AnalyticsMovingAverages_Text4 {
            get {
                return ResourceManager.GetString("AnalyticsMovingAverages_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set the MovingAverage&apos;s &lt;b&gt;type&lt;/b&gt; and &lt;b&gt;period&lt;/b&gt;
        ///        properties to determine the type of moving average
        ///        you want to create..
        /// </summary>
        internal static string AnalyticsMovingAverages_Text5 {
            get {
                return ResourceManager.GetString("AnalyticsMovingAverages_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to MovingAverage Type:.
        /// </summary>
        internal static string AnalyticsMovingAverages_Text6 {
            get {
                return ResourceManager.GetString("AnalyticsMovingAverages_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Period:.
        /// </summary>
        internal static string AnalyticsMovingAverages_Text7 {
            get {
                return ResourceManager.GetString("AnalyticsMovingAverages_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Moving Average.
        /// </summary>
        internal static string AnalyticsMovingAverages_Title {
            get {
                return ResourceManager.GetString("AnalyticsMovingAverages_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The TrendLine class extends the regular Series class to provide
        ///    a calculated series based on the data and parameters you
        ///    select..
        /// </summary>
        internal static string AnalyticsTrendLines_Text1 {
            get {
                return ResourceManager.GetString("AnalyticsTrendLines_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Randomize Data.
        /// </summary>
        internal static string AnalyticsTrendLines_Text10 {
            get {
                return ResourceManager.GetString("AnalyticsTrendLines_Text10", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To add trend lines to a chart, follow these steps:.
        /// </summary>
        internal static string AnalyticsTrendLines_Text2 {
            get {
                return ResourceManager.GetString("AnalyticsTrendLines_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Create one or more TrendLine objects,.
        /// </summary>
        internal static string AnalyticsTrendLines_Text3 {
            get {
                return ResourceManager.GetString("AnalyticsTrendLines_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Configure the TrendLine objects as you would a regular series,
        ///        setting their &lt;b&gt;binding&lt;/b&gt;, &lt;b&gt;chartType&lt;/b&gt;, and &lt;b&gt;style&lt;/b&gt;
        ///        properties for example, and.
        /// </summary>
        internal static string AnalyticsTrendLines_Text4 {
            get {
                return ResourceManager.GetString("AnalyticsTrendLines_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set the TrendLine&apos;s &lt;b&gt;fitType&lt;/b&gt; and &lt;b&gt;order&lt;/b&gt; properties
        ///        to determine the type of trend line you want to create..
        /// </summary>
        internal static string AnalyticsTrendLines_Text5 {
            get {
                return ResourceManager.GetString("AnalyticsTrendLines_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Trendline Type:.
        /// </summary>
        internal static string AnalyticsTrendLines_Text6 {
            get {
                return ResourceManager.GetString("AnalyticsTrendLines_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to None.
        /// </summary>
        internal static string AnalyticsTrendLines_Text7 {
            get {
                return ResourceManager.GetString("AnalyticsTrendLines_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Order:.
        /// </summary>
        internal static string AnalyticsTrendLines_Text8 {
            get {
                return ResourceManager.GetString("AnalyticsTrendLines_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Equation:.
        /// </summary>
        internal static string AnalyticsTrendLines_Text9 {
            get {
                return ResourceManager.GetString("AnalyticsTrendLines_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Trend Lines.
        /// </summary>
        internal static string AnalyticsTrendLines_Title {
            get {
                return ResourceManager.GetString("AnalyticsTrendLines_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Waterfall charts help in understanding the cumulative effect
        ///    of sequentially introduced positive or negative values.
        ///    The Waterfall chart is also known as a &quot;flying bricks&quot; chart
        ///    or Mario chart due to the apparent suspension of columns
        ///    in mid-air..
        /// </summary>
        internal static string AnalyticsWaterfallCharts_Text1 {
            get {
                return ResourceManager.GetString("AnalyticsWaterfallCharts_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To create a Waterfall chart, follow these steps:.
        /// </summary>
        internal static string AnalyticsWaterfallCharts_Text2 {
            get {
                return ResourceManager.GetString("AnalyticsWaterfallCharts_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Create a Waterfall series object,.
        /// </summary>
        internal static string AnalyticsWaterfallCharts_Text3 {
            get {
                return ResourceManager.GetString("AnalyticsWaterfallCharts_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Configure the Waterfall series by setting its
        ///        &lt;b&gt;name&lt;/b&gt; and &lt;b&gt;binding&lt;/b&gt;properties, and.
        /// </summary>
        internal static string AnalyticsWaterfallCharts_Text4 {
            get {
                return ResourceManager.GetString("AnalyticsWaterfallCharts_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set additional properties such as &lt;b&gt;showOutliers&lt;/b&gt;
        ///        and &lt;b&gt;showInnerPoints&lt;/b&gt; if you want to fine-tune
        ///        the Waterfall display..
        /// </summary>
        internal static string AnalyticsWaterfallCharts_Text5 {
            get {
                return ResourceManager.GetString("AnalyticsWaterfallCharts_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Show Connector Lines:.
        /// </summary>
        internal static string AnalyticsWaterfallCharts_Text6 {
            get {
                return ResourceManager.GetString("AnalyticsWaterfallCharts_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Show Total Bar:.
        /// </summary>
        internal static string AnalyticsWaterfallCharts_Text7 {
            get {
                return ResourceManager.GetString("AnalyticsWaterfallCharts_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Randomize Data.
        /// </summary>
        internal static string AnalyticsWaterfallCharts_Text8 {
            get {
                return ResourceManager.GetString("AnalyticsWaterfallCharts_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Waterfall.
        /// </summary>
        internal static string AnalyticsWaterfallCharts_Title {
            get {
                return ResourceManager.GetString("AnalyticsWaterfallCharts_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;wijmo.chart.analytics&lt;/b&gt; module contains classes that
        ///    extend the &lt;b&gt;Series&lt;/b&gt; class to provide extra information
        ///    about the data including: trend lines, moving averages,
        ///    error bars, box and waterfall plots, and function plots..
        /// </summary>
        internal static string Analytics_Text1 {
            get {
                return ResourceManager.GetString("Analytics_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The chart below has a regular series and two analytics series,
        ///    a &lt;b&gt;TrendLine&lt;/b&gt; and a &lt;b&gt;MovingAverage&lt;/b&gt;:.
        /// </summary>
        internal static string Analytics_Text2 {
            get {
                return ResourceManager.GetString("Analytics_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Analytics.
        /// </summary>
        internal static string Analytics_Title {
            get {
                return ResourceManager.GetString("Analytics_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A typical use for annotations is the addition of symbols
        ///    (text or images) to data points. The symbols typically
        ///    have tooltips or text with additional information about
        ///    the point they are attached to..
        /// </summary>
        internal static string AnnotationsSymbols_Text1 {
            get {
                return ResourceManager.GetString("AnnotationsSymbols_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The chart below has symbols that contain relevant (but fake)
        ///    headlines for some key dates:.
        /// </summary>
        internal static string AnnotationsSymbols_Text2 {
            get {
                return ResourceManager.GetString("AnnotationsSymbols_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Annotation Symbols.
        /// </summary>
        internal static string AnnotationsSymbols_Title {
            get {
                return ResourceManager.GetString("AnnotationsSymbols_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can use the FlexChart&apos;s &lt;b&gt;rendering&lt;/b&gt; and
        ///    &lt;b&gt;rendered&lt;/b&gt; events to add arbitrary elements
        ///    behind or above the regular chart elements..
        /// </summary>
        internal static string AnnotationsZonesRedux_Text1 {
            get {
                return ResourceManager.GetString("AnnotationsZonesRedux_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example,the chart below has &apos;buy&apos; and &apos;sell&apos;
        ///    zones created in the chart&apos;s &lt;b&gt;rendering&lt;/b&gt;
        ///    event handler:.
        /// </summary>
        internal static string AnnotationsZonesRedux_Text2 {
            get {
                return ResourceManager.GetString("AnnotationsZonesRedux_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Alarm Zones.
        /// </summary>
        internal static string AnnotationsZonesRedux_Title {
            get {
                return ResourceManager.GetString("AnnotationsZonesRedux_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can use annotations to create chart &apos;zones&apos;. For
        ///    example, the chart below has a &apos;buy&apos; and &apos;sell&apos; zones
        ///    represented by green and red Rectangle annotations:.
        /// </summary>
        internal static string AnnotationsZones_Text1 {
            get {
                return ResourceManager.GetString("AnnotationsZones_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Annotation Zones.
        /// </summary>
        internal static string AnnotationsZones_Title {
            get {
                return ResourceManager.GetString("AnnotationsZones_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Annotations are extra elements displayed over the chart to
        ///    highlight notable points or areas on the chart..
        /// </summary>
        internal static string Annotations_Text1 {
            get {
                return ResourceManager.GetString("Annotations_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To add annotations to a FlexChart, create an &lt;b&gt;annotationLayer&lt;/b&gt;
        ///    attached to the chart and populate it with annotation objects..
        /// </summary>
        internal static string Annotations_Text2 {
            get {
                return ResourceManager.GetString("Annotations_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to There are several types of annotation objects, including
        ///    Rectangle, Square, Circle, Ellipse, Line, Polygon, Image, and
        ///    Text. They may be attached to data points or to arbitrary
        ///    points in data or page coordinates..
        /// </summary>
        internal static string Annotations_Text3 {
            get {
                return ResourceManager.GetString("Annotations_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The chart below has an Ellipse annotation attached to data
        ///    point 15 and a Line annotation attached to the month of
        ///    February:.
        /// </summary>
        internal static string Annotations_Text4 {
            get {
                return ResourceManager.GetString("Annotations_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Annotations.
        /// </summary>
        internal static string Annotations_Title {
            get {
                return ResourceManager.GetString("Annotations_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use the axis &lt;b&gt;logBase&lt;/b&gt; property to spread clustered data
        ///    and improve the clarity of your charts without sacrificing
        ///    accuracy..
        /// </summary>
        internal static string AxesChartScaling_Text1 {
            get {
                return ResourceManager.GetString("AxesChartScaling_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use the axis &lt;b&gt;format&lt;/b&gt; property to automatically scale the
        ///    labels and show thousands or millions instead of very large
        ///    raw values..
        /// </summary>
        internal static string AxesChartScaling_Text2 {
            get {
                return ResourceManager.GetString("AxesChartScaling_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The bubble chart below shows the population (x), GDP (y),
        ///    and per-capita income (bubble size) for about 200 countries.
        ///    Notice how the use of log-axes spreads out the data and
        ///    makes the chart easy to read..
        /// </summary>
        internal static string AxesChartScaling_Text3 {
            get {
                return ResourceManager.GetString("AxesChartScaling_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Log Scale.
        /// </summary>
        internal static string AxesChartScaling_Text4 {
            get {
                return ResourceManager.GetString("AxesChartScaling_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Chart Scaling.
        /// </summary>
        internal static string AxesChartScaling_Title {
            get {
                return ResourceManager.GetString("AxesChartScaling_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The Axis class has an &lt;b&gt;itemFormatter&lt;/b&gt; property that allows
        ///    you to customize the content and appearance of specific labels
        ///    along the axes..
        /// </summary>
        internal static string AxesCustomLabels_Text1 {
            get {
                return ResourceManager.GetString("AxesCustomLabels_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If specified, the &lt;b&gt;itemFormatter&lt;/b&gt; function takes two parameters:.
        /// </summary>
        internal static string AxesCustomLabels_Text2 {
            get {
                return ResourceManager.GetString("AxesCustomLabels_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;engine&lt;/b&gt;: The IRenderEngine object used for rendering the labels..
        /// </summary>
        internal static string AxesCustomLabels_Text3 {
            get {
                return ResourceManager.GetString("AxesCustomLabels_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;label&lt;/b&gt;: An object that represents the label and has these properties:.
        /// </summary>
        internal static string AxesCustomLabels_Text4 {
            get {
                return ResourceManager.GetString("AxesCustomLabels_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;value&lt;/b&gt;: The value that the label represents..
        /// </summary>
        internal static string AxesCustomLabels_Text5 {
            get {
                return ResourceManager.GetString("AxesCustomLabels_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;text&lt;/b&gt;: The text content of the label
        ///                (usually the formatted value)..
        /// </summary>
        internal static string AxesCustomLabels_Text6 {
            get {
                return ResourceManager.GetString("AxesCustomLabels_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;pos&lt;/b&gt;: The position where the label will be rendered,
        ///                in control coordinates..
        /// </summary>
        internal static string AxesCustomLabels_Text7 {
            get {
                return ResourceManager.GetString("AxesCustomLabels_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;cls&lt;/b&gt;: A CSS class to be applied to the label element..
        /// </summary>
        internal static string AxesCustomLabels_Text8 {
            get {
                return ResourceManager.GetString("AxesCustomLabels_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Axis Labels.
        /// </summary>
        internal static string AxesCustomLabels_Title {
            get {
                return ResourceManager.GetString("AxesCustomLabels_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Most charts have two axes, X and Y. This works well as long
        ///    as all the data on the chart has the same nature and can
        ///    share the same scale..
        /// </summary>
        internal static string AxesExtraAxes_Text1 {
            get {
                return ResourceManager.GetString("AxesExtraAxes_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to But some charts contain series that show different types of
        ///    data, with different units and scales. The chart below has
        ///    two series that represent amounts (sales and expenses) and
        ///    one that represents quantities (downloads)..
        /// </summary>
        internal static string AxesExtraAxes_Text2 {
            get {
                return ResourceManager.GetString("AxesExtraAxes_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Plotting all the series against a single Y axis squeezes
        ///    the first two series against the bottom of the chart..
        /// </summary>
        internal static string AxesExtraAxes_Text3 {
            get {
                return ResourceManager.GetString("AxesExtraAxes_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The easiest way to solve this problem and still using a
        ///    single chart is to create a secondary Y axis and assign
        ///    it to the &lt;b&gt;axisY&lt;/b&gt; property of the &quot;Downloads&quot; series:.
        /// </summary>
        internal static string AxesExtraAxes_Text4 {
            get {
                return ResourceManager.GetString("AxesExtraAxes_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Secondary Y Axis.
        /// </summary>
        internal static string AxesExtraAxes_Text5 {
            get {
                return ResourceManager.GetString("AxesExtraAxes_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Extra Axes.
        /// </summary>
        internal static string AxesExtraAxes_Title {
            get {
                return ResourceManager.GetString("AxesExtraAxes_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, the FlexChart uses horizontal lines to show the
        ///    x-axis and major gridlines along the y-axis. This makes
        ///    charts clean and easy-to-read..
        /// </summary>
        internal static string AxesGridlinesTickmarks_Text1 {
            get {
                return ResourceManager.GetString("AxesGridlinesTickmarks_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can change this by modifying the &lt;b&gt;axisX&lt;/b&gt; and
        ///    &lt;b&gt;axisY&lt;/b&gt; properties. This example shows how you
        ///    create and control major and minor gridlines along
        ///    both axes, and how to customize them using CSS..
        /// </summary>
        internal static string AxesGridlinesTickmarks_Text2 {
            get {
                return ResourceManager.GetString("AxesGridlinesTickmarks_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Gridlines.
        /// </summary>
        internal static string AxesGridlinesTickmarks_Text3 {
            get {
                return ResourceManager.GetString("AxesGridlinesTickmarks_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom CSS.
        /// </summary>
        internal static string AxesGridlinesTickmarks_Text4 {
            get {
                return ResourceManager.GetString("AxesGridlinesTickmarks_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Units.
        /// </summary>
        internal static string AxesGridlinesTickmarks_Text5 {
            get {
                return ResourceManager.GetString("AxesGridlinesTickmarks_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to X Major.
        /// </summary>
        internal static string AxesGridlinesTickmarks_Text6 {
            get {
                return ResourceManager.GetString("AxesGridlinesTickmarks_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to X Minor.
        /// </summary>
        internal static string AxesGridlinesTickmarks_Text7 {
            get {
                return ResourceManager.GetString("AxesGridlinesTickmarks_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Y Major.
        /// </summary>
        internal static string AxesGridlinesTickmarks_Text8 {
            get {
                return ResourceManager.GetString("AxesGridlinesTickmarks_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Y Minor.
        /// </summary>
        internal static string AxesGridlinesTickmarks_Text9 {
            get {
                return ResourceManager.GetString("AxesGridlinesTickmarks_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Gridlines and Tickmarks.
        /// </summary>
        internal static string AxesGridlinesTickmarks_Title {
            get {
                return ResourceManager.GetString("AxesGridlinesTickmarks_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use the &lt;b&gt;axisX&lt;/b&gt; and &lt;b&gt;axisY&lt;/b&gt; properties to control
        ///    the labels shown along the axes..
        /// </summary>
        internal static string AxesLabelsFormats_Text1 {
            get {
                return ResourceManager.GetString("AxesLabelsFormats_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In this sample, we set the format of the Y axis labels to
        ///    &apos;n0,&apos;, which scales the values to show thousands instead
        ///    of the raw values. This is done by C1 MVC&apos;s Globalize class,
        ///    which takes the current culture into account..
        /// </summary>
        internal static string AxesLabelsFormats_Text2 {
            get {
                return ResourceManager.GetString("AxesLabelsFormats_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Notice how the labels along the X axis are automatically
        ///    rotated to avoid collisions. If you want to prevent that,
        ///    set the axis &lt;b&gt;labelAngle&lt;/b&gt; to a specific angle..
        /// </summary>
        internal static string AxesLabelsFormats_Text3 {
            get {
                return ResourceManager.GetString("AxesLabelsFormats_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Label Angle.
        /// </summary>
        internal static string AxesLabelsFormats_Text4 {
            get {
                return ResourceManager.GetString("AxesLabelsFormats_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to auto.
        /// </summary>
        internal static string AxesLabelsFormats_Text5 {
            get {
                return ResourceManager.GetString("AxesLabelsFormats_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Labels and Formats.
        /// </summary>
        internal static string AxesLabelsFormats_Title {
            get {
                return ResourceManager.GetString("AxesLabelsFormats_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default the FlexChart places the X axis at the bottom of
        ///    the plot area and the Y axis on the left. This keeps the
        ///    axes outside the plot area and away from the data..
        /// </summary>
        internal static string AxesOriginPosition_Text1 {
            get {
                return ResourceManager.GetString("AxesOriginPosition_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Position:.
        /// </summary>
        internal static string AxesOriginPosition_Text10 {
            get {
                return ResourceManager.GetString("AxesOriginPosition_Text10", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can change this default behavior using two properties:.
        /// </summary>
        internal static string AxesOriginPosition_Text2 {
            get {
                return ResourceManager.GetString("AxesOriginPosition_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;position&lt;/b&gt;: Specifies the position of the axis as
        ///        None, Left, Top, Right, Bottom, or Auto..
        /// </summary>
        internal static string AxesOriginPosition_Text3 {
            get {
                return ResourceManager.GetString("AxesOriginPosition_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;origin&lt;/b&gt;: Specifies the value where the axis
        ///        crosses its perpendicular axis. If speficied,
        ///        &lt;b&gt;origin&lt;/b&gt; takes precendence over
        ///        &lt;b&gt;position&lt;/b&gt;..
        /// </summary>
        internal static string AxesOriginPosition_Text4 {
            get {
                return ResourceManager.GetString("AxesOriginPosition_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to X Axis.
        /// </summary>
        internal static string AxesOriginPosition_Text5 {
            get {
                return ResourceManager.GetString("AxesOriginPosition_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Origin at Zero:.
        /// </summary>
        internal static string AxesOriginPosition_Text6 {
            get {
                return ResourceManager.GetString("AxesOriginPosition_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Position:.
        /// </summary>
        internal static string AxesOriginPosition_Text7 {
            get {
                return ResourceManager.GetString("AxesOriginPosition_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Y Axis.
        /// </summary>
        internal static string AxesOriginPosition_Text8 {
            get {
                return ResourceManager.GetString("AxesOriginPosition_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Origin at Zero:.
        /// </summary>
        internal static string AxesOriginPosition_Text9 {
            get {
                return ResourceManager.GetString("AxesOriginPosition_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Axis Origin and Position.
        /// </summary>
        internal static string AxesOriginPosition_Title {
            get {
                return ResourceManager.GetString("AxesOriginPosition_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexChart calculates axis ranges automatically, based on
        ///    the data being shown. Because of this, in most cases you
        ///    don&apos;t have to worry about setting the axis &lt;b&gt;min&lt;/b&gt;,
        ///    &lt;b&gt;max&lt;/b&gt;, &lt;b&gt;majorUnit&lt;/b&gt;, or &lt;b&gt;minorUnit&lt;/b&gt; properties..
        /// </summary>
        internal static string AxesRanges_Text1 {
            get {
                return ResourceManager.GetString("AxesRanges_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In a few cases, however, setting these values explicitly may
        ///    improve the chart..
        /// </summary>
        internal static string AxesRanges_Text2 {
            get {
                return ResourceManager.GetString("AxesRanges_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the chart below shows values that are relatively
        ///    close, so all bars have almost the same height. The chart shows
        ///    that sales are even across countries, but it does not show the
        ///    differences clearly..
        /// </summary>
        internal static string AxesRanges_Text3 {
            get {
                return ResourceManager.GetString("AxesRanges_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To emphasize the differences, click the &apos;Custom Range&apos; checkbox.
        ///    It will set the &lt;b&gt;min&lt;/b&gt; and &lt;b&gt;max&lt;/b&gt; properties of the
        ///    Y axis so it starts at 150k, close to the minimum value for
        ///    all countries but higher than zero. The chart will show the same
        ///    data, but the differences will appear much larger..
        /// </summary>
        internal static string AxesRanges_Text4 {
            get {
                return ResourceManager.GetString("AxesRanges_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Range.
        /// </summary>
        internal static string AxesRanges_Text5 {
            get {
                return ResourceManager.GetString("AxesRanges_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The Y axis does not start at zero, so the chart magnifies
        ///            differences in sales across countries. The largest difference
        ///            is only about 7%..
        /// </summary>
        internal static string AxesRanges_Text6 {
            get {
                return ResourceManager.GetString("AxesRanges_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Axis Ranges.
        /// </summary>
        internal static string AxesRanges_Title {
            get {
                return ResourceManager.GetString("AxesRanges_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example shows how you can implement a simple zooming
        ///    feature using the mouse events to modify the range on a
        ///    FlexChart axes..
        /// </summary>
        internal static string AxesZoom_Text1 {
            get {
                return ResourceManager.GetString("AxesZoom_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use the mouse to select a rectangular area on the plot
        ///    area. The chart will zoom in on the selected area.
        ///    Click the &quot;Reset Zoom&quot; button below the chart to return
        ///    to the original view:.
        /// </summary>
        internal static string AxesZoom_Text2 {
            get {
                return ResourceManager.GetString("AxesZoom_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexChart Zooming.
        /// </summary>
        internal static string AxesZoom_Title {
            get {
                return ResourceManager.GetString("AxesZoom_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Chart axes have two main purposes:.
        /// </summary>
        internal static string Axes_Text1 {
            get {
                return ResourceManager.GetString("Axes_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Alphabet Inc.
        /// </summary>
        internal static string Axes_Text10 {
            get {
                return ResourceManager.GetString("Axes_Text10", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;scaling&lt;/b&gt;: Axes set the range of values shown on the
        ///        chart. By default, this range is calculated automatically
        ///        by the chart. The ranges are used even if the axes are
        ///        hidden from view..
        /// </summary>
        internal static string Axes_Text2 {
            get {
                return ResourceManager.GetString("Axes_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;context&lt;/b&gt;: Axes display tickmarks and labels that
        ///        help identify the values being displayed (e.g. &quot;what
        ///        country and value does this bar represent?&quot;)..
        /// </summary>
        internal static string Axes_Text3 {
            get {
                return ResourceManager.GetString("Axes_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, the FlexChart uses horizontal lines to show the
        ///    x-axis and major gridlines along the y-axis. This makes
        ///    charts clean and easy-to-read..
        /// </summary>
        internal static string Axes_Text4 {
            get {
                return ResourceManager.GetString("Axes_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The chart below adds minor tickmarks and gridlines to
        ///    make it easier to compare the values on the chart..
        /// </summary>
        internal static string Axes_Text5 {
            get {
                return ResourceManager.GetString("Axes_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can remove the axes completely by setting their
        ///    &lt;b&gt;position&lt;/b&gt; property to &apos;None&apos;. The result is the
        ///    &apos;cleanest&apos; possible chart, with a high
        ///    &lt;a href=&quot;http://www.darkhorseanalytics.com/blog/data-looks-better-naked&quot; target=&quot;_blank&quot;&gt;data-to-ink ratio&lt;/a&gt;..
        /// </summary>
        internal static string Axes_Text6 {
            get {
                return ResourceManager.GetString("Axes_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In this example, the reduction is a little too radical,
        ///    but the chart is still usable (check the tooltips):.
        /// </summary>
        internal static string Axes_Text7 {
            get {
                return ResourceManager.GetString("Axes_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Show Axes.
        /// </summary>
        internal static string Axes_Text8 {
            get {
                return ResourceManager.GetString("Axes_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Alphabet Inc Trading Data.
        /// </summary>
        internal static string Axes_Text9 {
            get {
                return ResourceManager.GetString("Axes_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Axes.
        /// </summary>
        internal static string Axes_Title {
            get {
                return ResourceManager.GetString("Axes_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Bar charts are similar to rotated column charts..
        /// </summary>
        internal static string BarCharts_Text1 {
            get {
                return ResourceManager.GetString("BarCharts_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, items on the Y axis start from the bottom
        ///    of the chart, so the first items appear at the bottom
        ///    and the last at the top..
        /// </summary>
        internal static string BarCharts_Text2 {
            get {
                return ResourceManager.GetString("BarCharts_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to If you reverse the Y axis, items will start at the top
        ///    of the, which is often a more natural order:.
        /// </summary>
        internal static string BarCharts_Text3 {
            get {
                return ResourceManager.GetString("BarCharts_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Reverse Y axis:.
        /// </summary>
        internal static string BarCharts_Text4 {
            get {
                return ResourceManager.GetString("BarCharts_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Bar Charts.
        /// </summary>
        internal static string BarCharts_Title {
            get {
                return ResourceManager.GetString("BarCharts_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Unlike most other chart types, Bubble Charts display
        ///    three dimensions of data: X, Y, and size..
        /// </summary>
        internal static string BubbleCharts_Text1 {
            get {
                return ResourceManager.GetString("BubbleCharts_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To create bubble charts with the FlexChart control,
        ///    you must set the &lt;b&gt;binding&lt;/b&gt; property to a comma-delimited
        ///    list of property names. The first property will be bound to the
        ///    Y value, and the second to the bubble size..
        /// </summary>
        internal static string BubbleCharts_Text2 {
            get {
                return ResourceManager.GetString("BubbleCharts_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the chart below shows sales along the X axis,
        ///    expenses along the Y axis, and uses the number of downloads
        ///    to determine the bubble size:.
        /// </summary>
        internal static string BubbleCharts_Text3 {
            get {
                return ResourceManager.GetString("BubbleCharts_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Bubble Charts.
        /// </summary>
        internal static string BubbleCharts_Title {
            get {
                return ResourceManager.GetString("BubbleCharts_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Candlestick charts are used to describe price movements of a
        ///    security, derivative, or currency over time..
        /// </summary>
        internal static string CandlestickCharts_Text1 {
            get {
                return ResourceManager.GetString("CandlestickCharts_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To create candlestick charts with the FlexChart control,
        ///    set the &lt;b&gt;bindingX&lt;/b&gt; property to the name of the property
        ///    that contains the dates, and add a single series with
        ///    &lt;b&gt;binding&lt;/b&gt; set to a comma-delimited string containing
        ///    the names of the properties that represent the High, Low,
        ///    Open, and Close values..
        /// </summary>
        internal static string CandlestickCharts_Text2 {
            get {
                return ResourceManager.GetString("CandlestickCharts_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The size of the wick line is determined by the High and Low
        ///    values; the size of the bar is determined by the Open and Close
        ///    values.
        ///    The bar color indicates whether the Close value is higher or
        ///    lower than the Open value (empty/filled bar):.
        /// </summary>
        internal static string CandlestickCharts_Text3 {
            get {
                return ResourceManager.GetString("CandlestickCharts_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Candlestick Charts.
        /// </summary>
        internal static string CandlestickCharts_Title {
            get {
                return ResourceManager.GetString("CandlestickCharts_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexChart is composed of elements that can be customized
        ///    using its object model. The elements are:.
        /// </summary>
        internal static string ChartElements_Text1 {
            get {
                return ResourceManager.GetString("ChartElements_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;SeriesSymbol&lt;/b&gt;: A symbol in a chart series..
        /// </summary>
        internal static string ChartElements_Text10 {
            get {
                return ResourceManager.GetString("ChartElements_Text10", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;DataLabel&lt;/b&gt;: A label attached to a data point..
        /// </summary>
        internal static string ChartElements_Text11 {
            get {
                return ResourceManager.GetString("ChartElements_Text11", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can use the &lt;b&gt;hitTest&lt;/b&gt; method to determine what
        ///    chart area is under the mouse..
        /// </summary>
        internal static string ChartElements_Text12 {
            get {
                return ResourceManager.GetString("ChartElements_Text12", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Move the mouse over the chart below to see some information
        ///    about each element:.
        /// </summary>
        internal static string ChartElements_Text13 {
            get {
                return ResourceManager.GetString("ChartElements_Text13", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Header.
        /// </summary>
        internal static string ChartElements_Text14 {
            get {
                return ResourceManager.GetString("ChartElements_Text14", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Footer.
        /// </summary>
        internal static string ChartElements_Text15 {
            get {
                return ResourceManager.GetString("ChartElements_Text15", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;PlotArea&lt;/b&gt;: The area within the axes..
        /// </summary>
        internal static string ChartElements_Text2 {
            get {
                return ResourceManager.GetString("ChartElements_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;ChartArea&lt;/b&gt;: The area within the control but
        ///        outside the axes..
        /// </summary>
        internal static string ChartElements_Text3 {
            get {
                return ResourceManager.GetString("ChartElements_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Legend&lt;/b&gt;: The chart legend, usually on the
        ///        right of the plot area..
        /// </summary>
        internal static string ChartElements_Text4 {
            get {
                return ResourceManager.GetString("ChartElements_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Header&lt;/b&gt;: The chart header, above the plot area..
        /// </summary>
        internal static string ChartElements_Text5 {
            get {
                return ResourceManager.GetString("ChartElements_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Footer&lt;/b&gt;: The chart footer, below the plot area..
        /// </summary>
        internal static string ChartElements_Text6 {
            get {
                return ResourceManager.GetString("ChartElements_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;AxisX&lt;/b&gt;: The X-axis, usually horizontal..
        /// </summary>
        internal static string ChartElements_Text7 {
            get {
                return ResourceManager.GetString("ChartElements_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;AxisY&lt;/b&gt;: The Y-axis, usually vertical..
        /// </summary>
        internal static string ChartElements_Text8 {
            get {
                return ResourceManager.GetString("ChartElements_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Series&lt;/b&gt;: A chart series..
        /// </summary>
        internal static string ChartElements_Text9 {
            get {
                return ResourceManager.GetString("ChartElements_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Chart Elements and Hit-Testing.
        /// </summary>
        internal static string ChartElements_Title {
            get {
                return ResourceManager.GetString("ChartElements_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexChart has three properties that determine the
        ///    chart type:.
        /// </summary>
        internal static string ChartTypes_Text1 {
            get {
                return ResourceManager.GetString("ChartTypes_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;chartType&lt;/b&gt;:
        ///        Determines the default chart type to be used for all series objects.
        ///        Individual series can override this default..
        /// </summary>
        internal static string ChartTypes_Text2 {
            get {
                return ResourceManager.GetString("ChartTypes_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;stacking&lt;/b&gt;:
        ///        Determines whether series objects are plotted independently, stacked,
        ///        or stacked so their sum is 100%..
        /// </summary>
        internal static string ChartTypes_Text3 {
            get {
                return ResourceManager.GetString("ChartTypes_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;rotated&lt;/b&gt;:
        ///        Determines whether axes should be flipped so the X axis becomes
        ///        vertical and the Y axis horizontal..
        /// </summary>
        internal static string ChartTypes_Text4 {
            get {
                return ResourceManager.GetString("ChartTypes_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example shows the effect of these properties:.
        /// </summary>
        internal static string ChartTypes_Text5 {
            get {
                return ResourceManager.GetString("ChartTypes_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Chart Type:.
        /// </summary>
        internal static string ChartTypes_Text6 {
            get {
                return ResourceManager.GetString("ChartTypes_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Stacking:.
        /// </summary>
        internal static string ChartTypes_Text7 {
            get {
                return ResourceManager.GetString("ChartTypes_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Rotated:.
        /// </summary>
        internal static string ChartTypes_Text8 {
            get {
                return ResourceManager.GetString("ChartTypes_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexChart Chart Types.
        /// </summary>
        internal static string ChartTypes_Title {
            get {
                return ResourceManager.GetString("ChartTypes_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;dataLabels&lt;/b&gt; property allows you to show labels
        ///    next to each data point on the chart..
        /// </summary>
        internal static string DataLabels_Text1 {
            get {
                return ResourceManager.GetString("DataLabels_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To use it, set the following properties on the &lt;b&gt;dataLabels&lt;/b&gt;
        ///    object:.
        /// </summary>
        internal static string DataLabels_Text2 {
            get {
                return ResourceManager.GetString("DataLabels_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;content&lt;/b&gt;: String template with property holders,
        ///        similar to the string used to define tooltip content.
        ///        For example, &lt;code&gt;&apos;{value:n0}&apos;&lt;/code&gt;..
        /// </summary>
        internal static string DataLabels_Text3 {
            get {
                return ResourceManager.GetString("DataLabels_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;position&lt;/b&gt;: A
        ///        &lt;a href=&quot;http://help.grapecity.com/componentone/NetHelp/c1mvchelpers/webframe.html#wijmo.chart.LabelPosition.Enum.html&quot; target=&quot;_blank&quot;&gt;LabelPosition&lt;/a&gt;
        ///        value that determines where to place the labels relative
        ///        to the data points..
        /// </summary>
        internal static string DataLabels_Text4 {
            get {
                return ResourceManager.GetString("DataLabels_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;connectingLine&lt;/b&gt;: Whether to draw a line connecting
        ///        the labels and corresponding data points..
        /// </summary>
        internal static string DataLabels_Text5 {
            get {
                return ResourceManager.GetString("DataLabels_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;border&lt;/b&gt;: Whether to draw a border around the label..
        /// </summary>
        internal static string DataLabels_Text6 {
            get {
                return ResourceManager.GetString("DataLabels_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Label Position:.
        /// </summary>
        internal static string DataLabels_Text7 {
            get {
                return ResourceManager.GetString("DataLabels_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lines/Borders:.
        /// </summary>
        internal static string DataLabels_Text8 {
            get {
                return ResourceManager.GetString("DataLabels_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Downloads Only:.
        /// </summary>
        internal static string DataLabels_Text9 {
            get {
                return ResourceManager.GetString("DataLabels_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Data Labels.
        /// </summary>
        internal static string DataLabels_Title {
            get {
                return ResourceManager.GetString("DataLabels_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexChart provides events you can use to
        ///    customize the appearance and behavior of the
        ///    chart..
        /// </summary>
        internal static string Events_Text1 {
            get {
                return ResourceManager.GetString("Events_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to These events can be divided into categories:.
        /// </summary>
        internal static string Events_Text2 {
            get {
                return ResourceManager.GetString("Events_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Mouse&lt;/b&gt;:
        ///        The FlexChart relies on HTML events for mouse handling,
        ///        and provides a &lt;b&gt;hitTest&lt;/b&gt; method that can be used
        ///        to determine which part of the chart the event refers to.
        ///        Mouse events can be used to add functionality such as
        ///        zooming or drill-down..
        /// </summary>
        internal static string Events_Text3 {
            get {
                return ResourceManager.GetString("Events_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Selection&lt;/b&gt;:
        ///        When the chart&apos;s &lt;b&gt;selectionMode&lt;/b&gt; property is set
        ///        to &lt;b&gt;Series&lt;/b&gt; or &lt;b&gt;Point&lt;/b&gt;, the chart will allow users
        ///        select elements by clicking on them. The chart&apos;s &lt;b&gt;selection&lt;/b&gt;
        ///        property will be updated and the &lt;b&gt;selectionChanged&lt;/b&gt; event
        ///        will be fired. This event is typically used in master/detail
        ///        scenarios..
        /// </summary>
        internal static string Events_Text4 {
            get {
                return ResourceManager.GetString("Events_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Rendering&lt;/b&gt;:
        ///        The FlexChart has &lt;b&gt;rendering&lt;/b&gt; and &lt;b&gt;rendered&lt;/b&gt; events
        ///        that allow you do add custom elements to the chart, either in
        ///        the background or as overlays..
        /// </summary>
        internal static string Events_Text5 {
            get {
                return ResourceManager.GetString("Events_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Chart Events.
        /// </summary>
        internal static string Events_Title {
            get {
                return ResourceManager.GetString("Events_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Saving charts as images for inclusion in other documents
        ///    is a common requirement. Some browsers support this as
        ///    a context menu option, but not all..
        /// </summary>
        internal static string Export_Text1 {
            get {
                return ResourceManager.GetString("Export_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexChart&apos;s &lt;b&gt;saveImageToFile&lt;/b&gt; method makes this
        ///    really easy:.
        /// </summary>
        internal static string Export_Text2 {
            get {
                return ResourceManager.GetString("Export_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Save as:.
        /// </summary>
        internal static string Export_Text3 {
            get {
                return ResourceManager.GetString("Export_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Phase II Test Result.
        /// </summary>
        internal static string Export_Text4 {
            get {
                return ResourceManager.GetString("Export_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Experiment 1.
        /// </summary>
        internal static string Export_Text5 {
            get {
                return ResourceManager.GetString("Export_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Experiment 2.
        /// </summary>
        internal static string Export_Text6 {
            get {
                return ResourceManager.GetString("Export_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Experiment 3.
        /// </summary>
        internal static string Export_Text7 {
            get {
                return ResourceManager.GetString("Export_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexChart Export.
        /// </summary>
        internal static string Export_Title {
            get {
                return ResourceManager.GetString("Export_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In addition to the regular chart elements described
        ///    earlier (axes, plotArea, legend, header, footer etc),
        ///    you can add extra elements to the chart in several
        ///    ways:.
        /// </summary>
        internal static string ExtraElements_Text1 {
            get {
                return ResourceManager.GetString("ExtraElements_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;events&lt;/b&gt;:
        ///        Use the &lt;b&gt;rendering&lt;/b&gt; and &lt;b&gt;rendered&lt;/b&gt; events
        ///        to add arbitrary elements behind or in front of the
        ///        regular chart elements..
        /// </summary>
        internal static string ExtraElements_Text2 {
            get {
                return ResourceManager.GetString("ExtraElements_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;annotations&lt;/b&gt;:
        ///        Use the &lt;b&gt;wijmo.chart.annotation&lt;/b&gt; extension to
        ///        add annotations (shapes or text) to data points
        ///        or to chart areas..
        /// </summary>
        internal static string ExtraElements_Text3 {
            get {
                return ResourceManager.GetString("ExtraElements_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;analytics&lt;/b&gt;:
        ///        Use the &lt;b&gt;wijmo.chart.analytics&lt;/b&gt; extension to
        ///        add trendlines and moving averages to the chart..
        /// </summary>
        internal static string ExtraElements_Text4 {
            get {
                return ResourceManager.GetString("ExtraElements_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;plotAreas&lt;/b&gt;:
        ///        Use the &lt;b&gt;plotAreas&lt;/b&gt; property to add multiple
        ///        plot areas to the chart, using the same header,
        ///        footer, legend, and sharing axes..
        /// </summary>
        internal static string ExtraElements_Text5 {
            get {
                return ResourceManager.GetString("ExtraElements_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example,the chart below has &apos;buy&apos; and &apos;sell&apos;
        ///    zones created in the chart&apos;s &lt;b&gt;rendering&lt;/b&gt;
        ///    event handler:.
        /// </summary>
        internal static string ExtraElements_Text6 {
            get {
                return ResourceManager.GetString("ExtraElements_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Extra Chart Elements.
        /// </summary>
        internal static string ExtraElements_Title {
            get {
                return ResourceManager.GetString("ExtraElements_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example shows how you can add custom filtering and zooming
        ///    to a FlexChart..
        /// </summary>
        internal static string Filtering_Text1 {
            get {
                return ResourceManager.GetString("Filtering_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The filter is implemented using the CollectionView&apos;s &lt;b&gt;filter&lt;/b&gt;
        ///    property. Another option in this case would be to set the
        ///    range of the chart&apos;s X axis, but that would interfere with
        ///    the chart zooming..
        /// </summary>
        internal static string Filtering_Text2 {
            get {
                return ResourceManager.GetString("Filtering_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The zoom is implemented using the mouse wheel or regular
        ///    buttons. Both approaches work by changing the min/max properties
        ///    of the chart&apos;s axes..
        /// </summary>
        internal static string Filtering_Text3 {
            get {
                return ResourceManager.GetString("Filtering_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The wheel zooming is done around the mouse pointer; the buttons
        ///    zoom around the chart center..
        /// </summary>
        internal static string Filtering_Text4 {
            get {
                return ResourceManager.GetString("Filtering_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Filter: &lt;/b&gt;.
        /// </summary>
        internal static string Filtering_Text5 {
            get {
                return ResourceManager.GetString("Filtering_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Select Month.
        /// </summary>
        internal static string Filtering_Text6 {
            get {
                return ResourceManager.GetString("Filtering_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Zoom: &lt;/b&gt;.
        /// </summary>
        internal static string Filtering_Text7 {
            get {
                return ResourceManager.GetString("Filtering_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can also zoom with ctrl+mouse wheel..
        /// </summary>
        internal static string Filtering_Text8 {
            get {
                return ResourceManager.GetString("Filtering_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Filter and Wheel Zoom.
        /// </summary>
        internal static string Filtering_Title {
            get {
                return ResourceManager.GetString("Filtering_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Funnel charts show values along multiple stages in a process..
        /// </summary>
        internal static string FunnelCharts_Text1 {
            get {
                return ResourceManager.GetString("FunnelCharts_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, you could use a funnel chart to show the number of
        ///    sales prospects at each stage in a sales pipeline. Typically,
        ///    the values decrease gradually, making the bars resemble a
        ///    funnel..
        /// </summary>
        internal static string FunnelCharts_Text2 {
            get {
                return ResourceManager.GetString("FunnelCharts_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To create funnel charts with the FlexChart control, set the
        ///    &lt;b&gt;bindingX&lt;/b&gt; property to the name of the property that
        ///    contains the step along the pipeline, and add a single series
        ///    with &lt;b&gt;binding&lt;/b&gt; set to the amount of transactions at the
        ///    given step..
        /// </summary>
        internal static string FunnelCharts_Text3 {
            get {
                return ResourceManager.GetString("FunnelCharts_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can adjust the funnel&apos;s height, width, and style using
        ///    the &lt;b&gt;options&lt;/b&gt; property:.
        /// </summary>
        internal static string FunnelCharts_Text4 {
            get {
                return ResourceManager.GetString("FunnelCharts_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Neck Width:.
        /// </summary>
        internal static string FunnelCharts_Text5 {
            get {
                return ResourceManager.GetString("FunnelCharts_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Neck Height:.
        /// </summary>
        internal static string FunnelCharts_Text6 {
            get {
                return ResourceManager.GetString("FunnelCharts_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Neck Style:.
        /// </summary>
        internal static string FunnelCharts_Text7 {
            get {
                return ResourceManager.GetString("FunnelCharts_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Funnel Charts.
        /// </summary>
        internal static string FunnelCharts_Title {
            get {
                return ResourceManager.GetString("FunnelCharts_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexChart allows you to specify gradients for series style
        ///    properties. The gradients are specified as strings with
        ///    the following syntax:.
        /// </summary>
        internal static string Gradients_Text1 {
            get {
                return ResourceManager.GetString("Gradients_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Where:.
        /// </summary>
        internal static string Gradients_Text2 {
            get {
                return ResourceManager.GetString("Gradients_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;{type}&lt;/b&gt; is either &apos;l&apos; or &apos;r&apos;, for linear or radial gradients,.
        /// </summary>
        internal static string Gradients_Text3 {
            get {
                return ResourceManager.GetString("Gradients_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;{coords}&lt;/b&gt; is a set of three or four numbers that specify the
        ///        gradient direction (x1/y1/x2/y2 for linear, cx.cy.r for radial), and.
        /// </summary>
        internal static string Gradients_Text4 {
            get {
                return ResourceManager.GetString("Gradients_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;{color:offset:opacity}&lt;/b&gt; is an HTML color string optionally
        ///        followed by offset and opacity values. You may add add additional colors
        ///        using a hyphen as a separator..
        /// </summary>
        internal static string Gradients_Text5 {
            get {
                return ResourceManager.GetString("Gradients_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The chart below uses gradients to fill the area under
        ///    the series:.
        /// </summary>
        internal static string Gradients_Text6 {
            get {
                return ResourceManager.GetString("Gradients_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Series Gradients.
        /// </summary>
        internal static string Gradients_Title {
            get {
                return ResourceManager.GetString("Gradients_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example shows how you can leverage the grouping
        ///    features in the &lt;b&gt;CollectionView&lt;/b&gt; class to create
        ///    drill-down charts..
        /// </summary>
        internal static string GroupingDrillDown_Text1 {
            get {
                return ResourceManager.GetString("GroupingDrillDown_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Click on the bars to drill-down into any group. The
        ///    chart will be updated to show the new data, and the
        ///    chart&apos;s header will show breadcrumbs so you can
        ///    navigate back up the group hierarchy:.
        /// </summary>
        internal static string GroupingDrillDown_Text2 {
            get {
                return ResourceManager.GetString("GroupingDrillDown_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sales.
        /// </summary>
        internal static string GroupingDrillDown_Text3 {
            get {
                return ResourceManager.GetString("GroupingDrillDown_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Grouping and Drill-Down.
        /// </summary>
        internal static string GroupingDrillDown_Title {
            get {
                return ResourceManager.GetString("GroupingDrillDown_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to HighLowOpenClose charts are used to describe price movements of a
        ///    security, derivative, or currency over time. They are similar
        ///    to candlestick charts, except opening values are displayed using
        ///    lines to the left, and closing values are displayed using lines
        ///    lines to the right..
        /// </summary>
        internal static string HighLowOpenCloseCharts_Text1 {
            get {
                return ResourceManager.GetString("HighLowOpenCloseCharts_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to To create HighLowOpenClose charts with the FlexChart control,
        ///    set the &lt;b&gt;bindingX&lt;/b&gt; property to the name of the property
        ///    that contains the dates, and add a single series with
        ///    &lt;b&gt;binding&lt;/b&gt; set to a comma-delimited string containing
        ///    the names of the properties that represent the High, Low,
        ///    Open, and Close values..
        /// </summary>
        internal static string HighLowOpenCloseCharts_Text2 {
            get {
                return ResourceManager.GetString("HighLowOpenCloseCharts_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The size of the vertical line is determined by the High and
        ///    Low values; short line segments to the left and right
        ///    represent the Open and Close values:.
        /// </summary>
        internal static string HighLowOpenCloseCharts_Text3 {
            get {
                return ResourceManager.GetString("HighLowOpenCloseCharts_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to HighLowOpenClose Charts.
        /// </summary>
        internal static string HighLowOpenCloseCharts_Title {
            get {
                return ResourceManager.GetString("HighLowOpenCloseCharts_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexChart allows you to visualize tabular data as business
        ///    charts. It provides a variety of options about how to present
        ///    and interact with the data, including selection, zooming,
        ///    drill-down, formatting, etc..
        /// </summary>
        internal static string Index_Text1 {
            get {
                return ResourceManager.GetString("Index_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Bind the chart by setting its &lt;b&gt;itemsSource&lt;/b&gt; property to an
        ///    array containing regular JavaScript objects,
        ///    and populate the chart&apos;s &lt;b&gt;series&lt;/b&gt; collection with objects that define which
        ///    properties of the data items should be charted and how:.
        /// </summary>
        internal static string Index_Text2 {
            get {
                return ResourceManager.GetString("Index_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This is the data being charted. Because the grid and the chart
        ///    are bound to the same &lt;b&gt;CollectionView&lt;/b&gt;, the chart will be
        ///    updated if you edit or sort the data:.
        /// </summary>
        internal static string Index_Text3 {
            get {
                return ResourceManager.GetString("Index_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexChart.
        /// </summary>
        internal static string Index_Title {
            get {
                return ResourceManager.GetString("Index_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexChart receives notifications when the data
        ///    changes and updates the chart automatically..
        /// </summary>
        internal static string InteractiveAnimations_Text1 {
            get {
                return ResourceManager.GetString("InteractiveAnimations_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The chart below is bound to an &lt;b&gt;itemsSource&lt;/b&gt; that
        ///    receives new items at a given interval. When new items
        ///    are added to the data source, old items are removed
        ///    to keep the total item count constant. The result is
        ///    a dynamic scrolling chart..
        /// </summary>
        internal static string InteractiveAnimations_Text2 {
            get {
                return ResourceManager.GetString("InteractiveAnimations_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Update Interval:.
        /// </summary>
        internal static string InteractiveAnimations_Text3 {
            get {
                return ResourceManager.GetString("InteractiveAnimations_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to ms.
        /// </summary>
        internal static string InteractiveAnimations_Text4 {
            get {
                return ResourceManager.GetString("InteractiveAnimations_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Dynamic Chart.
        /// </summary>
        internal static string InteractiveAnimations_Title {
            get {
                return ResourceManager.GetString("InteractiveAnimations_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexChart uses the CollectionView class as its
        ///    data source, so it is inherently interactive. Any
        ///    changes made to the data will be automatically reflected
        ///    on the chart..
        /// </summary>
        internal static string InteractiveCharts_Text1 {
            get {
                return ResourceManager.GetString("InteractiveCharts_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the chart and the grid below are bound
        ///    to the same CollectionViewService, so if you edit the
        ///    data on the grid, or sort the grid&apos;s columns,
        ///    the chart will show the changes automatically:.
        /// </summary>
        internal static string InteractiveCharts_Text2 {
            get {
                return ResourceManager.GetString("InteractiveCharts_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In addition to this automatic type of interaction,
        ///    you can use events to add custom interactions to
        ///    the chart, including zooming, selection, grouping,
        ///    drill-downs, and animations..
        /// </summary>
        internal static string InteractiveCharts_Text3 {
            get {
                return ResourceManager.GetString("InteractiveCharts_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Interactive Charts.
        /// </summary>
        internal static string InteractiveCharts_Title {
            get {
                return ResourceManager.GetString("InteractiveCharts_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexChart&apos;s &lt;b&gt;itemFormatter&lt;/b&gt; property allows you
        ///    to specify a callback invoked when chart items are rendered.
        ///    The callback may customize the item or add new ones using the
        ///    chart engine&apos;s properties and methods..
        /// </summary>
        internal static string ItemFormatter_Text1 {
            get {
                return ResourceManager.GetString("ItemFormatter_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In this example, the &lt;b&gt;itemFormatter&lt;/b&gt; is used to
        ///    add line segments over periods when the data is
        ///    increasing:.
        /// </summary>
        internal static string ItemFormatter_Text2 {
            get {
                return ResourceManager.GetString("ItemFormatter_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexChart ItemFormatter.
        /// </summary>
        internal static string ItemFormatter_Title {
            get {
                return ResourceManager.GetString("ItemFormatter_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use the &lt;b&gt;legend.position&lt;/b&gt; property to determine the
        ///    position of the legend. The &quot;Auto&quot; position places the
        ///    legend to the right or below the chart depending on the
        ///    control size:.
        /// </summary>
        internal static string LegendPosition_Text1 {
            get {
                return ResourceManager.GetString("LegendPosition_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Legend Position:.
        /// </summary>
        internal static string LegendPosition_Text2 {
            get {
                return ResourceManager.GetString("LegendPosition_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Legend Position.
        /// </summary>
        internal static string LegendPosition_Title {
            get {
                return ResourceManager.GetString("LegendPosition_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use the &lt;b&gt;header&lt;/b&gt;, &lt;b&gt;footer&lt;/b&gt;, and axis &lt;b&gt;title&lt;/b&gt;
        ///    properties to add titles to your charts..
        /// </summary>
        internal static string LegendsTitles_Text1 {
            get {
                return ResourceManager.GetString("LegendsTitles_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The series elements can also have titles, defined by the
        ///    series &lt;b&gt;name&lt;/b&gt; property and displayed in the chart&apos;s
        ///    legend:.
        /// </summary>
        internal static string LegendsTitles_Text2 {
            get {
                return ResourceManager.GetString("LegendsTitles_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Header:.
        /// </summary>
        internal static string LegendsTitles_Text3 {
            get {
                return ResourceManager.GetString("LegendsTitles_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Footer:.
        /// </summary>
        internal static string LegendsTitles_Text4 {
            get {
                return ResourceManager.GetString("LegendsTitles_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to X-Axis Title:.
        /// </summary>
        internal static string LegendsTitles_Text5 {
            get {
                return ResourceManager.GetString("LegendsTitles_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Y-Axis Title:.
        /// </summary>
        internal static string LegendsTitles_Text6 {
            get {
                return ResourceManager.GetString("LegendsTitles_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Legends and Titles.
        /// </summary>
        internal static string LegendsTitles_Title {
            get {
                return ResourceManager.GetString("LegendsTitles_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use CSS to customize the style of the chart legend..
        /// </summary>
        internal static string LegendStyles_Text1 {
            get {
                return ResourceManager.GetString("LegendStyles_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Legend:.
        /// </summary>
        internal static string LegendStyles_Text2 {
            get {
                return ResourceManager.GetString("LegendStyles_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to My Great Chart.
        /// </summary>
        internal static string LegendStyles_Text3 {
            get {
                return ResourceManager.GetString("LegendStyles_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to powered by ComponentOne&apos;s MVC FlexChart.
        /// </summary>
        internal static string LegendStyles_Text4 {
            get {
                return ResourceManager.GetString("LegendStyles_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Country.
        /// </summary>
        internal static string LegendStyles_Text5 {
            get {
                return ResourceManager.GetString("LegendStyles_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Values/Units.
        /// </summary>
        internal static string LegendStyles_Text6 {
            get {
                return ResourceManager.GetString("LegendStyles_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Legend Styles.
        /// </summary>
        internal static string LegendStyles_Title {
            get {
                return ResourceManager.GetString("LegendStyles_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set the chart&apos;s &lt;b&gt;legendToggle&lt;/b&gt; property to true to
        ///    enable toggling the visibility of series when users
        ///    click the chart legend:.
        /// </summary>
        internal static string LegendToggle_Text1 {
            get {
                return ResourceManager.GetString("LegendToggle_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Legend Toggle:.
        /// </summary>
        internal static string LegendToggle_Text2 {
            get {
                return ResourceManager.GetString("LegendToggle_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Legend Series Toggle.
        /// </summary>
        internal static string LegendToggle_Title {
            get {
                return ResourceManager.GetString("LegendToggle_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The LineMarker class allows you to add a mouse-driven cursor
        ///    to your charts. The cursor consists of a text element used
        ///    to display information about the point under the mouse and
        ///    optional lines to indicate the exact position of the mouse..
        /// </summary>
        internal static string LineMarkers_Text1 {
            get {
                return ResourceManager.GetString("LineMarkers_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can customize the appearance of the LineMarker using CSS,
        ///    and its behavior using properties including &lt;b&gt;content&lt;/b&gt;,
        ///    &lt;b&gt;interaction&lt;/b&gt;, and &lt;b&gt;lines&lt;/b&gt;:.
        /// </summary>
        internal static string LineMarkers_Text2 {
            get {
                return ResourceManager.GetString("LineMarkers_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Lines:.
        /// </summary>
        internal static string LineMarkers_Text3 {
            get {
                return ResourceManager.GetString("LineMarkers_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Interaction:.
        /// </summary>
        internal static string LineMarkers_Text4 {
            get {
                return ResourceManager.GetString("LineMarkers_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Line Markers.
        /// </summary>
        internal static string LineMarkers_Title {
            get {
                return ResourceManager.GetString("LineMarkers_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Each series object in the FlexChart may specify its own
        ///    &lt;b&gt;chartType&lt;/b&gt; to override the chart&apos;s default. This
        ///    makes it easy to mix different chart types in a single
        ///    chart..
        /// </summary>
        internal static string MultipleChartTypes_Text1 {
            get {
                return ResourceManager.GetString("MultipleChartTypes_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example allows you to pick a chart type for the
        ///    &apos;Downloads&apos; series:.
        /// </summary>
        internal static string MultipleChartTypes_Text2 {
            get {
                return ResourceManager.GetString("MultipleChartTypes_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Series Chart Type:.
        /// </summary>
        internal static string MultipleChartTypes_Text3 {
            get {
                return ResourceManager.GetString("MultipleChartTypes_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Multiple Chart Types.
        /// </summary>
        internal static string MultipleChartTypes_Title {
            get {
                return ResourceManager.GetString("MultipleChartTypes_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexChart automatically picks colors for each series based
        ///    on a default palette, which you can override by setting the
        ///    &lt;b&gt;palette&lt;/b&gt; property..
        /// </summary>
        internal static string Palettes_Text1 {
            get {
                return ResourceManager.GetString("Palettes_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Please select a Palette:.
        /// </summary>
        internal static string Palettes_Text2 {
            get {
                return ResourceManager.GetString("Palettes_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexChart Palettes.
        /// </summary>
        internal static string Palettes_Title {
            get {
                return ResourceManager.GetString("Palettes_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, each FlexChart has two axes and a single Plot Area..
        /// </summary>
        internal static string PlotAreas_Text1 {
            get {
                return ResourceManager.GetString("PlotAreas_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You may create additional plot areas and stack them vertically
        ///    or horizontally. Vertically stacked plot areas usually have their
        ///    own Y axis and a shared X axis. The legend is shared by all plot
        ///    areas..
        /// </summary>
        internal static string PlotAreas_Text2 {
            get {
                return ResourceManager.GetString("PlotAreas_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the chart below has two plot areas. The first contains
        ///    two series and show amounts on the Y axis. The second contains a
        ///    single series and shows quantities on the Y axis:.
        /// </summary>
        internal static string PlotAreas_Text3 {
            get {
                return ResourceManager.GetString("PlotAreas_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sales, Expenses, and Downloads.
        /// </summary>
        internal static string PlotAreas_Text4 {
            get {
                return ResourceManager.GetString("PlotAreas_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Plot Areas.
        /// </summary>
        internal static string PlotAreas_Title {
            get {
                return ResourceManager.GetString("PlotAreas_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Range selectors allow users to zoom in on selected parts of
        ///    a chart by selecting a range on a secondary chart. The
        ///    most popular implementation is the one in Google Finance
        ///    charts..
        /// </summary>
        internal static string RangeSelectors_Text1 {
            get {
                return ResourceManager.GetString("RangeSelectors_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The &lt;b&gt;RangeSelector&lt;/b&gt; class in the
        ///    &lt;b&gt;wijmo.chart.interaction&lt;/b&gt; module makes it easy to add
        ///    range selectors to FlexChart controls:.
        /// </summary>
        internal static string RangeSelectors_Text2 {
            get {
                return ResourceManager.GetString("RangeSelectors_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Start with a regular FlexChart..
        /// </summary>
        internal static string RangeSelectors_Text3 {
            get {
                return ResourceManager.GetString("RangeSelectors_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Add a second FlexChart below the main chart, remove both
        ///        axes and set the height to a small value (say 60px) ..
        /// </summary>
        internal static string RangeSelectors_Text4 {
            get {
                return ResourceManager.GetString("RangeSelectors_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Create a &lt;b&gt;RangeSelector&lt;/b&gt; object using the second
        ///        chart as the constructor&apos;s parameter..
        /// </summary>
        internal static string RangeSelectors_Text5 {
            get {
                return ResourceManager.GetString("RangeSelectors_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Listen to the &lt;b&gt;RangeSelector&lt;/b&gt;&apos;s &lt;b&gt;rangeChanged&lt;/b&gt;
        ///        event to update the main chart&apos;s X-axis range..
        /// </summary>
        internal static string RangeSelectors_Text6 {
            get {
                return ResourceManager.GetString("RangeSelectors_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Range Selectors.
        /// </summary>
        internal static string RangeSelectors_Title {
            get {
                return ResourceManager.GetString("RangeSelectors_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexChart is data-driven. When there are changes to the
        ///    data it is bound to, or to any of its properties, the chart
        ///    goes through a render cycle, which consists of these steps:.
        /// </summary>
        internal static string RenderCycle_Text1 {
            get {
                return ResourceManager.GetString("RenderCycle_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Get the data&lt;/b&gt;:&lt;br /&gt;
        ///        The chart has an &lt;b&gt;itemsSource&lt;/b&gt; property that represents
        ///        the overall data source, and each series may override this
        ///        using its own local &lt;b&gt;itemsSource&lt;/b&gt; property. Similarly,
        ///        the chart has &lt;b&gt;bindingX&lt;/b&gt; and &lt;b&gt;binding&lt;/b&gt; properties
        ///        that determine the values to be charted for each series.&lt;br /&gt;
        ///        In most cases, you will set the &lt;b&gt;itemsSource&lt;/b&gt; and
        ///        &lt;b&gt;bindingX&lt;/b&gt; properties on the chart object, and the
        ///        &lt;b&gt;bind [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string RenderCycle_Text2 {
            get {
                return ResourceManager.GetString("RenderCycle_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Scale the data&lt;/b&gt;:&lt;br /&gt;
        ///        You may set the chart&apos;s range by setting the &lt;b&gt;min&lt;/b&gt; and
        ///        &lt;b&gt;max&lt;/b&gt; properties on the chart&apos;s axes. By default, those
        ///        properties are set to null, which causes the chart to scale
        ///        itself automatically. By default, series use the chart&apos;s
        ///        main set of axes, &lt;b&gt;axisX&lt;/b&gt; and &lt;b&gt;axisY&lt;/b&gt;; but you
        ///        may create additional axes and assign those axes to one or
        ///        more series..
        /// </summary>
        internal static string RenderCycle_Text3 {
            get {
                return ResourceManager.GetString("RenderCycle_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Raise the rendering event&lt;/b&gt;:&lt;br /&gt;
        ///        At this point, the chart is empty. Event handlers may use
        ///        &lt;b&gt;engine&lt;/b&gt; parameter of the &lt;b&gt;rendering&lt;/b&gt; event to
        ///        add custom elements that will render behind the chart data.
        ///        This can be used to add background elements such as alarm
        ///        zones..
        /// </summary>
        internal static string RenderCycle_Text4 {
            get {
                return ResourceManager.GetString("RenderCycle_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Render each series&lt;/b&gt;&lt;br /&gt;
        ///        In this step, the chart creates one or more SVG elements
        ///        to represent each series. The simplest and most efficient
        ///        chart types are &apos;Line&apos; and &apos;Spline&apos;, which can usually be
        ///        represented by a single SVG element.
        ///        Other chart types require more elements to render bars and
        ///        symbols.
        ///        The chart invokes a callback specified by the
        ///        &lt;b&gt;itemFormatter&lt;/b&gt; property to allow customization of
        ///        specific points in each seri [rest of string was truncated]&quot;;.
        /// </summary>
        internal static string RenderCycle_Text5 {
            get {
                return ResourceManager.GetString("RenderCycle_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to &lt;b&gt;Raise the rendered event&lt;/b&gt;:&lt;br /&gt;
        ///        At this point, the chart has been fully rendered.
        ///        Event handlers may use the &lt;b&gt;engine&lt;/b&gt; parameter of the
        ///        &lt;b&gt;rendered&lt;/b&gt; event to add custom elements that will
        ///        render above the chart data. This can be used to add
        ///        elements such as point annotations..
        /// </summary>
        internal static string RenderCycle_Text6 {
            get {
                return ResourceManager.GetString("RenderCycle_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexChart Render Cycle.
        /// </summary>
        internal static string RenderCycle_Title {
            get {
                return ResourceManager.GetString("RenderCycle_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexChart supports selection.
        ///    Use the &lt;b&gt;selectionMode&lt;/b&gt; property to specify whether
        ///    you want to allow selection by series, by data point,
        ///    or none at all (selection is off by default.).
        /// </summary>
        internal static string Selection_Text1 {
            get {
                return ResourceManager.GetString("Selection_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Setting the &lt;b&gt;selectionMode&lt;/b&gt; property to Series or Point
        ///    causes the FlexChart to update the &lt;b&gt;selection&lt;/b&gt; property
        ///    when the user clicks an item, and to apply the &quot;wj-state-selected&quot;
        ///    class to selected chart elements..
        /// </summary>
        internal static string Selection_Text2 {
            get {
                return ResourceManager.GetString("Selection_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The chart selection mechanism us based on the CollectionView
        ///    class, so if you have multiple controls connected to the
        ///    same data source, their selections will be synchronized
        ///    automatically..
        /// </summary>
        internal static string Selection_Text3 {
            get {
                return ResourceManager.GetString("Selection_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Selection Mode:.
        /// </summary>
        internal static string Selection_Text4 {
            get {
                return ResourceManager.GetString("Selection_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Chart Type:.
        /// </summary>
        internal static string Selection_Text5 {
            get {
                return ResourceManager.GetString("Selection_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Click a Series or a Point.
        /// </summary>
        internal static string Selection_Text6 {
            get {
                return ResourceManager.GetString("Selection_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexChart Selection.
        /// </summary>
        internal static string Selection_Title {
            get {
                return ResourceManager.GetString("Selection_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexChart&apos;s &lt;b&gt;itemsSource&lt;/b&gt; and &lt;b&gt;bindingX&lt;/b&gt;
        ///    properties apply to all series in the chart by default..
        /// </summary>
        internal static string SeriesDataSources_Text1 {
            get {
                return ResourceManager.GetString("SeriesDataSources_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Specific series may override those properties and use
        ///    different data sources and bindings. This allows you to
        ///    use multiple data sources on the same chart, and reduces
        ///    the need to pre-process data for charting..
        /// </summary>
        internal static string SeriesDataSources_Text2 {
            get {
                return ResourceManager.GetString("SeriesDataSources_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This demo creates several data sets and plots each one
        ///    as a different series:.
        /// </summary>
        internal static string SeriesDataSources_Text3 {
            get {
                return ResourceManager.GetString("SeriesDataSources_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Set Axis Origin to Zero.
        /// </summary>
        internal static string SeriesDataSources_Text4 {
            get {
                return ResourceManager.GetString("SeriesDataSources_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Data Sources.
        /// </summary>
        internal static string SeriesDataSources_Title {
            get {
                return ResourceManager.GetString("SeriesDataSources_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can easily implement a series-picker UI using the
        ///    chart&apos;s &lt;b&gt;series&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 SeriesPicker_Text1 {
            get {
                return ResourceManager.GetString("SeriesPicker_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the chart below starts with an auto-generated
        ///    set of series. Click the gear icon at the top-left corner to
        ///    show a &lt;b&gt;ListBox&lt;/b&gt; where you can select the series
        ///    you want to display..
        /// </summary>
        internal static string SeriesPicker_Text2 {
            get {
                return ResourceManager.GetString("SeriesPicker_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Note that you can achieve a similar result by setting the
        ///        chart&apos;s &lt;b&gt;legendToggle&lt;/b&gt; property to true. Once you do
        ///        that, the legend itself acts as a series picker: clicking
        ///        any series name in the legend toggles its visibility..
        /// </summary>
        internal static string SeriesPicker_Text3 {
            get {
                return ResourceManager.GetString("SeriesPicker_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Popup Series Picker.
        /// </summary>
        internal static string SeriesPicker_Title {
            get {
                return ResourceManager.GetString("SeriesPicker_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexChart automatically picks colors for each series based
        ///    on a default palette, which you can override by setting the
        ///    &lt;b&gt;palette&lt;/b&gt; property..
        /// </summary>
        internal static string SeriesStyles_Text1 {
            get {
                return ResourceManager.GetString("SeriesStyles_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to You can also override the default style settings for each series
        ///    by setting the &lt;b&gt;style&lt;/b&gt; and &lt;b&gt;symbolStyle&lt;/b&gt; properties of
        ///    any series to an object that specifies SVG styling attributes,
        ///    including fill, stroke, strokeThickness, and so on..
        /// </summary>
        internal static string SeriesStyles_Text2 {
            get {
                return ResourceManager.GetString("SeriesStyles_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The Series.style property is an exception to the general rule
        ///    that all styling in C1 MVC is done through CSS. This is because
        ///    many charts have dynamic series, which would be impossible to
        ///    style in advance..
        /// </summary>
        internal static string SeriesStyles_Text3 {
            get {
                return ResourceManager.GetString("SeriesStyles_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example uses the &lt;b&gt;style&lt;/b&gt; and &lt;b&gt;symbolStyle&lt;/b&gt;
        ///    properties to select style attributes for each series:.
        /// </summary>
        internal static string SeriesStyles_Text4 {
            get {
                return ResourceManager.GetString("SeriesStyles_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Series Styles.
        /// </summary>
        internal static string SeriesStyles_Title {
            get {
                return ResourceManager.GetString("SeriesStyles_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexChart &lt;b&gt;series&lt;/b&gt; property exposes a collection
        ///    of &lt;b&gt;Series&lt;/b&gt; objects that can be used to customize
        ///    the chart..
        /// </summary>
        internal static string Series_Text1 {
            get {
                return ResourceManager.GetString("Series_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This demo populates the &lt;b&gt;series&lt;/b&gt; collections automatically
        ///    based on the chart&apos;s &lt;b&gt;itemsSource&lt;/b&gt;, and shows the series
        ///    information on a grid where it can be edited:.
        /// </summary>
        internal static string Series_Text2 {
            get {
                return ResourceManager.GetString("Series_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexChart Series.
        /// </summary>
        internal static string Series_Title {
            get {
                return ResourceManager.GetString("Series_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The FlexChart allows you to visualize tabular data as business
        ///    charts. It provides a variety of options about how to present
        ///    and interact with the data, including selection, zooming,
        ///    drill-down, formatting, etc..
        /// </summary>
        internal static string Sorting_Text1 {
            get {
                return ResourceManager.GetString("Sorting_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Like all C1 MVC controls, the chart delegates all data-related
        ///    tasks to the CollectionView class, so if you want to filter,
        ///    sort, or group the data, you can do it using the CollectionView.
        ///    It may be useful to think of the FlexChart as a special type
        ///    of data grid, where columns are represented by series and
        ///    rows are data points on the chart..
        /// </summary>
        internal static string Sorting_Text2 {
            get {
                return ResourceManager.GetString("Sorting_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the chart below has buttons that allow users to
        ///    sort the data by changing the &lt;b&gt;sortDescriptions&lt;/b&gt; property
        ///    of the chart&apos;s &lt;b&gt;collectionView&lt;/b&gt;:.
        /// </summary>
        internal static string Sorting_Text3 {
            get {
                return ResourceManager.GetString("Sorting_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sort by:.
        /// </summary>
        internal static string Sorting_Text4 {
            get {
                return ResourceManager.GetString("Sorting_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to None.
        /// </summary>
        internal static string Sorting_Text5 {
            get {
                return ResourceManager.GetString("Sorting_Text5", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Country.
        /// </summary>
        internal static string Sorting_Text6 {
            get {
                return ResourceManager.GetString("Sorting_Text6", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Sales.
        /// </summary>
        internal static string Sorting_Text7 {
            get {
                return ResourceManager.GetString("Sorting_Text7", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Expenses.
        /// </summary>
        internal static string Sorting_Text8 {
            get {
                return ResourceManager.GetString("Sorting_Text8", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Downloads.
        /// </summary>
        internal static string Sorting_Text9 {
            get {
                return ResourceManager.GetString("Sorting_Text9", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexChart Architecture.
        /// </summary>
        internal static string Sorting_Title {
            get {
                return ResourceManager.GetString("Sorting_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Most chart types require that you provide a &lt;b&gt;binding&lt;/b&gt;
        ///    property to define the name of the property being charted.
        ///    These types include Column, Bar, Scatter, Line, Area, and
        ///    Spline..
        /// </summary>
        internal static string SpecialChartTypes_Text1 {
            get {
                return ResourceManager.GetString("SpecialChartTypes_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to A few chart types require additional information. For example,
        ///    Bubble charts type requires an additional value to determine
        ///    the bubble size. Candlestick charts require values to determine
        ///    the high/low/open and close values..
        /// </summary>
        internal static string SpecialChartTypes_Text2 {
            get {
                return ResourceManager.GetString("SpecialChartTypes_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to In these cases, the &lt;b&gt;binding&lt;/b&gt; property should be set to
        ///    a comma-delimited string containing the names of all the
        ///    properties to be used for creating the chart..
        /// </summary>
        internal static string SpecialChartTypes_Text3 {
            get {
                return ResourceManager.GetString("SpecialChartTypes_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to For example, the Bubble chart below sets the &lt;b&gt;binding&lt;/b&gt;
        ///    property of its series to &apos;Expenses,Downloads&apos;, so the
        ///    expenses are used as Y values and downloads determine the
        ///    bubble size:.
        /// </summary>
        internal static string SpecialChartTypes_Text4 {
            get {
                return ResourceManager.GetString("SpecialChartTypes_Text4", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Special Chart Types.
        /// </summary>
        internal static string SpecialChartTypes_Title {
            get {
                return ResourceManager.GetString("SpecialChartTypes_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Stacking chart controls is an alternative to creating
        ///    a single chart with multiple plot areas.
        ///    Use the &lt;b&gt;plotMargin&lt;/b&gt; property to ensure the
        ///    charts line up properly:.
        /// </summary>
        internal static string StackedCharts_Text1 {
            get {
                return ResourceManager.GetString("StackedCharts_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Stacked Charts.
        /// </summary>
        internal static string StackedCharts_Title {
            get {
                return ResourceManager.GetString("StackedCharts_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Like all C1 MVC controls, the FlexChart adds well-known class
        ///    names to elements in its DOM tree. These class names allow you
        ///    to define CSS rules that customize the appearance of each
        ///    chart element..
        /// </summary>
        internal static string Styling_Text1 {
            get {
                return ResourceManager.GetString("Styling_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to This example customizes a chart using CSS, and allows you
        ///    to toggle the CSS class to see the effect of the
        ///    customization:.
        /// </summary>
        internal static string Styling_Text2 {
            get {
                return ResourceManager.GetString("Styling_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom CSS.
        /// </summary>
        internal static string Styling_Text3 {
            get {
                return ResourceManager.GetString("Styling_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexChart CSS.
        /// </summary>
        internal static string Styling_Title {
            get {
                return ResourceManager.GetString("Styling_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Use CSS to customize the style of the chart titles..
        /// </summary>
        internal static string TitleStyles_Text1 {
            get {
                return ResourceManager.GetString("TitleStyles_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Custom Titles:.
        /// </summary>
        internal static string TitleStyles_Text2 {
            get {
                return ResourceManager.GetString("TitleStyles_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Title Styles.
        /// </summary>
        internal static string TitleStyles_Title {
            get {
                return ResourceManager.GetString("TitleStyles_Title", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to By default, the FlexChart shows tooltips with information
        ///    about the data point under the mouse. You can remove the
        ///    tooltips or customize their content using the &lt;b&gt;tooltip&lt;/b&gt;
        ///    property..
        /// </summary>
        internal static string Tooltips_Text1 {
            get {
                return ResourceManager.GetString("Tooltips_Text1", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to The tooltip&apos;s &lt;b&gt;content&lt;/b&gt; property is an HTML template
        ///    that may contains information about the series, the data
        ///    point, and the data element. For example:.
        /// </summary>
        internal static string Tooltips_Text2 {
            get {
                return ResourceManager.GetString("Tooltips_Text2", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to Tooltip Content:.
        /// </summary>
        internal static string Tooltips_Text3 {
            get {
                return ResourceManager.GetString("Tooltips_Text3", resourceCulture);
            }
        }
        
        /// <summary>
        ///   Looks up a localized string similar to FlexChart Tooltips.
        /// </summary>
        internal static string Tooltips_Title {
            get {
                return ResourceManager.GetString("Tooltips_Title", resourceCulture);
            }
        }
    }
}
