public MemberPickerDlg(IFileTreeView globalFileTreeView, IFileTreeView newFileTreeView, IImageManager imageManager) {
			InitializeComponent();
			DataContextChanged += (s, e) => {
				var data = DataContext as MemberPickerVM;
				if (data != null) {
					data.OpenAssembly = new OpenAssembly(globalFileTreeView.FileManager);
					data.PropertyChanged += MemberPickerVM_PropertyChanged;
				}
			};
			openImage.Source = imageManager.GetImage(GetType().Assembly, "Open", BackgroundType.DialogWindow);

			var treeView = (Control)newFileTreeView.TreeView.UIObject;
			cpTreeView.Content = treeView;
			Validation.SetErrorTemplate(treeView, (ControlTemplate)FindResource("noRedBorderOnValidationError"));
			treeView.AllowDrop = false;
			treeView.BorderThickness = new Thickness(1);

			var binding = new Binding {
				ValidatesOnDataErrors = true,
				ValidatesOnExceptions = true,
				UpdateSourceTrigger = UpdateSourceTrigger.PropertyChanged,
				Path = new PropertyPath("SelectedItem"),
				Mode = BindingMode.TwoWay,
			};
			treeView.SetBinding(Selector.SelectedItemProperty, binding);

			var cmd = new RelayCommand(a => {
				searchTextBox.SelectAll();
				searchTextBox.Focus();
			});
			InputBindings.Add(new KeyBinding(cmd, Key.E, ModifierKeys.Control));
			InputBindings.Add(new KeyBinding(cmd, Key.F, ModifierKeys.Control));
		}

 FileSearcherCreator(IFileTreeView fileTreeView, IImageManager imageManager, DotNetImageManager dotNetImageManager, ILanguageManager languageManager)
 {
     this.fileTreeView = fileTreeView;
     this.imageManager = imageManager;
     this.dotNetImageManager = dotNetImageManager;
     this.languageManager = languageManager;
 }

        public ItemSpotlightViewModel(IImageManager imageManager, IApiClient apiClient)
        {
            _apiClient = apiClient;
            _urlsToItems = new Dictionary<string, BaseItemDto>();
            Images = new ImageSlideshowViewModel(imageManager, Enumerable.Empty<string>()) {
                ImageStretch = Stretch.UniformToFill
            };

            Images.PropertyChanged += (s, e) => {
                if (e.PropertyName == "CurrentImageUrl") {
                    BaseItemDto item = CurrentItem;
                    CurrentCaption = item != null ? item.Name : null;
                    OnPropertyChanged("CurrentItem");
                }
            };

            ItemSelectedCommand = new RelayCommand(o => {
                BaseItemDto item = CurrentItem;
                Action<BaseItemDto> action = ItemSelectedAction;

                if (action != null && item != null) {
                    action(item);
                }
            });
        }

        public FavoritesViewModel(IPresentationManager presentation, IImageManager imageManager, IApiClient apiClient, ISessionManager session, INavigationService nav, IPlaybackManager playback, ILogger logger, double tileWidth, double tileHeight, IServerEvents serverEvents)
            : base(presentation, apiClient)
        {
            _sessionManager = session;
            _playbackManager = playback;
            _imageManager = imageManager;
            _navService = nav;
            _logger = logger;
            _serverEvents = serverEvents;

            TileWidth = tileWidth;
            TileHeight = tileHeight;

            var spotlightTileWidth = TileWidth * 2 + TilePadding;
            var spotlightTileHeight = spotlightTileWidth * 9 / 16;

            SpotlightViewModel = new ImageViewerViewModel(_imageManager, new List<ImageViewerImage>())
            {
                Height = spotlightTileHeight,
                Width = spotlightTileWidth,
                CustomCommandAction = i => _navService.NavigateToItem(i.Item, ViewType.Tv)
            };

            LoadViewModels();

            NavigateToFavoriteMoviesCommand = new RelayCommand(o => NavigateToFavorites("Movie"));
        }

 public OpenSideMenuMenuCommand(INavigator navigator, ISessionManager sessionManager,IImageManager imageManager, IApiClient apiClient)
 {
     _sessionManager = sessionManager;
     _imageManager = imageManager;
     _apiClient = apiClient;
     ExecuteCommand = new RelayCommand(arg => navigator.Navigate(Go.To.SideMenu()));
 }

 TreeViewManager(IThemeManager themeManager, IImageManager imageManager, [ImportMany] IEnumerable<Lazy<ITreeNodeDataCreator, ITreeNodeDataCreatorMetadata>> treeNodeDataCreators)
 {
     this.themeManager = themeManager;
     this.imageManager = imageManager;
     this.guidToCreator = new Dictionary<Guid, List<Lazy<ITreeNodeDataCreator, ITreeNodeDataCreatorMetadata>>>();
     InitializeGuidToCreator(treeNodeDataCreators);
 }

 public ToolTipContentCreatorContext(IImageManager imageManager, IDotNetImageManager dotNetImageManager, ILanguage language, ICodeToolTipSettings codeToolTipSettings)
 {
     this.imageManager = imageManager;
     this.dotNetImageManager = dotNetImageManager;
     this.language = language;
     this.codeToolTipSettings = codeToolTipSettings;
 }

		DnSpyLoaderManager(IImageManager imageManager, IThemeManager themeManager, ISettingsManager settingsManager, [ImportMany] IEnumerable<Lazy<IDnSpyLoader, IDnSpyLoaderMetadata>> mefLoaders) {
			this.imageManager = imageManager;
			this.themeManager = themeManager;
			this.settingsManager = settingsManager;
			this.loaders = mefLoaders.OrderBy(a => a.Metadata.Order).ToArray();
			this.windowLoader = new WindowLoader(this, imageManager, themeManager, settingsManager, loaders);
		}

 public CriticReviewListViewModel(IPresentationManager presentationManager, IApiClient apiClient, IImageManager imageManager, string itemId)
 {
     ImageManager = imageManager;
     _itemId = itemId;
     ApiClient = apiClient;
     PresentationManager = presentationManager;
 }

        public TreeViewImpl(ITreeViewManager treeViewManager, IThemeManager themeManager, IImageManager imageManager, Guid guid, TreeViewOptions options)
        {
            this.guid = guid;
            this.treeViewManager = treeViewManager;
            this.imageManager = imageManager;
            this.treeViewListener = options.TreeViewListener;
            this.sharpTreeView = new SharpTreeView();
            this.sharpTreeView.SelectionChanged += SharpTreeView_SelectionChanged;
            this.sharpTreeView.CanDragAndDrop = options.CanDragAndDrop;
            this.sharpTreeView.AllowDrop = options.AllowDrop;
            this.sharpTreeView.AllowDropOrder = options.AllowDrop;
            VirtualizingStackPanel.SetIsVirtualizing(this.sharpTreeView, options.IsVirtualizing);
            VirtualizingStackPanel.SetVirtualizationMode(this.sharpTreeView, options.VirtualizationMode);
            this.sharpTreeView.SelectionMode = options.SelectionMode;
            this.sharpTreeView.BorderThickness = new Thickness(0);
            this.sharpTreeView.ShowRoot = false;
            this.sharpTreeView.ShowLines = false;

            if (options.IsGridView) {
                this.sharpTreeView.ItemContainerStyle = (Style)Application.Current.FindResource(SharpGridView.ItemContainerStyleKey);
                this.sharpTreeView.Style = (Style)Application.Current.FindResource("SharpTreeViewGridViewStyle");
            }
            else {
                // Clear the value set by the constructor. This is required or our style won't be used.
                this.sharpTreeView.ClearValue(ItemsControl.ItemContainerStyleProperty);
                this.sharpTreeView.Style = (Style)Application.Current.FindResource(typeof(SharpTreeView));
            }

            this.sharpTreeView.GetPreviewInsideTextBackground = () => themeManager.Theme.GetColor(ColorType.SystemColorsHighlight).Background;
            this.sharpTreeView.GetPreviewInsideForeground = () => themeManager.Theme.GetColor(ColorType.SystemColorsHighlightText).Foreground;

            // Add the root at the end since Create() requires some stuff to have been initialized
            this.root = Create(options.RootNode ?? new TreeNodeDataImpl(new Guid(FileTVConstants.ROOT_NODE_GUID)));
            this.sharpTreeView.Root = this.root.Node;
        }

 public IconBarMargin(ITextEditorUIContext uiContext, ITextLineObjectManager textLineObjectManager, IImageManager imageManager, IThemeManager themeManager)
 {
     this.uiContext = uiContext;
     this.textLineObjectManager = textLineObjectManager;
     this.imageManager = imageManager;
     this.themeManager = themeManager;
 }

        public UserProfileWindow(DefaultThemePageMasterCommandsViewModel masterCommands, ISessionManager session, IPresentationManager presentationManager, IImageManager imageManager, IApiClient apiClient, DisplayPreferences displayPreferences, ListPageConfig options)
        {
            _session = session;
            _options = options;
            _displayPreferencesViewModel = new DisplayPreferencesViewModel(displayPreferences, presentationManager);
            _previousFocus = "";

            InitializeComponent();

            Loaded += UserProfileWindow_Loaded;
            Unloaded += UserProfileWindow_Unloaded;
            masterCommands.PageNavigated += masterCommands_PageNavigated;
            BtnClose.Click += BtnClose_Click;

            //Display preferences
            RadioList.Click += radioList_Click;
            RadioPoster.Click += radioPoster_Click;
            RadioThumbstrip.Click += radioThumbstrip_Click;
            RadioPosterStrip.Click += radioPosterStrip_Click;

            //Sort preferences
            RadioSortAscending.Click += RadioSortAscending_Click;
            RadioSortDescending.Click += RadioSortDescending_Click;

            //Focus tracking
            BtnClose.IsKeyboardFocusedChanged += Button_IsKeyboardFocusedChanged;
            HomeButton.IsKeyboardFocusedChanged += Button_IsKeyboardFocusedChanged;
            DisplayPreferencesButton.IsKeyboardFocusedChanged += Button_IsKeyboardFocusedChanged;
            SortButton.IsKeyboardFocusedChanged += Button_IsKeyboardFocusedChanged;
            SettingsButton.IsKeyboardFocusedChanged += Button_IsKeyboardFocusedChanged;
            LogoutButton.IsKeyboardFocusedChanged += Button_IsKeyboardFocusedChanged;
            ShutdownAppButton.IsKeyboardFocusedChanged += Button_IsKeyboardFocusedChanged;
            SleepButton.IsKeyboardFocusedChanged += Button_IsKeyboardFocusedChanged;
            RestartButton.IsKeyboardFocusedChanged += Button_IsKeyboardFocusedChanged;
            ShutdownButton.IsKeyboardFocusedChanged += Button_IsKeyboardFocusedChanged;

            RadioList.IsKeyboardFocusedChanged += Button_IsKeyboardFocusedChanged;
            RadioPosterStrip.IsKeyboardFocusedChanged += Button_IsKeyboardFocusedChanged;
            RadioPoster.IsKeyboardFocusedChanged += Button_IsKeyboardFocusedChanged;
            RadioThumbstrip.IsKeyboardFocusedChanged += Button_IsKeyboardFocusedChanged;

            RadioSortAscending.IsKeyboardFocusedChanged += Button_IsKeyboardFocusedChanged;
            RadioSortDescending.IsKeyboardFocusedChanged += Button_IsKeyboardFocusedChanged;
            CheckBoxSortRemember.IsKeyboardFocusedChanged += Button_IsKeyboardFocusedChanged;

            ContentGrid.DataContext = new DefaultThemeUserDtoViewModel(masterCommands, apiClient, imageManager, session)
            {
                User = session.CurrentUser,
                ImageHeight = 54
            };

            MainGrid.DataContext = this;
            CheckBoxSortRemember.DataContext = _displayPreferencesViewModel;

            if (displayPreferences != null)
            {
                //Always set to false to begin with in case the user is just doing a quick sort and doesn't want it saved.
                _displayPreferencesViewModel.RememberSorting = false;
            }
        }

 /// <summary>
 /// Parametrized constructor to inject the reference object implicitly 
 /// M.S.Prakash
 /// </summary>
 /// <param name="pm"></param>
 /// <param name="um"></param>
 public ListDonorProgramController(IProgrammLevelManager pm, IUserLevelManager um,IImageManager mgr,IDollarManager dm)
 {
     this.dm = dm;
     this.pm = pm;
     this.um = um;
     this.mgr = mgr;
 }

 public UserListViewModel(IPresentationManager presentationManager, IConnectionManager connectionManager, IImageManager imageManager, ISessionManager sessionManager, INavigationService navigation)
 {
     SessionManager = sessionManager;
     ImageManager = imageManager;
     ConnectionManager = connectionManager;
     PresentationManager = presentationManager;
 }

 CodeToolTipManager(IImageManager imageManager, IDotNetImageManager dotNetImageManager, ICodeToolTipSettings codeToolTipSettings, [ImportMany] IEnumerable<Lazy<IToolTipContentCreator, IToolTipContentCreatorMetadata>> mefCreators)
 {
     this.imageManager = imageManager;
     this.dotNetImageManager = dotNetImageManager;
     this.codeToolTipSettings = codeToolTipSettings;
     this.creators = mefCreators.OrderBy(a => a.Metadata.Order).ToArray();
 }

 public MainPageViewModel(IImageManager imageManager)
 {
     _imageManager = imageManager;
     _pauseButtonTitle = "Paused";
     _isRunning = false;
     _imageManager.OnTimerTick += _imageManager_OnTimerTick;
 }

 public UserListViewModel(IPresentationManager presentationManager, IImageManager imageManager, ISessionManager sessionManager, IApiClient apiClient)
 {
     ApiClient = apiClient;
     SessionManager = sessionManager;
     ImageManager = imageManager;
     PresentationManager = presentationManager;
 }

 BreakpointsVM(ILanguageManager languageManager, IImageManager imageManager, IThemeManager themeManager, IDebuggerSettings debuggerSettings, ITheDebugger theDebugger, IBreakpointManager breakpointManager, IBreakpointSettings breakpointSettings, Lazy<IModuleLoader> moduleLoader, IInMemoryModuleManager inMemoryModuleManager)
 {
     this.breakpointContext = new BreakpointContext(imageManager, moduleLoader) {
         Language = languageManager.Language,
         SyntaxHighlight = debuggerSettings.SyntaxHighlightBreakpoints,
         UseHexadecimal = debuggerSettings.UseHexadecimal,
         ShowTokens = breakpointSettings.ShowTokens,
         ShowModuleNames = breakpointSettings.ShowModuleNames,
         ShowParameterTypes = breakpointSettings.ShowParameterTypes,
         ShowParameterNames = breakpointSettings.ShowParameterNames,
         ShowOwnerTypes = breakpointSettings.ShowOwnerTypes,
         ShowReturnTypes = breakpointSettings.ShowReturnTypes,
         ShowNamespaces = breakpointSettings.ShowNamespaces,
         ShowTypeKeywords = breakpointSettings.ShowTypeKeywords,
     };
     this.breakpointManager = breakpointManager;
     this.theDebugger = theDebugger;
     this.breakpointList = new ObservableCollection<BreakpointVM>();
     breakpointSettings.PropertyChanged += BreakpointSettings_PropertyChanged;
     breakpointManager.OnListModified += BreakpointManager_OnListModified;
     debuggerSettings.PropertyChanged += DebuggerSettings_PropertyChanged;
     theDebugger.OnProcessStateChanged += TheDebugger_OnProcessStateChanged;
     themeManager.ThemeChanged += ThemeManager_ThemeChanged;
     languageManager.LanguageChanged += LanguageManager_LanguageChanged;
     inMemoryModuleManager.DynamicModulesLoaded += InMemoryModuleManager_DynamicModulesLoaded;
     foreach (var bp in breakpointManager.Breakpoints)
         AddBreakpoint(bp);
 }

        /// <summary>
        /// Initializes a new instance of the <see cref="MainWindow" /> class.
        /// </summary>
        public MainWindow(ILogger logger, IPlaybackManager playbackManager, IApiClient apiClient, IImageManager imageManager, IApplicationHost appHost, IPresentationManager appWindow, IUserInputManager userInput, ITheaterConfigurationManager config, INavigationService nav, IScreensaverManager screensaverManager)
            : base()
        {
            _logger = logger;
            _appHost = appHost;
            _appWindow = appWindow;
            _config = config;
            _playbackManager = playbackManager;
            UserInputManager = userInput;
            NavigationManager = nav;

            Loaded += MainWindow_Loaded;

            InitializeComponent();

            RotatingBackdrops = new RotatingBackdropsViewModel(apiClient, _config, imageManager, playbackManager, logger, screensaverManager);

            _config.ConfigurationUpdated += _config_ConfigurationUpdated;
            _playbackManager.PlaybackStarted += _playbackManager_PlaybackStarted;
            _playbackManager.PlaybackCompleted += _playbackManager_PlaybackCompleted;

            //Timeline.DesiredFrameRateProperty.OverrideMetadata(
            //    typeof(Timeline),
            //    new FrameworkPropertyMetadata { DefaultValue = 30 }
            //);
        }

 public UserListViewModel(IPresentationManager presentationManager, IApiClient apiClient, IImageManager imageManager, ISessionManager sessionManager, INavigationService navigation)
 {
     SessionManager = sessionManager;
     _navigation = navigation;
     ImageManager = imageManager;
     ApiClient = apiClient;
     PresentationManager = presentationManager;
 }