Commit 7c9faf4

// CommandIds.h

#ifndef __COMMANDIDS_H_

#define __COMMANDIDS_H_

#define cppCheckToolBar 0x101

#define cppCheckMenuGroup 0x1010

#define cppCheckToolBarGroup 0x1011

#define cmdidcppCheckConfig 0x2001

#define cmdidcppCheckParseFile 0x2002

#define cmdidcppCheckParseProject 0x2003

#define cmdidcppCheckParseSolution 0x2004

#define cmdidMyZoom 0x2005

#define bmpPic1 1

#define bmpPic2 2

#define bmpPicSmile 3

#define bmpPicX 4

#define bmpPicArrows 5

#endif // __COMMANDIDS_H_

// guids.h: definitions of GUIDs/IIDs/CLSIDs used in this VsPackage

#define guidcppCheckVisualStudioAddInPkg { 0x2D61439F, 0x3473, 0x46F4, { 0xB5, 0x14, 0xFC, 0xFA, 0x5, 0x89, 0x92, 0xBE } }

#ifdef DEFINE_GUID

DEFINE_GUID(CLSID_cppCheckVisualStudioAddIn,

0x2D61439F, 0x3473, 0x46F4, 0xB5, 0x14, 0xFC, 0xFA, 0x5, 0x89, 0x92, 0xBE );

#define guidcppCheckVisualStudioAddInCmdSet { 0x835D0309, 0xB686, 0x4942, { 0x98, 0xD9, 0xE, 0x57, 0xFD, 0x96, 0xFD, 0x1A } }

#ifdef DEFINE_GUID

DEFINE_GUID(CLSID_cppCheckVisualStudioAddInCmdSet,

0x835D0309, 0xB686, 0x4942, 0x98, 0xD9, 0xE, 0x57, 0xFD, 0x96, 0xFD, 0x1A );

#define IDB_MENU_IMAGES 300

#define IDB_FRAME_IMAGES 301

#define IDI_PACKAGE_ICON 400

//

// This is the file that defines the actual layout and type of the commands.

// It is divided in different sections (e.g. command definition, command

// placement, ...), with each defining a specific set of properties.

// See the comment before each section for more details about how to

// use it.

//

// The CTC compiler (the tool that translates this file into the binary

// format that VisualStudio will consume) has the ability to run a preprocessor

// on the ctc file; this preprocessor is (usually) the C++ preprocessor, so

// it is possible to define includes and macros with the same syntax used

// in C++ files. Using this ability of the compiler here, we include some files

// defining some of the constants that we will use inside the file.

#include "stdidcmd.h" // This is the file that defines the IDs for all the

// commands exposed by VisualStudio.

#include "vsshlids.h" // This header contains the command ids for the menus

// provided by the shell.

#include "msobtnid.h" // Definition of some CTC specific constants. In this sample

// we use it for the IDs inside the guidOfficeIcon group.

#include "CommandIds.h" // Definition of the IDs of the commands and CTC elements

// specific for this sample.

#include "Resource.h" // Definition of the IDs of the resources used by this package;

// Here it is used to include the bitmap with the images used for

// the commands.

#include "Guids.h" // This is the file with the definition of the Guid

// specific for this sample.

// shorthand macros for a more compact and manageable table

#define OI_NOID guidOfficeIcon:msotcidNoIcon

#define DIS_DEF DEFAULTDISABLED | DEFAULTINVISIBLE | DYNAMICVISIBILITY

#define VIS_DEF COMMANDWELLONLY

// The CMDS_SECTION section is where we the commands, menus and menu groups are defined.

// This section uses a Guid to identify the package that provides the command defined

// inside it.

CMDS_SECTION guidcppCheckVisualStudioAddInPkg

// Inside this section we have different sub-sections: one for the menus, another

// for the menu groups, one for the buttons (the actual commands), one for the combos

// and the last one for the bitmaps used. Each element is identified by a command id that

// is a unique pair of guid and numeric identifier; the guid part of the identifier is usually

