Filter using logical “or”

Many of the dialogs and drop-downs of Visual Assist allow efficient lookups via filtering. For example, filtering within Open File in Solution—a dialog with all files in a solution—lets one find a file quickly if only portions of a name are known. This means one can find veryLongFilenameInProjectTomato.cpp if he knows only “long” and “toma”.

Filtering takes many shapes. Aside from substrings, one can filter using simple expressions. Our expression syntax isn’t full regex but it is tailored to the content being searched.

In this blog post, I introduce searching using logical “or”.

Filtering using logical “or” is often applicable when searching VA Hashtags, where tags are created on-the-fly and often without standards. For example, developers might annotate code with VA Hashtags of the format “todo” followed by the name of the teammate who needs to review or fix the code, but names are entered as first names, last names, or misspelled variants thereof.

For tasks related to developer John Smith, we might find VA Hashtags in either of the following forms.

// #todoJohnSmith
// #todoJSmith

Filtering for “smith” in the VA Hashtags tool window easily finds both.


But a teammate might annotate code with only John’s first name.

// #todoJohn

In this case, filtering for “smith” won’t find the new hashtag. We need to search for “smith or john”, and we use a comma in our expression to do that.


Then, our code might also include unrelated hashtags for John, e.g., a comment directed only at him.

// #John, I fixed this for you.

The previous filtering for “smith or john” will include the unwanted entry.


To omit the unwanted entry, we need to search for “todo and smith” or “todo and John”. We do that with multiple substrings and a comma.


This final expression using logical “or” gives us exactly what we want.

You can use expressions in all dialogs and drop-downs that support filtering, including the several that support logical “or”:

If you want to know more about expressions, study one of the features that supports logical “or”, then experiment in all the dialogs and drop-downs you encounter.

Logical “or” requires Visual Assist build 2062 or newer.

Quick Refactoring Menu of Visual Assist offers more than refactoring

If you use Visual Assist, you are probably familiar with its Quick Refactoring Menu—available via a hovering icon or the default shortcut (Shift+Alt+Q). But, you might not appreciate how frequently the menu is available. Quick Action Menu is a more apt name.

Availability aside, the Quick Refactoring Menu is an efficient method of tapping into the features of Visual Assist because the menu contains only pertinent actions; it’s always concise. (If you examine the “Refactor (VA)” submenu of the editor’s context menu, you will find all possible actions. The entries enabled in any one scenario are the ones in the Quick Refactoring Menu.)

Available actions in the Quick Refactoring Menu depend on what Visual Assist thinks you might do and where you are: in whitespace, in a symbol, or with a selection.


Browse the following list of actions that can appear in the Quick Refactoring Menu. Look for unfamiliar actions and envision scenarios in which they make sense. Try a few and add them to your arsenal. If you can’t fathom when or where an action might be available, click through and find an answer in documentation.

Action Availability
Add Using or #include from a symbol declared externally
Add Member from a class name
Add Similar Member from a member of a class
Change Signature from an existing signature
Create Declaration from an implementation
Create File from whitespace
Create From Usage from an unknown symbol
Create Implementation from a declaration
Create Method Implementations from a class declaration
Document Method from the name of a method
Encapsulate Field from the declaration of a member
Extract Method with a selection
Find Reference from a symbol
Implement Interface / Virtual Methods from a class name
Introduce Variable with a selection or from whitespace
Move Implementation to Source File from a method defined in a header
Move Selection to New File with a selection
Rename from a symbol
Rename File(s) from whitespace

Reset zoom level of Visual Studio to 100%

If you have ever been frustrated by an inadvertent zoom-in or zoom-out in Visual Studio, you probably know there is no convenient way in the IDE to reset the zoom level to 100%. Instead, the IDE requires you to “reset” via increments until you reach 100%.


These inadvertent zooms occurred often enough among the developers of Visual Assist that one of them created a more efficient way to reset. You can have access to the functionality by assigning a shortcut to VAssistX.ResetEditorZoom. Use Ctrl+0 if you want to be consistent with the reset commands in web browsers.

