The Visual Studio 2008 C++ text editor only highlights matching braces if written the first time. Almost all text editors have the feature of highlighting matching braces if you put the cursor near to an open or close brace (even the Visual Studio C# editor). This add-in will provide this feature for C++ too. (Tested with Visual Studio 2008; for 2005, you need to change the version information in the "MatchingBraces.AddIn" file from 9.0 to 8.0).
To get the add-in working, we first need to get notified if the user has moved the cursor somewhere inside the text editor using the mouse or the keyboard. The Visual Studio Add-in API does not provide a functionality for mouse events. It is necessary to use a Window Hook using the SetWindowsHookEx() function. The built-in TextDocumentKeyPressEvents does not work with the arrow keys. For these keys, a keyboard hook is needed:
private void InitHook()
{
//init the mouse and keyboard hook
//with the thread id of the Visual Studio IDE
uint id = GetCurrentThreadId();
this.MouseProcDelegate = new HookProc(this.MouseProc);
mhhook = SetWindowsHookEx(WH_MOUSE,
this.MouseProcDelegate, IntPtr.Zero, id);
this.KeyboardProcDelegate =
new HookProcKeyboard(this.KeyboardProc);
khook = SetWindowsHookEx(WH_KEYBOARD,
this.KeyboardProcDelegate, IntPtr.Zero, id);
}
To make use of SetWindowsHookEx(), it is necessary to use the Platform Invoke stuff. If the user released a key or released a mouse button, the MouseProc (or KeyboardProc) 'function' will be called before the event reaches the Visual Studio window.
If KeyboardProc is called, we only know that a key is released somewhere. First, we need to make sure that a document is open and that the document is a C++ source code:
private int KeyboardProc(int code, IntPtr wParam, IntPtr lParam)
{
try
{
if (code != HC_ACTION)
{
return CallNextHookEx(khook, code, wParam, lParam);
}
//only with a C++ document open
if (_applicationObject.ActiveDocument == null ||
_applicationObject.ActiveDocument.Language != "C/C++")
{
return CallNextHookEx(mhhook, code, wParam, lParam);
}
Next, we need to check if the event occurred inside the editor window and not somewhere else:
//check if the editor window has the keyboard focus
IntPtr h = GetFocus();
if (!isEditorWindow(h))
{
return CallNextHookEx(mhhook, code, wParam, lParam);
}
[...]
private static bool isEditorWindow(IntPtr hWnd)
{
IntPtr res;
StringBuilder ClassName = new StringBuilder(256);
res = GetClassName(hWnd, ClassName, ClassName.Capacity);
if (res != IntPtr.Zero)
{
if (ClassName.ToString() == "VsTextEditPane")
{
return true;
}
}
return false;
}
This is the case if the keyboard focus belongs to a window with the class "VsTextEditPane".
Next, we are (almost) ready to highlight the matching braces:
private void Highlight()
{
try
{
TextSelection ts =
(TextSelection)_applicationObject.ActiveDocument.Selection;
if (!ts.IsEmpty)
{
return;
}
//create an edit point on the current cursor position
EditPoint ep = ts.ActivePoint.CreateEditPoint();
//get the letter on the left side of the cursor
String s = ep.GetText(-1);
//check if it is one of the braces: '{[( }])'
String pattern = "({|}|\\[|\\]|\\(|\\))";
if (System.Text.RegularExpressions.Regex.IsMatch(s, pattern))
{
//select the brace and rewrite it,
//this will trigger the matching braces
//functionality from Visual Studio
ts.CharLeft(true, 1);
ts.Text = s;
}
}
catch
{
}
}
Of course, it is first necessary to check if the cursor (returned by ts.ActivePoint.CreateEditPoint()) is on the right side of a brace, using GetText(-1) and a Regex which will match for all braces. If 'Yes', the brace will be selected using ts.CharLeft(true, 1) and replaced with a new one. This will trigger the built-in brace matching functionality of Visual Studio.
Everything between the call of _applicationObject.UndoContext.Open() and _applicationObject.UndoContext.SetAborted() will not be visible in the undo-list.
After calling UndoContext.SetAborted(), the cursor will jump to the last position before UndoContext.Open() was called. It is necessary to move the page back to the current position. To hide this movement from the user, it is necessary to forbid the updating of the editor window by using: SendMessage(EditorWindowHwnd, WM_SETREDRAW, (IntPtr)0, (IntPtr)0). If everything is finished, window updating could be re-enabled using SendMessage(EditorWindowHwnd, WM_SETREDRAW, (IntPtr)1, (IntPtr)0).
The add-in needs to rewrite the brace. This modifies the text as long as the cursor is near a brace. If you move the cursor away, the text is not modified anymore.
This is an essential feature for every text editor.
, because an intellisense menu will now always popup, showing you multiple choices.