コード例 #1
0
        /// <summary>
        /// Creates the date tick values.
        /// </summary>
        /// <param name="min">
        /// The min.
        /// </param>
        /// <param name="max">
        /// The max.
        /// </param>
        /// <param name="step">
        /// The step.
        /// </param>
        /// <param name="intervalType">
        /// Type of the interval.
        /// </param>
        /// <returns>
        /// Date tick values.
        /// </returns>
        private IList <double> CreateDateTickValues(
            double min, double max, double step, DateTimeIntervalType intervalType)
        {
            DateTime start = ToDateTime(min);

            switch (intervalType)
            {
            case DateTimeIntervalType.Weeks:

                // make sure the first tick is at the 1st day of a week
                start = start.AddDays(-(int)start.DayOfWeek + (int)this.FirstDayOfWeek);
                break;

            case DateTimeIntervalType.Months:

                // make sure the first tick is at the 1st of a month
                start = new DateTime(start.Year, start.Month, 1);
                break;

            case DateTimeIntervalType.Years:

                // make sure the first tick is at Jan 1st
                start = new DateTime(start.Year, 1, 1);
                break;
            }

            // Adds a tick to the end time to make sure the end DateTime is included.
            DateTime end = ToDateTime(max).AddTicks(1);

            DateTime current     = start;
            var      values      = new Collection <double>();
            double   eps         = step * 1e-3;
            DateTime minDateTime = ToDateTime(min - eps);
            DateTime maxDateTime = ToDateTime(max + eps);

            while (current < end)
            {
                if (current > minDateTime && current < maxDateTime)
                {
                    values.Add(ToDouble(current));
                }

                switch (intervalType)
                {
                case DateTimeIntervalType.Months:
                    current = current.AddMonths((int)Math.Ceiling(step));
                    break;

                case DateTimeIntervalType.Years:
                    current = current.AddYears((int)Math.Ceiling(step));
                    break;

                default:
                    current = current.AddDays(step);
                    break;
                }
            }

            return(values);
        }
コード例 #2
0
        /// <summary>
        /// IntervalTypeProperty property changed handler.
        /// </summary>
        /// <param name="d">DateTimeAxis that changed its InternalIntervalType.</param>
        /// <param name="e">Event arguments.</param>
        private static void OnIntervalTypePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            DateTimeAxis         source   = (DateTimeAxis)d;
            DateTimeIntervalType newValue = (DateTimeIntervalType)e.NewValue;

            source.OnIntervalTypePropertyChanged(newValue);
        }
コード例 #3
0
 public void SetTempAxisScaleAndInterval()
 {
     if (this.oldAxisSettings.Count == 0)
     {
         this.oldAxisSettings.Push(this.axis.maximum);
         this.oldAxisSettings.Push(this.axis.minimum);
         this.oldAxisSettings.Push(this.axis.majorGrid.interval);
         this.oldAxisSettings.Push(this.axis.majorGrid.intervalType);
         this.oldAxisSettings.Push(this.axis.majorGrid.intervalOffset);
         this.oldAxisSettings.Push(this.axis.majorGrid.intervalOffsetType);
         this.oldAxisSettings.Push(this.axis.majorTickMark.interval);
         this.oldAxisSettings.Push(this.axis.majorTickMark.intervalType);
         this.oldAxisSettings.Push(this.axis.majorTickMark.intervalOffset);
         this.oldAxisSettings.Push(this.axis.majorTickMark.intervalOffsetType);
         this.oldAxisSettings.Push(this.axis.LabelStyle.interval);
         this.oldAxisSettings.Push(this.axis.LabelStyle.intervalType);
         this.oldAxisSettings.Push(this.axis.LabelStyle.intervalOffset);
         this.oldAxisSettings.Push(this.axis.LabelStyle.intervalOffsetType);
     }
     this.axis.maximum                          = this.ScaleMaximum;
     this.axis.minimum                          = this.ScaleMinimum;
     this.axis.majorGrid.interval               = this.Interval;
     this.axis.majorGrid.intervalType           = this.IntervalType;
     this.axis.majorGrid.intervalOffset         = this.IntervalOffset;
     this.axis.majorGrid.intervalOffsetType     = this.IntervalOffsetType;
     this.axis.majorTickMark.interval           = this.Interval;
     this.axis.majorTickMark.intervalType       = this.IntervalType;
     this.axis.majorTickMark.intervalOffset     = this.IntervalOffset;
     this.axis.majorTickMark.intervalOffsetType = this.IntervalOffsetType;
     this.axis.LabelStyle.interval              = this.Interval;
     this.axis.LabelStyle.intervalType          = this.IntervalType;
     this.axis.LabelStyle.intervalOffset        = this.IntervalOffset;
     this.axis.LabelStyle.intervalOffsetType    = this.IntervalOffsetType;
 }
コード例 #4
0
 /// <summary>
 /// ViewEventArgs constructor.
 /// </summary>
 /// <param name="axis">Axis of the scale view.</param>
 /// <param name="newPosition">New scale view start position.</param>
 /// <param name="newSize">New scale view size.</param>
 /// <param name="newSizeType">New unit of measurement of the size.</param>
 public ViewEventArgs(Axis axis, double newPosition, double newSize, DateTimeIntervalType newSizeType)
 {
     _axis        = axis;
     NewPosition  = newPosition;
     NewSize      = newSize;
     _newSizeType = newSizeType;
 }
コード例 #5
0
        /// <summary>
        /// Initialize internal scrolling line size variables for later use.
        /// This size is used in to scroll chart one line up or down.
        /// </summary>
        private void GetCurrentViewSmallScrollSize()
        {
            //**************************************************************************
            //** Check if current scrolling line size was not already calculated
            //**************************************************************************
            if (double.IsNaN(_currentSmallScrollSize))
            {
                //**************************************************************************
                //** Calculate line size depending on the current scaleView size
                //**************************************************************************
                if (SizeType == DateTimeIntervalType.Auto || SizeType == DateTimeIntervalType.Number)
                {
                    // Set line size type
                    _currentSmallScrollSizeType = DateTimeIntervalType.Number;

                    // Devide scaleView by 20 to find the scrolling line size
                    double newSize = Size / 20.0;

                    // Make sure that current line size is even with minimum value
                    if (!double.IsNaN(SmallScrollMinSize) && SmallScrollMinSize != 0.0)
                    {
                        double rounder = (Math.Round(newSize / SmallScrollMinSize));
                        if (rounder < 0)
                        {
                            rounder = 1;
                        }
                        newSize = rounder * SmallScrollMinSize;
                    }

                    // Set new current line size
                    _currentSmallScrollSize = newSize;
                }
                else
                {
                    // Calculate line size for date/time
                    double viewEndPosition = Position + ChartHelper.GetIntervalSize(Position, Size, SizeType);
                    _currentSmallScrollSize = axis.CalcInterval(
                        Position,
                        viewEndPosition,
                        true,
                        out _currentSmallScrollSizeType,
                        ChartValueType.Auto);
                }

                //**************************************************************************
                //** Make sure calculated scroll line size is not smaller than the minimum
                //**************************************************************************
                if (!double.IsNaN(SmallScrollMinSize) && SmallScrollMinSize != 0.0)
                {
                    double newLineSize = ChartHelper.GetIntervalSize(Position, _currentSmallScrollSize, _currentSmallScrollSizeType);
                    double minLineSize = ChartHelper.GetIntervalSize(Position, SmallScrollMinSize, SmallScrollMinSizeType);
                    if (newLineSize < minLineSize)
                    {
                        _currentSmallScrollSize     = SmallScrollMinSize;
                        _currentSmallScrollSizeType = SmallScrollMinSizeType;
                    }
                }
            }
        }
コード例 #6
0
 /// <summary>
 /// Sets interval properties for the axis.
 /// Note that we use the Axis object's interval properties, and not the properties of its label,
 /// and major tick mark and grid line objects
 /// </summary>
 public void SetAxisInterval(Axis axis, double interval, DateTimeIntervalType intervalType, double intervalOffset, DateTimeIntervalType intervalOffsetType)
 {
     // Set interval-related properties
     axis.Interval           = interval;
     axis.IntervalType       = intervalType;
     axis.IntervalOffset     = intervalOffset;
     axis.IntervalOffsetType = intervalOffsetType;
 }
