void doubleCommentAction_Execute(ExecuteEventArgs ea)
        {
            var activeTextDocument = CodeRush.Documents.ActiveTextDocument;
            if (activeTextDocument == null)
            {
                return;
            }

            var selection = activeTextDocument.ActiveViewSelection;
            selection.ExtendToWholeLines();

            var lang = CodeRush.Language;

            var commentedSelection = string.Empty;

            var lines = selection.Lines;

            foreach (var line in lines)
            {
                var lineText = line.TrimStart();

                var commentLine = lang.GetComment(lang.GetComment(lineText));
                var idx = commentLine.LastIndexOf(System.Environment.NewLine);
                commentLine = commentLine.Remove(idx);
                commentedSelection += commentLine;
            }

            selection.Text = commentedSelection;
            selection.Format();

            if (selection.AnchorIsAtEnd)
                selection.SwapPoints();
            selection.Clear();
        }

        private void TemplateExpandWithCollapsedRegions_Execute(ExecuteEventArgs ea)
        {
            TextDocument ActiveDoc = CodeRush.Documents.ActiveTextDocument;

            using (ActiveDoc.NewCompoundAction("TemplateExpandWithCollapsedRegions"))
            {
                var LinesFromStart = CodeRush.Caret.Line;
                var LinesFromEnd = ActiveDoc.LineCount - LinesFromStart;

                DevExpress.CodeRush.Core.Action Action = CodeRush.Actions.Get("TemplateExpand");
                Action.DoExecute();

                // Calculate line range that template expanded into.
                SourceRange TemplateExpandRange = new SourceRange(new SourcePoint(LinesFromStart, 1),
                                              new SourcePoint(ActiveDoc.LineCount - LinesFromEnd,
                                                  ActiveDoc.GetLine(LinesFromEnd).Length - 1)
                    );
                // Reparse everything just in case.
                CodeRush.Documents.ParseActive();
                CodeRush.Documents.ActiveTextDocument.ParseIfTextChanged();

                // Execute a delayed collapse of all regions in the ExpansionRange
                RangeRegionCollapser Collapser = new RangeRegionCollapser(TemplateExpandRange);
                Collapser.PerformDelayedCollapse(150);

            }
        }

        public void Login(object sender, ExecuteEventArgs args)
        {
            IsLoading = true;
            DidLoginFail = false;

            LoginRepository.LoginAsync(
                new Models.LoginCredentials(UserName, args.MethodParameter as string),
                (result, authToken, ex) =>
                {
                    IsLoading = false;
                    if (ex == null)
                    {
                        DidLoginFail = !result;
                        if (!DidLoginFail)
                        {
                            UserMetaData.AuthToken = authToken;
                            Bxf.Shell.Instance.ShowView("/Views/Customers.xaml", null, null, null);
                        }
                    }
                    else
                    {
                        DidLoginFail = true;
                    }
                });
        }

 private void ExecuteOrganizeWORegions(ExecuteEventArgs ea)
 {
     ClassOrganizer organizer = new ClassOrganizer();
     organizer.Organize(CodeRush.Documents.ActiveTextDocument,
                              CodeRush.Source.ActiveType,
                              false);
 }

        private void exploreXafErrors_Execute(ExecuteEventArgs ea)
        {
            Project startUpProject = CodeRush.ApplicationObject.Solution.FindStartUpProject();
            Property outPut = startUpProject.ConfigurationManager.ActiveConfiguration.FindProperty(ConfigurationProperty.OutputPath);
            Property fullPath = startUpProject.FindProperty(ProjectProperty.FullPath);
            string path = Path.Combine(fullPath.Value.ToString(),outPut.Value.ToString());
            var reader = new InverseReader(Path.Combine(path,"expressAppFrameWork.log"));
            var stackTrace = new List<string>();
            while (!reader.SOF) {
                string readline = reader.Readline();
                stackTrace.Add(readline);
                if (readline.Trim().StartsWith("The error occured:")) {
                    stackTrace.Reverse();
                    string errorMessage = "";
                    foreach (string trace in stackTrace) {
                        errorMessage += trace + Environment.NewLine;
                        if (trace.Trim().StartsWith("----------------------------------------------------"))
                            break;
                    }
                    Clipboard.SetText(errorMessage);
                    break;
                }
            }
            reader.Close();

        }

        private void CleanupFileAndNamespaces_Execute(ExecuteEventArgs ea)
        {
            using (var action = CodeRush.Documents.ActiveTextDocument.NewCompoundAction("Cleanup File and Namespaces"))
            {
                // Store Address
                var Address = NavigationServices.GetCurrentAddress();

                // Find first NamespaceReference
                ElementEnumerable Enumerable =
                    new ElementEnumerable(CodeRush.Source.ActiveFileNode,
                                          LanguageElementType.NamespaceReference, true);
                NamespaceReference Reference = Enumerable.OfType<NamespaceReference>().FirstOrDefault();

                if (Reference == null)
                {
                    // No Namespace References to sort.
                    return;
                }
                // Move caret
                CodeRush.Caret.MoveTo(Reference.Range.Start);

                CleanupFile();
                InvokeRefactoring();
                // Restore Location
                NavigationServices.ResolveAddress(Address).Show();
            }
        }

        public void MovieSelected(object sender, ExecuteEventArgs args)
        {
            var movie = args.MethodParameter as Movie;
            var message = new ShowViewMessage(MoviesViewTargets.Detail, movie);

            MessageBus.Publish<ShowViewMessage>(message);
        }

        private void ReviseSelection_Execute(ExecuteEventArgs ea)
        {
            // Check we have a valid Active TextDocument and TextView
            TextDocument activeTextDocument = CodeRush.Documents.ActiveTextDocument;
            if (activeTextDocument == null)
                return;
            TextView activeView = activeTextDocument.ActiveView;
            if (activeView == null)
                return;

            // Extend Selection - This action only works on whole lines.
            activeView.Selection.ExtendToWholeLines();

            // Get Text in selection 
            SourceRange activeSelectionRange = activeView.Selection.Range;
            string textToDuplicate = activeTextDocument.GetText(activeSelectionRange);

            // Remove \r and split on \n - These will be added back later using GetComment
            string strippedText = textToDuplicate.Replace("\r", "");
            string[] commentedLines = strippedText.Split('\n');

            // Build Commented version of code 
            string commentedCode = String.Empty;
            for (int i = 0; i < commentedLines.Length; i++)
                if (commentedLines[i] != String.Empty || i != commentedLines.Length - 1)
                    commentedCode += CodeRush.Language.GetComment(" " + commentedLines[i]);

            // BuildReplacement text - Includes CommentedCode and OriginalText
            string textToInsert = CodeRush.Language.GetComment(" Old code:") + commentedCode
                                + CodeRush.Language.GetComment("-----------") + textToDuplicate;

            // Replace originalText with newly built code.
            activeTextDocument.SetText(activeSelectionRange, textToInsert);

        }

 private void exploreXafErrors_Execute(ExecuteEventArgs ea) {
     Project startUpProject = CodeRush.ApplicationObject.Solution.FindStartUpProject();
     Property outPut = startUpProject.ConfigurationManager.ActiveConfiguration.FindProperty(ConfigurationProperty.OutputPath);
     bool isWeb = IsWeb(startUpProject);
     string fullPath = startUpProject.FindProperty(ProjectProperty.FullPath).Value + "";
     string path = Path.Combine(fullPath, outPut.Value.ToString()) + "";
     if (isWeb)
         path = Path.GetDirectoryName(startUpProject.FullName);
     Func<Stream> streamSource = () => {
         var path1 = path + "";
         File.Copy(Path.Combine(path1, "expressAppFrameWork.log"), Path.Combine(path1, "expressAppFrameWork.locked"), true);
         return File.Open(Path.Combine(path1, "expressAppFrameWork.locked"), FileMode.Open, FileAccess.Read, FileShare.Read);
     };
     var reader = new ReverseLineReader(streamSource);
     var stackTrace = new List<string>();
     foreach (var readline in reader) {
         stackTrace.Add(readline);
         if (readline.Trim().StartsWith("The error occured:") || readline.Trim().StartsWith("The error occurred:")) {
             stackTrace.Reverse();
             string errorMessage = "";
             foreach (string trace in stackTrace) {
                 errorMessage += trace + Environment.NewLine;
                 if (trace.Trim().StartsWith("----------------------------------------------------"))
                     break;
             }
             Clipboard.SetText(errorMessage);
             break;
         }
     }
 }

 private void actReSharperGoToInheritor_Execute(ExecuteEventArgs ea)
 {
   if (CodeRush.Source.ActiveMember != null)
     CodeRush.Command.Execute("Navigate", "Overrides");
   else
     CodeRush.Command.Execute("Navigate", "Descendants");
 }

        private void actAddLogging_Execute(ExecuteEventArgs ea)
        {
            try
            {
                Class activeClass = CodeRush.Source.ActiveClass;

                //IEnumerable<Method> methods = (IEnumerable<Method>)activeClass.AllMethods;

                fileChangeCollection = new FileChangeCollection();

                foreach (var method in activeClass.AllMethods)
                {
                    Method methodDetails = (Method)method;

                    System.Diagnostics.Debug.WriteLine(string.Format("Method:  Name:>{0}<  Type:>{1}<", methodDetails.Name, methodDetails.MethodType));
                    AddLoggingToMethod((DevExpress.CodeRush.StructuralParser.Method)method);
                }

                //Method activeMethod = CodeRush.Source.ActiveMethod;

                //AddLoggingToMethod(activeMethod);

                CodeRush.File.ApplyChanges(fileChangeCollection);
                CodeRush.Source.ParseIfTextChanged();

            }
            catch (Exception ex)
            {
                System.Diagnostics.Debug.WriteLine(ex.ToString());
            }
        }

 private void actQuickPair_Execute(ExecuteEventArgs ea)
 {
     string left = actQuickPair.Parameters["Left"].ValueAsStr;
     string right = actQuickPair.Parameters["Right"].ValueAsStr;
     bool positionCaretBetweenDelimiters = actQuickPair.Parameters["CaretBetween"].ValueAsBool;
     if (left.StartsWith("\","))
     {
         if (right == "true")
             positionCaretBetweenDelimiters = true;
         right = left.Substring(2).Trim();
         left = "\"";
     }
     TextDocument activeTextDocument = CodeRush.Documents.ActiveTextDocument;
     if (activeTextDocument == null)
         return;
     TextView activeView = activeTextDocument.ActiveView;
     if (activeView == null)
         return;
     TextViewSelection selection = activeView.Selection;
     if (selection == null)
         return;
     TextViewCaret caret = activeView.Caret;
     if (caret == null)
         return;
     if (selection.Exists)
     {
         Embedding embedding = new Embedding();
         embedding.Style = EmbeddingStyle.StartEnd;
         string[] top = { left };
         string[] bottom = { right };
         embedding.Top = top;
         embedding.Bottom = bottom;
         if (positionCaretBetweenDelimiters)
             embedding.AdjustSelection = PostEmbeddingSelectionAdjustment.Leave;
         else
             embedding.AdjustSelection = PostEmbeddingSelectionAdjustment.Extend;
         bool needToMoveCaretToTheRight = false;
     if (selection.AnchorPosition < selection.ActivePosition)
             needToMoveCaretToTheRight = true;
         using (activeTextDocument.NewCompoundAction(STR_EmbedQuickPair))
         {
             activeTextDocument.EmbedSelection(embedding);
             if (needToMoveCaretToTheRight)
             {
                 selection.Set(selection.ActivePosition, selection.AnchorPosition);
             }
         }
     }
     else
     {
         if (CodeRush.Windows.IntellisenseEngine.HasSelectedCompletionSet(activeView))
             CodeRush.Command.Execute("Edit.InsertTab");
         using (activeTextDocument.NewCompoundAction(STR_QuickPair))
             if (positionCaretBetweenDelimiters)
                 activeTextDocument.ExpandText(caret.SourcePoint, left + "«Caret»«Field()»" + right + "«FinalTarget»");
             else
                 activeTextDocument.InsertText(caret.SourcePoint, left + right);
     }
 }

        private void ExecuteCutCurrentMember(ExecuteEventArgs ea)
        {
            bool selected =
                 Utilities.SelectCurrentMember(CodeRush.Caret, CodeRush.Documents.ActiveTextDocument);

            if (selected == true)
                CodeRush.Clipboard.Cut();
        }

 private void CollapseXML_Execute(ExecuteEventArgs ea)
 {
     var Doc = CodeRush.Documents.ActiveTextDocument;
     var elements = new ElementEnumerable(Doc.FileNode, LanguageElementType.HtmlElement, true);
     foreach (SP.HtmlElement html in elements.OfType<SP.HtmlElement>())
     {
         var attributes = html.Attributes.OfType<SP.HtmlAttribute>().ToList();
         if (attributes.Any(at => at.Name.ToLower() == "id" || at.Name.ToLower() == "name"))
             html.CollapseInView(Doc.ActiveView);
     }
 }

        private void action1_Execute(ExecuteEventArgs ea)
        {
            Document currentDocument = CodeRush.Documents == null ? null : CodeRush.Documents.Active;

              IMarker marker = CodeRush.Markers.Collect();

              if ((marker != null) && (currentDocument != null) &&
            !marker.FileName.Equals(currentDocument.FullName, StringComparison.OrdinalIgnoreCase))
              {
            currentDocument.Close(EnvDTE.vsSaveChanges.vsSaveChangesPrompt);
              }
        }

 private void ImportTemplates_Execute(ExecuteEventArgs ea)
 {
     // Package: https://raw2.github.com/RoryBecker/CodeRushTemplatePackages/master/CS_PluginTemplatesPackage.xml
     // Template: https://raw2.github.com/RoryBecker/CodeRushPluginTemplates/master/CS_NewAction.xml
     // Template: https://raw2.github.com/groovyghoul/fakeiteasy-coderush-templates/master/CSharp_Custom_FakeItEasy.xml
     //TemplateLoader TemplateLoader = new TemplateLoader();
     //TemplateLoader.ImportTemplatePackageViaUrl("https://raw2.github.com/RoryBecker/CodeRushTemplatePackages/master/CS_PluginTemplatesPackage.xml");
     //TemplateLoader.SaveAndReloadTemplates();
     using (TemplateImporter TemplateImporter = new TemplateImporter())
     {
         TemplateImporter.ShowDialog();
     }
 }

        private void convertProject_Execute(ExecuteEventArgs ea) {
            string path = Options.ReadString(Options.ProjectConverterPath);
            string token = Options.ReadString(Options.Token);
            if (!string.IsNullOrEmpty(path) && !string.IsNullOrEmpty(token)) {
                var directoryName = Path.GetDirectoryName(CodeRush.Solution.Active.FileName);

                var userName = string.Format("/s /k:{0} \"{1}\"", token, directoryName);
                Process.Start(path, userName);
                actionHint1.Text = "Project Converter Started !!!";
                Rectangle rectangle = Screen.PrimaryScreen.Bounds;
                actionHint1.PointTo(new Point(rectangle.Width / 2, rectangle.Height / 2));
            }
        }

 private void acnCreateTestMethod_Execute(ExecuteEventArgs ea)
 {
     if (!IsAvailable())
         return;
     var text = string.Empty;
     if (CodeRush.Selection.Exists)
         text = CodeRush.Selection.Text;
     else if (CodeRush.Caret.InsideComment)
         text = CodeRush.Source.ActiveComment.Name;
     else
         return;
     CreateTestMethod(text);
 }

		private void MultiSelectEdit_Execute(ExecuteEventArgs ea)
		{
			TextView TheView = CodeRush.TextViews.Active;
			var TheMultiSelect = CodeRush.MultiSelect.Get(TheView);
			if (TheMultiSelect == null || TheMultiSelect.Selections.Count == 0)
			{
				return;
			}
			var StartingSelectionRange = TheView.Selection.Range;
			LinkSourceRanges(TheView, StartingSelectionRange, TheMultiSelect.Selections.ToRanges());
			LinkOriginalRange(TheView, StartingSelectionRange, TheMultiSelect.Selections.ToRanges());
			TheMultiSelect.RefreshHighlighting(TheView);
		}

 private void action1_Execute(ExecuteEventArgs ea)
 {
     if (timer1.Enabled)
     {
         timer1.Enabled = false;
         timer1.Stop();
         _editorGraphics.FillRectangle(_background, GetRectangle(TextView.Active));
     }
     else
     {
         timer1.Enabled = true;
         timer1.Start();
     }
 }