VAssistX.ResetEditorZoom works only within the scope of the text editor, and you assign a shortcut in the usual manner–via the options dialog of the IDE.

Tools to understand new code: Enhanced Syntax Coloring

In my previous posts as guest contributor to this blog, I showed you how to use Go-To tools and different Find commands in Visual Assist. In this post, I describe improvements to syntax coloring available in Visual Assist, then close with a description of a tool window that combines several functions of the IDE and Visual Assist.

As in my previous posts, I will use Irrlicht Engine as my example project.

Enhanced Syntax Coloring

Syntax coloring in the IDE—whatever the version—makes code nice to read, and for me, faster to write. But, it’s the enhancements to coloring in Visual Assist that make code really easy to understand.

Let me compare default coloring of an older IDE, VS2008, with that of Visual Assist. (The comparison is similar for newer IDEs.) To the observant programmer, there are some real differences in what the IDE and Visual Assist provide:


If you look carefully, Visual Assist uses separate colors for meaningful separation of symbols:

  • classes/structures/types – these appear blue by default, as if they were keywords. I know they won’t change, and I won’t change them.
  • variables – dark blue, or navy to be precise, so I know the symbols have values and can be modified.
  • preprocessor macros – fuchsia, so I know to be cautious in how I use these.
  • methods – also brown, which lets me find quickly the external references in a block of code.

In addition to more meaningful coloring, I can display so-called stable symbols, like function names from third-party libraries, in italics. (See GetSystemInfo and QueryPerformanceFrequency in my example.) The italics tell me nobody has overridden a well-known symbol, and that I can trust its behavior. When I’m surprised not to see a symbol in italics, sometimes I take time to find out what’s different about it.

VA View

I’m going to jump abruptly to one last feature of Visual Assist that is handy for the new user: the VA View. The learning curve for the VA View is a bit steeper than it is for the other commands I’ve described, but I think the effort is worth it.

The VA View is a handy tool that combines several functions of the IDE and Visual Assist, all in a compact interface. I usually make the VA View a tab in the same docked tool window as the Solution Explorer and Class Browser. The VA View gives me most of what I use in the other two tool windows, and I switch to the Solution Explorer or Class Browser only when absolutely necessary.

Here is an example of the VA View, docked to the left of my source window in VS2008:


From top to bottom, the VA View has:

  • a drop-down for quick opening of any file in my solution. I can type partial matches in the list that opens, letting me find most files faster than I can with the Solution Explorer.
  • a drop-down for quick locating of symbols in my solution. This drop-down also supports filtering. If I know the name of a symbol, or most of it, I can jump to its definition faster than any other method of the IDE.
  • a most-recently-used (MRU) list of files and methods—ones that I’ve recently modified or visited. (Right+click in the MRU to adjust its settings.) Typically, the MRU lets me jump faster than tabbing windows or navigating back with Ctrl+-.
  • a hovering class browser (HCB) that tells me about the symbol I’m hovering over, or class I’m in. (Right+click to adjust this one as well.) In my example, the HCB is showing me SParticle members because my caret is somewhere in SParticle.

Again, the learning curve for the VA View is a little steeper than simpler features of Visual Assist—like syntax coloring. But, the VA View is ready handy and worth the little bit of time it takes to know it. And if you’re a keyboard user, you’ll be happy to know the entire interface to the VA View is available without a mouse.


In my three-part series, I tried to show new users of Visual Assist how to make use of the tool, especially when you land in front of a completely new code base. The stock IDE has many features to help you, but Visual Assist goes well beyond in functionality and performance.

Learn More

You can learn more about Enhanced Syntax Coloring and the VA View in the documentation for Visual Assist:

This article was contributed by Bartlomiej Filipek, who writes at Code And Graphics — a technical blog about C++ and OpenGL.

Tools to understand new code: Find

In my previous post as a guest contributor, I talked about moving between declaration and implementation of various symbols: methods, classes, variables… and even include files. The functionality helps a lot, but there are other tools in Visual Assist that we definitely need to know. This time, let’s have a look at some find commands in Visual Assist.

As in my last post, I will use Irrlicht Engine as my example project.

Find References

