Doozer List

Class

Creates object instances by invocating a type's parameterless constructor via System.Reflection.

Doozer name:		ICSharpCode.Core.ClassDoozer
Attributes:
class:	required	The fully qualified type name of the class to create an instace of.
Usage:		Everywhere where objects are expected.
Returns:		Any kind of object.

CodeCompletionBinding

Creates code completion bindings that manage code completion for one language.

Doozer name:		ICSharpCode.SharpDevelop.Editor.CodeCompletionBindingDoozer
Attributes:
class:	required	Name of the ICodeCompletionBinding class (normally deriving from DefaultCodeCompletionBinding).
extensions:	optional	List of semicolon-separated entries of the file extensions handled by the binding. If no extensions attribute is specified, the binding is activated in all files.
Usage:		Only in /AddIns/DefaultTextEditor/CodeCompletion
Returns:		The ICodeCompletionBinding class specified with the 'class' attribute, or a wrapper that lazy-loads the actual class when it is used in a file with the specified extension.

CommandBinding

Creates descriptor containing information about command binding

Doozer name:		ICSharpCode.Core.CommandBindingDoozer
Attributes:
command:	required	Name of routed UI command which triggers this binding
class:	required	Class implementing System.Window.Input.ICommand or ICSharpCode.Core class. CanExecute and Executed methods are used to handle raised event
lazy:	optional	Use lazy loading. If addin containing binded command is not loaded yet load asseblies referenced in add-in
Usage:		Only in /SharpDevelop/Workbench/CommandBindings
Returns:		CommandBindingDescriptor object

CustomProperty

Creates a custom property for project items.

Doozer name:		ICSharpCode.SharpDevelop.Project.CustomPropertyDoozer
Attributes:
name:	required	The name of the MSBuild meta data.
displayName:	optional	The display name of the property.
description:	optional	The description text for the property.
runCustomTool:	optional	Boolean property specifying whether the custom tool should be run when the property value is changed by the user. Default: false.
Usage:		In /SharpDevelop/Views/ProjectBrowser/ContextSpecificProperties
Returns:		A PropertyDescriptor object.

CustomTool

Creates CustomToolDescriptor objects.

Doozer name:		ICSharpCode.SharpDevelop.Project.CustomToolDoozer
Attributes:
id:	required	ID used to identify the custom tool.
class:	required	Name of the ICustomTool class.
fileNamePattern:	optional	Regular expression that specifies the file names for which the custom tool can be used. Example: "\.res(x|ources)$"
Usage:		Only in /SharpDevelop/CustomTools
Returns:		An CustomToolDescriptor object that wraps a ICustomTool object.

Example: Strongly typed resource generator

            <Path name = "/SharpDevelop/CustomTools">
            	<CustomTool id    = "ResXFileCodeGenerator"
            	            class = "ResourceEditor.ResourceCodeGeneratorTool"
            	            fileNamePattern = "\.res(x|ources)$"/>
            </Path>

Debugger

Creates debuggers.

Doozer name:		ICSharpCode.SharpDevelop.Debugging.DebuggerDoozer
Attributes:
class:	required	Name of the IDebugger class.
supportsStart:	optional	Specifies if the debugger supports the 'Start' command. Default: true
supportsStartWithoutDebugger:	optional	Specifies if the debugger supports the 'StartWithoutDebugger' command. Default: true
supportsStop:	optional	Specifies if the debugger supports the 'Stop' (kill running process) command. Default: true
supportsStepping:	optional	Specifies if the debugger supports stepping. Default: false
supportsExecutionControl:	optional	Specifies if the debugger supports execution control (break, resume). Default: false
Usage:		Only in /SharpDevelop/Services/DebuggerService/Debugger
Returns:		An DebuggerDescriptor object that exposes the attributes and the IDebugger object (lazy-loading).

Directory

Creates path names using a relative to the folder containing the addin file.

Doozer name:		ICSharpCode.SharpDevelop.DirectoryDoozer
Attributes:
path:	required	Path relative to the directory which contains the .addin file defining the codon.
Usage:		Where directory paths to a folder inside the addin directory are expected, e.g. /SharpDevelop/BackendBindings/Templates
Returns:		A string containing the full path name.

