static bool TreeView_IsVisible(TextViewContext context)
 {
     ModuleDef module;
     return context.TreeView == MainWindow.Instance.treeView &&
         ((module = ILSpyTreeNode.GetModule(context.SelectedTreeNodes)) != null) &&
         module.EntryPoint is MethodDef;
 }

		protected static void PreserveNodeSelection(TextViewContext context, Action action)
		{
			var treeView = context.TreeView;
			if (treeView == null)
				return;
	
			var instance = MainWindow.Instance;
			var oldNode = treeView.SelectedItem as SharpTreeNode;
			var path = MainWindow.GetPathForNode(oldNode);

			action();

			var newNode = instance.FindNodeByPath(path, false);

			// If not found let's try parent node
			if (newNode == null && path.Length > 1)
			{
				newNode = instance.FindNodeByPath(path.Take(path.Length - 1).ToArray(), false);
				if (oldNode != null)
					oldNode = oldNode.Parent;
			}

			if (newNode == null)
				return;

			instance.SelectNode(newNode);
			newNode.IsExpanded = oldNode != null && oldNode.IsExpanded;
		}

		internal static void RenameSelectedNode(this IRenamerContextMenu item, TextViewContext context, Action<TextViewContext> action)
		{
			var treeView = context.TreeView;
			var activeHandler = BaseContextMenu.ILSpyPackage.ActiveHandler;
			if (treeView == null || activeHandler == null)
				return;

			var targetObject = activeHandler.TargetObject;
			if (targetObject == null)
				return;

			var instance = MainWindow.Instance;
			var oldNode = treeView.SelectedItem as ILSpyTreeNode;
			var path = instance.GetPathForNode(oldNode);
			var oldName = RenameHelper.GetName(targetObject);

			action(context);

			var newNode = item.FindRenamedNode(oldNode, path, oldName, targetObject);
			if (newNode == null) 
				return;

			instance.SelectNode(newNode);
			newNode.IsExpanded = oldNode != null && oldNode.IsExpanded;
		}

 static bool TextEditor_IsVisible(TextViewContext context)
 {
     ModuleDef module;
     return context.TextView != null &&
         (module = GetModule()) != null &&
         module.EntryPoint is MethodDef;
 }

 public void Execute(TextViewContext context)
 {
     if (TreeView_IsVisible(context))
         MainWindow.Instance.JumpToReference(ILSpyTreeNode.GetModule(context.SelectedTreeNodes).EntryPoint);
     else if (TextEditor_IsVisible(context))
         MainWindow.Instance.JumpToReference(GetModule().EntryPoint);
 }

 public bool IsVisible(TextViewContext context)
 {
     return context.SelectedTreeNodes != null &&
         context.SelectedTreeNodes.Length == 1 &&
         context.SelectedTreeNodes[0] is AssemblyTreeNode &&
         !string.IsNullOrWhiteSpace(((AssemblyTreeNode)context.SelectedTreeNodes[0]).LoadedAssembly.FileName);
 }

        public override void Execute(TextViewContext context)
        {
            if (context.SelectedTreeNodes.Length != 1)
            {
                throw new Exception("SelectedTreeNodes = " + context.SelectedTreeNodes.Length);
            }
            var xCurrentField = context.SelectedTreeNodes[0] as FieldTreeNode;
            if (xCurrentField == null)
            {
                throw new Exception("Current TreeNode is not a Field!");
            }

            if (MessageBox.Show("Do you want to generate FieldAccess code to your clipboard?", "Cosmos Plug tool", MessageBoxButton.YesNo) == MessageBoxResult.No)
            {
                return;
            }


            Clipboard.SetText(String.Format("[FieldAccess(Name = \"{0} {1}.{2}\")] ref {3} field{2}",
                                            xCurrentField.FieldDefinition.FieldType.FullName,
                                            xCurrentField.FieldDefinition.DeclaringType.FullName,
                                            xCurrentField.FieldDefinition.Name,
                                            Utilities.GetCSharpTypeName(xCurrentField.FieldDefinition.FieldType)));
            MessageBox.Show("Done", "Cosmos Plug tool");
        }

        public override void Execute(TextViewContext context)
        {
            if (context.SelectedTreeNodes.Length != 1)
            {
                throw new Exception("SelectedTreeNodes = " + context.SelectedTreeNodes.Length);
            }
            var xCurrentProperty = context.SelectedTreeNodes[0] as PropertyTreeNode;
            if (xCurrentProperty == null)
            {
                throw new Exception("Current TreeNode is not a Property!");
            }

            if (MessageBox.Show("Do you want to generate plug code to your clipboard?", "Cosmos Plug tool", MessageBoxButton.YesNo) == MessageBoxResult.No)
            {
                return;
            }

            var xProp = xCurrentProperty.PropertyDefinition;
            var xSB = new StringBuilder();
            if (xProp.GetMethod != null)
            {
                xSB.AppendLine(GenerateMethodPlugEntry.GenerateMethod(xProp.GetMethod));
                xSB.AppendLine();
            }
            if (xProp.SetMethod != null)
            {
                xSB.AppendLine(GenerateMethodPlugEntry.GenerateMethod(xProp.SetMethod));
                xSB.AppendLine();
            }

            Clipboard.SetText(xSB.ToString().Trim());

            MessageBox.Show("Done", "Cosmos Plug tool");
        }

 public bool IsVisible(TextViewContext context)
 {
     var list = GetMappings(context);
     return list != null &&
         list.Count != 0 &&
         list[0].MemberMapping.MethodDefinition != null &&
         list[0].MemberMapping.MethodDefinition.Body != null &&
         list[0].MemberMapping.MethodDefinition.Body.Instructions.Count > 0;
 }

        public void Execute(TextViewContext context)
        {
            var types = context.SelectedTreeNodes
                .OfType<TypeTreeNode>()
                .Select(n => HAL.Converter.Type(n.TypeDefinition))
                .ToArray();

            Services.BrowseInteractions(types, true);
        }

        public void Execute(TextViewContext context)
        {
            var assemblyDefinitions = context.SelectedTreeNodes
                .OfType<AssemblyTreeNode>()
                .Select(n => Converter.Assembly(n.LoadedAssembly.AssemblyDefinition))
                .ToList();

            Services.BrowseAssemblies(assemblyDefinitions);
        }

        public bool IsVisible(TextViewContext context)
        {
            if (context.SelectedTreeNodes == null)
            {
                return false;
            }

            return context.SelectedTreeNodes.OfType<AssemblyTreeNode>().Count() > 0;
        }

        public bool IsVisible(TextViewContext context)
        {
            if (context.SelectedTreeNodes == null)
            {
                return false;
            }

            return context.SelectedTreeNodes.All(n => n is AssemblyTreeNode);
        }

        public void Execute(TextViewContext context)
        {
            var assemblyDefinitions = context.SelectedTreeNodes
                .OfType<AssemblyTreeNode>()
                .Select(n => HAL.Converter.Assembly(n.LoadedAssembly.AssemblyDefinition))
                .ToList();

            var window = WindowManager.AssemblyBrowsers.Single();
            window.ViewModel.AddAssemblies(assemblyDefinitions);
        }

        public bool IsVisible(TextViewContext context)
        {
            if (context.SelectedTreeNodes == null)
            {
                return false;
            }

            return (context.SelectedTreeNodes.Count() == 1)
                   && (context.SelectedTreeNodes.Single() is TypeTreeNode);
        }

 internal static IList<SourceCodeMapping> GetMappings(TextViewContext context)
 {
     if (context.TextView == null || context.Position == null)
         return null;
     var list = SourceCodeMappingUtils.Find(context.TextView, context.Position.Value.Line, context.Position.Value.Column);
     if (list.Count == 0)
         return null;
     if (!(list[0].StartLocation.Line <= context.Position.Value.Line && context.Position.Value.Line <= list[0].EndLocation.Line))
         return null;
     return list;
 }

 public override void Execute(TextViewContext context)
 {
     var obj = GetReference(context);
     if (obj != null) {
         var member = MainWindow.ResolveReference(obj);
         if (member == null)
             MainWindow.Instance.ShowMessageBox("Could not resolve member definition");
         else
             Execute(member);
     }
 }

        public void Execute(TextViewContext context)
        {
            var assemblyDefinitions = context.SelectedTreeNodes
                .OfType<AssemblyTreeNode>()
                .Select(n => n.LoadedAssembly.AssemblyDefinition);

            var window = new DependencyBrowserWindow(assemblyDefinitions.Select(HAL.Converter.Assembly))
            {
                Owner = Services.MainWindow
            };
            window.Show();
        }

        public void Execute(TextViewContext context)
        {
            var typeDefinition = context.SelectedTreeNodes
                .OfType<TypeTreeNode>()
                .Single().TypeDefinition;

            var window = new AncestryBrowserWindow(HAL.Converter.Type(typeDefinition))
                         	{
                         		Owner = MainWindow.Instance
                         	};
            window.Show();
        }

 public override bool IsVisible(TextViewContext context)
 {
     if (context.SelectedTreeNodes.Length != 1)
     {
         return false;
     }
     var xCurrentType = context.SelectedTreeNodes[0] as TypeTreeNode;
     if (xCurrentType == null)
     {
         return false;
     }
     return true;
 }