コード例 #7
0
 /// <summary>
 /// Sets interval properties for the axis. 
 /// Note that we use the Axis object's interval properties, and not the properties of its label,
 /// and major tick mark and grid line objects
 /// </summary>
 public void SetAxisInterval(Axis axis, double interval, DateTimeIntervalType intervalType, double intervalOffset, DateTimeIntervalType intervalOffsetType )
 {
     // Set interval-related properties
     axis.Interval = interval;
     axis.IntervalType = intervalType;
     axis.IntervalOffset = intervalOffset;
     axis.IntervalOffsetType = intervalOffsetType;
 }
コード例 #8
0
 /// <summary>
 /// 图表区X轴游标设置
 /// </summary>
 /// <param name="chart">图表对象</param>
 /// <param name="enable">启用/禁用游标用户界面和图表区范围选择用户界面</param>
 /// <param name="Interval">游标移动间隔</param>
 /// <param name="Intervaltype">游标移动间隔类型</param>
 public static void SetCursorX(Chart chart, bool enable, int Interval, DateTimeIntervalType Intervaltype)
 {
     chart.ChartAreas[0].CursorX.IsUserEnabled          = enable;
     chart.ChartAreas[0].CursorX.IsUserSelectionEnabled = enable;
     chart.ChartAreas[0].CursorX.Interval       = Interval;
     chart.ChartAreas[0].CursorX.IntervalOffset = Interval;
     chart.ChartAreas[0].CursorX.IntervalType   = Intervaltype;
 }
コード例 #9
0
ファイル: DateTimeAxisLabel.cs プロジェクト: t00/wpftoolkit
        /// <summary>
        /// IntervalTypeProperty property changed handler.
        /// </summary>
        /// <param name="d">DateTimeAxisLabel that changed its IntervalType.</param>
        /// <param name="e">Event arguments.</param>
        private static void OnIntervalTypePropertyChanged(System.Windows.DependencyObject d, System.Windows.DependencyPropertyChangedEventArgs e)
        {
            DateTimeAxisLabel    source   = (DateTimeAxisLabel)d;
            DateTimeIntervalType oldValue = (DateTimeIntervalType)e.OldValue;
            DateTimeIntervalType newValue = (DateTimeIntervalType)e.NewValue;

            source.OnIntervalTypePropertyChanged(oldValue, newValue);
        }
コード例 #10
0
 /// <summary>
 /// Sets interval properties for the axis. 
 /// Note that we use the Axis object's interval properties, and not the properties of its label,
 /// and major tick mark and grid line objects
 /// </summary>
 public void SetAxisInterval(System.Web.UI.DataVisualization.Charting.Axis axis, double interval, DateTimeIntervalType intervalType, double intervalOffset, DateTimeIntervalType intervalOffsetType )
 {
     // Set interval-related properties
     axis.Interval = interval;
     axis.IntervalType = intervalType;
     axis.IntervalOffset = intervalOffset;
     axis.IntervalOffsetType = intervalOffsetType;
 }
コード例 #11
0
ファイル: DateTimeAxis.cs プロジェクト: aelij/WPFToolkit
        /// <summary>
        ///     This method accepts a date time and increments it.
        /// </summary>
        /// <param name="date">A date time.</param>
        /// <param name="interval">
        ///     The interval used to increment the date time.
        /// </param>
        /// <returns>The new date time.</returns>
        private DateTime IncrementDateTime(DateTime date, double interval)
        {
            DateTimeIntervalType intervalType = ActualIntervalType;
            var span = new TimeSpan(0);

            if (intervalType == DateTimeIntervalType.Days)
            {
                span = TimeSpan.FromDays(interval);
            }
            else if (intervalType == DateTimeIntervalType.Hours)
            {
                span = TimeSpan.FromHours(interval);
            }
            else if (intervalType == DateTimeIntervalType.Milliseconds)
            {
                span = TimeSpan.FromMilliseconds(interval);
            }
            else if (intervalType == DateTimeIntervalType.Seconds)
            {
                span = TimeSpan.FromSeconds(interval);
            }
            else if (intervalType == DateTimeIntervalType.Minutes)
            {
                span = TimeSpan.FromMinutes(interval);
            }
            else if (intervalType == DateTimeIntervalType.Weeks)
            {
                span = TimeSpan.FromDays(7.0 * interval);
            }
            else if (intervalType == DateTimeIntervalType.Months)
            {
                // Special case handling when current date point
                // to the last day of the month
                bool lastMonthDay = date.Day == DateTime.DaysInMonth(date.Year, date.Month);

                // Add specified amount of months
                date = date.AddMonths((int)Math.Floor(interval));
                span = TimeSpan.FromDays(30.0 * (interval - Math.Floor(interval)));

                // Check if last month of the day was used
                if (lastMonthDay && span.Ticks == 0)
                {
                    // Make sure the last day of the month is selected
                    int daysInMobth = DateTime.DaysInMonth(date.Year, date.Month);
                    date = date.AddDays(daysInMobth - date.Day);
                }
            }
            else if (intervalType == DateTimeIntervalType.Years)
            {
                date = date.AddYears((int)Math.Floor(interval));
                span = TimeSpan.FromDays(365.0 * (interval - Math.Floor(interval)));
            }

            DateTime result = date.Add(span);

            return(result);
        }
コード例 #12
0
        /// <summary>
        /// Internal helper zooming method.
        /// </summary>
        /// <param name="viewPosition">New data scaleView start posiion.</param>
        /// <param name="viewSize">New data scaleView size.</param>
        /// <param name="viewSizeType">New data scaleView size units type.</param>
        /// <param name="fireChangeEvents">Fire scaleView position events from this method.</param>
        /// <param name="saveState">Indicates that current scaleView size/position must be save, so it can be restored later.</param>
        /// <returns>True if zoom operation was made.</returns>
        internal bool Zoom(
            double viewPosition,
            double viewSize,
            DateTimeIntervalType viewSizeType,
            bool fireChangeEvents,
            bool saveState)
        {
            // Validate new scaleView position and size
            ValidateViewPositionSize(ref viewPosition, ref viewSize, ref viewSizeType);

            // Fire scaleView position/size changing events
            ViewEventArgs arguments = new(axis, viewPosition, viewSize, viewSizeType);

            if (fireChangeEvents && GetChartObject() != null)
            {
                GetChartObject().OnAxisViewChanging(arguments);
                viewPosition = arguments.NewPosition;
                viewSize     = arguments.NewSize;
                viewSizeType = arguments.NewSizeType;
            }

            // Check if data scaleView position and size is different from current
            if (viewPosition == Position &&
                viewSize == Size &&
                viewSizeType == SizeType)
            {
                return(false);
            }

            // Save current data scaleView state, so it can be restored
            if (saveState)
            {
                SaveDataViewState();
            }

            // Change scaleView position/size
            _ignoreValidation = true;
            Position          = viewPosition;
            Size              = viewSize;
            SizeType          = viewSizeType;
            _ignoreValidation = false;

            // Reset current scrolling line size
            _currentSmallScrollSize = double.NaN;

            // Invalidate chart
            axis.Invalidate();

            // Fire scaleView position/size changed events
            if (fireChangeEvents && GetChartObject() != null)
            {
                GetChartObject().OnAxisViewChanged(arguments);
            }

            return(true);
        }
コード例 #13
0
        private double GetLogMinimum(double current, Series axisSeries)
        {
            double num = axis.GetViewMinimum();
            DateTimeIntervalType type = (IntervalOffsetType == DateTimeIntervalType.Auto) ? IntervalType : IntervalOffsetType;

            if (IntervalOffset != 0.0 && !double.IsNaN(IntervalOffset) && axisSeries == null)
            {
                num += axis.GetIntervalSize(num, IntervalOffset, type, axisSeries, 0.0, DateTimeIntervalType.Number, forceIntIndex: true, forceAbsInterval: false);
            }
            return(num + Math.Floor(current - num));
        }
コード例 #14
0
        private double GetLogMinimum(double current, Series axisSeries)
        {
            double num = this.axis.GetViewMinimum();
            DateTimeIntervalType type = (this.IntervalOffsetType == DateTimeIntervalType.Auto) ? this.IntervalType : this.IntervalOffsetType;

            if (this.IntervalOffset != 0.0 && !double.IsNaN(this.IntervalOffset) && axisSeries == null)
            {
                num += this.axis.GetIntervalSize(num, this.IntervalOffset, type, axisSeries, 0.0, DateTimeIntervalType.Number, true, false);
            }
            return(num + Math.Floor(current - num));
        }
コード例 #15
0
 /// <summary>
 /// Gets interval size as double number.
 /// </summary>
 /// <param name="current">Current value.</param>
 /// <param name="interval">Interval size.</param>
 /// <param name="type">AxisName of the interval (Month, Year, ...).</param>
 /// <returns>Interval size as double.</returns>
 internal static double GetIntervalSize(double current, double interval, DateTimeIntervalType type)
 {
     return(GetIntervalSize(
                current,
                interval,
                type,
                null,
                0,
                DateTimeIntervalType.Number,
                true,
                true));
 }
