public ContextMenuModel(IScreen owner, string name, string displayName, Bitmap image = null)
 {
     Owner = owner;
     Name = name;
     DisplayName = displayName;
     Image = image;
 }

 /// <summary>
 /// Erzeugt eine neue Instanz eines EdgeMovement-Objekts und initialisiert diese
 /// mit ihrem zugehörigen IGameScreen-Objekt screen, der Spielwelt world und
 /// Objektinformationen info.
 /// </summary>
 public EdgeMovement(IScreen screen, World world, KnotRenderer knotRenderer, Vector3 position)
     : base(screen, DisplayLayer.None)
 {
     Screen = screen;
     World = world;
     KnotRenderer = knotRenderer;
 }

		public UserPreferencesPageViewModel (IScreen hostScreen, UserSettings userSettings)
		{
			HostScreen = hostScreen;

			var tempPrefChanged = this.WhenAnyValue (x => x.TemperaturePreference).StartWith (userSettings.TemperaturePreference);

			tempPrefChanged
				.Subscribe (x => userSettings.TemperaturePreference = x);
			
			tempPrefChanged
				.Select (x => x == TemperatureUnit.Celsius ? "C" : "F")
				.ToProperty (this, vm => vm.TempPreferenceLabel, out _TempPreferenceLabel);



//			var volumePrefChanged = this.WhenAnyValue (x => x.VolumePreference);
			
//			volumePrefChanged
//				.StartWith (userSettings.VolumePreference)
//				.Do (x => System.Diagnostics.Debug.WriteLine ("setting vol pref {0}", x))
//				.Subscribe (x => userSettings.VolumePreference = x);
//
//			var equipLossChanged = this.WhenAnyValue (x => x.EquipmentLossVolume);
//
//			equipLossChanged
//				.StartWith (userSettings.EquipmentLossVolume)
//				.Subscribe (x => userSettings.EquipmentLossVolume = x);
//
//			var trubLossChanged = this.WhenAnyValue (x => x.TrubLossVolume);
//
//			trubLossChanged
//				.StartWith (userSettings.TrubLossVolume)
//				.Subscribe (x => userSettings.TrubLossVolume = x);
		}

        /// <summary>
        /// Erstellt ein neues Informationsobjekt für ein 3D-Modell, das eine Kante darstellt.
        /// [base="pipe1", Angles3.Zero, new Vector3 (10,10,10)]
        /// </summary>
        public Pipe(IScreen screen, IGrid grid, Knot knot, Edge edge, Node node1, Node node2)
            : base(screen: screen)
        {
            UniqueKey = edge.ToString ();

            // Weise Knoten und Kante zu
            Knot = knot;
            Edge = edge;
            Grid = grid;

            // Berechne die beiden Positionen, zwischen denen die Kante gezeichnet wird
            PositionFrom = node1;
            PositionTo = node2;

            // Kanten sind verschiebbar und auswählbar
            IsMovable = true;
            IsSelectable = true;

            // Berechne die Drehung
            Rotation += RotationMap [Edge.Direction];

            // Aktualisiere die Kategorie
            Coloring.OnColorChanged += UpdateCategory;
            IsSingleColored = true;

            incomplete = true;
        }

 public PersonListViewModel(IScreen hostScreen, IPersonRepository personRepository = null)
 {
     HostScreen = hostScreen;
     personRepository = personRepository ?? new PersonRepository();
     Persons = new ReactiveList<PersonItemViewModel>();
     NewPersonCommand = new ReactiveCommand(null);
     NewPersonCommand.RegisterAsyncAction(_ => { }).Subscribe(_ => HostScreen.Router.Navigate.Execute(new PersonAddViewModel(HostScreen)));
     RefreshCommand = new ReactiveCommand(null);
     var refresh = RefreshCommand.RegisterAsync<List<Person>>(_ => Observable.Start(() => personRepository.RetrievePersonsAsync().
                                                                                                           Result));
     refresh.Subscribe(list =>
     {
         using (Persons.SuppressChangeNotifications())
         {
             Persons.Clear();
             Persons.AddRange(personRepository.RetrievePersonsAsync().
                                               Result.Select(d => new PersonItemViewModel(d.FirstName,
                                                                      d.LastName,
                                                                      d.Age)));
         }
     });
     MessageBus.Current.Listen<Person>().
                Subscribe(p =>
                {
                    personRepository.AddPerson(p);
                    RefreshCommand.Execute(null);
                });
 }

        /// <summary>
        /// Erstelle einen neuen TextInputDialog.
        /// </summary>
        public TextInputDialog(IScreen screen, DisplayLayer drawOrder, string title, string text, string inputText)
            : base(screen, drawOrder, title)
        {
            textItem = new TextItem (screen, drawOrder, String.Empty);

            Cancel = (time) => {
                Close (time);
            };
            Submit = (time) => {
                Close (time);
            };

            Bounds.Size = new ScreenPoint (screen, 0.5f, 0.3f);
            // Der Titel-Text ist mittig ausgerichtet
            AlignX = HorizontalAlignment.Center;
            menu = new Menu (Screen, Index + DisplayLayer.Menu);
            menu.Bounds = ContentBounds;
            menu.Bounds.Padding = new ScreenPoint (screen, 0.010f, 0.019f);
            menu.ItemAlignX = HorizontalAlignment.Left;
            menu.ItemAlignY = VerticalAlignment.Center;

            //die Texteingabe
            textInput = new InputItem (Screen, Index + DisplayLayer.MenuItem, text, inputText);
            menu.Add (textInput);
            menu.Add (textItem);
            textInput.IsEnabled = true;
            textInput.IsInputEnabled = true;
            textInput.NameWidth = 0.35f;
            textInput.ValueWidth = 0.65f;

            ValidKeys.AddRange (new Keys[] { Keys.Enter, Keys.Escape });
        }

        public TwoFactorViewModel(IScreen host)
        {
            HostScreen = host;

            var codeHasBeenInput = this.WhenAny(x => x.Code, code => !string.IsNullOrWhiteSpace(code.Value));
            Submit = new ReactiveCommand(codeHasBeenInput);
        }

        public void AddScreen(IScreen screen)
        {
            _screens.Add(screen);

            if (_screens.Count == 1)
                _activeScreen = screen;
        }

        public HomeViewModel(ITelephonyService telephonyService = null, IScreen hostScreen = null)
        {
            TelephonyService = telephonyService ?? Locator.Current.GetService<ITelephonyService>();

            HostScreen = hostScreen ?? Locator.Current.GetService<IScreen>();

            var canComposeSMS = this.WhenAny(x => x.Recipient, x => !string.IsNullOrWhiteSpace(x.Value));
            ComposeSMS = ReactiveCommand.CreateAsyncTask(canComposeSMS,
                async _ => { await TelephonyService.ComposeSMS(Recipient); });
            ComposeSMS.ThrownExceptions.Subscribe(
                ex => UserError.Throw("Does this device have the capability to send SMS?", ex));

            var canComposeEmail = this.WhenAny(x => x.Recipient, x => !string.IsNullOrWhiteSpace(x.Value));
            ComposeEmail = ReactiveCommand.CreateAsyncTask(canComposeEmail, async _ =>
            {
                var email = new Email(Recipient);

                await TelephonyService.ComposeEmail(email);
            });
            ComposeEmail.ThrownExceptions.Subscribe(
                ex => UserError.Throw("The recipient is potentially not a well formed email address.", ex));

            var canMakePhoneCall = this.WhenAny(x => x.Recipient, x => !string.IsNullOrWhiteSpace(x.Value));
            MakePhoneCall = ReactiveCommand.CreateAsyncTask(canMakePhoneCall,
                async _ => { await TelephonyService.MakePhoneCall(Recipient); });
            MakePhoneCall.ThrownExceptions.Subscribe(
                ex => UserError.Throw("Does this device have the capability to make phone calls?", ex));

            var canMakeVideoCall = this.WhenAny(x => x.Recipient, x => !string.IsNullOrWhiteSpace(x.Value));
            MakeVideoCall = ReactiveCommand.CreateAsyncTask(canMakeVideoCall,
                async _ => { await TelephonyService.MakeVideoCall(Recipient); });
            MakeVideoCall.ThrownExceptions.Subscribe(
                ex => UserError.Throw("Does this device have the capability to make video calls?", ex));
        }

        public StoryTellerTabItem(IScreen screen, IEventAggregator events)
        {
            _screen = screen;
            _item = new TabItem();

            Func<Action<IScreenConductor>, Action> sendMessage = a => () => events.SendMessage(a);

            _item.Header = new StackPanel().Horizontal()
                .Configure(x =>
                {
                    x.Height = 25;
                })
                .AddText(screen.Title, x => _label = x)
                .Add(new TabCloser(sendMessage(s => s.Close(screen))));

            _label.VerticalAlignment = VerticalAlignment.Center;
            _label.Margin = new Thickness(0, 0, 5, 0);

            _item.Content = new DockPanel().With(screen.View);
            _item.Tag = screen;

            // Sets up a context menu for each tab in the screen that can capture "Close"
            // messages
            _item.ContextMenu = new ContextMenu().Configure(o =>
            {
                o.AddItem("Close", sendMessage(s => s.Close(screen)));
                o.AddItem("Close All But This", sendMessage(s => s.CloseAllBut(screen)));
                o.AddItem("Close All", sendMessage(s => s.CloseAll()));
            });
        }

 public LoginRouteViewModel(IScreen hostScreen)
 {
     HostScreen = hostScreen;
     var authentication = new Authentication();
     var canLogin = this.WhenAny(x => x.LoginName,
         x => x.Password,
         (l, p) => !String.IsNullOrWhiteSpace(l.Value) && !String.IsNullOrWhiteSpace(p.Value));
     LoginCommand = new ReactiveCommand(canLogin);
     var loggedIn = LoginCommand.RegisterAsync(_ => Observable.Start(() =>
     {
         var authenticationResult = authentication.AuthenticateAsync(LoginName,
             Password).
                                                   Result;
         return authenticationResult == AuthenticationResult.Authenticated
             ? "Přihlášen"
             : "Nepřihlášen";
     }));
     loggedIn.Subscribe(s =>
     {
         if (s == "Přihlášen")
             HostScreen.Router.Navigate.Execute(new PersonListViewModel(HostScreen));
     });
     message = new ObservableAsPropertyHelper<string>(loggedIn,
         s => raisePropertyChanged("Message"));
 }

 /// <summary>
 /// Erzeugt ein neues TextItem-Objekt und initialisiert dieses mit dem zugehörigen IGameScreen-Objekt.
 /// Zudem sind Angabe der Zeichenreihenfolge und der Zeichenkette, die angezeigt wird, für Pflicht.
 /// </summary>
 public TextBox(IScreen screen, DisplayLayer drawOrder, string text)
     : base(screen, drawOrder)
 {
     Text = text;
     State = WidgetState.None;
     spriteBatch = new SpriteBatch (screen.GraphicsDevice);
 }

        public MainViewModel(IScreen screen, ISettingsManager settingsManager, IVersionManager versionManager)
        {
            HostScreen = screen;

            Games = new GamesViewModel(Locator.Current);
            Downloads = new DownloadsViewModel(Locator.Current.GetService<IJobManager>());
            Messsages = new MessagesViewModel(Locator.Current.GetService<IDatabaseManager>(), Locator.Current.GetService<IMessageManager>());
            GotoSettings = ReactiveCommand.CreateAsyncObservable(_ => screen.Router.Navigate.ExecuteAsync(new SettingsViewModel(screen, settingsManager, versionManager, Locator.Current.GetService<IGameManager>())));

            // login status
            settingsManager.WhenAnyValue(sm => sm.AuthenticatedUser)
                .Select(u => u == null ? "Not logged." : $"Logged as {u.Name}")
                .ToProperty(this, x => x.LoginStatus, out _loginStatus);

            // show notice when new version arrives but hide when button was clicked
            versionManager.NewVersionAvailable
                .Where(release => release != null)
                .Subscribe(newRelease => {
                    ShowUpdateNotice = true;
                });
            CloseUpdateNotice.Subscribe(_ => {
                ShowUpdateNotice = false;
            });

            // restart button
            RestartApp.Subscribe(_ => { UpdateManager.RestartApp(); });
        }

 /// <summary>
 /// Gets the fully qualified name of a ViewModel. Just adds the AssemblyQualifiedName to the <see cref="GetViewModelName"/>.
 /// </summary>
 /// <param name="screen">The screen</param>
 /// <param name="targetPostFix">Either <see cref="HomePostFix"/> or <see cref="SinglePostFix"/></param>
 /// <param name="viewModelPostFix">The <see cref="ViewModelPostFix"/></param>
 /// <returns>The fully qualified ViewModel-Name</returns>
 private static string GetQualifiedViewModelName(IScreen screen, string targetPostFix, string viewModelPostFix)
 {
     string qualifiedName = screen.GetType().AssemblyQualifiedName;
     return qualifiedName.Replace(
         screen.GetType().Name,
         GetViewModelName(screen, targetPostFix, viewModelPostFix));
 }

 /// <summary>
 /// Erzeugt ein neues MenuButton-Objekt und initialisiert dieses mit dem zugehörigen IGameScreen-Objekt.
 /// Zudem sind Angabe der Zeichenreihenfolge, einer Zeichenkette für den Namen der Schaltfläche
 /// und der Aktion, welche bei einem Klick ausgeführt wird Pflicht.
 /// </summary>
 public Button(IScreen screen, DisplayLayer drawOrder, string name, Action<GameTime> onClick)
     : base(screen, drawOrder)
 {
     this.name = name;
     OnClick = onClick;
     spriteBatch = new SpriteBatch (screen.GraphicsDevice);
 }

        public ShellViewModel(
            IScreen screen,
            Func<SettingsViewModel> getSettings,
            Func<CheckForUpdatesViewModel> getForegroundUpdater,
            Func<BackgroundUpdaterViewModel> getBackgroundUpdater)
        {
            HostScreen = screen;

            SettingsCommand = new ReactiveAsyncCommand();
            SettingsCommand.RegisterAsyncAction(o => {
                var viewModel = getSettings();
                HostScreen.Navigate(viewModel);
            });

            UpdateBasicsCommand = new ReactiveAsyncCommand();
            UpdateBasicsCommand.RegisterAsyncAction(o => {
                var viewModel = getForegroundUpdater();
                HostScreen.Navigate(viewModel);
            });

            BackgroundUpdaterCommand = new ReactiveAsyncCommand(Observable.Return(false));
            BackgroundUpdaterCommand.RegisterAsyncAction(o => {
                var viewModel = getBackgroundUpdater();
                HostScreen.Navigate(viewModel);
            });
        }

        /// <summary>
        /// Erzeugt ein neues ConfirmDialog-Objekt und initialisiert dieses mit dem zugehörigen IGameScreen-Objekt.
        /// Zudem ist die Angabe der Zeichenreihenfolge Pflicht.
        /// </summary>
        public ComboBox(IScreen screen, DisplayLayer drawOrder, string text)
            : base(screen, drawOrder, String.Empty)
        {
            dropdown = new Menu (screen: screen, drawOrder: Index + DisplayLayer.Menu);
            dropdown.Bounds.Position = ValueBounds.Position;
            dropdown.Bounds.Size = new ScreenPoint (Screen, () => ValueBounds.Size.OnlyX + ValueBounds.Size.OnlyY * 10);
            dropdown.ItemForegroundColor = Design.ComboBoxItemForegroundColorFunc; // (s) => Container.ItemForegroundColor (s);
            dropdown.ItemBackgroundColor = Design.ComboBoxItemBackgroundColorFunc; // (s) => Design.WidgetBackground;
            dropdown.BackgroundColorFunc = (s) => Design.WidgetBackground;
            dropdown.ItemAlignX = HorizontalAlignment.Left;
            dropdown.ItemAlignY = VerticalAlignment.Center;
            dropdown.IsVisible = false;
            dropdownBorder = new Border (
                screen: screen,
                drawOrder: Index + DisplayLayer.Menu,
                widget: dropdown,
                lineWidth: 2,
                padding: 2
            );

            currentValue = new InputItem (screen: screen, drawOrder: Index, text: text, inputText: String.Empty);
            currentValue.Bounds = Bounds;
            currentValue.ForegroundColorFunc = (s) => ForegroundColor;
            currentValue.BackgroundColorFunc = (s) => Color.Transparent;
            currentValue.IsVisible = IsVisible;
            currentValue.IsMouseClickEventEnabled = false;

            ValidKeys.Add (Keys.Escape);
        }

        public BootstrapLoad(Game1 game, IScreen nextScreen, IScreen errorScreen, Action<Action, Action<String>> load)
        {
            Next = nextScreen;
            this.game = game;

            loadingThread = new Thread(a => load(() => complete = true, s => strings.Push(s)));
        }

        public CacheViewModel(IScreen hostScreen, IAppState appState)
        {
            HostScreen = hostScreen;

            appState.WhenAny(x => x.CachePath, x => x.Value)
                .Where(x => !String.IsNullOrWhiteSpace(x))
                .Select(x => (new DirectoryInfo(x)).Name)
                .ToProperty(this, x => x.UrlPathSegment, out _UrlPathSegment);

            Keys = new ReactiveList<string>();
            appState.WhenAny(x => x.CurrentCache, x => x.Value)
                .SelectMany(x => Observable.Start(() => x.GetAllKeys(), RxApp.TaskpoolScheduler))
                .ObserveOn(RxApp.MainThreadScheduler)
                .Subscribe(newKeys => {
                    Keys.Clear();
                    newKeys.ForEach(x => Keys.Add(x));
                });

            FilteredKeys = Keys.CreateDerivedCollection(
                key => key,
                key => FilterText == null || key.IndexOf(FilterText, StringComparison.OrdinalIgnoreCase) > -1,
                signalReset: this.WhenAny(x => x.FilterText, x => x.Value));

            SelectedViewer = "Text";

            this.WhenAny(x => x.SelectedKey, x => x.SelectedViewer, (k, v) => k.Value)
                .Where(x => x != null && SelectedViewer != null)
                .SelectMany(x => appState.CurrentCache.GetAsync(x).Catch(Observable.Return(default(byte[]))))
                .Select(x => createValueViewModel(x, SelectedViewer))
                .LoggedCatch(this, Observable.Return<ICacheValueViewModel>(null))
                .ToProperty(this, x => x.SelectedValue, out _SelectedValue);
        }

        public SearchViewModel(IScreen hostScreen, ILoginMethods loginMethods)
        {
            HostScreen = hostScreen;
            SearchResults = new ReactiveCollection<ISongTileViewModel>();
            var playApi = loginMethods.CurrentAuthenticatedClient;

            if (playApi == null) {
                hostScreen.Router.Navigate.Execute(RxApp.GetService<IWelcomeViewModel>());
                return;
            }

            var canSearch = this.WhenAny(x => x.SearchQuery, x => !String.IsNullOrWhiteSpace(x.Value));
            PerformSearch = new ReactiveAsyncCommand(canSearch);

            this.ObservableForProperty(x => x.SearchQuery)
                .Throttle(TimeSpan.FromMilliseconds(700), RxApp.DeferredScheduler)
                .InvokeCommand(PerformSearch);

            var searchResults = PerformSearch.RegisterAsyncObservable(_ => playApi.Search(SearchQuery));

            SearchResults = searchResults
                .Do(_ => SearchResults.Clear())
                .SelectMany(list => list.ToObservable())
                .LoggedCatch(this, Observable.Empty<Song>())
                .CreateCollection(x => (ISongTileViewModel) new SongTileViewModel(x, playApi));

            PerformSearch.ItemsInflight.StartWith(0)
                .Select(x => x > 0 ? Visibility.Visible : Visibility.Collapsed)
                .ToProperty(this, x => x.SearchBusySpinner);

            PerformSearch.ThrownExceptions.Subscribe(_ => { });

            GoBack = new ReactiveCommand();
            GoBack.InvokeCommand(hostScreen.Router.NavigateBack);
        }