示例#1
0
        internal TouchElementViewModel(TouchElement touch)
        {
            CultureInfo culture = CultureInfo.InvariantCulture;

            CompositeDisposable treeItemDisposable = new CompositeDisposable();
            CompositeDisposable listItemDisposable = new CompositeDisposable();

            LocationX = touch
                        .ToReactivePropertyAsSynchronized(
                x => x.LocationX,
                x => x.ToString(culture),
                x => double.Parse(x, NumberStyles.Float, culture),
                ignoreValidationErrorValue: true
                )
                        .SetValidateNotifyError(x =>
            {
                double result;
                string message;

                Utilities.TryParse(x, NumberRange.Any, out result, out message);

                return(message);
            })
                        .AddTo(disposable);

            LocationY = touch
                        .ToReactivePropertyAsSynchronized(
                x => x.LocationY,
                x => x.ToString(culture),
                x => double.Parse(x, NumberStyles.Float, culture),
                ignoreValidationErrorValue: true
                )
                        .SetValidateNotifyError(x =>
            {
                double result;
                string message;

                Utilities.TryParse(x, NumberRange.Any, out result, out message);

                return(message);
            })
                        .AddTo(disposable);

            SizeX = touch
                    .ToReactivePropertyAsSynchronized(
                x => x.SizeX,
                x => x.ToString(culture),
                x => double.Parse(x, NumberStyles.Float, culture),
                ignoreValidationErrorValue: true
                )
                    .SetValidateNotifyError(x =>
            {
                double result;
                string message;

                Utilities.TryParse(x, NumberRange.NonNegative, out result, out message);

                return(message);
            })
                    .AddTo(disposable);

            SizeY = touch
                    .ToReactivePropertyAsSynchronized(
                x => x.SizeY,
                x => x.ToString(culture),
                x => double.Parse(x, NumberStyles.Float, culture),
                ignoreValidationErrorValue: true
                )
                    .SetValidateNotifyError(x =>
            {
                double result;
                string message;

                Utilities.TryParse(x, NumberRange.NonNegative, out result, out message);

                return(message);
            })
                    .AddTo(disposable);

            JumpScreen = touch
                         .ToReactivePropertyAsSynchronized(x => x.JumpScreen)
                         .AddTo(disposable);

            SoundEntries = touch.SoundEntries
                           .ToReadOnlyReactiveCollection(x => new SoundEntryViewModel(x))
                           .AddTo(disposable);

            CommandEntries = touch.CommandEntries
                             .ToReadOnlyReactiveCollection(x => new CommandEntryViewModel(x))
                             .AddTo(disposable);

            Layer = touch
                    .ToReactivePropertyAsSynchronized(x => x.Layer)
                    .AddTo(disposable);

            TreeItem = touch
                       .ObserveProperty(x => x.TreeItem)
                       .Do(_ => TreeItem?.Value.Dispose())
                       .Select(x => new TreeViewItemViewModel(x))
                       .ToReactiveProperty()
                       .AddTo(disposable);

            TreeItem.Subscribe(x =>
            {
                treeItemDisposable.Dispose();
                treeItemDisposable = new CompositeDisposable();

                x.PropertyChangedAsObservable()
                .ToReadOnlyReactivePropertySlim(mode: ReactivePropertyMode.None)
                .Subscribe(_ => TreeItem.ForceNotify())
                .AddTo(treeItemDisposable);
            })
            .AddTo(disposable);

            SelectedTreeItem = touch
                               .ToReactivePropertyAsSynchronized(
                x => x.SelectedTreeItem,
                x => TreeItem.Value.SearchViewModel(x),
                x => x?.Model
                )
                               .AddTo(disposable);

            ListColumns = touch.ListColumns
                          .ToReadOnlyReactiveCollection(x => new ListViewColumnHeaderViewModel(x))
                          .AddTo(disposable);

            ListItems = touch.ListItems
                        .ToReadOnlyReactiveCollection(x => new ListViewItemViewModel(x))
                        .AddTo(disposable);

            SelectedListItem = touch
                               .ToReactivePropertyAsSynchronized(
                x => x.SelectedListItem,
                x => ListItems.FirstOrDefault(y => y.Model == x),
                x => x?.Model
                )
                               .AddTo(disposable);

            SelectedTreeItem
            .Subscribe(_ =>
            {
                SelectedListItem.Value = null;
                touch.CreateListColumns();
                touch.CreateListItems();
            })
            .AddTo(disposable);

            SelectedListItem
            .Where(x => x != null)
            .Subscribe(x =>
            {
                listItemDisposable.Dispose();
                listItemDisposable = new CompositeDisposable();

                CompositeDisposable tagDisposable = new CompositeDisposable();

                x.Tag
                .OfType <INotifyPropertyChanged>()
                .Subscribe(y =>
                {
                    tagDisposable.Dispose();
                    tagDisposable = new CompositeDisposable();

                    y.PropertyChangedAsObservable()
                    .Subscribe(_ => touch.UpdateListItem(x.Model))
                    .AddTo(tagDisposable);
                })
                .AddTo(listItemDisposable);

                tagDisposable.AddTo(listItemDisposable);
            })
            .AddTo(disposable);

            SelectedSoundEntry = SelectedListItem
                                 .Select(x => x?.Tag.Value as TouchElement.SoundEntry)
                                 .Do(_ => SelectedSoundEntry?.Value?.Dispose())
                                 .Select(x => x != null ? new SoundEntryViewModel(x) : null)
                                 .ToReadOnlyReactivePropertySlim()
                                 .AddTo(disposable);

            SelectedCommandEntry = SelectedListItem
                                   .Select(x => x?.Tag.Value as TouchElement.CommandEntry)
                                   .Do(_ => SelectedCommandEntry?.Value?.Dispose())
                                   .Select(x => x != null ? new CommandEntryViewModel(x) : null)
                                   .ToReadOnlyReactivePropertySlim()
                                   .AddTo(disposable);

            AddSoundEntry = SelectedTreeItem
                            .Select(x => x == TreeItem.Value.Children[0])
                            .ToReactiveCommand()
                            .WithSubscribe(touch.AddSoundEntry)
                            .AddTo(disposable);

            AddCommandEntry = SelectedTreeItem
                              .Select(x => x == TreeItem.Value.Children[1])
                              .ToReactiveCommand()
                              .WithSubscribe(touch.AddCommandEntry)
                              .AddTo(disposable);

            CopySoundEntry = SelectedSoundEntry
                             .Select(x => x != null)
                             .ToReactiveCommand()
                             .WithSubscribe(touch.CopySoundEntry)
                             .AddTo(disposable);

            CopyCommandEntry = SelectedCommandEntry
                               .Select(x => x != null)
                               .ToReactiveCommand()
                               .WithSubscribe(touch.CopyCommandEntry)
                               .AddTo(disposable);

            RemoveSoundEntry = SelectedSoundEntry
                               .Select(x => x != null)
                               .ToReactiveCommand()
                               .WithSubscribe(touch.RemoveSoundEntry)
                               .AddTo(disposable);

            RemoveCommandEntry = SelectedCommandEntry
                                 .Select(x => x != null)
                                 .ToReactiveCommand()
                                 .WithSubscribe(touch.RemoveCommandEntry)
                                 .AddTo(disposable);
        }