DisplayBinding

Creates DisplayBindingDescriptor objects. Primary display bindings can provide editors for additional file types (like the ResourceEditor), secondary display bindings can add tabs to existing display bindings (like the form designer).

Doozer name:		ICSharpCode.SharpDevelop.DisplayBindingDoozer
Attributes:
class:	required	Name of the IDisplayBinding or ISecondaryDisplayBinding class.
title:	required	Title of the display binding to use in the "Open With" dialog.
type:	optional	Type of the display binding (either "Primary" or "Secondary"). Default: "Primary".
fileNamePattern:	optional	Regular expression that specifies the file names for which the display binding will be used. Example: "\.res(x|ources)$"
Usage:		Only in /SharpDevelop/Workbench/DisplayBindings
Returns:		An DisplayBindingDescriptor object that wraps either a IDisplayBinding or a ISecondaryDisplayBinding object.

Example: Primary display binding: Resource editor

            <Path name = "/SharpDevelop/Workbench/DisplayBindings">
              <DisplayBinding id    = "ResourceEditor"
                              title = "Resource editor"
                              class = "ResourceEditor.ResourceEditorDisplayBinding"
                              insertbefore    = "Text"
                              fileNamePattern = "\.res(x|ources)$"/>
            </Path>

Example: Secondary display binding: Form designer

            <Path name = "/SharpDevelop/Workbench/DisplayBindings">
              <DisplayBinding id  = "FormsDesigner"
                              title = "Windows Forms Designer"
                              type  = "Secondary"
                              class = "ICSharpCode.FormsDesigner.FormsDesignerSecondaryDisplayBinding"
                              fileNamePattern = "\.(cs|vb)$" />
            </Path>

EditAction

Creates IEditAction objects for the text editor.

Doozer name:		ICSharpCode.SharpDevelop.DefaultEditor.Codons.EditActionDoozer
Attributes:
keys:	required	Comma-separated list of keyboard shortcuts that activate the edit action. E.g. "Control|C,Control|Insert"
class:	required	Name of the IEditAction class.
Usage:		Only in /AddIns/DefaultTextEditor/EditActions
Returns:		An IEditAction object.

FileFilter

Creates file filter entries for OpenFileDialogs or SaveFileDialogs.

Doozer name:		ICSharpCode.Core.FileFilterDoozer
Attributes:
name:	required	The name of the file filter entry.
extensions:	required	The extensions associated with this file filter entry.
Usage:		Only in /SharpDevelop/Workbench/FileFilter
Returns:		String in the format "name|extensions".

Icon

Creates associations between file types or node types in the project browser and icons in the resource service.

Doozer name:		ICSharpCode.Core.IconDoozer
Attributes:
resource:	required	The name of a bitmap resource in the resource service.
language:		This attribute is specified when a project icon association should be created. It specifies the language of the project types that use the icon.
extensions:		This attribute is specified when a file icon association should be created. It specifies the semicolon-separated list of file types that use the icon.
Usage:		Only in /Workspace/Icons
Returns:		An IconDescriptor object that exposes the attributes.

Include

Includes one or multiple items from another location in the addin tree. You can use the attribute "item" (to include a single item) OR the attribute "path" (to include all items from the target path).

Doozer name:		ICSharpCode.Core.IncludeDoozer
Attributes:
item:		When this attribute is used, the include doozer builds the item that is at the addin tree location specified by this attribute.
path:		When this attribute is used, the include doozer builds all items inside the path addin tree location specified by this attribute and returns an IBuildItemsModifier which includes all items in the output list.
Usage:		Everywhere
Returns:		Any object, depending on the included codon(s).

InputBinding

Creates descriptor containing information about input binding

Doozer name:		ICSharpCode.Core.InputBindingDoozer
Attributes:
command:	required	Name of routed UI command which is triggered by this binding
gesture:	required	Gesture which triggers this binding
Usage:		Only in /SharpDevelop/Workbench/InputBindings
Returns:		InputBindingDescriptor object

LanguageBinding

Creates LanguageBindingDescriptor objects for the project service.