// called "command set" and is used to group different command inside a logically related

// group; your package should define its own command set in order to avoid collisions

// with command ids defined by other packages.

// This is the sub-section that defines the menus and toolbars.

MENUS_BEGIN

// To define an element in this group you need an ID, a parent group, a display priority,

// a menu type, a name and a default text.

// NewMenu Relative to Group Priority Type Name Text

guidcppCheckVisualStudioAddInCmdSet:cppCheckToolBar, guidcppCheckVisualStudioAddInCmdSet:cppCheckToolBar, 0x100, TOOLBAR, "cppCheckToolBar", "cppCheck Toolbar";

MENUS_END

// In this section you can define new menu groups. A menu group is a container for

// other menus or buttons (commands); from a visual point of view you can see the

// group as the part of a menu contained between two lines. The parent of a group

// must be a menu.

NEWGROUPS_BEGIN

// NewGroup Parent Group Priority

guidcppCheckVisualStudioAddInCmdSet:cppCheckMenuGroup, guidSHLMainMenu:IDM_VS_MENU_TOOLS, 0x0600;

guidcppCheckVisualStudioAddInCmdSet:cppCheckToolBarGroup, guidcppCheckVisualStudioAddInCmdSet:cppCheckToolBar, 0x100;

NEWGROUPS_END

// Button section.

// This section defines the elements the user can interact with, like a menu command or a button

// or combo box in a toolbar.

BUTTONS_BEGIN

// To define a menu group you have to specify its ID, the parent menu and its display priority.

// Some commands are not defined as shared, so they use our package CLSID

// as the command set GUID. Also, by specifying blank for the FLAGS, the command is

// default visible and enabled. Other valid values for FLAGS are the following:

// DEFAULTDISABLED, DEFAULTINVISIBLE, DYNAMICVISIBILITY, TEXTCHANGES

// These values for FLAGS can be or'ed together, e.g. "DEFAULTINVISIBLE | DYNAMICVISIBILITY"

// If you do not want an image next to your command, set the image to "guidOfficeIcon:msotcidNoIcon"

// Command Parent Group Priority Image Type Visibility

guidcppCheckVisualStudioAddInCmdSet:cmdidcppCheckConfig, guidcppCheckVisualStudioAddInCmdSet:cppCheckMenuGroup, 0x0100, guidcppCheckVisualStudioAddInCmdSet:bmpPic1, BUTTON, , "cppCheck Config";

guidcppCheckVisualStudioAddInCmdSet:cmdidcppCheckParseFile, guidcppCheckVisualStudioAddInCmdSet:cppCheckMenuGroup, 0x0200, guidcppCheckVisualStudioAddInCmdSet:bmpPic2, BUTTON, , "cppCheck Parse File";

guidcppCheckVisualStudioAddInCmdSet:cmdidcppCheckParseProject, guidcppCheckVisualStudioAddInCmdSet:cppCheckMenuGroup, 0x0300, guidcppCheckVisualStudioAddInCmdSet:bmpPic2, BUTTON, , "cppCheck Parse Project";

guidcppCheckVisualStudioAddInCmdSet:cmdidcppCheckParseSolution, guidcppCheckVisualStudioAddInCmdSet:cppCheckMenuGroup, 0x0400, guidcppCheckVisualStudioAddInCmdSet:bmpPic2, BUTTON, , "cppCheck Parse Solution";

guidcppCheckVisualStudioAddInCmdSet:cmdidMyZoom, guidcppCheckVisualStudioAddInCmdSet:cppCheckToolBarGroup, 0x100, guidOfficeIcon:msotcidZoom, BUTTON, , "cppCheck Config";

BUTTONS_END

// The bitmaps section is used to define the bitmaps that are used for the commands.

BITMAPS_BEGIN

// The bitmap id is defined in a way that is a little bit different from the others:

// the declaration starts with a guid for the bitmap strip, then there is the resource id of the

// bitmap strip containing the bitmaps and then there are the numeric ids of the elements used

// inside a button definition. An important aspect of this declaration is that the element id