示例#2
0
        internal PanelViewModel(Panel panel)
        {
            CompositeDisposable treeItemDisposable = new CompositeDisposable();
            CompositeDisposable listItemDisposable = new CompositeDisposable();

            This = panel
                   .ObserveProperty(x => x.This)
                   .Do(_ => This?.Value.Dispose())
                   .Select(x => new ThisViewModel(x))
                   .ToReadOnlyReactivePropertySlim()
                   .AddTo(disposable);

            TreeItem = panel
                       .ObserveProperty(x => x.TreeItem)
                       .Do(_ => TreeItem?.Value.Dispose())
                       .Select(x => new TreeViewItemViewModel(x))
                       .ToReactiveProperty()
                       .AddTo(disposable);

            TreeItem.Subscribe(x =>
            {
                treeItemDisposable.Dispose();
                treeItemDisposable = new CompositeDisposable();

                x.PropertyChangedAsObservable()
                .ToReadOnlyReactivePropertySlim(mode: ReactivePropertyMode.None)
                .Subscribe(_ => TreeItem.ForceNotify())
                .AddTo(treeItemDisposable);
            })
            .AddTo(disposable);

            SelectedTreeItem = panel
                               .ToReactivePropertyAsSynchronized(
                x => x.SelectedTreeItem,
                x => TreeItem.Value.SearchViewModel(x),
                x => x?.Model
                )
                               .AddTo(disposable);

            ListColumns = panel.ListColumns
                          .ToReadOnlyReactiveCollection(x => new ListViewColumnHeaderViewModel(x))
                          .AddTo(disposable);

            ListItems = panel.ListItems
                        .ToReadOnlyReactiveCollection(x => new ListViewItemViewModel(x))
                        .AddTo(disposable);

            SelectedListItem = panel
                               .ToReactivePropertyAsSynchronized(
                x => x.SelectedListItem,
                x => ListItems.FirstOrDefault(y => y.Model == x),
                x => x?.Model
                )
                               .AddTo(disposable);

            SelectedTreeItem
            .Subscribe(_ =>
            {
                SelectedListItem.Value = null;
                panel.CreateListColumns();
                panel.CreateListItems();
            })
            .AddTo(disposable);

            SelectedListItem
            .Where(x => x != null)
            .Subscribe(x =>
            {
                listItemDisposable.Dispose();
                listItemDisposable = new CompositeDisposable();

                CompositeDisposable tagDisposable = new CompositeDisposable();

                x.Tag
                .OfType <INotifyPropertyChanged>()
                .Subscribe(y =>
                {
                    tagDisposable.Dispose();
                    tagDisposable = new CompositeDisposable();

                    CompositeDisposable subjectDisposable = new CompositeDisposable();

                    y.PropertyChangedAsObservable()
                    .Subscribe(_ => panel.UpdateListItem(x.Model))
                    .AddTo(tagDisposable);

                    Screen screen = y as Screen;
                    PilotLampElement pilotLamp         = y as PilotLampElement;
                    NeedleElement needle               = y as NeedleElement;
                    DigitalNumberElement digitalNumber = y as DigitalNumberElement;
                    DigitalGaugeElement digitalGauge   = y as DigitalGaugeElement;
                    LinearGaugeElement linearGauge     = y as LinearGaugeElement;

                    screen?.ObserveProperty(z => z.Number)
                    .Select(_ => TreeItem.Value.Children[1].Children.FirstOrDefault(z => z.Tag.Value == screen))
                    .Where(z => z != null)
                    .Subscribe(z => panel.RenameScreenTreeItem(z.Model))
                    .AddTo(tagDisposable);

                    pilotLamp?.ObserveProperty(z => z.Subject)
                    .Subscribe(z =>
                    {
                        subjectDisposable.Dispose();
                        subjectDisposable = new CompositeDisposable();

                        z.PropertyChangedAsObservable()
                        .Subscribe(_ => panel.UpdateListItem(x.Model))
                        .AddTo(subjectDisposable);
                    })
                    .AddTo(tagDisposable);

                    needle?.ObserveProperty(z => z.Subject)
                    .Subscribe(z =>
                    {
                        subjectDisposable.Dispose();
                        subjectDisposable = new CompositeDisposable();

                        z.PropertyChangedAsObservable()
                        .Subscribe(_ => panel.UpdateListItem(x.Model))
                        .AddTo(subjectDisposable);
                    })
                    .AddTo(tagDisposable);

                    digitalNumber?.ObserveProperty(z => z.Subject)
                    .Subscribe(z =>
                    {
                        subjectDisposable.Dispose();
                        subjectDisposable = new CompositeDisposable();

                        z.PropertyChangedAsObservable()
                        .Subscribe(_ => panel.UpdateListItem(x.Model))
                        .AddTo(subjectDisposable);
                    })
                    .AddTo(tagDisposable);

                    digitalGauge?.ObserveProperty(z => z.Subject)
                    .Subscribe(z =>
                    {
                        subjectDisposable.Dispose();
                        subjectDisposable = new CompositeDisposable();

                        z.PropertyChangedAsObservable()
                        .Subscribe(_ => panel.UpdateListItem(x.Model))
                        .AddTo(subjectDisposable);
                    })
                    .AddTo(tagDisposable);

                    linearGauge?.ObserveProperty(z => z.Subject)
                    .Subscribe(z =>
                    {
                        subjectDisposable.Dispose();
                        subjectDisposable = new CompositeDisposable();

                        z.PropertyChangedAsObservable()
                        .Subscribe(_ => panel.UpdateListItem(x.Model))
                        .AddTo(subjectDisposable);
                    })
                    .AddTo(tagDisposable);

                    subjectDisposable.AddTo(tagDisposable);
                })
                .AddTo(listItemDisposable);

                tagDisposable.AddTo(listItemDisposable);
            })
            .AddTo(disposable);

            SelectedScreen = SelectedListItem
                             .Select(x => x?.Tag.Value as Screen)
                             .Do(_ => SelectedScreen?.Value?.Dispose())
                             .Select(x => x != null ? new ScreenViewModel(x, panel.Screens.Where(y => y != x)) : null)
                             .ToReadOnlyReactivePropertySlim()
                             .AddTo(disposable);

            SelectedPilotLamp = SelectedListItem
                                .Select(x => x?.Tag.Value as PilotLampElement)
                                .Do(_ => SelectedPilotLamp?.Value?.Dispose())
                                .Select(x => x != null ? new PilotLampElementViewModel(x) : null)
                                .ToReadOnlyReactivePropertySlim()
                                .AddTo(disposable);

            SelectedNeedle = SelectedListItem
                             .Select(x => x?.Tag.Value as NeedleElement)
                             .Do(_ => SelectedNeedle?.Value?.Dispose())
                             .Select(x => x != null ? new NeedleElementViewModel(x) : null)
                             .ToReadOnlyReactivePropertySlim()
                             .AddTo(disposable);

            SelectedDigitalNumber = SelectedListItem
                                    .Select(x => x?.Tag.Value as DigitalNumberElement)
                                    .Do(_ => SelectedDigitalNumber?.Value?.Dispose())
                                    .Select(x => x != null ? new DigitalNumberElementViewModel(x) : null)
                                    .ToReadOnlyReactivePropertySlim()
                                    .AddTo(disposable);

            SelectedDigitalGauge = SelectedListItem
                                   .Select(x => x?.Tag.Value as DigitalGaugeElement)
                                   .Do(_ => SelectedDigitalGauge?.Value?.Dispose())
                                   .Select(x => x != null ? new DigitalGaugeElementViewModel(x) : null)
                                   .ToReadOnlyReactivePropertySlim()
                                   .AddTo(disposable);

            SelectedLinearGauge = SelectedListItem
                                  .Select(x => x?.Tag.Value as LinearGaugeElement)
                                  .Do(_ => SelectedLinearGauge?.Value?.Dispose())
                                  .Select(x => x != null ? new LinearGaugeElementViewModel(x) : null)
                                  .ToReadOnlyReactivePropertySlim()
                                  .AddTo(disposable);

            SelectedTimetable = SelectedListItem
                                .Select(x => x?.Tag.Value as TimetableElement)
                                .Do(_ => SelectedTimetable?.Value?.Dispose())
                                .Select(x => x != null ? new TimetableElementViewModel(x) : null)
                                .ToReadOnlyReactivePropertySlim()
                                .AddTo(disposable);

            SelectedTouch = SelectedListItem
                            .Select(x => x?.Tag.Value as TouchElement)
                            .Do(_ => SelectedTouch?.Value?.Dispose())
                            .Select(x => x != null ? new TouchElementViewModel(x) : null)
                            .ToReadOnlyReactivePropertySlim()
                            .AddTo(disposable);

            AddScreen = SelectedTreeItem
                        .Select(x => x == TreeItem.Value.Children[1])
                        .ToReactiveCommand()
                        .WithSubscribe(panel.AddScreen)
                        .AddTo(disposable);

            AddPilotLamp = SelectedTreeItem
                           .Select(x => TreeItem.Value.Children[1].Children.Any(y => x == y.Children[0].Children[0]) ||
                                   x == TreeItem.Value.Children[2].Children[0])
                           .ToReactiveCommand()
                           .WithSubscribe(panel.AddPilotLamp)
                           .AddTo(disposable);

            AddNeedle = SelectedTreeItem
                        .Select(x => TreeItem.Value.Children[1].Children.Any(y => x == y.Children[0].Children[1]) ||
                                x == TreeItem.Value.Children[2].Children[1])
                        .ToReactiveCommand()
                        .WithSubscribe(panel.AddNeedle)
                        .AddTo(disposable);

            AddDigitalNumber = SelectedTreeItem
                               .Select(x => TreeItem.Value.Children[1].Children.Any(y => x == y.Children[0].Children[2]) ||
                                       x == TreeItem.Value.Children[2].Children[2])
                               .ToReactiveCommand()
                               .WithSubscribe(panel.AddDigitalNumber)
                               .AddTo(disposable);

            AddDigitalGauge = SelectedTreeItem
                              .Select(x => TreeItem.Value.Children[1].Children.Any(y => x == y.Children[0].Children[3]) ||
                                      x == TreeItem.Value.Children[2].Children[3])
                              .ToReactiveCommand()
                              .WithSubscribe(panel.AddDigitalGauge)
                              .AddTo(disposable);

            AddLinearGauge = SelectedTreeItem
                             .Select(x => TreeItem.Value.Children[1].Children.Any(y => x == y.Children[0].Children[4]) ||
                                     x == TreeItem.Value.Children[2].Children[4])
                             .ToReactiveCommand()
                             .WithSubscribe(panel.AddLinearGauge)
                             .AddTo(disposable);

            AddTimetable = SelectedTreeItem
                           .Select(x => TreeItem.Value.Children[1].Children.Any(y => x == y.Children[0].Children[5]) ||
                                   x == TreeItem.Value.Children[2].Children[5])
                           .ToReactiveCommand()
                           .WithSubscribe(panel.AddTimetable)
                           .AddTo(disposable);

            AddTouch = SelectedTreeItem
                       .Select(x => TreeItem.Value.Children[1].Children.Any(y => x == y.Children[1]))
                       .ToReactiveCommand()
                       .WithSubscribe(panel.AddTouch)
                       .AddTo(disposable);

            CopyScreen = SelectedScreen
                         .Select(x => x != null)
                         .ToReactiveCommand()
                         .WithSubscribe(panel.CopyScreen)
                         .AddTo(disposable);

            CopyPilotLamp = SelectedPilotLamp
                            .Select(x => x != null)
                            .ToReactiveCommand()
                            .WithSubscribe(panel.CopyPilotLamp)
                            .AddTo(disposable);

            CopyNeedle = SelectedNeedle
                         .Select(x => x != null)
                         .ToReactiveCommand()
                         .WithSubscribe(panel.CopyNeedle)
                         .AddTo(disposable);

            CopyDigitalNumber = SelectedDigitalNumber
                                .Select(x => x != null)
                                .ToReactiveCommand()
                                .WithSubscribe(panel.CopyDigitalNumber)
                                .AddTo(disposable);

            CopyDigitalGauge = SelectedDigitalGauge
                               .Select(x => x != null)
                               .ToReactiveCommand()
                               .WithSubscribe(panel.CopyDigitalGauge)
                               .AddTo(disposable);

            CopyLinearGauge = SelectedLinearGauge
                              .Select(x => x != null)
                              .ToReactiveCommand()
                              .WithSubscribe(panel.CopyLinearGauge)
                              .AddTo(disposable);

            CopyTimetable = SelectedTimetable
                            .Select(x => x != null)
                            .ToReactiveCommand()
                            .WithSubscribe(panel.CopyTimetable)
                            .AddTo(disposable);

            CopyTouch = SelectedTouch
                        .Select(x => x != null)
                        .ToReactiveCommand()
                        .WithSubscribe(panel.CopyTouch)
                        .AddTo(disposable);

            RemoveScreen = SelectedScreen
                           .Select(x => x != null)
                           .ToReactiveCommand()
                           .WithSubscribe(panel.RemoveScreen)
                           .AddTo(disposable);

            RemovePilotLamp = SelectedPilotLamp
                              .Select(x => x != null)
                              .ToReactiveCommand()
                              .WithSubscribe(panel.RemovePilotLamp)
                              .AddTo(disposable);

            RemoveNeedle = SelectedNeedle
                           .Select(x => x != null)
                           .ToReactiveCommand()
                           .WithSubscribe(panel.RemoveNeedle)
                           .AddTo(disposable);

            RemoveDigitalNumber = SelectedDigitalNumber
                                  .Select(x => x != null)
                                  .ToReactiveCommand()
                                  .WithSubscribe(panel.RemoveDigitalNumber)
                                  .AddTo(disposable);

            RemoveDigitalGauge = SelectedDigitalGauge
                                 .Select(x => x != null)
                                 .ToReactiveCommand()
                                 .WithSubscribe(panel.RemoveDigitalGauge)
                                 .AddTo(disposable);

            RemoveLinearGauge = SelectedLinearGauge
                                .Select(x => x != null)
                                .ToReactiveCommand()
                                .WithSubscribe(panel.RemoveLinearGauge)
                                .AddTo(disposable);

            RemoveTimetable = SelectedTimetable
                              .Select(x => x != null)
                              .ToReactiveCommand()
                              .WithSubscribe(panel.RemoveTimetable)
                              .AddTo(disposable);

            RemoveTouch = SelectedTouch
                          .Select(x => x != null)
                          .ToReactiveCommand()
                          .WithSubscribe(panel.RemoveTouch)
                          .AddTo(disposable);

            treeItemDisposable.AddTo(disposable);
            listItemDisposable.AddTo(disposable);
        }