With Go To, we can jump from declaration to implementation smoothly. This is nice, but unfortunately, life is not that easy. Usually when we see an interesting variable or function, we would like to see not only its declaration or implementation, but how and where is it used.

Previously, we were curious about MaxAngleDegrees from CParticleBoxEmitter.cpp. We know than it’s a 32-bit integer variable used to generate rotations. But, where it is actually initialized?

With Visual Assist, press Shift+Alt+F (the default shortcut for its Find References) and you will see a dialog like this:


The window lists places where our variable is used. It seems that the variable is loaded from a settings file.

The basic list is, of course, nothing special—Visual Studio has a similar feature. But with Visual Assist, we have more benefits:

  • You can see a context of each line in a tooltip
  • You can view only Read or Write references
  • As with most Visual Assist tools, it works faster than the equivalent in Visual Studio. (Also, I’ve found that the results with Visual Assist are a bit more narrow.)

We can extend our search and go further:

  • MaxAngleDegrees is deserialized in CParticleBoxEmitter::deserializeAttributes
  • This method is called from CParticleSystemSceneNode::deserializeAttributes
  • It’s also polymorphic and might be called from CSceneLoaderIrr::readSceneNode

We can even track the whole system of loading scene nodes. We can now see the flow of this functionality. Without Find References, it would be very problematic.

Tip: You can also use Find References in File to, as the name suggests, see references to a symbol in the file you are actually in.

Find Symbol

Finding references for a given symbol is very useful, but what if you do not know an exact name? Maybe you just have some basic idea of what you want to find.

For instance, in Irrlicht Engine, we might want to see the implementation and an interface of a scene manager. Find References would not work well this time because we don’t have a reference. You could use the normal search box of Visual Studio, but you will probably end up with too many symbols and lines to check.

In this instance, you can use Find Symbol (Shift+Alt+S by default) in Visual Assist. Find Symbol opens a dialog box with all symbols from the current solution (and even third-party libraries!) I typed “manager scene” in the edit control of my dialog and got the following:


As you can see, “manager scene” is related to several different classes. We can double-click the most interesting object and go to its definition.

The Find Symbol dialog supports more advanced options as well, like searching only in classes (this will skip defines and free functions) or extending your search to files outside your solution.

Find Symbol is definitely much more convenient that the common search dialog of Visual Studio.


Our tool bag now contains two very important items: Go To and Find. We can now easily search for various symbols in solutions, easily go to their implementation/declarations. And with the Find commands, we are able to search for all occurrences of a given symbol and create a story of how it is used in a project.

Learn More

You can learn more about the Find commands in the documentation for Visual Assist:

This article was contributed by Bartlomiej Filipek, who writes at Code And Graphics — a technical blog about C++ and OpenGL.

Tools to understand new code: Go To

You’ve just started a new job and landed in front of a huge code base. Great! What a challenge! It would be nice to quickly get a general understanding of your project and be able to comfortably move around in the code. How do you do it?

In my series of articles as a guest contributor to this blog, you will learn about my favorite Visual Assist tools that help with code understanding. My tools are:

  • Go To
  • Find
  • Move
  • Additional tips

In this post, let’s take a look at Go To functionality.

As an example project, let’s take a look at Irrlicht Engine.

Go To

The feature in Visual Assist that I probably use most often is Go To. In short, it is an improvement for a very well-known tool from Visual Studio — Go to definition/declaration. But, we all know how this works (or actually doesn’t work) in VS. Sometimes you have to wait for a response from VS, or simply you cannot go anywhere.

With Visual Assist, you get a really nice, working version of the tool: just press Alt+G (the default keyboard shortcut), select where you want to go, and Visual Assist will go to it immediately!

Alt+G is especially useful when:

  • You are reading a class interface and you want to go to the implementation of some method. You can take a glance at the internal code, then quickly go back to the interface.
  • You want to check the declaration of a variable. Use Go To to see where the variable is declared (is it a local variable or maybe a member of a class).

Go To Example

I am in IParticleEmitter.h and I see the class IParticleEmitter interface declaration. There is an interesting method called emitt(...) — how is it implemented?

I can use Go To and get the following result:


Of course, Visual Assist sees that a method can have multiple polymorphic implementations. Go To allows one to select the desired implementation and jump into it. In the list, you can move via arrow keys, mouse, or assigned numbers/letters.

Now, I am in the implementation of this method: CParticleBoxEmitter::emitt. There is some code:

if (MaxAngleDegrees)
    core::vector3df tgt = Direction;
    tgt.rotateXYBy(os::Randomizer::frand() * MaxAngleDegrees);
    tgt.rotateYZBy(os::Randomizer::frand() * MaxAngleDegrees);
    tgt.rotateXZBy(os::Randomizer::frand() * MaxAngleDegrees);
    p.vector = tgt;

What is this MaxAngleDegrees? Is it a static constant or a class member? I can hover my mouse over it and get some basic information, but via Go To , I can go to the place where it is defined so I can see some more context.

When I want to return (to the interface that I was looking at initially), I can do it in several ways:

  • Ctrl+Tab to go to the previous window
  • Ctrl+- to go to the previous location
  • Navigate Back — a Visual Assist command that I will describe in another article

Tip: Additionally, Alt+G works in other situations; for instance, press Alt+G when the caret is in a line with the #include "#xyz" statement. You will simply move to the header!

Go To Related

Visual Assist goes even further than Go To with the implementation of another commend — Go To Related. If you use Shift+Alt+G instead of Alt+G, you will see a much more advanced version of Go To. For instance:


With Shift+Alt+G, I can see base classes, derived classes and even go to the definition a particular member!


Go To  and its related commands, Go To Related and Go To Member, are some of the most important tools in Visual Assist. The Go To commands enable us to move in the code quickly and jump among definition/use/declaration. The implementations in Visual Assist are very advanced and more efficient that the native Visual Studio solution.

Learn More

You can learn more about the Go To commands in the documentation for Visual Assist:

This article was contributed by Bartlomiej Filipek, who writes at Code And Graphics — a technical blog about C++ and OpenGL.

Organize VA Snippets with hashtags

For a user with a modest collection of VA Snippets, the built-in type filtering and auto-sorting of the VA Snippet Editor are sufficient tools to manage the collection. Type filtering divides VA Snippets by access method in the UI of Visual Assist, and auto-sorting within a type makes scrolling efficient. For the occasional VA Snippet that is hard to locate by type filter, the search capability in the VA Snippet Editor is an ample ancillary tool.

But for the user who has a massive collection of VA Snippets, built-in type filtering can fail to divide VA Snippets into manageable subsets. In these instances, hashtags in the descriptions of VA Snippets will tame the collection. You can add multiple hashtags to one VA Snippet, and tell the VA Snippet Editor to display only VA Snippets that include a specific hashtag(s).

If hashtags might help you stay organized, start with a reasonable set of hashtags for your collection. Remember, one VA Snippet can have multiple hashtags. For example, you can specify a language construct, custom type, and author for a single VA Snippet. With your hashtags in hand, scroll through your collection of VA Snippets and add the hashtags to your descriptions, separating your hashtags with commas or spaces.

Once you’ve added your hashtags, tell the VA Snippet Editor to display only entries containing a hashtag by:

  1. setting Type to “Search”
  2. entering a hashtag in the search field
  3. setting scope to “Search descriptions”

In the following example, I search for VA Snippets I’ve tagged as loop constructs. The editor shows only the five I’ve tagged:


Searches for VA Snippets that include any one of several tags requires you enable REs in searches and separate your hashtags with vertical bars—the symbol for “or” in an RE. For example, I can search for VA Snippets I’ve tagged as loop constructs or as switch statements:


Searches for VA Snippets that include multiple tags are a little trickier. The general pattern of an RE that finds VA Snippets with multiple tags is:


In the following example, I find VA Snippets tagged as loop constructs AND authored by Jeff:


If you have a large collection of VA Snippets, especially if you distribute the collection to other developers who browse through it, consider setting aside time to add hashtags. You may be more productive in the long run.

Filtering results of Find References

