public PublicRoomsPage(ViewModelBase viewModel)
            : base(viewModel)
        {
            var listView = new BindableListView
                {
                    ItemTemplate = new DataTemplate(() =>
                        {
                        var textCell = new TextCell();
                            textCell.SetBinding(TextCell.TextProperty, new Binding("Name"));
                            textCell.TextColor = Styling.BlackText;
                            //textCell.SetBinding(TextCell.DetailProperty, new Binding("Description"));
                            return textCell;
                        }),
                    SeparatorVisibility = SeparatorVisibility.None
                };

            listView.SetBinding(ListView.ItemsSourceProperty, new Binding("PublicRooms"));
            listView.SetBinding(BindableListView.ItemClickedCommandProperty, new Binding("SelectRoomCommand"));

            var loadingIndicator = new ActivityIndicator ();
            loadingIndicator.SetBinding(ActivityIndicator.IsRunningProperty, new Binding("IsBusy"));
            loadingIndicator.SetBinding(ActivityIndicator.IsVisibleProperty, new Binding("IsBusy"));

            Content = new StackLayout
            {
                Children =
                        {
                            loadingIndicator,
                            listView
                        }
            };
        }

        Window CreateWindow(ViewModelBase viewModel)
        {
            Type windowType;
            lock (_viewMap)
            {
                if (!_viewMap.ContainsKey(viewModel.GetType()))
                    throw new ArgumentException("viewModel not registered");
                windowType = _viewMap[viewModel.GetType()];
            }

            var window = (Window)Activator.CreateInstance(windowType);
            window.DataContext = viewModel;
            window.Closed += OnClosed;

            lock (_openedWindows)
            {
                // Last window opened is considered the 'owner' of the window.
                // May not be 100% correct in some situations but it is more
                // then good enough for handling dialog windows
                if (_openedWindows.Count > 0)
                {
                    Window lastOpened = _openedWindows[_openedWindows.Count - 1];

                    if (window != lastOpened)
                        window.Owner = lastOpened;
                }

                _openedWindows.Add(window);
            }

            // Listen for the close event
            Messenger.Default.Register<RequestCloseMessage>(window, viewModel, OnRequestClose);

            return window;
        }

        public bool ShowViewModel(string title, ViewModelBase viewModel)
        {
            var win = new DialogWindow(viewModel) {Title = title};
            win.ShowDialog();

            return win.CloseResult;
        }

        public EquipmentRightViewModel(ViewModelBase parent)
        {
            Parent = parent;

            Label11 = "Asset ID:";
            Label21 = "Fed Form:";
            Label12 = "Equipment Type:";
            Label22 = "Rated Voltage:";
            Label13 = "Location:";
            Label23 = "Problem?:";

            Equipment equipment = ((EquipmentViewModel)Parent).SelectedEquipment;

            TextBox11 = equipment.Asset_ID;
            //TextBox21 = equipment.f;
            TextBox12 = equipment.EquipmentTypeID.ToString();
            //TextBox22 = equipment;
            TextBox13 = equipment.LocationID.ToString();
            //TextBox23 = equipment;

            SetTab1Page();
            SetTab2Page();
            SetTab3Page();
            SetTab4Page();
            SetTab5Page();
            SetTab6Page();
            SetTab7Page();
            SetTab8Page();
        }

        public static async Task<ViewModelBase> Next(LinkViewModel parentLink, ViewModelBase currentActual)
        {
            if (parentLink != null)
            {
                var viewModelContextService = ServiceLocator.Current.GetInstance<IViewModelContextService>();
                var firstRedditViewModel = viewModelContextService.ContextStack.FirstOrDefault(context => context is RedditViewModel) as RedditViewModel;
                if (firstRedditViewModel != null)
                {
                    RepositionContextScroll(parentLink);

                    var imagesService = ServiceLocator.Current.GetInstance<IImagesService>();
                    var offlineService = ServiceLocator.Current.GetInstance<IOfflineService>();
                    var settingsService = ServiceLocator.Current.GetInstance<ISettingsService>();
                    ViewModelBase stackNext = null;
                    if (settingsService.OnlyFlipViewUnread && (stackNext = LinkHistory.Forward()) != null)
                    {
                        return stackNext;
                    }
                    else
                    {
                        var currentLinkPos = firstRedditViewModel.Links.IndexOf(parentLink);
                        var linksEnumerator = new NeverEndingRedditView(firstRedditViewModel, currentLinkPos, true);
                        var result = await MakeContextedTuple(imagesService, offlineService, settingsService, linksEnumerator);
                        LinkHistory.Push(currentActual);
                        return result;
                    }
                }
            }
            return null;
        }

        PivotItem MapViewModel(ViewModelBase viewModel)
        {
            var rvm = viewModel as RedditViewModel;

            var plainHeader = rvm.Heading == "The front page of this device" ? "front page" : rvm.Heading.ToLower();
            return new PivotItem { DataContext = viewModel, Header = rvm.IsTemporary ? "*" + plainHeader : plainHeader };
        }

        public void GotoReplyToPost(ViewModelBase currentContext, CommentsViewModel source)
        {

			source.CurrentlyFocused = source.AddReplyComment(null);
			Messenger.Default.Send<FocusChangedMessage>(new FocusChangedMessage(source));
			
        }

        /// <summary>
        /// Executes business logic to determine if an instance of the application should prompt the user to solicit user ratings.
        /// If it determines it should, the dialog to solicit ratings will be displayed.
        /// </summary>
        /// <returns>Awaitable task is returned.</returns>
        public async Task CheckForRatingsPromptAsync(ViewModelBase vm)
        {
            bool showPrompt = false;

            // PLACE YOUR CUSTOM RATE PROMPT LOGIC HERE!
            this.LastPromptedForRating = Platform.Current.Storage.LoadSetting<DateTime>(LAST_PROMPTED_FOR_RATING);

            // If trial, not expired, and less than 2 days away from expiring, set as TRUE
            bool preTrialExpiredBasedPrompt = 
                Platform.Current.AppInfo.IsTrial 
                && !Platform.Current.AppInfo.IsTrialExpired 
                && DateTime.Now.AddDays(2) > Platform.Current.AppInfo.TrialExpirationDate;

            if (preTrialExpiredBasedPrompt && this.LastPromptedForRating == DateTime.MinValue)
            {
                showPrompt = true;
            }
            else if (this.LastPromptedForRating != DateTime.MinValue && this.LastPromptedForRating.AddDays(21) < DateTime.Now)
            {
                // Every X days after the last prompt, set as TRUE
                showPrompt = true;
            }
            else if(this.LastPromptedForRating == DateTime.MinValue && Windows.ApplicationModel.Package.Current.InstalledDate.DateTime.AddDays(3) < DateTime.Now)
            {
                // First time prompt X days after initial install
                showPrompt = true;
            }

            if(showPrompt)
                await this.PromptForRatingAsync(vm);
        }

 public PageNavigationMessage(ViewModelBase bindingViewModel, NavigationKind kind)
 {
     this.BindingViewModel = bindingViewModel;
     if (kind == NavigationKind.Navigate)
         throw new ArgumentException("Navigate は Pageを含むコンストラクタが必要です。");
     this.Kind = kind;
 }

 public MvvmableContentPage(ViewModelBase viewModel)
 {
     _viewModel = viewModel;
     BindingContext = viewModel;
     Title = "SharedSquawk";
     BackgroundColor = Styling.BackgroundColor;
 }

        public WebViewBridge(IWebView webView, ViewModelBase viewModel)
        {
            _webView = webView;
            _bridge = new Bridge(viewModel, this);

            _webView.NativeViewInitialized += (sender, args) => _webView.DocumentReady += (sender2, args2) => Initialize();
        }

        public static void ProvideView(ViewModelBase vm, ViewModelBase parentVm = null)
        {
            IViewMap map = Maps.SingleOrDefault(x => x.ViewModelType == vm.GetType());

            if (map == null)
                return;

            var viewInstance = Activator.CreateInstance(map.ViewType) as Window;

            if (viewInstance == null)
                throw new InvalidOperationException(string.Format("Can not create an instance of {0}", map.ViewType));

            if (parentVm != null)
            {
                ViewInstance parent = RegisteredViews.SingleOrDefault(x => x.ViewModel == parentVm);

                if (parent != null)
                {
                    Window parentView = parent.View;

                    if (Application.Current.Windows.OfType<Window>().Any(x => Equals(x, parentView)))
                        viewInstance.Owner = parentView;
                }
            }

            viewInstance.DataContext = vm;

            RegisteredViews.Add(new ViewInstance(viewInstance, vm));

            viewInstance.Show();
        }

        public bool Show(ViewModelBase viewModel, int windowHeight = 600, int windowWidth = 860)
        {
            if(_window == null)
                _window = new WindowView();

            var refreashable = viewModel as IRefreashable;
            if (refreashable != null)
                refreashable.Refreash();

            if (_window.DataContext != null && _window.DataContext.Equals(viewModel))
            {
                return false;
            }

            if(_window.IsVisible)
            {
                _window.Focus();
                return false;
            }

            _window.Height = windowHeight;
            _window.Width = windowWidth;
            _window.Title = viewModel.ToString();
            _window.DataContext = viewModel;

            var result = _window.ShowDialog();

            _window = null;

            return result == true;
        }

        public void ApplyTo(ViewModelBase viewModel)
        {
            var dynamicObject = new DynamicObject(viewModel);

            var commands = dynamicObject.GetProperties().Where(p => p.PropertyType == typeof (DelegateCommand));

            foreach (var c in commands)
            {
                var command = c;
                var executeMethodName = string.Format("On{0}", command.Name);
                var canExecuteMethodName = string.Format("Can{0}", command.Name);

                var delegateCommand = command.GetValue(viewModel, null) as DelegateCommand;

                if (delegateCommand != null)
                {
                    if (dynamicObject.MethodExist(executeMethodName))
                    {
                        delegateCommand.ExecuteDelegate = () =>
                        {
                            dynamicObject.InvokeMethod(executeMethodName);
                        };
                    }

                    if (dynamicObject.MethodExist(canExecuteMethodName))
                    {
                        delegateCommand.CanExecuteDelegate = () =>
                        {
                            return (bool)dynamicObject.InvokeMethod(canExecuteMethodName);
                        };
                    }
                }
            }
        }

		/// <summary>
		/// Initializes the view model and registers events so that the OnLoaded and OnUnloaded methods are called. 
		/// This method must be called in the constructor after the <see cref="InitializeComponent"/> method call. 
		/// </summary>
		/// <param name="viewModel">The view model. </param>
		/// <param name="view">The view. </param>
		public static void RegisterViewModel(ViewModelBase viewModel, FrameworkElement view)
		{
			viewModel.Initialize();

			view.Loaded += (sender, args) => viewModel.CallOnLoaded();
			view.Unloaded += (sender, args) => viewModel.CallOnUnloaded();
		}

 public void PushViewModelContext(ViewModelBase viewModel)
 {
     lock (this)
     {
         _contextStack.Push(viewModel);
     }
 }

 public void PopViewModelContext(ViewModelBase viewModel)
 {
     lock (this)
     {
         _contextStack = new Stack<ViewModelBase>(_contextStack.Where(vm => vm != viewModel));
     }
 }

        public SiteViewModel(ViewModelBase parent, Site selectedSite) //: base()
        {
            Parent = parent;
 
            SelectedSite = selectedSite;
            SetLeftPanel();
        }

		public void FocusWindow(ViewModelBase viewModel)
		{
			if (this.openWindows.ContainsKey(viewModel))
			{
				this.openWindows[viewModel].Focus();
			}
		}

        public static async Task<ViewModelBase> Previous(LinkViewModel parentLink, ViewModelBase currentActual)
        {
            if (parentLink != null)
            {
                var viewModelContextService = ServiceLocator.Current.GetInstance<IViewModelContextService>();
                var firstRedditViewModel = viewModelContextService.ContextStack.FirstOrDefault(context => context is RedditViewModel) as RedditViewModel;
                if (firstRedditViewModel != null)
                {
                    RepositionContextScroll(parentLink);

                    var imagesService = ServiceLocator.Current.GetInstance<IImagesService>();
                    var offlineService = ServiceLocator.Current.GetInstance<IOfflineService>();
                    var settingsService = ServiceLocator.Current.GetInstance<ISettingsService>();
                    //need to go backwards in time, not paying attention to the unread rules
                    ViewModelBase stackPrevious = null;
                    var emptyForward = LinkHistory.EmptyForward;
                    if (settingsService.OnlyFlipViewUnread && (stackPrevious = LinkHistory.Backward()) != null)
                    {
                        if (emptyForward)
                            LinkHistory.Push(currentActual);

                        return stackPrevious;
                    }
                    else
                    {
                        var currentLinkPos = firstRedditViewModel.Links.IndexOf(parentLink);
                        var linksEnumerator = new NeverEndingRedditView(firstRedditViewModel, currentLinkPos, false);
                        return await MakeContextedTuple(imagesService, offlineService, settingsService, linksEnumerator);
                    }

                }
            }
            return null;
        }