Doozer name:		ICSharpCode.SharpDevelop.LanguageBindingDoozer
Attributes:
guid:	required	Project type GUID of the project used by MsBuild.
supportedextensions:	required	Semicolon-separated list of file extensions that are compilable files in the project. (e.g. ".boo")
projectfileextension:	required	File extension of project files. (e.g. ".booproj")
class:	required	Name of the ILanguageBinding class.
Usage:		Only in /SharpDevelop/Workbench/LanguageBindings
Returns:		An LanguageBindingDescriptor object that wraps the ILanguageBinding object.

MenuItem

Creates menu items from a location in the addin tree.

Doozer name:		ICSharpCode.Core.MenuItemDoozer
Attributes:
label:	required	Label of the menu item.
type:	optional	This attribute must be one of these values: Separator, CheckBox, Item=Command, Menu (=with subitems), Builder (=class implementing ISubmenuBuilder). Default: Command.
loadclasslazy:	optional	Only for the type "Item"/"Command". When set to false, the command class is loaded immediately instead of the usual lazy-loading.
icon:	optional	Icon of the menu item.
class:	optional	Command class that is run when item is clicked.
command:	optional	A WPF routed command that is executed when item is clicked. Currently, this property is supported only for WPF Menus. Only one of the "class" and "command" attributes can be used on a menu entry.
link:	optional	Only for the type "Item"/"Command". Opens a webpage instead of running a command when clicking the item.
shortcut:	optional	Shortcut that activates the command (e.g. "Control|S").
Children:		If "type" is "Menu", the item can have sub-menuitems.
Usage:		Any menu strip paths or context menu paths, e.g. /SharpDevelop/Workbench/MainMenu
Returns:		A MenuItemDescriptor object.
Conditions:		Conditions are handled by the item, "Exclude" maps to "Visible = false", "Disable" to "Enabled = false"

OptionPanel

Creates DefaultOptionPanelDescriptor objects that are used in option dialogs.

Doozer name:		ICSharpCode.SharpDevelop.OptionPanelDoozer
Attributes:
class:		Name of the IOptionPanel class. Optional if the page has subpages.
label:	required	Caption of the dialog panel.
Children:		In the SharpDevelop options, option pages can have subpages by specifying them as children in the AddInTree.
Usage:		In /SharpDevelop/BackendBindings/ProjectOptions/ and /SharpDevelop/Dialogs/OptionsDialog
Returns:		A DefaultOptionPanelDescriptor object.

Pad

Creates PadDescriptor objects for SharpDevelop pads.

Doozer name:		ICSharpCode.SharpDevelop.PadDoozer
Attributes:
class:	required	IPadContent class that is loaded when the pad content is shown for the first time.
title:	required	Title of the pad that is shown in the user interface. Should be a resource string, e.g. "${res:AddIns.HtmlHelp2.Contents}"
icon:	optional	Specifies the name of the icon resource used for the pad. Pad icon resources must be registered with the ResourceService before the workbench is loaded!
category:	optional	Category of the pad. It is possible to create menu items that automatically contain show commands for all pads in a certain category. Pads in the category "Main" will show up in the "View" menu, the category "Tools" in the "View -> Tools" menu, the category "Debugger" in the "View -> Debugger" menu.
shortcut:	optional	Shortcut that activates the 'Show pad' command (e.g. "Control|Alt|T").
Usage:		Only in /Workspace/Parser
Returns:		An PadDescriptor object that wraps the IPadContent object.

Parser

Creates ParserDescriptor objects for the parsing service.

Doozer name:		ICSharpCode.SharpDevelop.ParserDoozer
Attributes:
supportedextensions:		Semicolon-separated list of file extensions for which the parser is used. (e.g. ".boo")
projectfileextension:		File extension of project files. (e.g. ".booproj")
class:		Name of the IParser class.
Usage:		Only in /Workspace/Parser
Returns:		An ParserDescriptor object that wraps the IParser object.

ProjectContentRegistry

Creates ProjectContentRegistryDescriptor objects for the parsing service.

