public RegisterRangeEditorViewModel(RangeModel originalRangeModel)
        {
            if (originalRangeModel == null)
                throw new ArgumentNullException(nameof(originalRangeModel));

            _originalRangeModel = originalRangeModel;

            _name = originalRangeModel.Name;
            _startingRegisterIndex = originalRangeModel.StartIndex;
            _registerType = originalRangeModel.RegisterType;

            if (originalRangeModel.Fields != null)
            {
                Fields.AddRange(originalRangeModel.Fields.Select(f => new FieldEditorViewModel(f.Clone())));
            }

            OkCommand = new RelayCommand(Ok, CanOk);
            CancelCommand = new RelayCommand(Cancel);

            MoveUpCommand = new RelayCommand(MoveUp, CanMoveUp);
            MoveDownCommand = new RelayCommand(MoveDown, CanMoveDown);
            DeleteCommand = new RelayCommand(Delete, CanDelete);
            MoveToTopCommand = new RelayCommand(MoveToTop, CanMoveToTop);
            MoveToBottomCommand = new RelayCommand(MoveToBottom, CanMoveToBottom);
            InsertAboveCommand = new RelayCommand(InsertAbove, CanInsertAbove);
            InsertBelowCommand = new RelayCommand(InsertBelow, CanInsertBelow);

            _fields.CollectionChanged += FieldsOnCollectionChanged;
        }
        public RegisterRangeViewModel(IModbusAdapterProvider modbusAdapterProvider, RangeModel rangeModel, SlaveViewModel parent, IDirty dirty)
            : base(dirty)
        {
            if (rangeModel == null)
                throw new ArgumentNullException(nameof(rangeModel));

            _parent = parent;
            _dirty = dirty;
            _modbusAdapterProvider = modbusAdapterProvider;

            EditCommand = new RelayCommand(Edit, CanEdit);
            ReadCommand = new RelayCommand(Read, CanRead);
            WriteCommand = new RelayCommand(Write, CanWrite);
            DeleteCommand = new RelayCommand(Delete, CanDelete);

            PopulateFromModel(rangeModel);
        }
        private void AddRegisters()
        {
            var rangeModel = new RangeModel()
            {
                Name = CreateNewRangeName(),
                StartIndex = 1,
                RegisterType = RegisterType.Holding,
                IsExpanded = true
            };

            var rangeEditorViewModel = new RegisterRangeEditorViewModel(rangeModel);

            var dialog = new RegisterRangeEditorView()
            {
                DataContext = rangeEditorViewModel
            };

            if (dialog.ShowDialog() == true)
            {
                var updatedRangeModel = rangeEditorViewModel.GetModel();

                var rangeViewModel = new RegisterRangeViewModel(_modbusAdapterProvider, updatedRangeModel, this, _dirty);

                _ranges.Add(rangeViewModel);

                _dirty.MarkDirtySafe();
            }
        }
        private void PopulateFromModel(RangeModel rangeModel)
        {
            //Set the name
            Name = rangeModel.Name;

            //Ditch the old fields
            _fieldEditors.Clear();

            //Create the fields
            _fields = rangeModel.Fields.Select(f => FieldTypeServiceFactory.GetFieldTypeService(f.FieldType).CreateRuntimeField(f)).ToArray();

            //Set up the field editors
            _fieldEditors.AddRange(_fields.SelectMany(f => f.FieldEditors));

            //Save this
            _rangeModel = rangeModel;

            //To expand or not expand. That is the question. Whether tis nobler to...
            IsExpanded = rangeModel.IsExpanded;
        }