FileListLoader(IAppWindow appWindow, FileListManager fileListManager, FileTabManager fileTabManager, FileTabSerializer fileTabSerializer, [ImportMany] IEnumerable<Lazy<IFileListListener, IFileListListenerMetadata>> mefListeners) {
			this.fileListManager = fileListManager;
			this.fileTabManager = fileTabManager;
			this.fileTabSerializer = fileTabSerializer;
			this.listeners = mefListeners.OrderBy(a => a.Metadata.Order).ToArray();
			appWindow.MainWindowClosed += AppWindow_MainWindowClosed;
		}

		NavigationCommandInstaller(IDocumentTabService documentTabService, IAppWindow appWindow) {
			this.documentTabService = documentTabService;
			Debug.Assert(Application.Current != null && Application.Current.MainWindow != null);
			var cmds = appWindow.MainWindowCommands;
			cmds.Add(NavigationCommands.BrowseBack, new RelayCommand(a => BrowseBack(), a => CanBrowseBack));
			cmds.Add(NavigationCommands.BrowseForward, new RelayCommand(a => BrowseForward(), a => CanBrowseForward));
		}

		AboutScreenMenuItem(IDocumentViewerContentFactoryProvider documentViewerContentFactoryProvider, IDocumentTabService documentTabService, IAppWindow appWindow, IExtensionService extensionService, IContentTypeRegistryService contentTypeRegistryService) {
			this.documentViewerContentFactoryProvider = documentViewerContentFactoryProvider;
			this.documentTabService = documentTabService;
			this.appWindow = appWindow;
			this.extensionService = extensionService;
			aboutContentType = contentTypeRegistryService.GetContentType(ContentTypes.AboutDnSpy);
		}

		DocumentListLoader(IAppWindow appWindow, DocumentListService documentListService, DocumentTabService documentTabService, DocumentTabSerializer documentTabSerializer, [ImportMany] IEnumerable<Lazy<IDocumentListListener, IDocumentListListenerMetadata>> documentListListeners) {
			this.documentListService = documentListService;
			this.documentTabService = documentTabService;
			this.documentTabSerializer = documentTabSerializer;
			this.documentListListeners = documentListListeners.OrderBy(a => a.Metadata.Order).ToArray();
			appWindow.MainWindowClosed += AppWindow_MainWindowClosed;
		}

 NavigationCommandInstaller(IFileTabManager fileTabManager, IAppWindow appWindow)
 {
     this.fileTabManager = fileTabManager;
     Debug.Assert(Application.Current != null && Application.Current.MainWindow != null);
     var cmds = appWindow.MainWindowCommands;
     cmds.Add(NavigationCommands.BrowseBack, new RelayCommand(a => BrowseBack(), a => CanBrowseBack));
     cmds.Add(NavigationCommands.BrowseForward, new RelayCommand(a => BrowseForward(), a => CanBrowseForward));
 }

		ExportProjectCommand(IAppWindow appWindow, IFileTreeView fileTreeView, ILanguageManager languageManager, IFileTreeViewSettings fileTreeViewSettings, IExportToProjectSettings exportToProjectSettings, [ImportMany] IEnumerable<Lazy<IBamlDecompiler>> bamlDecompilers) {
			this.appWindow = appWindow;
			this.fileTreeView = fileTreeView;
			this.languageManager = languageManager;
			this.fileTreeViewSettings = fileTreeViewSettings;
			this.exportToProjectSettings = exportToProjectSettings;
			this.bamlDecompiler = bamlDecompilers.FirstOrDefault();
		}

 public MouseEvent(IAppWindow window, int wheelDelta, int x, int y)
 {
     Type = MouseEventType.Wheel;
     Window = window;
     WheelDelta = wheelDelta;
     X = x;
     Y = y;
 }

		InMemoryModuleManager(ITheDebugger theDebugger, IFileTabManager fileTabManager, Lazy<IMethodAnnotations> methodAnnotations, IAppWindow appWindow) {
			this.fileTabManager = fileTabManager;
			this.fileTreeView = fileTabManager.FileTreeView;
			this.fileManager = this.fileTreeView.FileManager;
			this.appWindow = appWindow;
			this.methodAnnotations = methodAnnotations;
			this.theDebugger = theDebugger;
			theDebugger.OnProcessStateChanged_First += TheDebugger_OnProcessStateChanged_First;
		}

		ExportProjectCommand(IAppWindow appWindow, IDocumentTreeView documentTreeView, IDecompilerService decompilerService, IDocumentTreeViewSettings documentTreeViewSettings, IExportToProjectSettings exportToProjectSettings, [ImportMany] IEnumerable<Lazy<IBamlDecompiler>> bamlDecompilers, [ImportMany] IEnumerable<Lazy<IXamlOutputOptionsProvider>> xamlOutputOptionsProviders) {
			this.appWindow = appWindow;
			this.documentTreeView = documentTreeView;
			this.decompilerService = decompilerService;
			this.documentTreeViewSettings = documentTreeViewSettings;
			this.exportToProjectSettings = exportToProjectSettings;
			bamlDecompiler = bamlDecompilers.FirstOrDefault();
			xamlOutputOptionsProvider = xamlOutputOptionsProviders.FirstOrDefault();
		}

 public CloseWindowController(IAppWindow win, IIOPortHandler[] portHandlers)
 {
     _win = win;
     _state = ClosingState.NoClosing;
     _portHandlers = portHandlers;
     _portHandlerClosedStates = new Dictionary<IIOPortHandler, bool>();
     foreach (IIOPortHandler handler in portHandlers)
         _portHandlerClosedStates[handler] = false;
 }

		UndoRedoCommmandLoader(IWpfCommandManager wpfCommandManager, Lazy<IUndoCommandManager> undoCommandManager, IAppWindow appWindow, IMessageBoxManager messageBoxManager) {
			this.undoCommandManager = undoCommandManager;
			this.messageBoxManager = messageBoxManager;

			var cmds = wpfCommandManager.GetCommands(CommandConstants.GUID_MAINWINDOW);
			cmds.Add(UndoRoutedCommands.Undo, (s, e) => undoCommandManager.Value.Undo(), (s, e) => e.CanExecute = undoCommandManager.Value.CanUndo);
			cmds.Add(UndoRoutedCommands.Redo, (s, e) => undoCommandManager.Value.Redo(), (s, e) => e.CanExecute = undoCommandManager.Value.CanRedo);

			appWindow.MainWindowClosing += AppWindow_MainWindowClosing;
		}

		InMemoryModuleService(ITheDebugger theDebugger, IDocumentTabService documentTabService, Lazy<IMethodAnnotations> methodAnnotations, IAppWindow appWindow, SimpleProcessReader simpleProcessReader) {
			this.documentTabService = documentTabService;
			documentTreeView = documentTabService.DocumentTreeView;
			documentService = documentTreeView.DocumentService;
			this.appWindow = appWindow;
			this.methodAnnotations = methodAnnotations;
			this.theDebugger = theDebugger;
			this.simpleProcessReader = simpleProcessReader;
			theDebugger.OnProcessStateChanged_First += TheDebugger_OnProcessStateChanged_First;
		}

		UndoRedoCommmandLoader(IWpfCommandService wpfCommandService, Lazy<IUndoCommandService> undoCommandService, IAppWindow appWindow, IMessageBoxService messageBoxService) {
			this.undoCommandService = undoCommandService;
			this.messageBoxService = messageBoxService;

			var cmds = wpfCommandService.GetCommands(ControlConstants.GUID_MAINWINDOW);
			cmds.Add(UndoRoutedCommands.Undo, (s, e) => undoCommandService.Value.Undo(), (s, e) => e.CanExecute = undoCommandService.Value.CanUndo);
			cmds.Add(UndoRoutedCommands.Redo, (s, e) => undoCommandService.Value.Redo(), (s, e) => e.CanExecute = undoCommandService.Value.CanRedo);

			appWindow.MainWindowClosing += AppWindow_MainWindowClosing;
		}

		AppSettingsService(IClassificationFormatMapService classificationFormatMapService, ITextElementProvider textElementProvider, IAppWindow appWindow, ITreeViewService treeViewService, ITreeViewNodeTextElementProvider treeViewNodeTextElementProvider, [ImportMany] IEnumerable<Lazy<IAppSettingsPageContainer, IAppSettingsPageContainerMetadata>> appSettingsPageContainers, [ImportMany] IEnumerable<Lazy<IAppSettingsPageProvider>> appSettingsPageProviders, [ImportMany] IEnumerable<Lazy<IAppSettingsModifiedListener, IAppSettingsModifiedListenerMetadata>> appSettingsModifiedListeners) {
			classificationFormatMap = classificationFormatMapService.GetClassificationFormatMap(AppearanceCategoryConstants.UIMisc);
			this.textElementProvider = textElementProvider;
			this.appWindow = appWindow;
			this.treeViewService = treeViewService;
			this.treeViewNodeTextElementProvider = treeViewNodeTextElementProvider;
			this.appSettingsPageContainers = appSettingsPageContainers.OrderBy(a => a.Metadata.Order).ToArray();
			this.appSettingsPageProviders = appSettingsPageProviders.ToArray();
			this.appSettingsModifiedListeners = appSettingsModifiedListeners.OrderBy(a => a.Metadata.Order).ToArray();
		}

 public bool closeResourcesReady(IAppWindow appWin)
 {
     if (this._appWinReadyToClose.ContainsKey(appWin))
     {
         this._appWinReadyToClose[appWin] = true;
     }
     else
     {
         GlobalServices.ErrMsg("WDSApplication.closeResourcesReady:", "No window found");
         return false;
     }
     bool flag = true;
     foreach (IAppWindow window in this._appWinReadyToClose.Keys)
     {
         if (!this._appWinReadyToClose[window])
         {
             flag = false;
             break;
         }
     }
     if (flag)
     {
         Form form = (Form) this._mainWin;
         if (form.InvokeRequired)
         {
             form.Invoke(new MethodInvoker(form.Close));
         }
         else
         {
             form.Close();
         }
         if (this._helperWins == null)
         {
             return flag;
         }
         foreach (IAppWindow window2 in this._helperWins)
         {
             form = (Form) window2;
             if (form.InvokeRequired)
             {
                 form.Invoke(new MethodInvoker(form.Close));
             }
             else
             {
                 form.Close();
             }
         }
     }
     return flag;
 }

        public void formClosingEventHandler(ref object sender, ref FormClosingEventArgs e, IAppWindow win, string appId, bool AllowCancel)
        {
            bool isOwnedByDDI = _portHandlers[0].getAdtRecord().IsOwnedByDDI;
            if ((_state == ClosingState.NoClosing) ||
                ((_state == ClosingState.ClosingResources) && isOwnedByDDI)
                )
            {
                e.Cancel = true;
                if (win.AppDataChanged)
                {
                    switch (DialogResult.No)
                    {
                        case DialogResult.Yes:
                            win.saveLocal();
                            if (!isOwnedByDDI)
                            {
                                break;
                            }
                            ClosingJobs(win);
                            return;

                        case DialogResult.No:
                            if (!isOwnedByDDI)
                            {
                                break;
                            }
                            ClosingJobs(win);
                            return;

                        case DialogResult.Cancel:
                            WDSApplicationManager.instance().AppCloseAllowed = false;
                            return;
                    }
                }
                if ((e.CloseReason == CloseReason.MdiFormClosing) || (e.CloseReason == CloseReason.ApplicationExitCall))
                {
                    GlobalServices.WarnMsg(appId, "Sending TerminateWDS Request to WDS Core");
                    WDSApplicationManager.instance().terminateWDS();
                }
                else if (_portHandlers[0].getAdtRecord().IsOwnedByDDI)
                    ClosingJobs(win);
                else
                    WDSApplicationManager.instance().closeApplications(_portHandlers[0].getAdtRecord());
            }
        }

 public void closeApplication(IAppWindow appWin)
 {
     lock (_soApps)
     {
         foreach (WDSApplication application in this._apps)
         {
             if (application.hasWindow(appWin))
             {
                 if (!_removeApps.Contains(application))
                 {
                     _removeApps.Add(application);
                     application.startClosing();
                 }
                 break;
             }
         }
     }
 }

 public FullScreenCommand(IAppWindow appWindow)
     : base(MetroWindow.FullScreenCommand)
 {
     this.window = (MetroWindow)appWindow.MainWindow;
 }

 FullScreenInit(IAppWindow appWindow, IFileTreeView fileTreeView)
 {
     var fullScreenCommand = new FullScreenCommand(appWindow);
     appWindow.MainWindowCommands.Add(MetroWindow.FullScreenCommand, (s, e) => fullScreenCommand.FullScreen(), (s, e) => e.CanExecute = true, ModifierKeys.Shift | ModifierKeys.Alt, Key.Enter);
     appWindow.MainWindowCommands.Add(CollapseUnusedNodesCommand, (s, e) => fileTreeView.TreeView.CollapseUnusedNodes(), (s, e) => e.CanExecute = true, ModifierKeys.Control | ModifierKeys.Shift, Key.W);
 }

 static Matrix4x4 CreateProjectionMatrix(IAppWindow window)
 {
     const float fieldOfView = 0.65f;
     const float nearPlane = 0.1f;
     const float farPlane = 1000f;
     var aspectRatio = (float)window.ClientWidth / window.ClientHeight;
     return Matrix4x4.CreatePerspectiveFieldOfView(fieldOfView, aspectRatio, nearPlane, farPlane);
 }