Doozer name:		ICSharpCode.SharpDevelop.ProjectContentRegistryDoozer
Attributes:
class:		Name of the ProjectContentRegistry class.
Usage:		Only in /Workspace/ProjectContentRegistry
Returns:		An RegistryDescriptor object that wraps a ProjectContentRegistry object.
Conditions:		Conditions are handled by the item, the condition "caller" will be the project to which the references requiring the registry belong to. You should always use the <ProjectActive> condition to restrict the project type your registry is used for.

RoutedUICommand

Creates descriptor containing information about routed UI command

Doozer name:		ICSharpCode.Core.RoutedUICommandDoozer
Attributes:
name:	required	Routed UI command name
text:	required	Routed UI command displayed name
Usage:		Only in /SharpDevelop/Workbench/CommandBindings
Returns:		RoutedUICommandDescriptor object

SchemeExtension

Creates browser scheme extensions that can intercept calls on one protocol.

Doozer name:		ICSharpCode.SharpDevelop.BrowserDisplayBinding.SchemeExtensionDoozer
Attributes:
scheme:	required	Specifies the name of the protocol the extension handles. (e.g. 'ms-help' or 'startpage')
class:	required	Name of the ISchemeExtension class (normally deriving from DefaultSchemeExtension).
Usage:		Only in /SharpDevelop/Views/Browser/SchemeExtensions
Returns:		An SchemeExtensionDescriptor object that exposes the protocol name and ISchemeExtension object (lazy-loading).

SyntaxMode

Creates AddInTreeSyntaxMode objects that wrap a .xshd syntax mode stored as resource in the addin assembly.

Doozer name:		ICSharpCode.SharpDevelop.DefaultEditor.Codons.SyntaxModeDoozer
Attributes:
name:	required	Name of the language for which the syntax mode is used.
extensions:	required	Semicolon-separated list of file extensions for which the syntax mode is used.
resource:	required	Fully qualified name of the resource file.
Usage:		Only in /SharpDevelop/ViewContent/DefaultTextEditor/SyntaxModes
Returns:		An AddInTreeSyntaxMode object that loads the resource from the addin assembly when its CreateTextReader method is called.

String

Creates a string.

Doozer name:		ICSharpCode.Core.StringDoozer
Attributes:
text:	required	The string to return.
Returns:		The string specified by 'text', passed through the StringParser.

TaskBoundAdditionalLogger

Creates IMSBuildAdditionalLogger objects that are only activated when a specific MSBuild task is running.

Doozer name:		ICSharpCode.SharpDevelop.Project.TaskBoundAdditionalLoggerDoozer
Attributes:
class:	required	Name of the IMSBuildAdditionalLogger class.
taskname:	required	Specifies the name of the MSBuild task that must be running for this logger to be active.
Usage:		Only in /SharpDevelop/MSBuildEngine/AdditionalLoggers
Returns:		A IMSBuildAdditionalLogger object that lazy-loads the specified IMSBuildAdditionalLogger when the specified task is running.

Example:

            <TaskBoundAdditionalLogger
            	id = "FxCopLogger"
            	taskname = "FxCop"
            	class = "ICSharpCode.CodeAnalysis.FxCopLogger"/>

ToolbarItem

Creates tool bar items from a location in the addin tree.

Doozer name:		ICSharpCode.Core.ToolbarItemDoozer
Attributes:
label:	optional	Label of the tool bar item.
icon:	optional	Icon of the tool bar item.
type:	optional	This attribute must be one of these values: Separator, CheckBox, Item, ComboBox, DropDownButton
loadclasslazy:	optional	Only for the type "Item". When set to false, the command class is loaded immediately instead of the usual lazy-loading.
tooltip:	optional	Tooltip of the tool bar item.
class:		Command class that is run when item is clicked; or class that manages the ComboBox/DropDownButton. Required for everything except "Separator".
Usage:		Any toolbar strip paths, e.g. /SharpDevelop/Workbench/ToolBar
Children:		A drop down button has menu items as sub elements.
Returns:		A ToolStrip* object, depending on the type attribute.
Conditions:		Conditions are handled by the item, "Exclude" maps to "Visible = false", "Disable" to "Enabled = false"