public TableLegendViewModel(
			ICurvePool curvePool,
			IStaticRulerManager staticRulerManager,
			RefRulerColumnCollection refRulerColumnCollection,
			Func<int, RulerColumnCollection> createRulerColumnCollection)
        {
            _curvePool = curvePool;
            // TODO: Wenn sich die Kurven-Daten ändern, müssen die Rulers ebenfalls upgedatet werden

            _curvePool.CurveAdded += CurveAdded;
            _curvePool.CurveRemoved += CurveRemoved;

            _curvePool.Curves
                .OfType<TimeDoubleCurve>()
                .ForEachElement(it => _curves.Add(new TableLegendItemViewModel(it)));

            _staticRulerManager = staticRulerManager;
            _staticRulerManager.RulersChanged += ResetRulerColumns;
            _staticRulerManager.ReferenceRulerChanged += ResetRulerColumns;

            _updateRulerObservable = _updateRulerValuesSubject
                .Sample(TimeSpan.FromMilliseconds(100))
                .ObserveOn(SynchronizationContext.Current)
                .Subscribe(o => UpdateRulerColumns());

            _refRulerColumnCollection = refRulerColumnCollection;
            _createRulerColumnCollection = createRulerColumnCollection;
        }
        public RefRulerColumnInfo(
			IStaticRulerManager staticRulerManager,
			ITable table,
			IColumn column)
        {
            _staticRulerManager = staticRulerManager;
            _table = table;

            _column = column;
            _column.SetIsVisible(false);
            _column.SetHeader("REF");
        }
        public RulerViewModel(
			TimeAxis timeAxis,
			IStaticRulerManager rulerManager,
			int rulerIndex)
        {
            _timeAxis = timeAxis;
            _timeAxis.BoundsChanged += _timeAxis_BoundsChanged;
            _rulerIndex = rulerIndex;

            _rulerManager = rulerManager;
            _rulerManager.ReferenceRulerChanged += _rulerManager_ReferenceRulerChanged;

            DeleteCommand = new RelayCommand(Delete);
            GotoCommand = new RelayCommand(Goto);
        }
        public HStaticRulerControl(
			HStaticRuler staticRuler,
			IStaticRulerManager staticRulerManager,
			IHStaticRulerSurface rulerSurface,
			TimeAxis timeAxis,
			ICurvePool curvePool,
			IOnlineMode onlineMode,
			IDrawingAreaInfo drawingAreaInfo)
        {
            _timeAxis = timeAxis;
            _timeAxis.BoundsChanged += (s, e) =>
                {
                    UpdatePosition();
                    UpdateDiffs();
                };

            _drawingAreaInfo = drawingAreaInfo;
            _drawingAreaInfo.DrawingSizeChanged += (s, e) =>
                {
                    UpdatePosition();
                    UpdateDiffs();
                };

            _staticRuler = staticRuler;
            _staticRuler.PositionUpdated += (s, e) => UpdatePosition();

            _staticRulerManager = staticRulerManager;
            _staticRulerManager.ReferenceRulerChanged += () =>
                {
                    OnPropertyChanged("IsReference");
                    UpdateDiffs();
                };

            _rulerSurface = rulerSurface;

            RemoveCommand = new RelayCommand(Remove);
            SetAsReferenceCommand = new RelayCommand(_staticRuler.ToggleReference);

            _onlineMode = onlineMode;

            _curvePool = curvePool;
            _curvePool.SelectedCurveChanged += (s, e) => UpdateDiffs();

            InitializeComponent();

            _moveHelper = new UiMoveHelper(backgroundGrid, Cursors.ScrollWE, _onlineMode);
            _moveHelper.Moved += moveHelper_Moved;
            _moveHelper.IsCapturedChanged += MenuStateChanged;

            MouseEnter += (s, e) =>
                {
                    MenuStateChanged();
                    UpdateZIndex();
                };
            MouseLeave += (s, e) =>
                {
                    MenuStateChanged();
                    UpdateZIndex();
                };
            menuPopup.MouseEnter += (s, e) => MenuStateChanged();
            menuPopup.MouseLeave += (s, e) => MenuStateChanged();

            UpdatePosition();
            UpdateDiffs();
        }
        public RulerColumnCollection(
			IColumnConfiguration columnConfiguration,
			IStaticRulerManager staticRulerManager,
			ITable table,
			int rulerIndex)
        {
            _columnConfiguration = columnConfiguration;
            _table = table;
            _rulerColumns = new List<RulerColumnInfo>();

            // Value
            _valueColumn = new RulerColumnInfo(
                (curve, ruler) => curve.GetFormattedValue(
                    curve.DataSeries.GetValueAtTime(ruler.Position, GetValueMode.MiddleValue)),
                    //FormatDefinitions.FloatingComma),
                staticRulerManager,
                _table,
                _table.CreateColumn(),
                rulerIndex,
                MlResources.RulerShortText,
                false);
            AddColumn(_valueColumn);

            // Y-Delta
            _yDeltaColumn = new RulerColumnInfo(
                (curve, ruler) => curve.GetFormattedValue(
                    ruler.GetDiff(curve.DataSeries).CompareValue),
                    //FormatDefinitions.FloatingComma),
                staticRulerManager,
                _table,
                _table.CreateColumn(),
                rulerIndex,
                MlResources.DeltaY,
                true);
            AddColumn(_yDeltaColumn);

            // T-Delta
            _tDeltaColumn = new RulerColumnInfo(
                (curve, ruler) => ruler
                    .GetDiff(curve.DataSeries)
                    .TimeDiff.Abs().GetFormattedValue(),
                staticRulerManager,
                _table,
                _table.CreateColumn(),
                rulerIndex,
                MlResources.DeltaT,
                true);
            AddColumn(_tDeltaColumn);

            // Min
            _minColumn = new RulerColumnInfo(
                (curve, ruler) => curve.GetFormattedValue(
                    ruler
                        .GetAggregate(curve.DataSeries, list => list.Select(it => it.Y).MinOrFallback(double.NaN))
                        .CompareValue),
                    //FormatDefinitions.FloatingComma),
                staticRulerManager,
                _table,
                _table.CreateColumn(),
                rulerIndex,
                MlResources.Min,
                true);
            AddColumn(_minColumn);

            // Max
            _maxColumn = new RulerColumnInfo(
                (curve, ruler) => curve.GetFormattedValue(
                    ruler
                        .GetAggregate(curve.DataSeries, list => list.Select(it => it.Y).MaxOrFallback(double.NaN))
                        .CompareValue),
                    //FormatDefinitions.FloatingComma),
                staticRulerManager,
                _table,
                _table.CreateColumn(),
                rulerIndex,
                MlResources.Max,
                true);
            AddColumn(_maxColumn);

            // Avg
            _avgColumn = new RulerColumnInfo(
                (curve, ruler) => curve.GetFormattedValue(
                    ruler
                        .GetAggregate(curve.DataSeries, list => list.Select(it => it.Y).AverageOrFallback(double.NaN))
                        .CompareValue),
                    //FormatDefinitions.FloatingComma),
                staticRulerManager,
                _table,
                _table.CreateColumn(),
                rulerIndex,
                MlResources.Avg,
                true);
            AddColumn(_avgColumn);

            //// Sum
            //_rulerColumns.Add(
            //    new RulerColumnInfo(
            //        (curve, ruler) => ruler
            //            .GetAggregate(curve, Sum)
            //            .CompareValue.GetFormattedValue(FormatDefinitions.FloatingComma),
            //        _staticRulerManager,
            //        i,
            //        dataGrid,
            //        "Σ (minute) " + (i + 1) + "-" + nextRulerLabel));
        }