コード例 #16
0
 public DateTimeAxis(
     AxisPosition position,
     DateTime firstDateTime,
     DateTime lastDateTime,
     string title  = null,
     string format = null,
     DateTimeIntervalType intervalType = DateTimeIntervalType.Auto)
     : this(position, title, format, intervalType)
 {
     this.Minimum = ToDouble(firstDateTime);
     this.Maximum = ToDouble(lastDateTime);
 }
コード例 #17
0
ファイル: DateTimeAxis.cs プロジェクト: EstunSWRD/oxyplot_src
        /// <summary>
        /// Creates <see cref="DateTime" /> tick values.
        /// </summary>
        /// <param name="min">The min.</param>
        /// <param name="max">The max.</param>
        /// <param name="interval">The interval.</param>
        /// <param name="intervalType">The interval type.</param>
        /// <returns>A list of <see cref="DateTime" /> tick values.</returns>
        private IList <double> CreateDateTimeTickValues(
            double min, double max, double interval, DateTimeIntervalType intervalType)
        {
            // If the step size is more than 7 days (e.g. months or years) we use a specialized tick generation method that adds tick values with uneven spacing...
            if (intervalType > DateTimeIntervalType.Days)
            {
                return(this.CreateDateTickValues(min, max, interval, intervalType));
            }

            // For shorter step sizes we use the method from Axis
            return(this.CreateTickValues(min, max, interval));
        }
コード例 #18
0
        public DateTimeAxis(
            AxisPosition position,
            string title  = null,
            string format = null,
            DateTimeIntervalType intervalType = DateTimeIntervalType.Auto)
            : base(position, title)
        {
            this.FirstDayOfWeek   = DayOfWeek.Monday;
            this.CalendarWeekRule = CalendarWeekRule.FirstFourDayWeek;

            this.StringFormat = format;
            this.IntervalType = intervalType;
        }
コード例 #19
0
        /// <summary>
        /// Returns the actual interval to use to determine which values are
        /// displayed in the axis.
        /// </summary>
        /// <param name="availableSize">The available size.</param>
        /// <returns>The actual interval to use to determine which values are
        /// displayed in the axis.
        /// </returns>
        private double CalculateActualInterval(Size availableSize)
        {
            if (Interval != null)
            {
                return(Interval.Value);
            }

            DateTimeIntervalType intervalType = new DateTimeIntervalType();
            double interval = CalculateDateTimeInterval(ActualDateTimeRange.Minimum, ActualDateTimeRange.Maximum, out intervalType, availableSize);

            ActualIntervalType = intervalType;
            return(interval);
        }
コード例 #20
0
ファイル: DateTimeAxis.cs プロジェクト: Celderon/oxyplot
        public DateTimeAxis(
            AxisPosition position,
            string title = null,
            string format = null,
            DateTimeIntervalType intervalType = DateTimeIntervalType.Auto)
            : base(position, title)
        {
            this.FirstDayOfWeek = DayOfWeek.Monday;
            this.CalendarWeekRule = CalendarWeekRule.FirstFourDayWeek;

            this.StringFormat = format;
            this.IntervalType = intervalType;
        }
コード例 #21
0
        internal void HScrollerScroll(DateTime viewTimeBegin, DateTime viewTimeEnd, DateTimeIntervalType scaleType,
                                      DateTime curViewTimeBegin, DateTime curViewTimeEnd)
        {
            var pz = new List <object> {
                viewTimeBegin, viewTimeEnd, scaleType
            };
            var cpz = new List <object> {
                curViewTimeBegin, curViewTimeEnd, scaleType
            };
            var cmd = new UserCommand(EUserCommand.SetTimeView, null, pz, cpz);

            AddCommand(cmd, false);
        }
コード例 #22
0
ファイル: ChartHelp.cs プロジェクト: harborsiem/ELEMNTViewer
        public ChartHelp(Chart chart)
        {
            this.chart             = chart;
            chart.AxisViewChanged += new EventHandler <ViewEventArgs>(Chart_AxisViewChanged);
            CheckBoxTag.Chart      = chart;
            CheckBoxTag.ChartHelp  = this;
            ChartArea chartArea1 = chart.ChartAreas["ChartArea1"];

            resetZoomAxisInterval      = chartArea1.AxisX.Interval;
            resetZoomAxisIntervalType  = chartArea1.AxisX.IntervalType;
            resetZoomLabelInterval     = chartArea1.AxisX.LabelStyle.Interval;
            resetZoomLabelIntervalType = chartArea1.AxisX.LabelStyle.IntervalType;
            chart.PrePaint            += new EventHandler <ChartPaintEventArgs>(chartMain_PrePaint);
        }
コード例 #23
0
ファイル: ChartHelp.cs プロジェクト: harborsiem/ELEMNTViewer
        public void SetIntervals(TimeSpan delta)
        {
            chart.SuspendLayout();
            Axis axisX1 = chart.ChartAreas["ChartArea1"].AxisX;

            if (delta <= new TimeSpan(0, 5, 0, 0))
            {
                if (delta <= new TimeSpan(0, 0, 30, 0))
                {
                    axisX1.MajorGrid.Interval      = 1D;
                    axisX1.MajorGrid.IntervalType  = DateTimeIntervalType.Minutes;
                    axisX1.LabelStyle.Interval     = 1D;
                    axisX1.LabelStyle.IntervalType = DateTimeIntervalType.Minutes;
                    axisX1.Interval            = 1D;
                    axisX1.IntervalType        = DateTimeIntervalType.Minutes;
                    resetZoomLabelInterval     = 1D;
                    resetZoomLabelIntervalType = DateTimeIntervalType.Minutes;
                    resetZoomAxisInterval      = 1D;
                    resetZoomAxisIntervalType  = DateTimeIntervalType.Minutes;
                }
                else
                {
                    axisX1.MajorGrid.Interval      = 15D;
                    axisX1.MajorGrid.IntervalType  = DateTimeIntervalType.Minutes;
                    axisX1.LabelStyle.Interval     = 15D;
                    axisX1.LabelStyle.IntervalType = DateTimeIntervalType.Minutes;
                    axisX1.Interval            = 15D;
                    axisX1.IntervalType        = DateTimeIntervalType.Minutes;
                    resetZoomLabelInterval     = 15D;
                    resetZoomLabelIntervalType = DateTimeIntervalType.Minutes;
                    resetZoomAxisInterval      = 15D;
                    resetZoomAxisIntervalType  = DateTimeIntervalType.Minutes;
                }
            }
            else
            {
                axisX1.MajorGrid.Interval      = 1D;
                axisX1.MajorGrid.IntervalType  = DateTimeIntervalType.Hours;
                axisX1.LabelStyle.Interval     = 1D;
                axisX1.LabelStyle.IntervalType = DateTimeIntervalType.Hours;
                axisX1.Interval            = 1D;
                axisX1.IntervalType        = DateTimeIntervalType.Hours;
                resetZoomLabelInterval     = 1D;
                resetZoomLabelIntervalType = DateTimeIntervalType.Hours;
                resetZoomAxisInterval      = 1D;
                resetZoomAxisIntervalType  = DateTimeIntervalType.Hours;
            }
            chart.ResumeLayout();
        }
コード例 #24
0
        internal bool VizirChanged(DateTime vizirTime, DateTime curVizirTime, DateTime curViewMin, DateTime curViewMax,
                                   DateTimeIntervalType curViewTimeIntervalType)
        {
            if (curVizirTime != vizirTime)
            {
                var cpz = new List <object> {
                    curVizirTime, curViewMin, curViewMax, curViewTimeIntervalType
                };
                var cmd = new UserCommand(EUserCommand.SetVizir, null, vizirTime, cpz);
                AddCommand(cmd, false);
                return(true);
            }

            return(false);
        }
コード例 #25
0
        /// <summary>
        /// Returns the actual interval to use to determine which values are
        /// displayed in the axis.
        /// </summary>
        /// <returns>The actual interval to use to determine which values are
        /// displayed in the axis.
        /// </returns>
        private double CalculateActualInterval()
        {
            if (Interval != null)
            {
                return(Interval.Value);
            }

            Range <DateTime> actualDateTimeRange = ToDateTimeRange(this.ActualRange);

            DateTimeIntervalType intervalType;
            double interval = CalculateDateTimeInterval(actualDateTimeRange.Minimum, actualDateTimeRange.Maximum, out intervalType);

            ActualIntervalType = intervalType;
            return(interval);
        }
