public RecipesViewModel()
        {
            // initialize commands
            m_addNewRecipeCommand = new RelayCommand(AddNewRecipe);
            m_deleteRecipeCommand = new RelayCommand<RecipeDataModel>(DeleteRecipe);
            m_addHopsIngredientToRecipeCommand = new RelayCommand<Hops>(AddHopsIngredient);
            m_addFermentableIngredientToRecipeCommand = new RelayCommand<Fermentable>(AddFermentableIngredient);
            m_changeYeastCommand = new RelayCommand<Yeast>(ChangeYeast);
            m_deleteHopsIngredientCommand = new RelayCommand<IHopsIngredient>(DeleteHopsIngredient);
            m_deleteFermentableIngredientCommand = new RelayCommand<IFermentableIngredient>(DeleteFermentableIngredient);

            // get available ingredients
            List<IngredientTypeBase> allAvailableIngredients = RecipeUtility.GetAvailableIngredients().OrderBy(ingredient => ingredient.Name).ToList();
            m_availableHops = allAvailableIngredients.OfType<Hops>().ToReadOnlyObservableCollection();
            m_availableFermentables = allAvailableIngredients.OfType<Fermentable>().ToReadOnlyObservableCollection();
            m_availableYeasts = allAvailableIngredients.OfType<Yeast>().ToReadOnlyObservableCollection();

            List<Style> beerStyles = RecipeUtility.GetAvailableBeerStyles().OrderBy(style => style.Name).ToList();
            m_availableBeerStyles = beerStyles.ToReadOnlyObservableCollection();
            m_savedRecipes = new ObservableCollection<RecipeDataModel>(RecipeUtility.GetSavedRecipes(beerStyles));

            GetSettings();

            // set the current recipe to the first in the collection
            CurrentRecipe = m_savedRecipes.FirstOrDefault();
        }

 public UserVM(User user, bool innerAvatarOnly)
 {
     Model = user;
       avatar = new AvatarVM(user.Avatar, innerAvatarOnly);
       commands = new ObservableCollection<MenuCommand>();
       Commands = new ReadOnlyObservableCollection<MenuCommand>(commands);
 }

 public UserRateListViewModel(IUserInterop userInterop, IControllerInterop controllerInterop, Dispatcher dispatcher, BaseEntityDTO entity)
     : base(userInterop, controllerInterop, dispatcher)
 {
     this.entity = entity;
     rates = new ObservableCollection<UserRateItemDTO>();
     Rates = new ReadOnlyObservableCollection<UserRateItemDTO>(rates);
 }

 public MainWindowViewModel(
     IAssigmentsCache assigmentsCache, 
     ITagsCache tagsCache,
     IAddAssigmentService addAssigmentService,
     Func<IAssigment, IAssigmentViewModel> assigmentViewModelFactory,
     Func<ITag, ISelectableTagViewModel> tagViewModelFactory)
 {
     ApplicationTitle = "ToDo";
     Assigments = new ReadOnlyObservableCollection<IAssigmentViewModel>(_assigments);
     AvalibleTags = new ReadOnlyObservableCollection<ISelectableTagViewModel>(_avalibleTags);
     AddAssigment = new AddAssigmentCommand(this);
     _addAssigmentService = addAssigmentService;
     _assigmentViewModelFactory = assigmentViewModelFactory;
     _tagViewModelFactory = tagViewModelFactory;
     foreach (var assigment in assigmentsCache.Items)
     {
         _assigments.Add(assigmentViewModelFactory(assigment));
     }
     assigmentsCache.AssimentAdded += OnAssimentAdded;
     foreach (var tag in tagsCache.Items)
     {
         _avalibleTags.Add(_tagViewModelFactory(tag));
     }
     tagsCache.TagAdded += OnTagAdded;
 }

 public void Select_ReadOnlyObservableCollection_InputContentsMatchOutputContents()
 {
     var readOnlySource = new ReadOnlyObservableCollection<Person>(_source);
     ReadOnlyContinuousCollection<Person> output = from person in readOnlySource
                                                   select person;
     Assert.AreEqual(readOnlySource, output);
 }

        public SessionsViewModel()
        {
            r_Sessions = new ObservableCollection<Session>();
            Sessions = new ReadOnlyObservableCollection<Session>(r_Sessions);

            KanColleGame.Current.Proxy.NewSession += r => DispatcherUtil.UIDispatcher.BeginInvoke(new Action<Session>(r_Sessions.Add), r);
        }

        public RecentFilesViewModel(IRecentFileCollection recentFileCollection, ISchedulerProvider schedulerProvider)
        {
            _recentFileCollection = recentFileCollection;
            if (recentFileCollection == null) throw new ArgumentNullException(nameof(recentFileCollection));
            if (schedulerProvider == null) throw new ArgumentNullException(nameof(schedulerProvider));
            
            ReadOnlyObservableCollection<RecentFileProxy> data;
            var recentLoader = recentFileCollection.Items
                .Connect()
                .Transform(rf => new RecentFileProxy(rf, toOpen =>
                                                            {
                                                                _fileOpenRequest.OnNext(new FileInfo(toOpen.Name));
                                                            },
                                                            recentFileCollection.Remove))
                .Sort(SortExpressionComparer<RecentFileProxy>.Descending(proxy => proxy.Timestamp))
                .ObserveOn(schedulerProvider.MainThread)
                .Bind(out data)
                .Subscribe();

            Files = data;

            _cleanUp = Disposable.Create(() =>
            {
                recentLoader.Dispose();
                _fileOpenRequest.OnCompleted();
            }) ;
        }

        private DesktopStartMenuContext()
        {
            IsApplicationActive = true;
            Entries = _programsModel.Entry.Childs;

            SidePanelEntries = new ReadOnlyObservableCollection<StartPanelEntry>(_sidePanelEntries);
        }

 /// <summary>
 /// Initializes a new instance of the FilterRulePanelController class.
 /// </summary>
 public FilterRulePanelController()
 {
     this.filterRulePanelItems = 
         new ObservableCollection<FilterRulePanelItem>();
     this.readOnlyFilterRulePanelItems = 
         new ReadOnlyObservableCollection<FilterRulePanelItem>(this.filterRulePanelItems);
 }

 public StorageServicesAdapter(PortableDevice device)
 {
     this.device = device;
     portableDeviceClass = device.PortableDeviceClass;
     storages = new ObservableCollection<PortableDeviceFunctionalObject>(ExtractStorageServices());
     Storages = new ReadOnlyObservableCollection<PortableDeviceFunctionalObject>(storages);
 }

        /// <summary>
        /// Constuctor.
        /// </summary>
        /// <param name="viewModelStore">The store this view model belongs to.</param>
        /// <param name="modelTreeView">Diagram tree view.</param>
        public SerializationViewModel(ViewModelStore viewModelStore, SerializationModel serializationModel)
            : base(viewModelStore)
        {
            this.allVMs = new ObservableCollection<SerializedDomainModelViewModel>();
            this.serializationModel = serializationModel;
            this.selectedVMS = new Collection<object>();

            this.rootVMs = new ObservableCollection<SerializedDomainModelViewModel>();
            this.rootVMsRO = new ReadOnlyObservableCollection<SerializedDomainModelViewModel>(this.rootVMs);

            this.selectRelationshipCommand = new DelegateCommand(SelectRelationshipCommand_Executed);
            this.moveUpCommand = new DelegateCommand(MoveUpCommand_Executed, MoveUpCommand_CanExecute);
            this.moveDownCommand = new DelegateCommand(MoveDownCommand_Executed, MoveDownCommand_CanExecute);

            if (this.serializationModel.SerializedDomainModel != null)
            {
                this.rootVMs.Add(new SerializedDomainModelViewModel(this.ViewModelStore, this.serializationModel.SerializedDomainModel));
            }
            if (this.serializationModel != null)
            {
                foreach (SerializationClass c in this.serializationModel.Children)
                    if (c is SerializedDomainClass)
                        this.AddChild(c as SerializedDomainClass);

                this.EventManager.GetEvent<ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(SerializationModelHasChildren.DomainClassId),
                    true, this.serializationModel.Id, new System.Action<ElementAddedEventArgs>(OnChildAdded));
                this.EventManager.GetEvent<ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(SerializationModelHasChildren.DomainClassId),
                    true, this.serializationModel.Id, new System.Action<ElementDeletedEventArgs>(OnChildRemoved));
                
            }
        }

        public MiniMapWindow(Route route, Region region)
        {
            InitializeComponent();
            Region = region;

            var waypoints = new List<Waypoint>();
            var connections = new List<Connection>();

            foreach (var conn in route.Path)
            {
                if (conn.Source.Region == region)
                    waypoints.Add(conn.Source);

                if (conn.Target.Region == region)
                    waypoints.Add(conn.Target);

                if (conn.Source.Region == region && conn.Target.Region == region)
                    connections.Add(conn);
            }

            Waypoints = new ReadOnlyObservableCollection<Waypoint>(new ObservableCollection<Waypoint>(waypoints));
            Connections = new ReadOnlyObservableCollection<Connection>(new ObservableCollection<Connection>(connections));

            DataContext = this;
        }

        public MainWindowViewModel() {
            Pokemons = new ReadOnlyObservableCollection<SniperInfoModel>(GlobalVariables.PokemonsInternal);
            SettingsComand = new ActionCommand(ShowSettings);
            StartStopCommand = new ActionCommand(Startstop);
            DebugComand = new ActionCommand(ShowDebug);

            Settings.Default.DebugOutput = "Debug stuff in here!";
            //var poke = new SniperInfo {
            //    Id = PokemonId.Missingno,
            //    Latitude = 45.99999,
            //    Longitude = 66.6677,
            //    ExpirationTimestamp = DateTime.Now
            //};
            //var y = new SniperInfoModel {
            //    Info = poke,
            //    Icon = new BitmapImage(new Uri(Path.Combine(iconPath, $"{(int) poke.Id}.png")))
            //};
            //GlobalVariables.PokemonsInternal.Add(y);

            GlobalSettings.Output = new Output();
            Program p = new Program();
            Thread a = new Thread(p.Start) { IsBackground = true};
            //Start(); p
            a.Start();
        }

 public NotificationInfoContainer(PlatformClient client, bool isReadedItemOnly)
     : base(client)
 {
     _isReadedItemOnly = isReadedItemOnly;
     _notifications = new ObservableCollection<NotificationInfo>();
     Notifications = new ReadOnlyObservableCollection<NotificationInfo>(_notifications);
 }

 public ChatRoom(ChatServerImpl server)
 {
     _server = server;
     _users = new ObservableCollection<IChatUser>();
     Users = new ReadOnlyObservableCollection<IChatUser>(_users);
     RoomId = Guid.NewGuid().ToString("N");
 }

 public Message()
 {
     textCollection = new ObservableCollection<string>();
     keyCollection = new ObservableCollection<KeyPress>();
     Text = new ReadOnlyObservableCollection<string>(textCollection);
     Keys = new ReadOnlyObservableCollection<KeyPress>(keyCollection);
 }

        public SelectProviderPage()
        {
            InitializeComponent();
            DataContext = this;

            readonlyChildren = new ReadOnlyObservableCollection<IWizardPage>(children);

            // Register to self so that we can handler user interactions.
            PropertyChanged += PropertyChangedHandler;

            providerManager = ServiceLocator.Instance.Get<IProviderManager>();
            if (providerManager != null)
            {
                foreach (var guid in providerManager)
                {
                    providers.Add(providerManager.GetInformation(guid));

                    // If any additional page, we shall cache them with the
                    // same index, so make sure the collection matches providers.
                    additionalPages.Add(null);
                }
            }

            LoggerName = "Untitled";
        }

        /// <summary>
        /// Constuctor.
        /// </summary>
        /// <param name="viewModelStore">The store this view model belongs to.</param>
        public MainSurfaceViewModel(ViewModelStore viewModelStore)
            : base(viewModelStore)
        {
            this.rootNodeVMs = new ObservableCollection<ModelContextViewModel>();
            this.rootNodeVMsRO = new ReadOnlyObservableCollection<ModelContextViewModel>(this.rootNodeVMs);

            if (this.ModelData.MetaModel != null)
            {
                foreach (BaseModelContext mc in this.ModelData.MetaModel.ModelContexts)
                    AddModelContext(mc);

                // subscribe
                this.EventManager.GetEvent<ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(MetaModelHasModelContexts.DomainClassId),
                    true, this.ModelData.MetaModel.Id, new Action<ElementAddedEventArgs>(OnModelContextAdded));

                this.EventManager.GetEvent<ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(MetaModelHasModelContexts.DomainClassId),
                    true, this.ModelData.MetaModel.Id, new Action<ElementDeletedEventArgs>(OnModelContextRemoved));

                if (this.ModelContextVMs.Count > 0)
                    this.selectedItem = this.ModelContextVMs[0];
            }


           this.EventManager.GetEvent<SelectionChangedEvent>().Subscribe(new Action<SelectionChangedEventArgs>(OnSelectionChanged));
        }

        /// <summary>
        /// Constructor. This view model constructed with 'bHookUpEvents=true' does react on model changes.
        /// </summary>
        /// <param name="viewModelStore">The store this view model belongs to.</param>
        /// <param name="embeddingDiagramNode">Element represented by this view model.</param>
        public EmbeddingDiagramNodeViewModel(ViewModelStore viewModelStore, EmbeddingDiagramNode embeddingDiagramNode, EmbeddingDiagramNodeViewModel parent)
            : base(viewModelStore, embeddingDiagramNode)
        {
            this.parent = parent;

            this.embeddingNodeVMs = new ObservableCollection<EmbeddingDiagramNodeViewModel>();
            this.embeddingNodeVMsRO = new ReadOnlyObservableCollection<EmbeddingDiagramNodeViewModel>(this.embeddingNodeVMs);

            if (this.EmbeddingDiagramNode != null)
            {
                foreach (EmbeddingDiagramNode node in this.EmbeddingDiagramNode.EmbeddingDiagramNodes)
                    this.AddEmbeddingDiagramNode(node);

                this.EventManager.GetEvent<ModelElementPropertyChangedEvent>().Subscribe(this.EmbeddingDiagramNode.Id, new Action<ElementPropertyChangedEventArgs>(OnElementPropertyChanged));

                this.EventManager.GetEvent<ModelElementLinkAddedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(EmbeddingDiagramNodeHasEmbeddingDiagramNodes.DomainClassId),
                    true, this.EmbeddingDiagramNode.Id, new Action<ElementAddedEventArgs>(OnEmbeddingDiagramNodeAdded));

                this.EventManager.GetEvent<ModelElementLinkDeletedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(EmbeddingDiagramNodeHasEmbeddingDiagramNodes.DomainClassId),
                    true, this.EmbeddingDiagramNode.Id, new Action<ElementDeletedEventArgs>(OnEmbeddingDiagramNodeRemoved));

                this.EventManager.GetEvent<ModelRolePlayerMovedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRelationship(EmbeddingDiagramNodeHasEmbeddingDiagramNodes.DomainClassId),
                    this.EmbeddingDiagramNode.Id, new Action<RolePlayerOrderChangedEventArgs>(OnEmbeddingDiagramNodeMoved));

                this.EventManager.GetEvent<ModelRolePlayerChangedEvent>().Subscribe(this.Store.DomainDataDirectory.GetDomainRole(EmbeddingDiagramNodeHasEmbeddingDiagramNodes.SourceEmbeddingDiagramNodeDomainRoleId),
                    new Action<RolePlayerChangedEventArgs>(OnEmbeddingDiagramNodeChanged));
            }

            expandCollapseTreeCommand = new DelegateCommand(ExpandCollapseTreeCommand_Executed);
        }

        public PersonEntry(ILocationService locationService, IAddress address)
        {
            _locationService = locationService;
            _address = address;

            _roAvailableCountries = new ReadOnlyObservableCollection<ICountry>(_availableCountries);
        }