示例#3
0
        internal SoundViewModel(Sound sound)
        {
            CompositeDisposable treeItemDisposable = new CompositeDisposable();
            CompositeDisposable listItemDisposable = new CompositeDisposable();

            Simulation.TrainManager.TrainManager.RunSounds   = sound.SoundElements.OfType <RunElement>().ToList();
            Simulation.TrainManager.TrainManager.MotorSounds = sound.SoundElements.OfType <MotorElement>().ToList();

            sound.SoundElements
            .ObserveAddChanged()
            .Subscribe(x =>
            {
                RunElement run     = x as RunElement;
                MotorElement motor = x as MotorElement;

                if (run != null)
                {
                    Simulation.TrainManager.TrainManager.RunSounds.Add(run);
                }

                if (motor != null)
                {
                    Simulation.TrainManager.TrainManager.MotorSounds.Add(motor);
                }
            })
            .AddTo(disposable);

            sound.SoundElements
            .ObserveRemoveChanged()
            .Subscribe(x =>
            {
                RunElement run     = x as RunElement;
                MotorElement motor = x as MotorElement;

                if (run != null)
                {
                    Simulation.TrainManager.TrainManager.RunSounds.Remove(run);
                }

                if (motor != null)
                {
                    Simulation.TrainManager.TrainManager.MotorSounds.Remove(motor);
                }
            })
            .AddTo(disposable);

            TreeItem = sound
                       .ObserveProperty(x => x.TreeItem)
                       .Do(_ => TreeItem?.Value.Dispose())
                       .Select(x => new TreeViewItemViewModel(x))
                       .ToReactiveProperty()
                       .AddTo(disposable);

            TreeItem.Subscribe(x =>
            {
                treeItemDisposable.Dispose();
                treeItemDisposable = new CompositeDisposable();

                x.PropertyChangedAsObservable()
                .ToReadOnlyReactivePropertySlim(mode: ReactivePropertyMode.None)
                .Subscribe(_ => TreeItem.ForceNotify())
                .AddTo(treeItemDisposable);
            })
            .AddTo(disposable);

            SelectedTreeItem = sound
                               .ToReactivePropertyAsSynchronized(
                x => x.SelectedTreeItem,
                x => TreeItem.Value.SearchViewModel(x),
                x => x?.Model
                )
                               .AddTo(disposable);

            ListColumns = sound.ListColumns
                          .ToReadOnlyReactiveCollection(x => new ListViewColumnHeaderViewModel(x))
                          .AddTo(disposable);

            ListItems = sound.ListItems
                        .ToReadOnlyReactiveCollection(x => new ListViewItemViewModel(x))
                        .AddTo(disposable);

            SelectedListItem = sound
                               .ToReactivePropertyAsSynchronized(
                x => x.SelectedListItem,
                x => ListItems.FirstOrDefault(y => y.Model == x),
                x => x?.Model
                )
                               .AddTo(disposable);

            SelectedTreeItem
            .Subscribe(_ =>
            {
                SelectedListItem.Value = null;
                sound.CreateListColumns();
                sound.CreateListItems();
            })
            .AddTo(disposable);

            SelectedListItem
            .Where(x => x != null)
            .Subscribe(x =>
            {
                listItemDisposable.Dispose();
                listItemDisposable = new CompositeDisposable();

                CompositeDisposable tagDisposable = new CompositeDisposable();

                x.Tag
                .OfType <INotifyPropertyChanged>()
                .Subscribe(y =>
                {
                    tagDisposable.Dispose();
                    tagDisposable = new CompositeDisposable();

                    y.PropertyChangedAsObservable()
                    .Subscribe(_ => sound.UpdateListItem(x.Model))
                    .AddTo(tagDisposable);
                })
                .AddTo(listItemDisposable);

                tagDisposable.AddTo(listItemDisposable);
            })
            .AddTo(disposable);

            SelectedRun = SelectedListItem
                          .Select(x => x?.Tag.Value as RunElement)
                          .Do(_ => SelectedRun?.Value?.Dispose())
                          .Select(x => x != null ? new RunElementViewModel(x, sound.SoundElements.OfType <RunElement>().Where(y => y != x)) : null)
                          .ToReadOnlyReactivePropertySlim()
                          .AddTo(disposable);

            SelectedFlange = SelectedListItem
                             .Select(x => x?.Tag.Value as FlangeElement)
                             .Do(_ => SelectedFlange?.Value?.Dispose())
                             .Select(x => x != null ? new FlangeElementViewModel(x, sound.SoundElements.OfType <FlangeElement>().Where(y => y != x)) : null)
                             .ToReadOnlyReactivePropertySlim()
                             .AddTo(disposable);

            SelectedMotor = SelectedListItem
                            .Select(x => x?.Tag.Value as MotorElement)
                            .Do(_ => SelectedMotor?.Value?.Dispose())
                            .Select(x => x != null ? new MotorElementViewModel(x, sound.SoundElements.OfType <MotorElement>().Where(y => y != x)) : null)
                            .ToReadOnlyReactivePropertySlim()
                            .AddTo(disposable);

            SelectedFrontSwitch = SelectedListItem
                                  .Select(x => x?.Tag.Value as FrontSwitchElement)
                                  .Do(_ => SelectedFrontSwitch?.Value?.Dispose())
                                  .Select(x => x != null ? new FrontSwitchElementViewModel(x, sound.SoundElements.OfType <FrontSwitchElement>().Where(y => y != x)) : null)
                                  .ToReadOnlyReactivePropertySlim()
                                  .AddTo(disposable);

            SelectedRearSwitch = SelectedListItem
                                 .Select(x => x?.Tag.Value as RearSwitchElement)
                                 .Do(_ => SelectedRearSwitch?.Value?.Dispose())
                                 .Select(x => x != null ? new RearSwitchElementViewModel(x, sound.SoundElements.OfType <RearSwitchElement>().Where(y => y != x)) : null)
                                 .ToReadOnlyReactivePropertySlim()
                                 .AddTo(disposable);

            SelectedBrake = SelectedListItem
                            .Select(x => x?.Tag.Value as BrakeElement)
                            .Do(_ => SelectedBrake?.Value?.Dispose())
                            .Select(x => x != null ? new BrakeElementViewModel(x, sound.SoundElements.OfType <BrakeElement>().Where(y => y != x)) : null)
                            .ToReadOnlyReactivePropertySlim()
                            .AddTo(disposable);

            SelectedCompressor = SelectedListItem
                                 .Select(x => x?.Tag.Value as CompressorElement)
                                 .Do(_ => SelectedCompressor?.Value?.Dispose())
                                 .Select(x => x != null ? new CompressorElementViewModel(x, sound.SoundElements.OfType <CompressorElement>().Where(y => y != x)) : null)
                                 .ToReadOnlyReactivePropertySlim()
                                 .AddTo(disposable);

            SelectedSuspension = SelectedListItem
                                 .Select(x => x?.Tag.Value as SuspensionElement)
                                 .Do(_ => SelectedSuspension?.Value?.Dispose())
                                 .Select(x => x != null ? new SuspensionElementViewModel(x, sound.SoundElements.OfType <SuspensionElement>().Where(y => y != x)) : null)
                                 .ToReadOnlyReactivePropertySlim()
                                 .AddTo(disposable);

            SelectedPrimaryHorn = SelectedListItem
                                  .Select(x => x?.Tag.Value as PrimaryHornElement)
                                  .Do(_ => SelectedPrimaryHorn?.Value?.Dispose())
                                  .Select(x => x != null ? new PrimaryHornElementViewModel(x, sound.SoundElements.OfType <PrimaryHornElement>().Where(y => y != x)) : null)
                                  .ToReadOnlyReactivePropertySlim()
                                  .AddTo(disposable);

            SelectedSecondaryHorn = SelectedListItem
                                    .Select(x => x?.Tag.Value as SecondaryHornElement)
                                    .Do(_ => SelectedSecondaryHorn?.Value?.Dispose())
                                    .Select(x => x != null ? new SecondaryHornElementViewModel(x, sound.SoundElements.OfType <SecondaryHornElement>().Where(y => y != x)) : null)
                                    .ToReadOnlyReactivePropertySlim()
                                    .AddTo(disposable);

            SelectedMusicHorn = SelectedListItem
                                .Select(x => x?.Tag.Value as MusicHornElement)
                                .Do(_ => SelectedMusicHorn?.Value?.Dispose())
                                .Select(x => x != null ? new MusicHornElementViewModel(x, sound.SoundElements.OfType <MusicHornElement>().Where(y => y != x)) : null)
                                .ToReadOnlyReactivePropertySlim()
                                .AddTo(disposable);

            SelectedDoor = SelectedListItem
                           .Select(x => x?.Tag.Value as DoorElement)
                           .Do(_ => SelectedDoor?.Value?.Dispose())
                           .Select(x => x != null ? new DoorElementViewModel(x, sound.SoundElements.OfType <DoorElement>().Where(y => y != x)) : null)
                           .ToReadOnlyReactivePropertySlim()
                           .AddTo(disposable);

            SelectedAts = SelectedListItem
                          .Select(x => x?.Tag.Value as AtsElement)
                          .Do(_ => SelectedAts?.Value?.Dispose())
                          .Select(x => x != null ? new AtsElementViewModel(x, sound.SoundElements.OfType <AtsElement>().Where(y => y != x)) : null)
                          .ToReadOnlyReactivePropertySlim()
                          .AddTo(disposable);

            SelectedBuzzer = SelectedListItem
                             .Select(x => x?.Tag.Value as BuzzerElement)
                             .Do(_ => SelectedBuzzer?.Value?.Dispose())
                             .Select(x => x != null ? new BuzzerElementViewModel(x, sound.SoundElements.OfType <BuzzerElement>().Where(y => y != x)) : null)
                             .ToReadOnlyReactivePropertySlim()
                             .AddTo(disposable);

            SelectedPilotLamp = SelectedListItem
                                .Select(x => x?.Tag.Value as PilotLampElement)
                                .Do(_ => SelectedPilotLamp?.Value?.Dispose())
                                .Select(x => x != null ? new PilotLampElementViewModel(x, sound.SoundElements.OfType <PilotLampElement>().Where(y => y != x)) : null)
                                .ToReadOnlyReactivePropertySlim()
                                .AddTo(disposable);

            SelectedBrakeHandle = SelectedListItem
                                  .Select(x => x?.Tag.Value as BrakeHandleElement)
                                  .Do(_ => SelectedBrakeHandle?.Value?.Dispose())
                                  .Select(x => x != null ? new BrakeHandleElementViewModel(x, sound.SoundElements.OfType <BrakeHandleElement>().Where(y => y != x)) : null)
                                  .ToReadOnlyReactivePropertySlim()
                                  .AddTo(disposable);

            SelectedMasterController = SelectedListItem
                                       .Select(x => x?.Tag.Value as MasterControllerElement)
                                       .Do(_ => SelectedMasterController?.Value?.Dispose())
                                       .Select(x => x != null ? new MasterControllerElementViewModel(x, sound.SoundElements.OfType <MasterControllerElement>().Where(y => y != x)) : null)
                                       .ToReadOnlyReactivePropertySlim()
                                       .AddTo(disposable);

            SelectedReverser = SelectedListItem
                               .Select(x => x?.Tag.Value as ReverserElement)
                               .Do(_ => SelectedReverser?.Value?.Dispose())
                               .Select(x => x != null ? new ReverserElementViewModel(x, sound.SoundElements.OfType <ReverserElement>().Where(y => y != x)) : null)
                               .ToReadOnlyReactivePropertySlim()
                               .AddTo(disposable);

            SelectedBreaker = SelectedListItem
                              .Select(x => x?.Tag.Value as BreakerElement)
                              .Do(_ => SelectedBreaker?.Value?.Dispose())
                              .Select(x => x != null ? new BreakerElementViewModel(x, sound.SoundElements.OfType <BreakerElement>().Where(y => y != x)) : null)
                              .ToReadOnlyReactivePropertySlim()
                              .AddTo(disposable);

            SelectedRequestStop = SelectedListItem
                                  .Select(x => x?.Tag.Value as RequestStopElement)
                                  .Do(_ => SelectedAts?.Value?.Dispose())
                                  .Select(x => x != null ? new RequestStopElementViewModel(x, sound.SoundElements.OfType <RequestStopElement>().Where(y => y != x)) : null)
                                  .ToReadOnlyReactivePropertySlim()
                                  .AddTo(disposable);

            SelectedTouch = SelectedListItem
                            .Select(x => x?.Tag.Value as TouchElement)
                            .Do(_ => SelectedTouch?.Value?.Dispose())
                            .Select(x => x != null ? new TouchElementViewModel(x, sound.SoundElements.OfType <TouchElement>().Where(y => y != x)) : null)
                            .ToReadOnlyReactivePropertySlim()
                            .AddTo(disposable);

            SelectedOthers = SelectedListItem
                             .Select(x => x?.Tag.Value as OthersElement)
                             .Do(_ => SelectedOthers?.Value?.Dispose())
                             .Select(x => x != null ? new OthersElementViewModel(x, sound.SoundElements.OfType <OthersElement>().Where(y => y != x)) : null)
                             .ToReadOnlyReactivePropertySlim()
                             .AddTo(disposable);

            AddRun = SelectedTreeItem
                     .Select(x => x == TreeItem.Value.Children[0])
                     .ToReactiveCommand()
                     .WithSubscribe(sound.AddElement <RunElement>)
                     .AddTo(disposable);

            AddFlange = SelectedTreeItem
                        .Select(x => x == TreeItem.Value.Children[1])
                        .ToReactiveCommand()
                        .WithSubscribe(sound.AddElement <FlangeElement>)
                        .AddTo(disposable);

            AddMotor = SelectedTreeItem
                       .Select(x => x == TreeItem.Value.Children[2])
                       .ToReactiveCommand()
                       .WithSubscribe(sound.AddElement <MotorElement>)
                       .AddTo(disposable);

            AddFrontSwitch = SelectedTreeItem
                             .Select(x => x == TreeItem.Value.Children[3])
                             .ToReactiveCommand()
                             .WithSubscribe(sound.AddElement <FrontSwitchElement>)
                             .AddTo(disposable);

            AddRearSwitch = SelectedTreeItem
                            .Select(x => x == TreeItem.Value.Children[4])
                            .ToReactiveCommand()
                            .WithSubscribe(sound.AddElement <RearSwitchElement>)
                            .AddTo(disposable);

            AddBrake = new[]
            {
                SelectedTreeItem.Select(x => x == TreeItem.Value.Children[5]),
                sound.SoundElements
                .CollectionChangedAsObservable()
                .ToReadOnlyReactivePropertySlim()
                .Select(_ => Enum.GetValues(typeof(BrakeKey))
                        .OfType <BrakeKey>()
                        .Except(sound.SoundElements.OfType <BrakeElement>().Select(y => y.Key))
                        .Any()
                        )
            }
            .CombineLatestValuesAreAllTrue()
            .ToReactiveCommand()
            .WithSubscribe(sound.AddElement <BrakeElement, BrakeKey>)
            .AddTo(disposable);

            AddCompressor = new[]
            {
                SelectedTreeItem.Select(x => x == TreeItem.Value.Children[6]),
                sound.SoundElements
                .CollectionChangedAsObservable()
                .ToReadOnlyReactivePropertySlim()
                .Select(_ => Enum.GetValues(typeof(CompressorKey))
                        .OfType <CompressorKey>()
                        .Except(sound.SoundElements.OfType <CompressorElement>().Select(y => y.Key))
                        .Any()
                        )
            }
            .CombineLatestValuesAreAllTrue()
            .ToReactiveCommand()
            .WithSubscribe(sound.AddElement <CompressorElement, CompressorKey>)
            .AddTo(disposable);

            AddSuspension = new[]
            {
                SelectedTreeItem.Select(x => x == TreeItem.Value.Children[7]),
                sound.SoundElements
                .CollectionChangedAsObservable()
                .ToReadOnlyReactivePropertySlim()
                .Select(_ => Enum.GetValues(typeof(SuspensionKey))
                        .OfType <SuspensionKey>()
                        .Except(sound.SoundElements.OfType <SuspensionElement>().Select(y => y.Key))
                        .Any()
                        )
            }
            .CombineLatestValuesAreAllTrue()
            .ToReactiveCommand()
            .WithSubscribe(sound.AddElement <SuspensionElement, SuspensionKey>)
            .AddTo(disposable);

            AddPrimaryHorn = new[]
            {
                SelectedTreeItem.Select(x => x == TreeItem.Value.Children[8]),
                sound.SoundElements
                .CollectionChangedAsObservable()
                .ToReadOnlyReactivePropertySlim()
                .Select(_ => Enum.GetValues(typeof(HornKey))
                        .OfType <HornKey>()
                        .Except(sound.SoundElements.OfType <PrimaryHornElement>().Select(y => y.Key))
                        .Any()
                        )
            }
            .CombineLatestValuesAreAllTrue()
            .ToReactiveCommand()
            .WithSubscribe(sound.AddElement <PrimaryHornElement, HornKey>)
            .AddTo(disposable);

            AddSecondaryHorn = new[]
            {
                SelectedTreeItem.Select(x => x == TreeItem.Value.Children[9]),
                sound.SoundElements
                .CollectionChangedAsObservable()
                .ToReadOnlyReactivePropertySlim()
                .Select(_ => Enum.GetValues(typeof(HornKey))
                        .OfType <HornKey>()
                        .Except(sound.SoundElements.OfType <SecondaryHornElement>().Select(y => y.Key))
                        .Any()
                        )
            }
            .CombineLatestValuesAreAllTrue()
            .ToReactiveCommand()
            .WithSubscribe(sound.AddElement <SecondaryHornElement, HornKey>)
            .AddTo(disposable);

            AddMusicHorn = new[]
            {
                SelectedTreeItem.Select(x => x == TreeItem.Value.Children[10]),
                sound.SoundElements
                .CollectionChangedAsObservable()
                .ToReadOnlyReactivePropertySlim()
                .Select(_ => Enum.GetValues(typeof(HornKey))
                        .OfType <HornKey>()
                        .Except(sound.SoundElements.OfType <MusicHornElement>().Select(y => y.Key))
                        .Any()
                        )
            }
            .CombineLatestValuesAreAllTrue()
            .ToReactiveCommand()
            .WithSubscribe(sound.AddElement <MusicHornElement, HornKey>)
            .AddTo(disposable);

            AddDoor = new[]
            {
                SelectedTreeItem.Select(x => x == TreeItem.Value.Children[11]),
                sound.SoundElements
                .CollectionChangedAsObservable()
                .ToReadOnlyReactivePropertySlim()
                .Select(_ => Enum.GetValues(typeof(DoorKey))
                        .OfType <DoorKey>()
                        .Except(sound.SoundElements.OfType <DoorElement>().Select(y => y.Key))
                        .Any()
                        )
            }
            .CombineLatestValuesAreAllTrue()
            .ToReactiveCommand()
            .WithSubscribe(sound.AddElement <DoorElement, DoorKey>)
            .AddTo(disposable);

            AddAts = SelectedTreeItem
                     .Select(x => x == TreeItem.Value.Children[12])
                     .ToReactiveCommand()
                     .WithSubscribe(sound.AddElement <AtsElement>)
                     .AddTo(disposable);

            AddBuzzer = new[]
            {
                SelectedTreeItem.Select(x => x == TreeItem.Value.Children[13]),
                sound.SoundElements
                .CollectionChangedAsObservable()
                .ToReadOnlyReactivePropertySlim()
                .Select(_ => Enum.GetValues(typeof(BuzzerKey))
                        .OfType <BuzzerKey>()
                        .Except(sound.SoundElements.OfType <BuzzerElement>().Select(y => y.Key))
                        .Any()
                        )
            }
            .CombineLatestValuesAreAllTrue()
            .ToReactiveCommand()
            .WithSubscribe(sound.AddElement <BuzzerElement, BuzzerKey>)
            .AddTo(disposable);

            AddPilotLamp = new[]
            {
                SelectedTreeItem.Select(x => x == TreeItem.Value.Children[14]),
                sound.SoundElements
                .CollectionChangedAsObservable()
                .ToReadOnlyReactivePropertySlim()
                .Select(_ => Enum.GetValues(typeof(PilotLampKey))
                        .OfType <PilotLampKey>()
                        .Except(sound.SoundElements.OfType <PilotLampElement>().Select(y => y.Key))
                        .Any()
                        )
            }
            .CombineLatestValuesAreAllTrue()
            .ToReactiveCommand()
            .WithSubscribe(sound.AddElement <PilotLampElement, PilotLampKey>)
            .AddTo(disposable);

            AddBrakeHandle = new[]
            {
                SelectedTreeItem.Select(x => x == TreeItem.Value.Children[15]),
                sound.SoundElements
                .CollectionChangedAsObservable()
                .ToReadOnlyReactivePropertySlim()
                .Select(_ => Enum.GetValues(typeof(BrakeHandleKey))
                        .OfType <BrakeHandleKey>()
                        .Except(sound.SoundElements.OfType <BrakeHandleElement>().Select(y => y.Key))
                        .Any()
                        )
            }
            .CombineLatestValuesAreAllTrue()
            .ToReactiveCommand()
            .WithSubscribe(sound.AddElement <BrakeHandleElement, BrakeHandleKey>)
            .AddTo(disposable);

            AddMasterController = new[]
            {
                SelectedTreeItem.Select(x => x == TreeItem.Value.Children[16]),
                sound.SoundElements
                .CollectionChangedAsObservable()
                .ToReadOnlyReactivePropertySlim()
                .Select(_ => Enum.GetValues(typeof(MasterControllerKey))
                        .OfType <MasterControllerKey>()
                        .Except(sound.SoundElements.OfType <MasterControllerElement>().Select(y => y.Key))
                        .Any()
                        )
            }
            .CombineLatestValuesAreAllTrue()
            .ToReactiveCommand()
            .WithSubscribe(sound.AddElement <MasterControllerElement, MasterControllerKey>)
            .AddTo(disposable);

            AddReverser = new[]
            {
                SelectedTreeItem.Select(x => x == TreeItem.Value.Children[17]),
                sound.SoundElements
                .CollectionChangedAsObservable()
                .ToReadOnlyReactivePropertySlim()
                .Select(_ => Enum.GetValues(typeof(ReverserKey))
                        .OfType <ReverserKey>()
                        .Except(sound.SoundElements.OfType <ReverserElement>().Select(y => y.Key))
                        .Any()
                        )
            }
            .CombineLatestValuesAreAllTrue()
            .ToReactiveCommand()
            .WithSubscribe(sound.AddElement <ReverserElement, ReverserKey>)
            .AddTo(disposable);

            AddBreaker = new[]
            {
                SelectedTreeItem.Select(x => x == TreeItem.Value.Children[18]),
                sound.SoundElements
                .CollectionChangedAsObservable()
                .ToReadOnlyReactivePropertySlim()
                .Select(_ => Enum.GetValues(typeof(BreakerKey))
                        .OfType <BreakerKey>()
                        .Except(sound.SoundElements.OfType <BreakerElement>().Select(y => y.Key))
                        .Any()
                        )
            }
            .CombineLatestValuesAreAllTrue()
            .ToReactiveCommand()
            .WithSubscribe(sound.AddElement <BreakerElement, BreakerKey>)
            .AddTo(disposable);

            AddRequestStop = new[]
            {
                SelectedTreeItem.Select(x => x == TreeItem.Value.Children[19]),
                sound.SoundElements
                .CollectionChangedAsObservable()
                .ToReadOnlyReactivePropertySlim()
                .Select(_ => Enum.GetValues(typeof(RequestStopKey))
                        .OfType <RequestStopKey>()
                        .Except(sound.SoundElements.OfType <RequestStopElement>().Select(y => y.Key))
                        .Any()
                        )
            }
            .CombineLatestValuesAreAllTrue()
            .ToReactiveCommand()
            .WithSubscribe(sound.AddElement <RequestStopElement, RequestStopKey>)
            .AddTo(disposable);

            AddTouch = SelectedTreeItem
                       .Select(x => x == TreeItem.Value.Children[20])
                       .ToReactiveCommand()
                       .WithSubscribe(sound.AddElement <TouchElement>)
                       .AddTo(disposable);

            AddOthers = new[]
            {
                SelectedTreeItem.Select(x => x == TreeItem.Value.Children[21]),
                sound.SoundElements
                .CollectionChangedAsObservable()
                .ToReadOnlyReactivePropertySlim()
                .Select(_ => Enum.GetValues(typeof(OthersKey))
                        .OfType <OthersKey>()
                        .Except(sound.SoundElements.OfType <OthersElement>().Select(y => y.Key))
                        .Any()
                        )
            }
            .CombineLatestValuesAreAllTrue()
            .ToReactiveCommand()
            .WithSubscribe(sound.AddElement <OthersElement, OthersKey>)
            .AddTo(disposable);

            RemoveRun = SelectedRun
                        .Select(x => x != null)
                        .ToReactiveCommand()
                        .WithSubscribe(sound.RemoveElement <RunElement>)
                        .AddTo(disposable);

            RemoveFlange = SelectedFlange
                           .Select(x => x != null)
                           .ToReactiveCommand()
                           .WithSubscribe(sound.RemoveElement <FlangeElement>)
                           .AddTo(disposable);

            RemoveMotor = SelectedMotor
                          .Select(x => x != null)
                          .ToReactiveCommand()
                          .WithSubscribe(sound.RemoveElement <MotorElement>)
                          .AddTo(disposable);

            RemoveFrontSwitch = SelectedFrontSwitch
                                .Select(x => x != null)
                                .ToReactiveCommand()
                                .WithSubscribe(sound.RemoveElement <FrontSwitchElement>)
                                .AddTo(disposable);

            RemoveRearSwitch = SelectedRearSwitch
                               .Select(x => x != null)
                               .ToReactiveCommand()
                               .WithSubscribe(sound.RemoveElement <RearSwitchElement>)
                               .AddTo(disposable);

            RemoveBrake = SelectedBrake
                          .Select(x => x != null)
                          .ToReactiveCommand()
                          .WithSubscribe(sound.RemoveElement <BrakeElement>)
                          .AddTo(disposable);

            RemoveCompressor = SelectedCompressor
                               .Select(x => x != null)
                               .ToReactiveCommand()
                               .WithSubscribe(sound.RemoveElement <CompressorElement>)
                               .AddTo(disposable);

            RemoveSuspension = SelectedSuspension
                               .Select(x => x != null)
                               .ToReactiveCommand()
                               .WithSubscribe(sound.RemoveElement <SuspensionElement>)
                               .AddTo(disposable);

            RemovePrimaryHorn = SelectedPrimaryHorn
                                .Select(x => x != null)
                                .ToReactiveCommand()
                                .WithSubscribe(sound.RemoveElement <PrimaryHornElement>)
                                .AddTo(disposable);

            RemoveSecondaryHorn = SelectedSecondaryHorn
                                  .Select(x => x != null)
                                  .ToReactiveCommand()
                                  .WithSubscribe(sound.RemoveElement <SecondaryHornElement>)
                                  .AddTo(disposable);

            RemoveMusicHorn = SelectedMusicHorn
                              .Select(x => x != null)
                              .ToReactiveCommand()
                              .WithSubscribe(sound.RemoveElement <MusicHornElement>)
                              .AddTo(disposable);

            RemoveDoor = SelectedDoor
                         .Select(x => x != null)
                         .ToReactiveCommand()
                         .WithSubscribe(sound.RemoveElement <DoorElement>)
                         .AddTo(disposable);

            RemoveAts = SelectedAts
                        .Select(x => x != null)
                        .ToReactiveCommand()
                        .WithSubscribe(sound.RemoveElement <AtsElement>)
                        .AddTo(disposable);

            RemoveBuzzer = SelectedBuzzer
                           .Select(x => x != null)
                           .ToReactiveCommand()
                           .WithSubscribe(sound.RemoveElement <BuzzerElement>)
                           .AddTo(disposable);

            RemovePilotLamp = SelectedPilotLamp
                              .Select(x => x != null)
                              .ToReactiveCommand()
                              .WithSubscribe(sound.RemoveElement <PilotLampElement>)
                              .AddTo(disposable);

            RemoveBrakeHandle = SelectedBrakeHandle
                                .Select(x => x != null)
                                .ToReactiveCommand()
                                .WithSubscribe(sound.RemoveElement <BrakeHandleElement>)
                                .AddTo(disposable);

            RemoveMasterController = SelectedMasterController
                                     .Select(x => x != null)
                                     .ToReactiveCommand()
                                     .WithSubscribe(sound.RemoveElement <MasterControllerElement>)
                                     .AddTo(disposable);

            RemoveReverser = SelectedReverser
                             .Select(x => x != null)
                             .ToReactiveCommand()
                             .WithSubscribe(sound.RemoveElement <ReverserElement>)
                             .AddTo(disposable);

            RemoveBreaker = SelectedBreaker
                            .Select(x => x != null)
                            .ToReactiveCommand()
                            .WithSubscribe(sound.RemoveElement <BreakerElement>)
                            .AddTo(disposable);

            RemoveRequestStop = SelectedRequestStop
                                .Select(x => x != null)
                                .ToReactiveCommand()
                                .WithSubscribe(sound.RemoveElement <RequestStopElement>)
                                .AddTo(disposable);

            RemoveTouch = SelectedTouch
                          .Select(x => x != null)
                          .ToReactiveCommand()
                          .WithSubscribe(sound.RemoveElement <TouchElement>)
                          .AddTo(disposable);

            RemoveOthers = SelectedOthers
                           .Select(x => x != null)
                           .ToReactiveCommand()
                           .WithSubscribe(sound.RemoveElement <OthersElement>)
                           .AddTo(disposable);

            treeItemDisposable.AddTo(disposable);
            listItemDisposable.AddTo(disposable);
        }