コード例 #26
0
 public override object ConvertTo(ITypeDescriptorContext context, CultureInfo culture, object value, Type destinationType)
 {
     if (context != null && context.Instance != null && destinationType == typeof(string))
     {
         DateTimeIntervalType dateTimeIntervalType = DateTimeIntervalType.Auto;
         double       num      = 0.0;
         PropertyInfo property = context.Instance.GetType().GetProperty("IntervalType");
         if (property != null)
         {
             dateTimeIntervalType = (DateTimeIntervalType)property.GetValue(context.Instance, null);
         }
         property = context.Instance.GetType().GetProperty("Interval");
         if (property != null)
         {
             num = (double)property.GetValue(context.Instance, null);
         }
         if (dateTimeIntervalType == DateTimeIntervalType.Auto)
         {
             Axis axis = null;
             if (context.Instance is Axis)
             {
                 axis = (Axis)context.Instance;
             }
             else
             {
                 MethodInfo method = context.Instance.GetType().GetMethod("GetAxis");
                 if (method != null)
                 {
                     axis = (Axis)method.Invoke(context.Instance, null);
                 }
             }
             if (axis != null)
             {
                 dateTimeIntervalType = axis.GetAxisIntervalType();
             }
         }
         if ((context.Instance.GetType() != typeof(StripLine) || num == 0.0) && dateTimeIntervalType != DateTimeIntervalType.Number && dateTimeIntervalType != 0)
         {
             if (dateTimeIntervalType < DateTimeIntervalType.Hours)
             {
                 return(DateTime.FromOADate((double)value).ToShortDateString());
             }
             return(DateTime.FromOADate((double)value).ToString("g", CultureInfo.CurrentCulture));
         }
     }
     return(base.ConvertTo(context, culture, value, destinationType));
 }
コード例 #27
0
        public DateTime GetMinDate(DateTime maxDate, DateTimeIntervalType dtintType, int dtOffset)
        {
            if (DateTimeIntervalType.Minutes == dtintType)
            {
                return(maxDate.AddMinutes(-dtOffset));
            }
            else if (DateTimeIntervalType.Hours == dtintType)
            {
                return(maxDate.AddHours(-dtOffset));
            }
            else if (DateTimeIntervalType.Days == dtintType)
            {
                return(maxDate.AddHours(-dtOffset));
            }


            return(maxDate);
        }
コード例 #28
0
        //Если viewTimeIntervalType = DateTimeIntervalType.NotSet - автоопределение _axisXIntervalType
        internal bool SetTimeView(DateTime viewTimeBegin, DateTime viewTimeEnd, DateTimeIntervalType scaleType,
                                  DateTime curViewTimeBegin, DateTime curViewTimeEnd, DateTimeIntervalType curScaleType)
        {
            if ((viewTimeBegin != curViewTimeBegin) || (viewTimeEnd != curViewTimeEnd) || (scaleType != curScaleType))
            {
                var pz = new List <object> {
                    viewTimeBegin, viewTimeEnd, scaleType
                };
                var cpz = new List <object> {
                    curViewTimeBegin, curViewTimeEnd, curScaleType
                };
                var cmd = new UserCommand(EUserCommand.SetTimeView, null, pz, cpz);
                AddCommand(cmd);
                return(true);
            }

            return(false);
        }
コード例 #29
0
 private void CorrectMinMax(DateTimeIntervalType dtintType, int interv, ref DateTime dtMinCorr, ref DateTime dtMaxCorr)
 {
     if (DateTimeIntervalType.Minutes == dtintType)
     {
         dtMinCorr = dtMinCorr.AddMinutes(-interv);
         dtMaxCorr = dtMaxCorr.AddMinutes(interv);
     }
     else if (DateTimeIntervalType.Hours == dtintType)
     {
         dtMinCorr = dtMinCorr.AddHours(-interv);
         dtMaxCorr = dtMaxCorr.AddHours(interv);
     }
     else if (DateTimeIntervalType.Days == dtintType)
     {
         dtMinCorr = dtMinCorr.AddDays(-interv);
         dtMaxCorr = dtMaxCorr.AddDays(interv);
     }
 }
コード例 #30
0
 /// <summary>
 /// Gets interval size as double number.
 /// </summary>
 /// <param name="current">Current value.</param>
 /// <param name="interval">Interval size.</param>
 /// <param name="type">AxisName of the interval (Month, Year, ...).</param>
 /// <param name="series">First series connected to the axis.</param>
 /// <param name="intervalOffset">Offset size.</param>
 /// <param name="intervalOffsetType">Offset type(Month, Year, ...).</param>
 /// <param name="forceIntIndex">Force Integer indexed</param>
 /// <returns>Interval size as double.</returns>
 internal static double GetIntervalSize(
     double current,
     double interval,
     DateTimeIntervalType type,
     Series series,
     double intervalOffset,
     DateTimeIntervalType intervalOffsetType,
     bool forceIntIndex)
 {
     return(GetIntervalSize(
                current,
                interval,
                type,
                series,
                intervalOffset,
                intervalOffsetType,
                forceIntIndex,
                true));
 }
コード例 #31
0
        private void SetXAxisForDate(Axis axis, DateTimeIntervalType t)
        {
            axis.LabelStyle.Angle  = int.Parse(LocalizedChartControl.XAxisLabelAngle);
            axis.LabelStyle.Format = GraphInformation.XAxisDateFormat;


            axis.LabelStyle.Interval     = 1;
            axis.LabelStyle.IntervalType = t;

            axis.MajorTickMark.Interval     = 1;
            axis.MajorTickMark.IntervalType = t;
            axis.MajorTickMark.Size         = 1;

            axis.MajorGrid.Interval     = 1;
            axis.MajorGrid.IntervalType = t;
            axis.MajorGrid.LineWidth    = 1;


            if (t == DateTimeIntervalType.Weeks)
            {
                axis.MajorGrid.LineColor    = GraphInformation.DarkXAxisLineColour;
                axis.MinorGrid.Enabled      = true;
                axis.MinorGrid.LineWidth    = 1;
                axis.MinorGrid.LineColor    = GraphInformation.LightXAxisLineColour;
                axis.MinorGrid.Interval     = 1;
                axis.MinorGrid.IntervalType = DateTimeIntervalType.Days;

                //Offsets
                axis.MajorGrid.IntervalOffset     = 1;
                axis.MajorGrid.IntervalOffsetType = DateTimeIntervalType.Days;

                axis.MajorTickMark.IntervalOffset     = 1;
                axis.MajorTickMark.IntervalOffsetType = DateTimeIntervalType.Days;

                axis.LabelStyle.IntervalOffset     = 1;
                axis.LabelStyle.IntervalOffsetType = DateTimeIntervalType.Days;
            }
            else
            {
                axis.MajorGrid.LineColor = GraphInformation.LightXAxisLineColour;
            }
        }
コード例 #32
0
 public void RestoreAxisScaleAndInterval()
 {
     if (this.oldAxisSettings.Count > 0)
     {
         this.axis.LabelStyle.intervalOffsetType    = (DateTimeIntervalType)this.oldAxisSettings.Pop();
         this.axis.LabelStyle.intervalOffset        = (double)this.oldAxisSettings.Pop();
         this.axis.LabelStyle.intervalType          = (DateTimeIntervalType)this.oldAxisSettings.Pop();
         this.axis.LabelStyle.interval              = (double)this.oldAxisSettings.Pop();
         this.axis.majorTickMark.intervalOffsetType = (DateTimeIntervalType)this.oldAxisSettings.Pop();
         this.axis.majorTickMark.intervalOffset     = (double)this.oldAxisSettings.Pop();
         this.axis.majorTickMark.intervalType       = (DateTimeIntervalType)this.oldAxisSettings.Pop();
         this.axis.majorTickMark.interval           = (double)this.oldAxisSettings.Pop();
         this.axis.majorGrid.intervalOffsetType     = (DateTimeIntervalType)this.oldAxisSettings.Pop();
         this.axis.majorGrid.intervalOffset         = (double)this.oldAxisSettings.Pop();
         this.axis.majorGrid.intervalType           = (DateTimeIntervalType)this.oldAxisSettings.Pop();
         this.axis.majorGrid.interval = (double)this.oldAxisSettings.Pop();
         this.axis.minimum            = (double)this.oldAxisSettings.Pop();
         this.axis.maximum            = (double)this.oldAxisSettings.Pop();
     }
 }
