Code Window

One of the common features that add-in modules offer is the ability to manipulate the code in windows. In this chapter, we will create an add-in to interact with the code in an open document window. We will explore how to pull code from the window, manipulate it, and write it back.

Simple code manipulation

We are still going to use the wizard to create our basic add-in, but rather than attach our code to the Tools menu, this time we will attach it to the context menu of the code window. So let’s start up the wizard with the following:

• Visual C# (or your preferred language).
• Application Host: Only Visual Studio.
• Name/Description: CodeHelp and Send sample of code to a guru…
• Create UI Menu and do not load at start-up.

What this add-in will do is allow you to send an email with a sample of code to your local guru (hopefully you have one) and ask him or her what the code is doing. The add-in will then leave a [TODO] comment indicating that the code was sent to a guru and we need to document what is being accomplished by this code when the guru replies.

Attaching to the code window

Since our add-in module is going to attach to the code window instead of the main menu, we need to code our connection logic slightly differently.

We are searching for the “Code Window” (precise spelling is important) and adding a pop-up menu control to it, rather than to the usual menu.

Responding to the click

When the user selects the menu item, the Exec() method will be called to process the Send code to the Guru… menu option.

Since the code will only be called from a code window (since our menu item is attached to the context menu), we can assume an active document will always be available.

Getting selected code

Once we have the selected text and confirmed some text was selected:

We can build a mail message and send it to our guru.

Note: You will need to add a reference to System.net.mail and define a string constant GuruEmail and a string constant fromDomain with your e-mail domain.

Tweak the code fragment

Now that we’ve sent our code to the guru for his or her comments and review, we want to mark the code with a to-do comment so we can add documentation when the guru replies to our email.

In this example, we are adding the comment and the to-do token that the IDE currently uses for tasks. This will allow our comment to be found easily using the task list window within Visual Studio.

Putting the code back

And now that we’ve assembled our revised code string, we need to update the editor with the revision. This is accomplished by copying the revised text to the Windows clipboard as text, and then pasting that text back to the editor.

This is just a simple example of basic interaction with the contents of the code window. We don’t perform any analysis of the content. We simply grab the code, tweak it somehow, and then put it back. However, this is only part of the capabilities built into Visual Studio.

Moving the code around

You do not have to put the samples or code revisions back where they came from. You can add code to the top or beginning of the file, or even at a random spot in the middle (although users are not likely to appreciate that).

Text Document

In order to manipulate the document, you need access to the TextDocument object associated with the current document. This is accomplished with the following command:

The TextDocument object provides two point objects (StartPoint and EndPoint) referring to the expected locations in the body of text. In addition, there are some simple methods to mark and replace text within the document that matches a particular pattern.

For example, the following code sample will replace all occurrences of double with float in the document associated with the text document.

You can also add FindOptions as the third parameter to control case matching, where to start searching the document, whether to match the whole word, etc. If you need to perform simple replacements on the entire document, the Text Document object provides the methods to do just that.

Edit point

The Text Document object also allows you to create an EditPoint object, which can be used to position your code anywhere within the document and make edits, deletions, insertions, etc. To create the edit point variable, use the following command:

This allows a much finer degree of control over text manipulation. An edit point is the location in the file where you want to manipulate text. If you create an EditPoint object with no parameters, it is the same as the starting point from the text document. You can also specify a point as a parameter, so you could create an edit point based on the last location in the document by using EndPoint.

Once you have the EditPoint object, you have a variety of navigation functions to move through the text, such as:

• CharLeft(n): Move to the left n characters.
• CharRight(n): Move to the right n characters.
• EndOfLine(): Move to the end of the current line.
• LineDown(n): Move down n lines.
• LineUp(n): Move up n lines.
• WordLeft(n): Move to the left n words.
• WordRight(n): Move to the right n words.

When the point is positioned, you can insert text into the document. You can also use the Get methods to extract text from the document. For example, the following sample looks for lines beginning with using and adds a comment indicating the line needs to be converted to imports when converting from C# to Visual Basic.

More complex code manipulation

While the methods and examples in this chapter allow simple text manipulations, they do not provide much in the way of parsing your source code. Fortunately, Visual Studio has a built-in class system that allows us to analyze code windows much more efficiently, without writing our own code parsers or worrying about VB.NET or C#. This system is the code model, and is described in the next chapter.