SwitchToThreadNewTabThreadsCtxMenuCommand(Lazy <ITheDebugger> theDebugger, Lazy <IThreadsContent> threadsContent, Lazy <IStackFrameManager> stackFrameManager, IFileTabManager fileTabManager, Lazy <IModuleLoader> moduleLoader)
: base(theDebugger, threadsContent)
{
this.stackFrameManager = stackFrameManager;
this.fileTabManager = fileTabManager;
this.moduleLoader = moduleLoader;
}
static void Execute(IFileTabManager fileTabManager, ResourceRef resRef)
{
if (resRef == null)
return;
var modNode = fileTabManager.FileTreeView.FindNode(resRef.Module);
Debug.Assert(modNode != null);
if (modNode == null)
return;
modNode.TreeNode.EnsureChildrenLoaded();
var resDirNode = modNode.TreeNode.DataChildren.FirstOrDefault(a => a is IResourcesFolderNode);
Debug.Assert(resDirNode != null);
if (resDirNode == null)
return;
resDirNode.TreeNode.EnsureChildrenLoaded();
var resSetNode = resDirNode.TreeNode.DataChildren.FirstOrDefault(a => a is IResourceElementSetNode && ((IResourceElementSetNode)a).Name == resRef.Filename);
Debug.Assert(resSetNode != null);
if (resSetNode == null)
return;
resSetNode.TreeNode.EnsureChildrenLoaded();
var resNode = resSetNode.TreeNode.DataChildren.FirstOrDefault(a => a is IResourceElementNode && ((IResourceElementNode)a).Name == resRef.ResourceName);
Debug.Assert(resNode != null);
if (resNode == null)
return;
fileTabManager.FollowReference(resNode);
}
AboutScreenMenuItem(IFileTabManager fileTabManager, IAppWindow appWindow, IExtensionManager extensionManager, IContentTypeRegistryService contentTypeRegistryService)
{
this.fileTabManager = fileTabManager;
this.appWindow = appWindow;
this.extensionManager = extensionManager;
this.aboutContentType = contentTypeRegistryService.GetContentType(ContentTypes.AboutDnSpy);
}
GoToSourceCallStackCtxMenuCommand(Lazy <ITheDebugger> theDebugger, Lazy <ICallStackContent> callStackContent, IFileTabManager fileTabManager, Lazy <IModuleLoader> moduleLoader, IModuleIdProvider moduleIdProvider)
: base(theDebugger, callStackContent)
{
this.fileTabManager = fileTabManager;
this.moduleLoader = moduleLoader;
this.moduleIdProvider = moduleIdProvider;
}
internal static ModuleDef GetCurrentModule(IFileTabManager fileTabManager)
{
var tab = fileTabManager.ActiveTab;
if (tab == null)
return null;
return tab.Content.Nodes.FirstOrDefault().GetModule();
}
AllTabsMenuItemCommand(IFileTabManager fileTabManager, ISaveManager saveManager, ITabsVMSettings tabsVMSettings, IAppWindow appWindow)
: base(fileTabManager)
{
this.saveManager = saveManager;
this.tabsVMSettings = tabsVMSettings;
this.appWindow = appWindow;
}
DocumentSaver(Lazy <IUndoCommandManager> undoCommandManager, Lazy <IMmapDisabler> mmapDisabler, IFileTabManager fileTabManager, IAppWindow appWindow)
{
this.undoCommandManager = undoCommandManager;
this.mmapDisabler = mmapDisabler;
this.fileTabManager = fileTabManager;
this.appWindow = appWindow;
}
SwitchToFrameNewTabCallStackCtxMenuCommand(Lazy <ITheDebugger> theDebugger, Lazy <ICallStackContent> callStackContent, Lazy <IStackFrameManager> stackFrameManager, IFileTabManager fileTabManager, Lazy <IModuleLoader> moduleLoader)
: base(theDebugger, callStackContent)
{
this.stackFrameManager = stackFrameManager;
this.fileTabManager = fileTabManager;
this.moduleLoader = moduleLoader;
}
public FileTabReferenceResult Create(IFileTabManager fileTabManager, IFileTabContent sourceContent, object @ref)
{
var node = @ref as IFileTreeNodeData;
if (node != null)
{
return(Create(node));
}
var nsRef = @ref as NamespaceRef;
if (nsRef != null)
{
return(Create(nsRef));
}
var file = @ref as IDnSpyFile;
if (file != null)
{
return(Create(file));
}
var asm = @ref as AssemblyDef;
if (asm != null)
{
return(Create(asm));
}
var mod = @ref as ModuleDef;
if (mod != null)
{
return(Create(mod));
}
return(null);
}
GoToSourceNewTabBreakpointCtxMenuCommand(Lazy <IBreakpointsContent> breakpointsContent, Lazy <IModuleLoader> moduleLoader, IFileTabManager fileTabManager, IModuleIdProvider moduleIdProvider)
: base(breakpointsContent)
{
this.moduleLoader = moduleLoader;
this.fileTabManager = fileTabManager;
this.moduleIdProvider = moduleIdProvider;
}
CommandLoader(IWpfCommandManager wpfCommandManager, IFileTabManager fileTabManager,
DeleteResourceCommand.EditMenuCommand removeCmd1,
DeleteResourceElementCommand.EditMenuCommand removeCmd2,
DeleteResourceCommand.CodeCommand removeCmd3,
DeleteResourceElementCommand.CodeCommand removeCmd4,
ResourceSettingsCommand.EditMenuCommand settingsCmd10,
ResourceSettingsCommand.CodeCommand settingsCmd11,
ResourceElementSettingsCommand.EditMenuCommand settingsCmd20,
ResourceElementSettingsCommand.CodeCommand settingsCmd21,
ImageResourceElementSettingsCommand.EditMenuCommand settingsCmd30,
ImageResourceElementSettingsCommand.CodeCommand settingsCmd31,
SerializedImageResourceElementSettingsCommand.EditMenuCommand settingsCmd40,
SerializedImageResourceElementSettingsCommand.CodeCommand settingsCmd41,
SerializedImageListStreamerResourceElementSettingsCommand.EditMenuCommand settingsCmd50,
SerializedImageListStreamerResourceElementSettingsCommand.CodeCommand settingsCmd51) {
wpfCommandManager.AddRemoveCommand(removeCmd1);
wpfCommandManager.AddRemoveCommand(removeCmd2);
wpfCommandManager.AddRemoveCommand(removeCmd3, fileTabManager);
wpfCommandManager.AddRemoveCommand(removeCmd4, fileTabManager);
wpfCommandManager.AddSettingsCommand(fileTabManager, settingsCmd10, settingsCmd11);
wpfCommandManager.AddSettingsCommand(fileTabManager, settingsCmd20, settingsCmd21);
wpfCommandManager.AddSettingsCommand(fileTabManager, settingsCmd30, settingsCmd31);
wpfCommandManager.AddSettingsCommand(fileTabManager, settingsCmd40, settingsCmd41);
wpfCommandManager.AddSettingsCommand(fileTabManager, settingsCmd50, settingsCmd51);
}
public static bool GoToIL(IFileTabManager fileTabManager, IDnSpyFile file, uint token, uint ilOffset, bool newTab) {
if (file == null)
return false;
var method = file.ModuleDef.ResolveToken(token) as MethodDef;
if (method == null)
return false;
var serMod = SerializedDnModuleCreator.Create(fileTabManager.FileTreeView, method.Module);
var key = new SerializedDnToken(serMod, method.MDToken);
bool found = fileTabManager.FileTreeView.FindNode(method.Module) != null;
if (found) {
fileTabManager.FollowReference(method, newTab, true, e => {
Debug.Assert(e.Tab.UIContext is ITextEditorUIContext);
if (e.Success && !e.HasMovedCaret) {
MoveCaretTo(e.Tab.UIContext as ITextEditorUIContext, key, ilOffset);
e.HasMovedCaret = true;
}
});
return true;
}
Dispatcher.CurrentDispatcher.BeginInvoke(DispatcherPriority.Background, new Action(() => {
fileTabManager.FollowReference(method, newTab, true, e => {
Debug.Assert(e.Tab.UIContext is ITextEditorUIContext);
if (e.Success && !e.HasMovedCaret) {
MoveCaretTo(e.Tab.UIContext as ITextEditorUIContext, key, ilOffset);
e.HasMovedCaret = true;
}
});
}));
return true;
}
GoToModuleNewTabModulesCtxMenuCommand(Lazy <ITheDebugger> theDebugger, Lazy <IModulesContent> modulesContent, IFileTabManager fileTabManager, Lazy <IModuleLoader> moduleLoader, Lazy <IInMemoryModuleManager> inMemoryModuleManager)
: base(theDebugger, modulesContent)
{
this.fileTabManager = fileTabManager;
this.moduleLoader = moduleLoader;
this.inMemoryModuleManager = inMemoryModuleManager;
}
internal static void GoTo(Lazy <IStackFrameManager> stackFrameManager, IFileTabManager fileTabManager, Lazy <IModuleLoader> moduleLoader, ThreadsCtxMenuContext context, bool newTab)
{
if (context.SelectedItems.Length == 0)
{
return;
}
GoTo(fileTabManager, moduleLoader.Value, stackFrameManager.Value, context.SelectedItems[0], newTab);
}
internal static void Execute(IStackFrameManager stackFrameManager, IFileTabManager fileTabManager, IModuleLoader moduleLoader, CallStackFrameVM vm, bool newTab)
{
if (vm != null)
{
stackFrameManager.SelectedFrameNumber = vm.Index;
FrameUtils.GoTo(fileTabManager, moduleLoader, vm.Frame, newTab);
}
}
GoToCommand(IWpfCommandManager wpfCommandManager, IFileTabManager fileTabManager, IMessageBoxManager messageBoxManager)
{
this.fileTabManager = fileTabManager;
this.messageBoxManager = messageBoxManager;
var cmds = wpfCommandManager.GetCommands(CommandConstants.GUID_TEXTEDITOR_UICONTEXT);
cmds.Add(GoToRoutedCommand, Execute, CanExecute, ModifierKeys.Control, Key.G);
}
SaveModuleCommand(IFileTabManager fileTabManager, Lazy <IUndoCommandManager> undoCommandManager, Lazy <IHexDocumentManager> hexDocumentManager, Lazy <IDocumentSaver> documentSaver)
: base(fileTabManager.FileTreeView)
{
this.fileTabManager = fileTabManager;
this.undoCommandManager = undoCommandManager;
this.hexDocumentManager = hexDocumentManager;
this.documentSaver = documentSaver;
}
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));
}
public static bool GoTo(IFileTabManager fileTabManager, IModuleLoader moduleLoader, CorFrame frame, bool newTab) {
if (GoToIL(fileTabManager, moduleLoader, frame, newTab))
return true;
//TODO: eg. native frame or internal frame
return false;
}
CopyILBytesLoader(IWpfCommandManager wpfCommandManager, IFileTabManager fileTabManager, Lazy <IMethodAnnotations> methodAnnotations)
{
this.fileTabManager = fileTabManager;
this.methodAnnotations = methodAnnotations;
var cmds = wpfCommandManager.GetCommands(CommandConstants.GUID_TEXTEDITOR_UICONTEXT);
cmds.Add(CopyILBytesCommand, CopyILBytesExecuted, CopyILBytesCanExecute, ModifierKeys.Control, Key.B);
}
SaveModuleCommand(IFileTabManager fileTabManager, Lazy<IUndoCommandManager> undoCommandManager, Lazy<IHexDocumentManager> hexDocumentManager, Lazy<IDocumentSaver> documentSaver)
: base(fileTabManager.FileTreeView)
{
this.fileTabManager = fileTabManager;
this.undoCommandManager = undoCommandManager;
this.hexDocumentManager = hexDocumentManager;
this.documentSaver = documentSaver;
}
static void ExecuteInternal(IFileTabManager fileTabManager, Lazy <IInMemoryModuleManager> inMemoryModuleManager, ModulesCtxMenuContext context, bool newTab)
{
if (context == null || context.SelectedItems.Length == 0)
{
return;
}
ExecuteInternal(fileTabManager, inMemoryModuleManager, context.SelectedItems[0], newTab);
}
FileListLoader(IAppWindow appWindow, FileListManager fileListManager, IFileTabManager 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;
}
public TabsVM(IFileTabManager fileTabManager, ISaveManager saveManager, ITabsVMSettings tabsVMSettings)
{
this.fileTabManager = fileTabManager;
this.saveManager = saveManager;
this.tabsVMSettings = tabsVMSettings;
this.tabsList = new ObservableCollection<TabVM>(fileTabManager.SortedTabs.Select(a => new TabVM(this, a)));
this.SelectedItem = tabsList.Count == 0 ? null : tabsList[0];
InitializeSaveText();
}
public TabsVM(IFileTabManager fileTabManager, ISaveManager saveManager, ITabsVMSettings tabsVMSettings)
{
this.fileTabManager = fileTabManager;
this.saveManager = saveManager;
this.Settings = tabsVMSettings;
this.tabsList = new ObservableCollection <TabVM>(fileTabManager.SortedTabs.Select(a => new TabVM(this, a)));
this.SelectedItem = tabsList.Count == 0 ? null : tabsList[0];
InitializeSaveText();
}
static void ExecuteInternal(IFileTabManager fileTabManager, MDTableContext context)
{
var @ref = GetAddressReference(context);
if (@ref != null)
{
fileTabManager.FollowReference(@ref);
}
}
StackFrameManager(ITheDebugger theDebugger, IFileTabManager fileTabManager, ITextLineObjectManager textLineObjectManager, Lazy<IModuleLoader> moduleLoader, ITextEditorUIContextManager textEditorUIContextManager) {
this.theDebugger = theDebugger;
this.fileTabManager = fileTabManager;
this.textLineObjectManager = textLineObjectManager;
this.moduleLoader = moduleLoader;
textEditorUIContextManager.Add(OnTextEditorUIContextEvent, TextEditorUIContextManagerConstants.ORDER_DEBUGGER_CALLSTACK);
theDebugger.OnProcessStateChanged += TheDebugger_OnProcessStateChanged;
theDebugger.ProcessRunning += TheDebugger_ProcessRunning;
}
internal static void GoTo(IFileTabManager fileTabManager, IModuleLoader moduleLoader, IStackFrameManager stackFrameManager, ThreadVM vm, bool newTab)
{
if (vm == null)
{
return;
}
stackFrameManager.SelectedThread = vm.Thread;
FrameUtils.GoTo(fileTabManager, moduleLoader, vm.Thread.AllFrames.FirstOrDefault(f => f.IsILFrame), newTab);
}
FileTabReferenceResult Create(TokenReference tokRef, IFileTabManager fileTabManager) {
var node = HexFileTreeNodeDataFinder.FindNode(fileTabManager.FileTreeView, tokRef);
if (node == null)
return null;
var content = fileTabManager.TryCreateContent(new IFileTreeNodeData[] { node });
if (content == null)
return null;
return new FileTabReferenceResult(content);
}
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));
}
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;
}
static ITokenResolver GetResolver(IFileTabManager fileTabManager, out IFileTab tab)
{
tab = fileTabManager.ActiveTab;
if (tab == null)
{
return(null);
}
return(tab.Content.Nodes.FirstOrDefault().GetModule());
}
public FileTabReferenceResult Create(IFileTabManager fileTabManager, IFileTabContent sourceContent, object @ref)
{
var textRef = @ref as TextReference;
if (textRef != null)
{
@ref = textRef.Reference;
}
var node = @ref as IFileTreeNodeData;
if (node != null)
{
return(Create(node));
}
var nsRef = @ref as NamespaceRef;
if (nsRef != null)
{
return(Create(nsRef));
}
var nsRef2 = @ref as NamespaceReference;
if (nsRef2 != null)
{
return(Create(nsRef2));
}
var file = @ref as IDnSpyFile;
if (file != null)
{
return(Create(file));
}
var asm = @ref as AssemblyDef;
if (asm != null)
{
return(Create(asm));
}
var mod = @ref as ModuleDef;
if (mod != null)
{
return(Create(mod));
}
var asmRef = @ref as IAssembly;
if (asmRef != null)
{
file = fileTreeView.FileManager.Resolve(asmRef, null);
if (file != null)
{
return(Create(file));
}
}
return(null);
}
public FileTabReferenceResult Create(IFileTabManager fileTabManager, IFileTabContent sourceContent, object @ref) {
var addrRef = @ref as AddressReference;
if (addrRef == null) {
var codeRef = @ref as CodeReference;
addrRef = codeRef == null ? null : codeRef.Reference as AddressReference;
}
if (addrRef != null)
return Create(addrRef, fileTabManager.FileTreeView);
return null;
}
public static bool GoToIL(IFileTabManager fileTabManager, IModuleLoader moduleLoader, CorFrame frame, bool newTab) {
if (!CanGoToIL(frame))
return false;
var func = frame.Function;
if (func == null)
return false;
return DebugUtils.GoToIL(fileTabManager, moduleLoader.LoadModule(func.Module, true), frame.Token, frame.GetILOffset(moduleLoader), newTab);
}
InstallTabCommands(IAppWindow appWindow, IFileTabManager fileTabManager)
{
this.fileTabManager = fileTabManager;
var cmds = appWindow.MainWindowCommands;
cmds.Add(new RoutedCommand("OpenNewTab", typeof(InstallTabCommands)), (s, e) => OpenNewTab(), (s, e) => e.CanExecute = CanOpenNewTab, ModifierKeys.Control, Key.T);
cmds.Add(new RoutedCommand("CloseActiveTab", typeof(InstallTabCommands)), (s, e) => CloseActiveTab(), (s, e) => e.CanExecute = CanCloseActiveTab, ModifierKeys.Control, Key.F4);
cmds.Add(new RoutedCommand("SelectNextTab", typeof(InstallTabCommands)), (s, e) => SelectNextTab(), (s, e) => e.CanExecute = CanSelectNextTab, ModifierKeys.Control, Key.Tab);
cmds.Add(new RoutedCommand("SelectPrevTab", typeof(InstallTabCommands)), (s, e) => SelectPrevTab(), (s, e) => e.CanExecute = CanSelectPrevTab, ModifierKeys.Control | ModifierKeys.Shift, Key.Tab);
}
public static void AddSettingsCommand(this IWpfCommandManager wpfCommandManager, IFileTabManager fileTabManager, EditMenuHandler treeViewCmd, CodeContextMenuHandler textEditorCmd) {
if (treeViewCmd != null) {
var cmds = wpfCommandManager.GetCommands(CommandConstants.GUID_FILE_TREEVIEW);
cmds.Add(SettingsRoutedCommand, new EditMenuHandlerCommandProxy(treeViewCmd));
}
if (textEditorCmd != null) {
var cmds = wpfCommandManager.GetCommands(CommandConstants.GUID_TEXTEDITOR_UICONTEXT);
cmds.Add(SettingsRoutedCommand, new CodeContextMenuHandlerCommandProxy(textEditorCmd, fileTabManager), ModifierKeys.Alt, Key.Enter);
}
}
StackFrameManager(ITheDebugger theDebugger, IFileTabManager fileTabManager, ITextLineObjectManager textLineObjectManager, Lazy <IModuleLoader> moduleLoader, ITextEditorUIContextManager textEditorUIContextManager)
{
this.theDebugger = theDebugger;
this.fileTabManager = fileTabManager;
this.textLineObjectManager = textLineObjectManager;
this.moduleLoader = moduleLoader;
textEditorUIContextManager.Add(OnTextEditorUIContextEvent, TextEditorUIContextManagerConstants.ORDER_DEBUGGER_CALLSTACK);
theDebugger.OnProcessStateChanged += TheDebugger_OnProcessStateChanged;
theDebugger.ProcessRunning += TheDebugger_ProcessRunning;
}
static MethodDef GetEntryPoint(IFileTabManager fileTabManager, IMenuItemContext context)
{
if (context.CreatorObject.Guid != new Guid(MenuConstants.GUIDOBJ_TEXTEDITORCONTROL_GUID))
{
return(null);
}
var module = GetCurrentModule(fileTabManager);
return(module == null ? null : module.EntryPoint as MethodDef);
}
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.OnProcessStateChanged2 += TheDebugger_OnProcessStateChanged2;
}
public FileTabReferenceResult Create(IFileTabManager fileTabManager, IFileTabContent sourceContent, object @ref) {
var tokRef = @ref as TokenReference;
if (tokRef == null) {
var codeRef = @ref as CodeReference;
tokRef = codeRef == null ? null : codeRef.Reference as TokenReference;
}
if (tokRef != null)
return Create(tokRef, fileTabManager);
return null;
}
BreakpointsContent(IWpfCommandManager wpfCommandManager, Lazy <IBreakpointsVM> breakpointsVM, Lazy <IModuleLoader> moduleLoader, IFileTabManager fileTabManager)
{
this.breakpointsControl = new BreakpointsControl();
this.moduleLoader = moduleLoader;
this.fileTabManager = fileTabManager;
this.vmBreakpoints = breakpointsVM;
wpfCommandManager.Add(CommandConstants.GUID_DEBUGGER_BREAKPOINTS_CONTROL, breakpointsControl);
wpfCommandManager.Add(CommandConstants.GUID_DEBUGGER_BREAKPOINTS_LISTVIEW, breakpointsControl.ListView);
}
internal static ModuleDef GetCurrentModule(IFileTabManager fileTabManager)
{
var tab = fileTabManager.ActiveTab;
if (tab == null)
{
return(null);
}
return(tab.Content.Nodes.FirstOrDefault().GetModule());
}
public TreeViewUpdater(IFileTabManager fileTabManager, CorModuleDefFile cmdf, IModuleFileNode node, HashSet<uint> modifiedTypes, HashSet<uint> loadedClassTokens) {
Debug.Assert(node.DnSpyFile == cmdf);
this.fileTabManager = fileTabManager;
this.CorModuleDefFile = cmdf;
this.ModuleNode = node;
this.modifiedTypes = new HashSet<uint>(modifiedTypes);
this.loadedClassTokens = loadedClassTokens;
this.checkedTypes = new HashSet<TypeDef>();
this.modNode = node;
}
public TreeViewUpdater(IFileTabManager fileTabManager, CorModuleDefFile cmdf, IModuleFileNode node, HashSet <uint> modifiedTypes, HashSet <uint> loadedClassTokens)
{
Debug.Assert(node.DnSpyFile == cmdf);
this.fileTabManager = fileTabManager;
this.CorModuleDefFile = cmdf;
this.ModuleNode = node;
this.modifiedTypes = new HashSet <uint>(modifiedTypes);
this.loadedClassTokens = loadedClassTokens;
this.checkedTypes = new HashSet <TypeDef>();
this.modNode = node;
}
public static bool GoTo(IFileTabManager fileTabManager, IModuleLoader moduleLoader, CorFrame frame, bool newTab)
{
if (GoToIL(fileTabManager, moduleLoader, frame, newTab))
{
return(true);
}
//TODO: eg. native frame or internal frame
return(false);
}
internal static void ExecuteInternal(IFileTabManager fileTabManager) {
IFileTab tab;
var resolver = GetResolver(fileTabManager, out tab);
if (resolver == null)
return;
var member = AskForDef(dnSpy_Resources.GoToToken_Title, resolver);
if (member == null)
return;
tab.FollowReference(member, false);
}
ThreadsContent(IWpfCommandManager wpfCommandManager, IThreadsVM threadsVM, IThemeManager themeManager, Lazy<IStackFrameManager> stackFrameManager, IFileTabManager fileTabManager, Lazy<IModuleLoader> moduleLoader) {
this.stackFrameManager = stackFrameManager;
this.fileTabManager = fileTabManager;
this.moduleLoader = moduleLoader;
this.threadsControl = new ThreadsControl();
this.vmThreads = threadsVM;
this.threadsControl.DataContext = this.vmThreads;
this.threadsControl.ThreadsListViewDoubleClick += ThreadsControl_ThreadsListViewDoubleClick;
themeManager.ThemeChanged += ThemeManager_ThemeChanged;
wpfCommandManager.Add(CommandConstants.GUID_DEBUGGER_THREADS_CONTROL, threadsControl);
wpfCommandManager.Add(CommandConstants.GUID_DEBUGGER_THREADS_LISTVIEW, threadsControl.ListView);
}
public FileTabReferenceResult Create(IFileTabManager fileTabManager, IFileTabContent sourceContent, object @ref)
{
var codeRef = @ref as CodeReference;
if (codeRef != null) {
var result = CreateMemberRefResult(fileTabManager, codeRef.Reference);
if (result != null)
return result;
return CreateLocalRefResult(sourceContent, codeRef);
}
return CreateMemberRefResult(fileTabManager, @ref);
}
ModulesContent(IWpfCommandManager wpfCommandManager, IThemeManager themeManager, IModulesVM modulesVM, IFileTabManager fileTabManager, Lazy<ModuleLoader> moduleLoader, Lazy<IInMemoryModuleManager> inMemoryModuleManager) {
this.modulesControl = new ModulesControl();
this.vmModules = modulesVM;
this.fileTabManager = fileTabManager;
this.moduleLoader = moduleLoader;
this.inMemoryModuleManager = inMemoryModuleManager;
this.modulesControl.DataContext = this.vmModules;
this.modulesControl.ModulesListViewDoubleClick += ModulesControl_ModulesListViewDoubleClick;
themeManager.ThemeChanged += ThemeManager_ThemeChanged;
wpfCommandManager.Add(CommandConstants.GUID_DEBUGGER_MODULES_CONTROL, modulesControl);
wpfCommandManager.Add(CommandConstants.GUID_DEBUGGER_MODULES_LISTVIEW, modulesControl.ListView);
}
CallStackContent(IWpfCommandManager wpfCommandManager, IThemeManager themeManager, ICallStackVM callStackVM, Lazy<IStackFrameManager> stackFrameManager, IFileTabManager fileTabManager, Lazy<IModuleLoader> moduleLoader) {
this.callStackControl = new CallStackControl();
this.vmCallStack = callStackVM;
this.stackFrameManager = stackFrameManager;
this.fileTabManager = fileTabManager;
this.moduleLoader = moduleLoader;
this.callStackControl.DataContext = this.vmCallStack;
this.callStackControl.CallStackListViewDoubleClick += CallStackControl_CallStackListViewDoubleClick;
themeManager.ThemeChanged += ThemeManager_ThemeChanged;
wpfCommandManager.Add(CommandConstants.GUID_DEBUGGER_CALLSTACK_CONTROL, callStackControl);
wpfCommandManager.Add(CommandConstants.GUID_DEBUGGER_CALLSTACK_LISTVIEW, callStackControl.ListView);
}
GoToTokenLoader(IWpfCommandManager wpfCommandManager, IFileTabManager fileTabManager) {
this.fileTabManager = fileTabManager;
var cmds = wpfCommandManager.GetCommands(CommandConstants.GUID_TEXTEDITOR_UICONTEXT);
cmds.Add(GoToToken,
(s, e) => GoToTokenCommand.ExecuteInternal(fileTabManager),
(s, e) => e.CanExecute = GoToTokenCommand.CanExecuteInternal(fileTabManager),
ModifierKeys.Control, Key.D);
cmds = wpfCommandManager.GetCommands(CommandConstants.GUID_FILE_TREEVIEW);
cmds.Add(GoToToken,
(s, e) => GoToTokenCommand.ExecuteInternal(fileTabManager),
(s, e) => e.CanExecute = GoToTokenCommand.CanExecuteInternal(fileTabManager),
ModifierKeys.Control, Key.D);
}
public FileTabReferenceResult Create(IFileTabManager fileTabManager, IFileTabContent sourceContent, object @ref)
{
var node = @ref as IFileTreeNodeData;
if (node != null)
return Create(node);
var nsRef = @ref as NamespaceRef;
if (nsRef != null)
return Create(nsRef);
var file = @ref as IDnSpyFile;
if (file != null)
return Create(file);
var asm = @ref as AssemblyDef;
if (asm != null)
return Create(asm);
var mod = @ref as ModuleDef;
if (mod != null)
return Create(mod);
return null;
}
AppWindow(IThemeManager themeManager, IImageManager imageManager, IAppSettings appSettings, ISettingsManager settingsManager, IFileTabManager fileTabManager, AppToolBar appToolBar, MainWindowControl mainWindowControl, IWpfCommandManager wpfCommandManager, ILanguageManager languageManager)
{
this.assemblyInformationalVersion = CalculateAssemblyInformationalVersion(GetType().Assembly);
this.uiSettings = new UISettings(settingsManager);
this.uiSettings.Read();
this.appSettings = appSettings;
this.stackedContent = new StackedContent<IStackedContentChild>(margin: new Thickness(6));
this.themeManager = themeManager;
themeManager.ThemeChanged += ThemeManager_ThemeChanged;
this.imageManager = imageManager;
this.fileTabManager = fileTabManager;
this.statusBar = new AppStatusBar();
this.appToolBar = appToolBar;
this.mainWindowControl = mainWindowControl;
this.wpfCommandManager = wpfCommandManager;
this.languageManager = languageManager;
this.mainWindowCommands = wpfCommandManager.GetCommands(CommandConstants.GUID_MAINWINDOW);
this.mainWindowClosing = new WeakEventList<CancelEventArgs>();
this.mainWindowClosed = new WeakEventList<EventArgs>();
this.appSettings.PropertyChanged += AppSettings_PropertyChanged;
InitializeTextFormatterProvider();
}
AnalyzeCommandLoader(IMainToolWindowManager mainToolWindowManager, IWpfCommandManager wpfCommandManager, IFileTabManager fileTabManager, Lazy<IAnalyzerManager> analyzerManager, ILanguageManager languageManager) {
this.mainToolWindowManager = mainToolWindowManager;
this.fileTabManager = fileTabManager;
this.analyzerManager = analyzerManager;
this.languageManager = languageManager;
var cmds = wpfCommandManager.GetCommands(CommandConstants.GUID_TEXTEDITOR_UICONTEXT);
cmds.Add(AnalyzeRoutedCommand, TextEditor_Executed, TextEditor_CanExecute, ModifierKeys.Control, Key.R);
cmds.Add(AnalyzeRoutedCommand, ShowAnalyzerExecuted, ShowAnalyzerCanExecute, ModifierKeys.Control, Key.R);
cmds = wpfCommandManager.GetCommands(CommandConstants.GUID_FILE_TREEVIEW);
cmds.Add(AnalyzeRoutedCommand, FileTreeView_Executed, FileTreeView_CanExecute, ModifierKeys.Control, Key.R);
cmds.Add(AnalyzeRoutedCommand, ShowAnalyzerExecuted, ShowAnalyzerCanExecute, ModifierKeys.Control, Key.R);
cmds = wpfCommandManager.GetCommands(CommandConstants.GUID_ANALYZER_TREEVIEW);
cmds.Add(AnalyzeRoutedCommand, AnalyzerTreeView_Executed, AnalyzerTreeView_CanExecute, ModifierKeys.Control, Key.R);
cmds.Add(AnalyzeRoutedCommand, ShowAnalyzerExecuted, ShowAnalyzerCanExecute, ModifierKeys.Control, Key.R);
cmds = wpfCommandManager.GetCommands(CommandConstants.GUID_SEARCH_LISTBOX);
cmds.Add(AnalyzeRoutedCommand, SearchListBox_Executed, SearchListBox_CanExecute, ModifierKeys.Control, Key.R);
cmds.Add(AnalyzeRoutedCommand, ShowAnalyzerExecuted, ShowAnalyzerCanExecute, ModifierKeys.Control, Key.R);
}
BamlRefresher(BamlSettingsImpl bamlSettings, IFileTabManager fileTabManager) {
this.fileTabManager = fileTabManager;
bamlSettings.PropertyChanged += BamlSettings_PropertyChanged;
}
CopyILBytesLoader(IWpfCommandManager wpfCommandManager, IFileTabManager fileTabManager, Lazy<IMethodAnnotations> methodAnnotations) {
this.fileTabManager = fileTabManager;
this.methodAnnotations = methodAnnotations;
var cmds = wpfCommandManager.GetCommands(CommandConstants.GUID_TEXTEDITOR_UICONTEXT);
cmds.Add(CopyILBytesCommand, CopyILBytesExecuted, CopyILBytesCanExecute, ModifierKeys.Control, Key.B);
}
DecompilerAppSettingsModifiedListener(IFileTabManager fileTabManager) {
this.fileTabManager = fileTabManager;
}
ShowCodeEditorCommandLoader(IWpfCommandManager wpfCommandManager, IFileTabManager fileTabManager)
{
var cmds = wpfCommandManager.GetCommands(CommandConstants.GUID_MAINWINDOW);
cmds.Add(ShowCodeEditorRoutedCommand,
(s, e) => { var tab = fileTabManager.ActiveTab; if (tab != null) tab.TrySetFocus(); },
(s, e) => e.CanExecute = fileTabManager.ActiveTab != null,
ModifierKeys.Control | ModifierKeys.Alt, Key.D0,
ModifierKeys.Control | ModifierKeys.Alt, Key.NumPad0,
ModifierKeys.None, Key.F7);
cmds.Add(ShowCodeEditorRoutedCommand, ModifierKeys.None, Key.Escape);
}
SaveTabCtxMenuCommand(ISaveManager saveManager, IFileTabManager fileTabManager)
: base(ApplicationCommands.Save)
{
this.saveManager = saveManager;
this.fileTabManager = fileTabManager;
}