コード例 #33
0
        internal static DateTime IncreaseInterval(DateTime date, double interval, DateTimeIntervalType intervalType)
        {
            TimeSpan span = new TimeSpan(0);
            DateTime result;

            if (intervalType == DateTimeIntervalType.Days)
            {
                span = TimeSpan.FromDays(interval);
            }
            else if (intervalType == DateTimeIntervalType.Hours)
            {
                span = TimeSpan.FromHours(interval);
            }
            else if (intervalType == DateTimeIntervalType.Milliseconds)
            {
                span = TimeSpan.FromMilliseconds(interval);
            }
            else if (intervalType == DateTimeIntervalType.Seconds)
            {
                span = TimeSpan.FromSeconds(interval);
            }
            else if (intervalType == DateTimeIntervalType.Minutes)
            {
                span = TimeSpan.FromMinutes(interval);
            }
            else if (intervalType == DateTimeIntervalType.Months)
            {
                date = date.AddMonths((int)Math.Floor(interval));
                span = TimeSpan.FromDays(30.0 * (interval - Math.Floor(interval)));
            }
            else if (intervalType == DateTimeIntervalType.Years)
            {
                date = date.AddYears((int)Math.Floor(interval));
                span = TimeSpan.FromDays(365.0 * (interval - Math.Floor(interval)));
            }

            result = date.Add(span);

            return(result);
        }
コード例 #34
0
ファイル: DateTimeAxis.cs プロジェクト: huoxudong125/oxyplot
        /// <summary>
        /// Updates the intervals.
        /// </summary>
        /// <param name="plotArea">The plot area.</param>
        internal override void UpdateIntervals(OxyRect plotArea)
        {
            base.UpdateIntervals(plotArea);
            switch (this.actualIntervalType)
            {
                case DateTimeIntervalType.Years:
                    this.ActualMinorStep = 31;
                    this.actualMinorIntervalType = DateTimeIntervalType.Years;
                    if (this.StringFormat == null)
                    {
                        this.ActualStringFormat = "yyyy";
                    }

                    break;
                case DateTimeIntervalType.Months:
                    this.actualMinorIntervalType = DateTimeIntervalType.Months;
                    if (this.StringFormat == null)
                    {
                        this.ActualStringFormat = "yyyy-MM-dd";
                    }

                    break;
                case DateTimeIntervalType.Weeks:
                    this.actualMinorIntervalType = DateTimeIntervalType.Days;
                    this.ActualMajorStep = 7;
                    this.ActualMinorStep = 1;
                    if (this.StringFormat == null)
                    {
                        this.ActualStringFormat = "yyyy/ww";
                    }

                    break;
                case DateTimeIntervalType.Days:
                    this.ActualMinorStep = this.ActualMajorStep;
                    if (this.StringFormat == null)
                    {
                        this.ActualStringFormat = "yyyy-MM-dd";
                    }

                    break;
                case DateTimeIntervalType.Hours:
                    this.ActualMinorStep = this.ActualMajorStep;
                    if (this.StringFormat == null)
                    {
                        this.ActualStringFormat = "HH:mm";
                    }

                    break;
                case DateTimeIntervalType.Minutes:
                    this.ActualMinorStep = this.ActualMajorStep;
                    if (this.StringFormat == null)
                    {
                        this.ActualStringFormat = "HH:mm";
                    }

                    break;
                case DateTimeIntervalType.Seconds:
                    this.ActualMinorStep = this.ActualMajorStep;
                    if (this.StringFormat == null)
                    {
                        this.ActualStringFormat = "HH:mm:ss";
                    }

                    break;
                case DateTimeIntervalType.Manual:
                    break;
                case DateTimeIntervalType.Auto:
                    break;
            }
        }
コード例 #35
0
ファイル: TrendViewer.cs プロジェクト: guozanhua/phmi
        private IEnumerable<KeyValuePair<double, DateTime>> GetHorisontalAxesMarkers(
            DateTime leftTime,
            DateTime rightTime,
            double left,
            double right,
            out DateTimeIntervalType intervalType,
            out int interval)
        {
            var deltaX = Math.Abs(right - left);
            var gridLinesNumber = (int) deltaX/MinimumXAxesStep + 1;

            interval = 0;
            intervalType = DateTimeIntervalType.Years;

            var markers = new List<KeyValuePair<double, DateTime>>();
            if (gridLinesNumber > 1)
            {
                var leftTimeTicks = leftTime.Ticks;
                var rightTimeTicks = rightTime.Ticks;
                var xKoefficient = (right - left)/(rightTimeTicks - leftTimeTicks);

                var step = new TimeSpan((rightTimeTicks - leftTimeTicks)/(gridLinesNumber - 1));

                GetDateTimeInterval(step, out intervalType, out interval);
                var currentDateTime = GetStartDateTime(leftTime, intervalType, interval);
                while (currentDateTime <= rightTime)
                {
                    if (currentDateTime >= leftTime)
                    {
                        var xKoordinate = left + (currentDateTime.Ticks - leftTimeTicks)*xKoefficient;
                        markers.Add(new KeyValuePair<double, DateTime>(xKoordinate, currentDateTime));
                    }
                    currentDateTime = AddIntervalToDateTime(currentDateTime, intervalType, interval);
                }
            }
            return markers;
        }
コード例 #36
0
        /// <summary>
        /// Creates the date tick values.
        /// </summary>
        /// <param name="min">
        /// The min.
        /// </param>
        /// <param name="max">
        /// The max.
        /// </param>
        /// <param name="step">
        /// The step.
        /// </param>
        /// <param name="intervalType">
        /// Type of the interval.
        /// </param>
        /// <returns>
        /// Date tick values.
        /// </returns>
        private IList<double> CreateDateTickValues(
            double min, double max, double step, DateTimeIntervalType intervalType)
        {
            DateTime start = ToDateTime(min);
            switch (intervalType)
            {
                case DateTimeIntervalType.Weeks:

                    // make sure the first tick is at the 1st day of a week
                    start = start.AddDays(-(int)start.DayOfWeek + (int)this.FirstDayOfWeek);
                    break;
                case DateTimeIntervalType.Months:

                    // make sure the first tick is at the 1st of a month
                    start = new DateTime(start.Year, start.Month, 1);
                    break;
                case DateTimeIntervalType.Years:

                    // make sure the first tick is at Jan 1st
                    start = new DateTime(start.Year, 1, 1);
                    break;
            }

            // Adds a tick to the end time to make sure the end DateTime is included.
            DateTime end = ToDateTime(max).AddTicks(1);

            DateTime current = start;
            var values = new Collection<double>();
            double eps = step * 1e-3;
            DateTime minDateTime = ToDateTime(min - eps);
            DateTime maxDateTime = ToDateTime(max + eps);
            while (current < end)
            {
                if (current > minDateTime && current < maxDateTime)
                {
                    values.Add(ToDouble(current));
                }

                switch (intervalType)
                {
                    case DateTimeIntervalType.Months:
                        current = current.AddMonths((int)Math.Ceiling(step));
                        break;
                    case DateTimeIntervalType.Years:
                        current = current.AddYears((int)Math.Ceiling(step));
                        break;
                    default:
                        current = current.AddDays(step);
                        break;
                }
            }

            return values;
        }
コード例 #37
0
 /// <summary>
 /// Initializes a new instance of the <see cref="DateTimeAxis" /> class.
 /// </summary>
 /// <param name="pos">The position of the axis.</param>
 /// <param name="firstDateTime">The first date/time on the axis.</param>
 /// <param name="lastDateTime">The last date/time on the axis.</param>
 /// <param name="title">The axis title.</param>
 /// <param name="format">The string format for the axis values.</param>
 /// <param name="intervalType">The interval type.</param>
 public DateTimeAxis(
 AxisPosition pos,
 DateTime firstDateTime,
 DateTime lastDateTime,
 string title = null,
 string format = null,
 DateTimeIntervalType intervalType = DateTimeIntervalType.Auto)
     : this(pos, title, format, intervalType)
 {
     this.Minimum = ToDouble(firstDateTime);
     this.Maximum = ToDouble(lastDateTime);
 }