// must be the actual index (1-based) of the bitmap inside the bitmap strip.

// Bitmap Bitmap Index, Bitmap Index, ...

guidcppCheckVisualStudioAddInCmdSet:IDB_MENU_IMAGES, bmpPic1, bmpPic2, bmpPicSmile, bmpPicX, bmpPicArrows;

BITMAPS_END

CMDS_END

// Within this section you can specify the set of commands defined somewhere else that your

// packages uses; for instance if your package uses the standard ‘Copy’ command, you don’t

// need to define it, because it is defined by the shell, but you have to use this section

// of the CTC file to notify the shell that your package uses it using this section.

CMDUSED_SECTION

CMDUSED_END

// Inside this section, we have the ability to place menu groups inside some other menu or

// menu / commands inside other groups.

// For instance, it is possible to place one of VisualStudio's menus or commands inside one of our

// groups or one of our groups inside a menu defined somewhere else.

CMDPLACEMENT_SECTION

// Command Group Priority

CMDPLACEMENT_END

VISIBILITY_SECTION

// Command GUID when visible

VISIBILITY_END

// This section is where you can associate a command with a keyboard shortcut; this association is

// valid within a specific UI context, that is when the shell is inside a specific mode, e.g. during

// debugging, editing a file or when the user is using a specific designer.

KEYBINDINGS_SECTION

// To define a binding, you have to specify the sequence of keys to press to activate the command

// (keystate); the syntax to use is <key>[:<special keys>] where the special keys section can be

// empty. The accepted special keys and their representation are:

// Alt - A

// Control - C

// Shift - S

// Windows Key - W

// For example, if you want to define a binding for <Control>C the definition will be 'C':C; if the

// binding is <Control><Alt>C, then the keybinding is 'C':AC.

//

// Notice that Visual Studio has a lot of components and commands, so it can be difficult to find a

// key binding not used by somebody else; if the key bindings are conflicting only one will be used

// and one problem is that the shell will not inform the user that a conflict was found. The only

// way to detect the problem is to start Visual Studio under debugger, try to execute any command

// and look if there is a message in the output window about a duplicated accelerator found.

// Command when available emulation keystate

KEYBINDINGS_END

// Guids.cs

using System;

namespace Ambre.cppCheckVisualStudioAddIn

static class GuidList

{

public const string guidcppCheckVisualStudioAddInPkgString = "2d61439f-3473-46f4-b514-fcfa058992be";

public const string guidcppCheckVisualStudioAddInCmdSetString = "835d0309-b686-4942-98d9-0e57fd96fd1a";

public static readonly Guid guidcppCheckVisualStudioAddInPkg = new Guid(guidcppCheckVisualStudioAddInPkgString);

public static readonly Guid guidcppCheckVisualStudioAddInCmdSet = new Guid(guidcppCheckVisualStudioAddInCmdSetString);

};

// PkgCmdID.cs

using System;

namespace Ambre.cppCheckVisualStudioAddIn

static class PkgCmdIDList

{

public const int cmdidcppCheckConfig = 0x2001;

public const int cmdidcppCheckParseFile = 0x2002;

public const int cmdidcppCheckParseProject = 0x2003;

public const int cmdidcppCheckParseSolution = 0x2004;

public const int cmdidMyZoom = 0x2005;

};

using System.Reflection;

using System.Runtime.CompilerServices;

using System.Runtime.InteropServices;

[assembly: AssemblyTitle("cppCheckVisualStudioAddIn")]

[assembly: AssemblyDescription("")]

[assembly: AssemblyConfiguration("")]

[assembly: AssemblyCompany("Ambre")]

[assembly: AssemblyProduct("cppCheckVisualStudioAddIn")]

[assembly: AssemblyCopyright("")]

[assembly: AssemblyTrademark("")]

[assembly: AssemblyCulture("")]

[assembly: ComVisible(true)]

[assembly: AssemblyVersion("1.0.*")]

[assembly: AssemblyFileVersion("1.0.0.0")]