Beispiel #1
0
        public void updateLineGauge()
        {
            LinearScale linearScale = new LinearScale();

            linearScale.StartValue         = 20;
            linearScale.EndValue           = 100;
            linearScale.MajorIntervalCount = 20;
            //linearScale.MinorIntervalCount = 5;

            LinearScaleLevelBar linearScaleLevelBar = new LinearScaleLevelBar();

            linearScaleLevelBar.Value = 20;

            LinearScaleRange linearScaleRange = new LinearScaleRange();

            linearScaleRange.StartValue = 0;
            linearScaleRange.EndValue   = 100;


            //Add Items
            linearScale.LevelBars.Add(linearScaleLevelBar);
            linearScale.Ranges.Add(linearScaleRange);


            LineGauge.Scales.Add(linearScale);
        }
        void HighRangeIndicatorLeave(object sender, IndicatorLeaveEventArgs e)
        {
            LinearScaleRange range = sender as LinearScaleRange;

            if (range != null)
            {
                pressure = e.NewValue < range.StartValueAbsolute ? PressureState.Normal : PressureState.Undefined;
                UpdateWeatherState();
            }
        }
Beispiel #3
0
        static void AddScaleRanges(LinearScale scale)
        {
            LinearScaleRange range1 = new LinearScaleRange();

            range1.AppearanceRange.ContentBrush = new SolidBrushObject(Color.Green);
            range1.StartValue = 0;
            range1.EndValue   = 20;

            LinearScaleRange range2 = new LinearScaleRange();

            range2.AppearanceRange.ContentBrush = new SolidBrushObject(Color.Yellow);
            range2.StartValue = 20;
            range2.EndValue   = 40;

            LinearScaleRange range3 = new LinearScaleRange();

            range3.AppearanceRange.ContentBrush = new SolidBrushObject(Color.Red);
            range3.StartValue = 40;
            range3.EndValue   = 100;

            scale.Ranges.Clear();
            scale.Ranges.AddRange(new IRange[] { range1, range2, range3 });
        }
        public void BindSummaryData(object dataSource, List <ProjectSummary> statisticNumberList)
        {
            EntityBindingSource.DataSource          = dataSource;
            StatisticNumberBindingSource.DataSource = statisticNumberList;
            if (saleServiceName.DataBindings.Count <= 0)
            {
                saleServiceName.DataBindings.Add(new System.Windows.Forms.Binding("EditValue", this.EntityBindingSource, "SaleService.FullName", true));
            }
            if (ManagerName.DataBindings.Count <= 0)
            {
                ManagerName.DataBindings.Add(new System.Windows.Forms.Binding("EditValue", this.EntityBindingSource, "Manager.FullName", true));
            }
            if (EntityBindingSource.Current == null)
            {
                return;
            }
            var      project       = EntityBindingSource.Current.AsDyanmic();
            DateTime beginDate     = project.ActualStartDate == null ? DateTime.Today : project.ActualStartDate;
            DateTime endDate       = project.PlannedEndDate == null ? DateTime.Today : project.PlannedEndDate;
            DateTime actualEndDate = project.ActualEndDate == null ? DateTime.Today : project.ActualEndDate;
            DateTime currentDate   = DateTime.Today;
            TimeSpan span          = endDate - beginDate;

            if (actualEndDate > endDate)
            {
                span = actualEndDate - beginDate;
            }
            TimeSpan currentSpan = currentDate - beginDate;

            DateLinearScale.MaxValue = span.Days;
            DateLinearScale.Value    = currentSpan.Days;
            DateGauge.Labels[0].Text = "S:" + beginDate.ToShortDateString(); //Properties.Resources.BeginDate
            DateGauge.Labels[1].Text = "E:" + endDate.ToShortDateString();   //Properties.Resources.EndDate
            DateGauge.Labels[3].Text = "A:" + actualEndDate.ToShortDateString();
            if (currentSpan.Days <= span.Days)
            {
                DateGauge.Labels[2].Text = "C:" + currentDate.ToShortDateString();//Properties.Resources.CurrentDate
            }
            else
            {
                DateGauge.Labels[2].Text = string.Empty;
            }
            float positionX = 250;

            if (DateLinearScale.MaxValue > 0)
            {
                float cX = (positionX - DateGauge.Labels[0].Position.X) * (currentSpan.Days / DateLinearScale.MaxValue);
                float eX = (positionX - DateGauge.Labels[0].Position.X) * ((endDate - beginDate).Days / DateLinearScale.MaxValue);
                float aX = (positionX - DateGauge.Labels[0].Position.X) * ((actualEndDate - beginDate).Days / DateLinearScale.MaxValue);
                DateGauge.Labels[1].Position = new PointF2D(eX, DateGauge.Labels[0].Position.Y);
                DateGauge.Labels[2].Position = new PointF2D(cX, DateGauge.Labels[2].Position.Y);
                DateGauge.Labels[3].Position = new PointF2D(aX, DateGauge.Labels[0].Position.Y);
                if (DateGauge.Labels[1].Position.X - DateGauge.Labels[0].Position.X < 40)
                {
                    DateGauge.Labels[1].Position = new PointF2D(eX, DateGauge.Labels[0].Position.Y - 10);
                }
                if (DateGauge.Labels[3].Position.X - DateGauge.Labels[0].Position.X < 40)
                {
                    DateGauge.Labels[3].Position = new PointF2D(aX, DateGauge.Labels[0].Position.Y - 10);
                }
                if (DateGauge.Labels[3].Position.X - DateGauge.Labels[1].Position.X < 40)
                {
                    DateGauge.Labels[3].Position = new PointF2D(aX, DateGauge.Labels[1].Position.Y - 10);
                }
            }

            DateLinearScale.Ranges.Clear();
            string[] rangeColor = { "Green", "Red" };//"GreenYellow", "Yellow",
            for (int rangeIndex = 0; rangeIndex < rangeColor.Length; rangeIndex++)
            {
                LinearScaleRange range = new LinearScaleRange();
                range.ShapeOffset = -5;
                if (actualEndDate > endDate)
                {
                    range.EndValue   = rangeIndex == 0 ? (endDate - beginDate).Days : (actualEndDate - beginDate).Days;
                    range.StartValue = rangeIndex == 0 ? 0 : (endDate - beginDate).Days;
                }
                else
                {
                    range.EndValue   = rangeIndex == 0 ? (actualEndDate - beginDate).Days : (endDate - beginDate).Days;
                    range.StartValue = rangeIndex == 0 ? 0 : (actualEndDate - beginDate).Days;
                }
                range.AppearanceRange.ContentBrush = new DevExpress.XtraGauges.Core.Drawing.SolidBrushObject("Color:" + rangeColor[rangeIndex]);
                DateLinearScale.Ranges.Add(range);
            }

            //
            if (statisticNumberList.Count <= 0)
            {
                return;
            }
            float evaluateExactlyRate = (float)statisticNumberList[0].SumEvaluateExactlyRate * 100;

            arcEvaluateExactlyRate.Ranges[3].EndValue   = 100;
            arcEvaluateExactlyRate.Ranges[4].StartValue = 0;
            arcEvaluateExactlyRate.Ranges[4].EndValue   = 0;
            arcEvaluateExactlyRate.Ranges[5].StartValue = 0;
            arcEvaluateExactlyRate.Ranges[5].EndValue   = 0;
            if (evaluateExactlyRate > 100)
            {
                circularGaugeEvaluateExactlyRate.Scales[0].MaxValue = evaluateExactlyRate > 150 ? 150 : evaluateExactlyRate;
                if (evaluateExactlyRate <= 110)
                {
                    arcEvaluateExactlyRate.Ranges[3].EndValue = evaluateExactlyRate;
                }
                else
                {
                    arcEvaluateExactlyRate.Ranges[3].EndValue   = 110;
                    arcEvaluateExactlyRate.Ranges[4].StartValue = 110;
                    if (evaluateExactlyRate > 110 && evaluateExactlyRate <= 130)
                    {
                        arcEvaluateExactlyRate.Ranges[4].EndValue = evaluateExactlyRate;
                    }
                    else
                    {
                        arcEvaluateExactlyRate.Ranges[4].EndValue   = 130;
                        arcEvaluateExactlyRate.Ranges[5].StartValue = 130;
                    }
                    if (evaluateExactlyRate > 130 && evaluateExactlyRate <= 150)
                    {
                        arcEvaluateExactlyRate.Ranges[5].EndValue = evaluateExactlyRate;
                    }
                }
            }
            else
            {
                circularGaugeEvaluateExactlyRate.Scales[0].MaxValue = 100;
            }

            circularGaugeEvaluateExactlyRate.Scales[0].Value    = evaluateExactlyRate;
            circularGaugeEvaluateExactlyRate.Scales[1].MaxValue = (float)statisticNumberList[0].SumActualWorkHours;

            float inputEffortRate = (float)statisticNumberList[0].SumInputEffortRate * 100;

            arcInputEffortRate.Ranges[3].EndValue   = 100;
            arcInputEffortRate.Ranges[4].StartValue = 0;
            arcInputEffortRate.Ranges[4].EndValue   = 0;
            arcInputEffortRate.Ranges[5].StartValue = 0;
            arcInputEffortRate.Ranges[5].EndValue   = 0;
            if (inputEffortRate > 100)
            {
                circularGaugeInputEffortRate.Scales[0].MaxValue = inputEffortRate > 150 ? 150 : inputEffortRate;
                if (inputEffortRate <= 110)
                {
                    arcInputEffortRate.Ranges[3].EndValue = inputEffortRate;
                }
                else
                {
                    arcInputEffortRate.Ranges[3].EndValue   = 110;
                    arcInputEffortRate.Ranges[4].StartValue = 110;
                    if (inputEffortRate > 110 && inputEffortRate <= 130)
                    {
                        arcInputEffortRate.Ranges[4].EndValue = inputEffortRate;
                    }
                    else
                    {
                        arcInputEffortRate.Ranges[4].EndValue   = 130;
                        arcInputEffortRate.Ranges[5].StartValue = 130;
                    }
                    if (inputEffortRate > 130 && inputEffortRate <= 150)
                    {
                        arcInputEffortRate.Ranges[5].EndValue = inputEffortRate;
                    }
                }
            }
            else
            {
                circularGaugeInputEffortRate.Scales[0].MaxValue = 100;
            }
            circularGaugeInputEffortRate.Scales[0].Value    = inputEffortRate;
            circularGaugeInputEffortRate.Scales[1].MaxValue = (float)statisticNumberList[0].SumActualInput;
        }