コード例 #38
0
ファイル: TrendViewer.cs プロジェクト: guozanhua/phmi
 private static DateTime GetStartDateTime(DateTime leftDateTime, DateTimeIntervalType intervalType, int interval)
 {
     switch (intervalType)
     {
         case DateTimeIntervalType.Years:
             return new DateTime(
                 leftDateTime.Year,
                 1,
                 1);
         case DateTimeIntervalType.Months:
             return new DateTime(
                 leftDateTime.Year,
                 leftDateTime.Month,
                 1);
         case DateTimeIntervalType.Days:
             return new DateTime(
                 leftDateTime.Year,
                 leftDateTime.Month,
                 leftDateTime.Day);
         case DateTimeIntervalType.Hours:
             return new DateTime(
                 leftDateTime.Year,
                 leftDateTime.Month,
                 leftDateTime.Day,
                 leftDateTime.Hour/interval*interval,
                 0,
                 0);
         case DateTimeIntervalType.Minutes:
             return new DateTime(
                 leftDateTime.Year,
                 leftDateTime.Month,
                 leftDateTime.Day,
                 leftDateTime.Hour,
                 leftDateTime.Minute/interval*interval,
                 0);
         case DateTimeIntervalType.Seconds:
             return new DateTime(
                 leftDateTime.Year,
                 leftDateTime.Month,
                 leftDateTime.Day,
                 leftDateTime.Hour,
                 leftDateTime.Minute,
                 leftDateTime.Second/interval*interval);
         case DateTimeIntervalType.Milliseconds:
             return new DateTime(
                 leftDateTime.Year,
                 leftDateTime.Month,
                 leftDateTime.Day,
                 leftDateTime.Hour,
                 leftDateTime.Minute,
                 leftDateTime.Second,
                 leftDateTime.Millisecond/interval*interval);
         default:
             return leftDateTime;
     }
 }
コード例 #39
0
 /// <summary>
 /// IntervalTypeProperty property changed handler.
 /// </summary>
 /// <param name="oldValue">Old value.</param>
 /// <param name="newValue">New value.</param>        
 protected virtual void OnIntervalTypePropertyChanged(DateTimeIntervalType oldValue, DateTimeIntervalType newValue)
 {
     UpdateFormattedContent();
 }
コード例 #40
0
ファイル: DateTimeAxis.cs プロジェクト: huoxudong125/oxyplot
        /// <summary>
        /// Creates <see cref="DateTime" /> tick values.
        /// </summary>
        /// <param name="min">The min.</param>
        /// <param name="max">The max.</param>
        /// <param name="interval">The interval.</param>
        /// <param name="intervalType">The interval type.</param>
        /// <returns>A list of <see cref="DateTime" /> tick values.</returns>
        private IList<double> CreateDateTimeTickValues(
            double min, double max, double interval, DateTimeIntervalType intervalType)
        {
            // If the step size is more than 7 days (e.g. months or years) we use a specialized tick generation method that adds tick values with uneven spacing...
            if (intervalType > DateTimeIntervalType.Days)
            {
                return this.CreateDateTickValues(min, max, interval, intervalType);
            }

            // For shorter step sizes we use the method from Axis
            return this.CreateTickValues(min, max, interval);
        }
コード例 #41
0
ファイル: DateTimeAxis.cs プロジェクト: saggett/ReligionsTree
        /// <summary>
        /// Returns the actual interval to use to determine which values are 
        /// displayed in the axis.
        /// </summary>
        /// <param name="availableSize">The available size.</param>
        /// <returns>The actual interval to use to determine which values are 
        /// displayed in the axis.
        /// </returns>
        private double CalculateActualInterval(Size availableSize)
        {
            if (Interval != null)
            {
                return Interval.Value;
            }

            Range<DateTime> actualDateTimeRange = ToDateTimeRange(this.ActualRange);

            DateTimeIntervalType intervalType;
            double interval = CalculateDateTimeInterval(actualDateTimeRange.Minimum, actualDateTimeRange.Maximum, out intervalType, availableSize);
            ActualIntervalType = intervalType;
            return interval;
        }
コード例 #42
0
ファイル: TrendViewer.cs プロジェクト: guozanhua/phmi
 private static string GetFirstDateTimeLabelFormat(DateTimeIntervalType intervalType)
 {
     switch (intervalType)
     {
         case DateTimeIntervalType.Years:
             return "yyyy";
         case DateTimeIntervalType.Months:
             return "yyyy";
         case DateTimeIntervalType.Days:
             return "yyyy";
         case DateTimeIntervalType.Hours:
             return "dd.MM.yyyy";
         case DateTimeIntervalType.Minutes:
             return "dd.MM.yyyy";
         case DateTimeIntervalType.Seconds:
             return "dd.MM.yyyy";
         case DateTimeIntervalType.Milliseconds:
             return "dd.MM.yyyy HH:mm";
         default:
             return null;
     }
 }
コード例 #43
0
ファイル: DateTimeAxis.cs プロジェクト: huoxudong125/oxyplot
        /// <summary>
        /// Calculates the actual interval.
        /// </summary>
        /// <param name="availableSize">Size of the available area.</param>
        /// <param name="maxIntervalSize">Maximum length of the intervals.</param>
        /// <returns>The calculate actual interval.</returns>
        protected override double CalculateActualInterval(double availableSize, double maxIntervalSize)
        {
            const double Year = 365.25;
            const double Month = 30.5;
            const double Week = 7;
            const double Day = 1.0;
            const double Hour = Day / 24;
            const double Minute = Hour / 60;
            const double Second = Minute / 60;

            double range = Math.Abs(this.ActualMinimum - this.ActualMaximum);

            var goodIntervals = new[]
                                    {
                                        Second, 2 * Second, 5 * Second, 10 * Second, 30 * Second, Minute, 2 * Minute,
                                        5 * Minute, 10 * Minute, 30 * Minute, Hour, 4 * Hour, 8 * Hour, 12 * Hour, Day,
                                        2 * Day, 5 * Day, Week, 2 * Week, Month, 2 * Month, 3 * Month, 4 * Month,
                                        6 * Month, Year
                                    };

            double interval = goodIntervals[0];

            int maxNumberOfIntervals = Math.Max((int)(availableSize / maxIntervalSize), 2);

            while (true)
            {
                if (range / interval < maxNumberOfIntervals)
                {
                    break;
                }

                double nextInterval = goodIntervals.FirstOrDefault(i => i > interval);
                if (Math.Abs(nextInterval) <= double.Epsilon)
                {
                    nextInterval = interval * 2;
                }

                interval = nextInterval;
            }

            this.actualIntervalType = this.IntervalType;
            this.actualMinorIntervalType = this.MinorIntervalType;

            if (this.IntervalType == DateTimeIntervalType.Auto)
            {
                this.actualIntervalType = DateTimeIntervalType.Seconds;
                if (interval >= 1.0 / 24 / 60)
                {
                    this.actualIntervalType = DateTimeIntervalType.Minutes;
                }

                if (interval >= 1.0 / 24)
                {
                    this.actualIntervalType = DateTimeIntervalType.Hours;
                }

                if (interval >= 1)
                {
                    this.actualIntervalType = DateTimeIntervalType.Days;
                }

                if (interval >= 30)
                {
                    this.actualIntervalType = DateTimeIntervalType.Months;
                }

                if (range >= 365.25)
                {
                    this.actualIntervalType = DateTimeIntervalType.Years;
                }
            }

            if (this.actualIntervalType == DateTimeIntervalType.Months)
            {
                double monthsRange = range / 30.5;
                interval = this.CalculateActualInterval(availableSize, maxIntervalSize, monthsRange);
            }

            if (this.actualIntervalType == DateTimeIntervalType.Years)
            {
                double yearsRange = range / 365.25;
                interval = this.CalculateActualInterval(availableSize, maxIntervalSize, yearsRange);
            }

            if (this.actualMinorIntervalType == DateTimeIntervalType.Auto)
            {
                switch (this.actualIntervalType)
                {
                    case DateTimeIntervalType.Years:
                        this.actualMinorIntervalType = DateTimeIntervalType.Months;
                        break;
                    case DateTimeIntervalType.Months:
                        this.actualMinorIntervalType = DateTimeIntervalType.Days;
                        break;
                    case DateTimeIntervalType.Weeks:
                        this.actualMinorIntervalType = DateTimeIntervalType.Days;
                        break;
                    case DateTimeIntervalType.Days:
                        this.actualMinorIntervalType = DateTimeIntervalType.Hours;
                        break;
                    case DateTimeIntervalType.Hours:
                        this.actualMinorIntervalType = DateTimeIntervalType.Minutes;
                        break;
                    default:
                        this.actualMinorIntervalType = DateTimeIntervalType.Days;
                        break;
                }
            }

            return interval;
        }