We regularly hear from C/C++ and C# users that Find References is their most-used feature of Visual Assist. Despite the existence of a similarly named feature in Visual Studio, the functionality and speed provided by our version appears to be a game changer. And Find References keeps getting better.

Beginning with Visual Assist build 2036, you can filter the results of Find References, in original and cloned windows. Although filtering is available via the context menu, keyboard access is the way to go.

I begin with a simple example that includes a reference to a quantity in a comment, its definition, one write access, and one read access.


Find References (Shift+Alt+F) on quantity produces a results window with four entries, one of each type.


Although Find References has always differentiated read versus write references—blue and pink in my example—you can now use shortcuts R and W to filter by type. When focus is in the results, press W to remove the write reference(s).


Press W again to make the write reference reappear, then R to remove the read reference(s).


Initializations aren’t considered write references. Instead, they are included in definition references, which are filtered with the D shortcut. (In C/C++, declarations are also filtered with D.)

“References” in coMments and strings are filtered using M, and if my example had any, unknown/Guess hits would be filtered with G. Hence, pressing RDM immediately after my initial find would leave me with only the write reference.


Filter states aren’t sticky. Each Find References begins with all results, and each of the shortcuts initially removes references.

Additionally, filter states are specific to the window. You can show read references in one window and write references in a cloned window—to one or different symbols. If you can’t remember the state of a filter in a window, toggle it and look for a change in the vertical scroll bar.

Shortcuts for Highlight All (H) and Search All Projects (P) work similarly. H toggles the highlighting of references in source windows; P refreshes search results to include references from all projects, or restrict them to the current project. (Because quantity is a local variable in my example, my searches were always restricted to the current file.) .

Open the context menu of Find References if you forget the shortcuts. Only those that apply to your results are visible.


Find References in Visual Assist is powerful and complex, and you need time and revisits to take full advantage of the command. Try the filtering described in this post, check out a previous post about using Find References to manage a task , then hit the documentation when you are ready for more.

Automatically add C++11 override to virtual methods

The C++11 standard has been approved and C++14 is around the corner. These new standards define a lot of interesting language features, one of them being support for the override identifier. You can append “override” to a virtual function declaration and tell the compiler that you want to override a virtual method inherited from a base class. If the virtual method does not exist in the base class, or has a different signature, the compiler raises an error and the compilation fails.


Use of override is very useful for detecting errors, at compile time, caused by typos and bad copy-pastes.

Visual Studio has supported override since Visual Studio 2010, and so has Visual Assist. But if you want Visual Assist to insert “override” automatically—when using the code generation feature Implement Virtual Methods—you need to tell it via the Windows Registry.

Note: Beginning with Visual Assist build 2042, you can insert “override” automatically via the options dialog of Visual Assist. The following instructions apply to build 2036 and older.

Exit your IDE(s) so Visual Assist does not overwrite your changes, then using the registry editor, navigate to this key:

HKEY_CURRENT_USER\Software\Whole Tomato\Visual Assist X\<IDE_SPEC>

Change the value of UseOverrideKeywordInImplementInterface from 00 to 01.


Restart you IDE, and from now on, Visual Assist will append override to the signatures of your virtual methods.

This article was contributed by Manuel Maier, student at Hochschule der Medien Stuttgart, Germany.

Implementing Virtual Methods with Visual Assist

Visual Assist has a feature—Implement Virtual Methods—that makes it easy to implement an interface, or abstract methods of a base class. You don’t need to create anything manually.

Move the caret to a base or interface class in the declaration of your derived class, or to the derived class if you want to implement methods from all bases classes.

Open a refactoring menu—via the context menu or Shift+Alt+Q—and select Implement Virtual Methods.


A dialog will open, letting you choose the methods to implement.


Visual Assist updates the declaration of your class, and create stubs in its implementation. By default, an exception is placed in the body of each method.


You can change the default by modifying the VA Snippet for “Create from Usage Method Body”.


If you add methods to an interface, repeat the process and Visual Assist will automatically disable existing methods.


The declaration and implementation of your new method will be inserted in the correct locations, relative to the existing methods.


That’s all there is to it.

This article was contributed by Lei Zhu, student at the College of San Mateo, CA.