コード例 #44
0
ファイル: DateTimeAxis.cs プロジェクト: huoxudong125/oxyplot
        /// <summary>
        /// Creates the date tick values.
        /// </summary>
        /// <param name="min">The min.</param>
        /// <param name="max">The max.</param>
        /// <param name="step">The step.</param>
        /// <param name="intervalType">Type of the interval.</param>
        /// <returns>Date tick values.</returns>
        private IList<double> CreateDateTickValues(
            double min, double max, double step, DateTimeIntervalType intervalType)
        {
            var values = new Collection<double>();
            var start = ToDateTime(min);
            if (start.Ticks == 0)
            {
                // Invalid start time
                return values;
            }

            switch (intervalType)
            {
                case DateTimeIntervalType.Weeks:

                    // make sure the first tick is at the 1st day of a week
                    start = start.AddDays(-(int)start.DayOfWeek + (int)this.FirstDayOfWeek);
                    break;
                case DateTimeIntervalType.Months:

                    // make sure the first tick is at the 1st of a month
                    start = new DateTime(start.Year, start.Month, 1);
                    break;
                case DateTimeIntervalType.Years:

                    // make sure the first tick is at Jan 1st
                    start = new DateTime(start.Year, 1, 1);
                    break;
            }

            // Adds a tick to the end time to make sure the end DateTime is included.
            var end = ToDateTime(max).AddTicks(1);
            if (end.Ticks == 0)
            {
                // Invalid end time
                return values;
            }

            var current = start;
            double eps = step * 1e-3;
            var minDateTime = ToDateTime(min - eps);
            var maxDateTime = ToDateTime(max + eps);

            if (minDateTime.Ticks == 0 || maxDateTime.Ticks == 0)
            {
                // Invalid min/max time
                return values;
            }

            while (current < end)
            {
                if (current > minDateTime && current < maxDateTime)
                {
                    values.Add(ToDouble(current));
                }

                try
                {
                    switch (intervalType)
                    {
                        case DateTimeIntervalType.Months:
                            current = current.AddMonths((int)Math.Ceiling(step));
                            break;
                        case DateTimeIntervalType.Years:
                            current = current.AddYears((int)Math.Ceiling(step));
                            break;
                        default:
                            current = current.AddDays(step);
                            break;
                    }
                }
                catch (ArgumentOutOfRangeException)
                {
                    // AddMonths/AddYears/AddDays can throw an exception
                    // We could test this by comparing to MaxDayValue/MinDayValue, but it is easier to catch the exception...
                    break;
                }
            }

            return values;
        }
コード例 #45
0
 /// <summary>
 /// IntervalTypeProperty property changed handler.
 /// </summary>
 /// <param name="newValue">New value.</param>
 private void OnIntervalTypePropertyChanged(DateTimeIntervalType newValue)
 {
     this.ActualIntervalType = newValue;
     Invalidate();
 }
コード例 #46
0
ファイル: TrendViewer.cs プロジェクト: guozanhua/phmi
 private static void GetDateTimeInterval(TimeSpan step, out DateTimeIntervalType intervalType, out int interval)
 {
     const int daysInYear = 365;
     const int daysInMonth = 31;
     intervalType = DateTimeIntervalType.Years;
     interval = 0;
     if (step.TotalDays >= daysInYear)
     {
         intervalType = DateTimeIntervalType.Years;
         interval = (int) GetNormalValue(step.TotalDays/daysInYear);
     }
     else if (step.TotalDays >= daysInMonth)
     {
         intervalType = DateTimeIntervalType.Months;
         interval = (int) GetNormalValue(step.TotalDays/daysInMonth);
     }
     else if ((int) step.TotalDays > 0)
     {
         intervalType = DateTimeIntervalType.Days;
         interval = (int) GetNormalValue(step.TotalDays);
     }
     else if ((int) step.TotalHours > 0)
     {
         intervalType = DateTimeIntervalType.Hours;
         interval = (int) GetNormalValue(step.TotalHours);
     }
     else if ((int) step.TotalMinutes > 0)
     {
         intervalType = DateTimeIntervalType.Minutes;
         interval = (int) GetNormalValue(step.TotalMinutes);
     }
     else if ((int) step.TotalSeconds > 0)
     {
         intervalType = DateTimeIntervalType.Seconds;
         interval = (int) GetNormalValue(step.TotalSeconds);
     }
     else if ((int) step.TotalMilliseconds > 0)
     {
         intervalType = DateTimeIntervalType.Milliseconds;
         interval = (int) GetNormalValue(step.TotalMilliseconds);
     }
     if (interval == 0)
         interval = 1;
 }
コード例 #47
0
        private double CalculateDateTimeInterval(DateTime minimum, DateTime maximum, out DateTimeIntervalType type, Size availableSize)
        {
            DateTime dateTimeMin = minimum;
            DateTime dateTimeMax = maximum;
            TimeSpan timeSpan = dateTimeMax.Subtract(dateTimeMin);

            // this algorithm is designed to return close to 10 intervals.
            // we need to align the time span for PrefferedNumberOfIntervals
            double maxIntervals = Orientation == AxisOrientation.X ? MaximumAxisIntervalsPer200Pixels * 0.8 : MaximumAxisIntervalsPer200Pixels;
            double rangeMultiplicator = GetLength(availableSize) / (200 * 10 / maxIntervals);
            timeSpan = new TimeSpan((long)((double)timeSpan.Ticks / rangeMultiplicator));

            // Minutes
            double inter = timeSpan.TotalMinutes;

            // For Range less than 60 seconds interval is 5 sec
            if (inter <= 1.0)
            {
                // Milli Seconds
                double milliSeconds = timeSpan.TotalMilliseconds;
                if (milliSeconds <= 10)
                {
                    type = DateTimeIntervalType.Milliseconds;
                    return 1;
                }
                if (milliSeconds <= 50)
                {
                    type = DateTimeIntervalType.Milliseconds;
                    return 4;
                }
                if (milliSeconds <= 200)
                {
                    type = DateTimeIntervalType.Milliseconds;
                    return 20;
                }
                if (milliSeconds <= 500)
                {
                    type = DateTimeIntervalType.Milliseconds;
                    return 50;
                }

                // Seconds
                double seconds = timeSpan.TotalSeconds;

                if (seconds <= 7)
                {
                    type = DateTimeIntervalType.Seconds;
                    return 1;
                }
                else if (seconds <= 15)
                {
                    type = DateTimeIntervalType.Seconds;
                    return 2;
                }
                else if (seconds <= 30)
                {
                    type = DateTimeIntervalType.Seconds;
                    return 5;
                }
                else if (seconds <= 60)
                {
                    type = DateTimeIntervalType.Seconds;
                    return 10;
                }
            }
            else if (inter <= 2.0)
            {
                // For Range less than 120 seconds interval is 10 sec
                type = DateTimeIntervalType.Seconds;
                return 20;
            }
            else if (inter <= 3.0)
            {
                // For Range less than 180 seconds interval is 30 sec
                type = DateTimeIntervalType.Seconds;
                return 30;
            }
            else if (inter <= 10)
            {
                // For Range less than 10 minutes interval is 1 min
                type = DateTimeIntervalType.Minutes;
                return 1;
            }
            else if (inter <= 20)
            {
                // For Range less than 20 minutes interval is 1 min
                type = DateTimeIntervalType.Minutes;
                return 2;
            }
            else if (inter <= 60)
            {
                // For Range less than 60 minutes interval is 5 min
                type = DateTimeIntervalType.Minutes;
                return 5;
            }
            else if (inter <= 120)
            {
                // For Range less than 120 minutes interval is 10 min
                type = DateTimeIntervalType.Minutes;
                return 10;
            }
            else if (inter <= 180)
            {
                // For Range less than 180 minutes interval is 30 min
                type = DateTimeIntervalType.Minutes;
                return 30;
            }
            else if (inter <= 60 * 12)
            {
                // For Range less than 12 hours interval is 1 hour
                type = DateTimeIntervalType.Hours;
                return 1;
            }
            else if (inter <= 60 * 24)
            {
                // For Range less than 24 hours interval is 4 hour
                type = DateTimeIntervalType.Hours;
                return 4;
            }
            else if (inter <= 60 * 24 * 2)
            {
                // For Range less than 2 days interval is 6 hour
                type = DateTimeIntervalType.Hours;
                return 6;
            }
            else if (inter <= 60 * 24 * 3)
            {
                // For Range less than 3 days interval is 12 hour
                type = DateTimeIntervalType.Hours;
                return 12;
            }
            else if (inter <= 60 * 24 * 10)
            {
                // For Range less than 10 days interval is 1 day
                type = DateTimeIntervalType.Days;
                return 1;
            }
            else if (inter <= 60 * 24 * 20)
            {
                // For Range less than 20 days interval is 2 day
                type = DateTimeIntervalType.Days;
                return 2;
            }
            else if (inter <= 60 * 24 * 30)
            {
                // For Range less than 30 days interval is 3 day
                type = DateTimeIntervalType.Days;
                return 3;
            }
            else if (inter <= 60 * 24 * 30.5 * 2)
            {
                // For Range less than 2 months interval is 1 week
                type = DateTimeIntervalType.Weeks;
                return 1;
            }
            else if (inter <= 60 * 24 * 30.5 * 5)
            {
                // For Range less than 5 months interval is 2weeks
                type = DateTimeIntervalType.Weeks;
                return 2;
            }
            else if (inter <= 60 * 24 * 30.5 * 12)
            {
                // For Range less than 12 months interval is 1 month
                type = DateTimeIntervalType.Months;
                return 1;
            }
            else if (inter <= 60 * 24 * 30.5 * 24)
            {
                // For Range less than 24 months interval is 3 month
                type = DateTimeIntervalType.Months;
                return 3;
            }
            else if (inter <= 60 * 24 * 30.5 * 48)
            {
                // For Range less than 48 months interval is 6 months 
                type = DateTimeIntervalType.Months;
                return 6;
            }

            // For Range more than 48 months interval is year 
            type = DateTimeIntervalType.Years;
            double years = inter / 60 / 24 / 365;
            if (years < 5)
            {
                return 1;
            }
            else if (years < 10)
            {
                return 2;
            }

            // Make a correction of the interval
            return Math.Floor(years / 5);
        }
コード例 #48
0
ファイル: AxisScaleView.cs プロジェクト: nobled/mono
		public void Zoom (double viewPosition, double viewSize, DateTimeIntervalType viewSizeType, bool saveState)
		{
			throw new NotImplementedException();
		}
コード例 #49
0
 /// <summary>
 /// Sets interval properties for the axis. 
 /// Note that we use the Axis object's interval properties, and not the properties of its label,
 /// and major tick mark and grid line objects
 /// </summary>
 public void SetAxisInterval(Axis axis, double interval, DateTimeIntervalType intervalType)
 {
     SetAxisInterval(axis, interval, intervalType, 0, DateTimeIntervalType.Auto);
 }
コード例 #50
0
        /// <summary>
        /// Adjusts the beginning of the first interval depending on the type and size.
        /// </summary>
        /// <param name="start">Original start point.</param>
        /// <param name="intervalSize">Interval size.</param>
        /// <param name="type">Type of the interval (Month, Year, ...).</param>
        /// <returns>
        /// Adjusted interval start position.
        /// </returns>
        private static DateTime AlignIntervalStart(DateTime start, double intervalSize, DateTimeIntervalType type)
        {
            // Do not adjust start position for these interval type
            if (type == DateTimeIntervalType.Auto)
            {
                return start;
            }

            // Get the beginning of the interval depending on type
            DateTime newStartDate = start;

            // Adjust the months interval depending on size
            if (intervalSize > 0.0 && intervalSize != 1.0)
            {
                if (type == DateTimeIntervalType.Months && intervalSize <= 12.0 && intervalSize > 1)
                {
                    // Make sure that the beginning is aligned correctly for cases
                    // like quarters and half years
                    DateTime resultDate = newStartDate;
                    DateTime sizeAdjustedDate = new DateTime(newStartDate.Year, 1, 1, 0, 0, 0);
                    while (sizeAdjustedDate < newStartDate)
                    {
                        resultDate = sizeAdjustedDate;
                        sizeAdjustedDate = sizeAdjustedDate.AddMonths((int)intervalSize);
                    }

                    newStartDate = resultDate;
                    return newStartDate;
                }
            }

            // Check interval type
            switch (type)
            {
                case DateTimeIntervalType.Years:
                    int year = (int)((int)(newStartDate.Year / intervalSize) * intervalSize);
                    if (year <= 0)
                    {
                        year = 1;
                    }
                    newStartDate = new DateTime(year, 1, 1, 0, 0, 0);
                    break;

                case DateTimeIntervalType.Months:
                    int month = (int)((int)(newStartDate.Month / intervalSize) * intervalSize);
                    if (month <= 0)
                    {
                        month = 1;
                    }
                    newStartDate = new DateTime(newStartDate.Year, month, 1, 0, 0, 0);
                    break;

                case DateTimeIntervalType.Days:
                    int day = (int)((int)(newStartDate.Day / intervalSize) * intervalSize);
                    if (day <= 0)
                    {
                        day = 1;
                    }
                    newStartDate = new DateTime(newStartDate.Year, newStartDate.Month, day, 0, 0, 0);
                    break;

                case DateTimeIntervalType.Hours:
                    int hour = (int)((int)(newStartDate.Hour / intervalSize) * intervalSize);
                    newStartDate = new DateTime(
                        newStartDate.Year,
                        newStartDate.Month,
                        newStartDate.Day,
                        hour,
                        0,
                        0);
                    break;

                case DateTimeIntervalType.Minutes:
                    int minute = (int)((int)(newStartDate.Minute / intervalSize) * intervalSize);
                    newStartDate = new DateTime(
                        newStartDate.Year,
                        newStartDate.Month,
                        newStartDate.Day,
                        newStartDate.Hour,
                        minute,
                        0);
                    break;

                case DateTimeIntervalType.Seconds:
                    int second = (int)((int)(newStartDate.Second / intervalSize) * intervalSize);
                    newStartDate = new DateTime(
                        newStartDate.Year,
                        newStartDate.Month,
                        newStartDate.Day,
                        newStartDate.Hour,
                        newStartDate.Minute,
                        second,
                        0);
                    break;

                case DateTimeIntervalType.Milliseconds:
                    int milliseconds = (int)((int)(newStartDate.Millisecond / intervalSize) * intervalSize);
                    newStartDate = new DateTime(
                        newStartDate.Year,
                        newStartDate.Month,
                        newStartDate.Day,
                        newStartDate.Hour,
                        newStartDate.Minute,
                        newStartDate.Second,
                        milliseconds);
                    break;

                case DateTimeIntervalType.Weeks:

                    // Elements that have interval set to weeks should be aligned to the 
                    // nearest start of week no matter how many weeks is the interval.
                    newStartDate = new DateTime(
                        newStartDate.Year,
                        newStartDate.Month,
                        newStartDate.Day,
                        0,
                        0,
                        0);

                    newStartDate = newStartDate.AddDays(-((int)newStartDate.DayOfWeek));
                    break;
            }

            return newStartDate;
        }
コード例 #51
0
 /// <summary>
 /// Sets interval properties for the axis. 
 /// Note that we use the Axis object's interval properties, and not the properties of its label,
 /// and major tick mark and grid line objects
 /// </summary>
 public void SetAxisInterval(System.Web.UI.DataVisualization.Charting.Axis axis, double interval, DateTimeIntervalType intervalType)
 {
     SetAxisInterval(axis, interval, intervalType, 0, DateTimeIntervalType.Auto);
 }
コード例 #52
0
ファイル: TrendViewer.cs プロジェクト: guozanhua/phmi
 private static DateTime AddIntervalToDateTime(DateTime dateTime, DateTimeIntervalType intervalType, int interval)
 {
     switch (intervalType)
     {
         case DateTimeIntervalType.Years:
             return dateTime.AddYears(interval);
         case DateTimeIntervalType.Months:
             return dateTime.AddMonths(interval);
         case DateTimeIntervalType.Days:
             return dateTime.AddDays(interval);
         case DateTimeIntervalType.Hours:
             return dateTime.AddHours(interval);
         case DateTimeIntervalType.Minutes:
             return dateTime.AddMinutes(interval);
         case DateTimeIntervalType.Seconds:
             return dateTime.AddSeconds(interval);
         case DateTimeIntervalType.Milliseconds:
             return dateTime.AddMilliseconds(interval);
         default:
             return dateTime.AddYears(1);
     }
 }
コード例 #53
0
        /// <summary>
        /// Returns the actual interval to use to determine which values are 
        /// displayed in the axis.
        /// </summary>
        /// <param name="availableSize">The available size.</param>
        /// <returns>The actual interval to use to determine which values are 
        /// displayed in the axis.
        /// </returns>
        private double CalculateActualInterval(Size availableSize)
        {
            if (Interval != null)
            {
                return Interval.Value;
            }

            DateTimeIntervalType intervalType = new DateTimeIntervalType();
            double interval = CalculateDateTimeInterval(ActualDateTimeRange.Minimum, ActualDateTimeRange.Maximum, out intervalType, availableSize);
            ActualIntervalType = intervalType;
            return interval;
        }