AtomineerUtils Development History

This addin began as a VBScript macro (for an in-house comment format for C code) in 1996, and evolved over the years as I moved between companies and languages. Version 2 added C++ support, and version 3 began supporting Doxygen format. In version 4 it was upgraded to support C# and DocXml format and became capable of updating existing comments. For version 5 it was converted into an add-in and significantly refactored and given an installer, preferences, rules xml and outlining commands.

Limited public release began at version 5.42 (Aug 2008), and widespread release at 5.79 (March 2009). When I found that donations didn't even cover my hosting and support costs, version 7.00 introduced the 'Pro' variant for a minimal charge. Visual Basic support was introduced in v7.10.

July 2010

7.22

Added more support for conversions between comment formats. The new <Conversions> section of the rules allows simple transforms to be applied to entry tags as they are read so that they may be read from one format (e.g Doxygen) and converted to a new format (e.g. DocXML). Currently the support is mainly for conversions to DocXML, although the system works bidirectionally, and specific support for conversion to Doxygen could be added should anyone request it.
Fixed a small bug in the new existing-comment parsing algorithm that could be confused by a multiline comment occurring immediately inside a method, causing the wrong line of code to be documented.
'Doc all in Scope' now reports read-only files once, rather than once per code element.
Significantly improved parsing of operators, and added support for the less-used operators.
Improved handling of indentation in some cases when using base class documentation.
Improved parsing of attributes containing comments.
Doxygen comment auto-brief entries may now be preceeded by an /ingroup entry.
A few improvements to the documentation Rules.

7.21

Added an 'Add Doc Comment' command at the top of the context menu. This can be disabled in the AtomineerUtils options if you don't want it.
Doxygen/Javadoc auto-brief mode now picks up the brief text properly if the brief is on the same line as the /**
Fixed handling of uppercased acronyms in property names (e.g. URL), which were being output as 'Gets uRL...'.
Improved the technique used by Declare/Implement C++ method for handling nested namespace/class names.
Fixed an errant chunk of C++ scoping code that was applied to VB parsing, causing occasional addition of the class name into generated summary text.
Copy constructors are now detected and documented as such.
In DocXml, Properties and Indexers now have an optional <remarks> section, allowing you to add remarks without AtomineerUtils stripping them away as 'illegal' entries.
Fixed a Doxygen comment updating glitch that occurred if the <returns> element was forced into comments for void methods by using _blankentry.
Made some minor code tweaks and rules additions to improve the commenting operation in a few special cases.

June 2010

7.20

Apologies for the unusually long gap between releases. I've been hard at work with some major under-the-bonnet improvements and a big change to the website, and there have been a number of interruptions by life-with-kids in the last month. I expect to now resume the normal rate of 1-2 releases per month.

Re-wrote the existing-comment detection/parsing algorithm. The previous algorithm evolved from handling a fixed format to handling highly customisable formats for mulitple languages, and had recently reached its scalability limits. I've redesigned the algorithm to encompasses all the features required in a leaner, faster, and much more robust manner. Improvements: it is now possible to use exactly the same text for the separator lines and line headers; it handles non-doc comments immediately prior to a code element much better; it copes robustly with comments that contain code snippets; it can now more reliably parse and convert user-defined comment block formats as well as /// and /** ... */ comment styles to the configured style; the DocComment command now runs approximately 30% faster on typical cases.
'Document all in this scope' can now be interrupted by pressing escape, and runs about 30% faster.
When generating documentation for overloads and overrides, the formatting would sometimes be incorrect for the first line. This issue has now been corrected so that derived documentation formats much more cleanly.
AtomineerUtils now detects the newline format of documents, so it works properly on Macintosh or UNIX source files.
Fixed a small oversight in some method processing code that could very occasionally lead to a delay when generating documentation comments in large code files.
Fixed a parsing error that caused new comments to be inserted in incorrect locations if a non-documentation comment was discovered above a code element, or if no separator lines were used and no blank lines were placed between a doc-comment and the code element.
Fixed a problem with the output from Implement/Declare C++ method when there was whitespace between the function name and open bracket.
Added new global variables: %projectpathname% and %projectfolder%. If you have a file in a sub-folder of your project, these return the project-relative file/folder pathname. The default file comment now uses %projectpathname% by default instead of just the folder and leafname.
AddDocComment now adds the class scope to the doxygen prototype for methods in header files.
AddDocComment now uses the 'space after #region' preference to control the space inserted after C++ public/private/protected statements.
When writing preferences out to custom files, it now exports 'user-guide' comments into each custom file so that the docs you need to edit the rules are readily available in every prefs section that you customise.
Improved handling of explicit/implicit constructors.
Improved handling of enum entries.
Added two new commands, SuppressUI and AllowUI. These cannot be executed from the AtomineerUtils menu, but may be invoked from a macro with DTE.ExecuteCommand("Atomineer.Utils.Commands.SuppressUI"). SuppressUI suppresses (almost) all MessageBox reports from AtomineerUtils so that its commands can be safely executed within a macro. AllowUI simply reverts to the regular behaviour.
Fixed a bug in the preferences that saved the 'single line comment suffix' incorrectly when (none) was chosen, causing this text to be added to the comments.
A large update to the website, causing the gap between releases to be somewhat longer than usual. I hope to return to a more regular release schedule soon.

April 2010

7.12

Added new preferences that allow an old comment format to be converted into your new AtomineerUtils style. The preference options describe the top/bottom block separator lines and the prefix used on the remaining lines of the comment. The content within the block must use the Doxygen or DocXml syntax. If AtomineerUtils is able to parse the old format it will then regenerate the comment in your primary format. It is able to convert between Doxygen and DocXml formats (the core entry tags that AtomineerUtils knows will be converted properly (e.g. summary/brief, returns/return, seealso/sa, etc). Any additional tags must be entered into your template so that AtomineerUtils knows what to look for. If you use this feature and find situations that AtomineerUtils fails to convert well, please send me some examples and I'll see if I can improve the conversion.
'Document All In This Scope' now allows you to document all elements in the global scope by executing the command with the cursor in the first line of the file. (Mainly useful for C code, but sometimes handy in other languages too)
Added preferences for single-line comments allowing the user to set the prefix (and optional suffix) used for the comments so that any of the doxygen single-line comment styles can now be generated - e.g ///! or //!< or /*!< ... */ etc
Added an additional preference allowing the number of blank lines enforced above a DocComment to be independently configured for comments that follow an #if/#else/#region directive.
Fixed a problem with empty embedded XML elements in XmlDoc entries.
<file> templates may now use <, > and " encoding to embed literal characters into the file comment. This allows a StyleCop-compatible form of file comment (which is a hybrid of Xml in a normal (non-doc-comment) comment block) to be used. An example of this is now in the DocXmlTemplates section of the Rules.xml file.
Fixed a failure in 'Open Header/Source file' if the target file was blank.
Added support for doxygen 'throw', 'throws', 'exceptions' aliases for 'exception'

March 2010

7.11

Improved the algorithms for extracting overload, override and implemented-interface documentation from the intellisense system. The new system provides a higher quality best-match result, resulting in even better final documentation. Under some circumstances an error from the Intellisense system could cause AtomineerUtils to revert to the default auto-doc text - this has now been fixed.
AtomineerUtils Pro now has a much improved mechanism for specifying its rules. The default rules remain in Rules.xml, the format of which is unchanged. However, user customisations and comment format preferences can now be saved into separate files (one for each major element in Rules.xml) which are executed in preference to the defaults in Rules.xml. This allows users to customise most aspects of AtomineerUtils without having to merge their changes every time they update to a newer version.
In addition, a new preference allows the custom rules files to be fetched from a 'search path', so that they can be stored in any user defined location - This allows the rules customisations and comment format preferences to be held under Source Control or in a network folder for easy deployment throughout an organisation and/or safe backup.
Corrected the handling of explicitly implemented interface method names.
Updated and improved the User Guide.

7.10

Added support for Visual Basic in the 'Add DocComment' and 'Word wrap comment' commands. The parser is primarily based on the VB 9.0 spec, so please let me know if you find any legacy VB code that it doesn't comment well. Note that only the above commands currently support VB - support will be extended to other commands in future.
Added 'isOptional' variable for use in parameter rules (Currently only supported for Visual Basic).
Fixed a bug in AUTOBRIEF mode which truncated the brief text if a block format with no line prefixes (only top/bottom separators) was configured.
The block format options now work for Doxygen comments. The first line of an entry is always added directly after the doxygen command, but the indent level of any subsequent lines can now be set with this preference to be the left edge of the block, one tab of indent from the left of the block, or to line up the left side of the block of text with the start of the first line (the old style).
'Implement C++ Accessors' now has an additional option controlling the naming of the Set method's parameter. As with the member and method name templates, use 'varName' or 'VarName' to use the name of the variable (and control the case of the leading character), you can add any prefix/suffix you require, or alternatively you may use a fixed name (e.g. 'value').
Fixed a case-insensitivity bug that caused the capitalisation for some 'Implement Property/Accessor' options to be lost (e.g. 'varName' would change to 'VarName') when re-opening the Options window.
Fixed handling of namespaced exception names in C++
Fixed handling of namespaced parameter names and return types in C#. Only the leafname is now passed into the rules, so (e.g.) 'System.EventArgs' is commented using the rules for 'EventArgs'.
Improved exception rules - Now handles both 'SomeNameException' and 'ESomeName' naming styles.
Fixed a small bug in the documentation generated for casting operators.
Improved layout of controls in the preferences slightly.

January 2010

7.03

Word wrap can now be suppressed by ending a line with exactly two spaces. This suffix causes a newline to be retained at that location - very useful for achieving correct formatting of numbered lists.
Fixed a bug in code...endcode processing (only in Doxygen comments using the \code command form, word wrap was not suppressed).
'Add access methods' has been split into two commands - 'Create C++ accessors' and 'Create C# or C++/CLI property'. These commands both do the same thing except when applied to C++, one produces a pair of get/set C++ methods and the other produces a C++/CLI property.
For the new 'Create C++ accessors' command, you can now specify a pair of naming templates in the options. These contain the text 'VarName' as a placeholder for the value name, and may include any prefix and/or suffix you wish to build the get/set methods in the form you desire. Use 'varName' rather than 'VarName' to control the capitalisation. This allows you to have method names such as 'GetSpeed,SetSpeed', 'Speed,SetSpeed', 'set_speed,get_speed' etc.
Add Doc Comment now works for C++/CLI properties.
The 'Create C++ accessors' and 'Create C# or C++/CLI property' member variable style preference now gives you more control. It must contain the text 'VarName', but can have any prefix and/or suffix (e.g. 'm_VarName_'). These custom prefixes/suffixes are stripped off variables to generate the accessor name correctly. In C# it is also used to generate the name of the backing field. Use 'varName' or 'VarName' to control the capitalisation. In addition, this command still strips off common prefixes (such as _ or m_), and now handles underscores used as suffixes.
Fixed a bug in class/struct handling for C++ namespaces.
Insertion positions are now correctly located when commenting in C++ header files where an access specifier (e.g. public:) immediately preceeds the code element being documented.

7.02

Added Document all in this scope command. This scans a namespace/class/struct/interface/enum scope, applying the 'Add Doc Comment' command to all the primary child code elements (class, method, property, enum etc) within it in a single pass. This is invaluable for:
- Quickly and easily building the documentation structure for all the entries in an enum definition,
- Converting existing comments (e.g. in the Visual Studio default XmlDoc /// format) into the configured AtomineerUtils format,
- Automating updates to documentation after changing the AtomineerUtils block format or preferences,
- For automating an initial documentation pass - but it is most important in this case to then read and manually update the resulting documentation to be sure that it is accurate and complete. AtomineerUtils gives a great starting point for documentation, but it doesn't (can't) add all the most critical bits of information about special cases etc that make documentation truly effective and informative.
Fixed doxygen commenting of template class, file and namespace comments which were affected by a recent parsing upgrade.
Improved handling of fatal errors to ensure that the VS undo system is not affected by an AtomineerUtils failure.
Create Property no longer creates an auto-property for a variable with a default value, but converts it directly to a property with a backing field so that the default is retained.

December 2009

7.01	Now parses and provides auto-documentation for member variable declarations (sharing most of the rules with Parameters and Typedefs via the <Execute> command). Now parses and provides auto-documentation for structs (sharing the rules for classes). Now supports <pre>, <code>, @code...@endcode, and @verbatim...@endverbatim tags. These blocks are now left untouched (word wrap is suppressed within them). Note that the start/end tags must be the first nonblank text in the line. Improved handling of optional entries - you can now add entries like <customtag _optional="true"> to templates to specify that this entry is legal but should not be automatically added by AtomineerUtils. This improves the handling for these entries and allows you to specify precisely where such elements will be positioned in your doc comments. Templates now include optional seealso, sa, and example entries. Improved parsing of attributes - special characters and extra indentation within attribute parameters, and multi-line attribute declarations, could cause method documentation to be incorrectly generated or positioned. No longer attempts to add doc comments if executed on common undocumentable statements (for loops etc) or preprocessor directives. If you enter a specific username in the options, it is now used verbatim (if you used initials like JCW they would be 'tidied' to Jcw. It now uses JCW as it should). Removed [in,out] specifier for const pointers. Removed a legacy line of code that generated 'Thrown when .' for undocumented exceptions.
7.00	Major new release. AtomineerUtils was split into two products, a free trial (AtomineerUtils) and a charged (but very inexpensive) version (AtomineerUtils Pro).
	Ability to fully customise the comment style (separator & line prefix style, and control of blank lines between entries) Enhanced auto-doc engine. AtomineerUtils Pro will derive new documentation from related code elements, re-using appropriate portions of existing documentation to build excellent documentation for the following code elements: Implemented interface members Overridden virtual methods Overloaded methods Parameters. AtomineerUtils Pro will duplicate documentation for parameters of the same name/type wherever they are repeated in the class, keeping the documentation consistent throughout. Now supports Doxygen JAVADOC_AUTOBRIEF style, where the 'brief' entry does not have a tag introducing it. Note that this disables inclusion of the prototype tag, and will only work if the brief entry is the first entry within the comment.

November 2009

6.12

Added the <Execute> command for Rules.xml. This allows you to 'include' a block of rules from elsewhere in the rules.xml at the position of the Execute command. The included block can be a standard rules block (e.g. 'Parameters' or 'Classes') or it can be a user-defined block (e.g. 'JasonsExtras')
Added support for comments on simple typedefs. This includes a new 'Typedefs' section in Rules.xml to control the documentation output. Note that this currently only applies to type aliases (not function aliases)
Added support for C++/CLI System::Void
Added support for C++ templates
Fixed a recent breakage in enum entry parsing that caused entries with an assignment to be mishandled.
Fixed C# Property commenting in interfaces, which was not picking up the get/set declarations correctly.
Fixed parsing of operators containing whitespace in the name ('operator ==' rather than 'operator==')
Fixed a bug in handling of blank custom documentation entries with auto-punctuation disabled, which caused the custom entry to be skipped in the output documentation.
Fixed a potential failure in handling of blank entries.
Fixed Word Wrap Comment command to wrap at the configured column - it was wrapping 2 chars too late.
Added two Implement/Declare method preferences (in the Misc section):
- Switch to the newly implemented code after implementing: If enabled, the command will leave you in the file where the new code has been added (to allow you to immediately edit the result). If disabled, you will remain in the file where the command was executed (to allow many methods to be conveniently implemented/declared in a row)
- When implementing a method, you can now choose not to automatically add a DocComment to it.
Added a few improvements to the rules.xml.
Improved the installer icon.

October 2009

6.11

Added %name% and %type% variables for use in top-separator lines. This makes it possible to add a header with information like "Method: WriteAllFiles" embedded in it. Combined with '\n' to generate a multiline separator, this allows a lot more flexiblity of block style. Note that multiline separators usually needs to be in a /** ... */ format block (with blank line headers) in order to be parsed and updated correctly by AtomineerUtils. An example 3-line header format is now available in the AtomineerUtils Options drop-down list.
Exception documentation parser now handles managed C++ better.
Added support for C++/CLI tracking references (% and ^%)

6.10

Create Property/Accessors for C++ now uses an improved indentation/column alignment algorithm.
Fixed a silly bug in the parsing of C++ constructors that could enter an incomplete prototype into doxygen comments.

September 2009

6.09	Fixed a small bug in parsing constructors with default parameters and static initialisers. Create Property/Accessors for C# has been upgraded in VS008 and VS2010 to support auto properties: Executing the command on a variable declaration converts it into a C# 3 automatic property. Executing the command on an automatic property declaration converts it into an explicit property implementation and a backing field. (You can execute it twice in succession to get from a variable to an explicit property as used to happen). The backing field for 'SomeProperty' will be given the name 'someProperty' by default - a prefix can be added in the preferences to generate fields with names such as 'mSomeProperty', 'm_SomeProperty', '_SomeProperty', etc. In addition, it no longer adds debugger attributes to generated properties in Visual Studio 2008 or later versions (as the IDE provides much improved debugger stepping controls). A small bug was fixed that caused it to fail in some circumstances when executed on a variable with a static initialiser. Combined the two lesser preference tabs into a 'Misc' tab to reduce the number of tab pages.
6.08	Added 'General' tab to the Preferences. This allows you to hide sets of menu commands (Outlining, Clipboard, and C++) that you don't wish to use, to remove 'junk' from the user interface. Word Wrap Comment now supports doxygen //! comments. Fixed a minor parsing glitch that caused the wrong type of comment to be generated when commenting a declaration of an operator= in a header file. 'Check for Updates' now pings Atomineer.com to determine if your copy of the addin is up to date. Added 'Help...' command to launch the AtomineerUtils hopme page in your web browser.
6.07	Major bugfix - An obfuscation glitch stopped the block formatting options working properly, leaving users stuck in 'FramedFlush' mode.

August 2009

6.06	Added templates for controlling documentation of interface and abstract-class methods. The new default templates produce simpler comments (no author/date or exception entries). This is on the basis that you seldom need to know the author of an interface declaration; this information is usually only important in the concrete implementations. It also allows you to remove blank lines to make interface definitions more compact and easier to scan through. Now properly handles attempts to edit read only documents (read-only files, documents auto-generated from metadata, attempts to edit files while the applcation is being debugged, etc). Now handles single-line properties regardless of where the cursor is in the line. Attempting to add a line comment now does nothing if a line comment is already present on the previous line
6.05	Fixed a stupid bug in 6.04 - I left the default for Doxygen comments with prototypes/declarations disabled. Doxygen prototype no longer picks up member initialisers from constructors.
6.04	Added handling of several more 'simple' types to the C++ 'Add Accessor' command. Added %specialType% for methods, allowing the rules to access whether a method is normal, static, inline, abstract, virtual, or override. Quite a few rules improvement (e.g. now documents static constructors, interface files) Added an option to suppress or include the declaration/prototype entry in doxygen comments. Now supports documentation of macros (#define). The rules.xml templates contain a new <def> template to control these comments. Added support for use of \ for continuation of lines in methods and macros Word wrap no longer splits parameter names in doxygen declaration/prototype entries. Improved handling of [in,out] to preserve user-edited [in] or [out] tagging. Fixed a small [in,out] formatting glitch in doxygen. The block-format for groups of similar entries now also applies to single entries of types that are normally in a group (params, exceptions, etc). Fixed a bug in Create Accessor for C++ that caused it to insert the accessor in every public/protected/private block (how the heck did that get broken?!) Parser is no longer confused by a < character if it occurs in an operator method Cleaned up the options window, breaking the DocComment options into three separate tabs. This allowed me to make the options cleaner & more descriptive, and make it easier to use with restricted screen resolutions (600px height).
6.03	Added new command for C/C++: Open Source or Header. This simply finds the source/header file that matches the header/source file you are working in. More work on "Implement/Declare C++ method". Now handles extra prototype entries such as DLLEXPORT. Handles namespaces properly, and now inserts the generated code in the correct scope. %ContainingClass% is now available even when intellisense is unavailable. Improved the block-formatting options. By default, all contiguous entries with the same tag (a block of entries) are formatted so that the text for all entries is indented to start at the same column - This makes param lists more readable. Added a preference to disable this so that every entry is treated standalone - This is less readable, but minimises the space used. When updating a comment, the autodoc entry will now override any existing entry that is essentially blank. Several improvements to parsing of class names. Fixed a bug in detecting const methods under very rare conditions. Fixed a block grouping bug when updating blocks of user-defined elements, that caused blank lines to be inserted between all the entries in the block. Fixed a parsing bug that caused one form of static class declaration to be commented as a property

July 2009

6.02	"Implement C++ method from header" has been upgraded, and is now called "Implement/Declare C++ method". When used in a header, now locates the paired .cpp file and appends the generated method to it. When used in a source file, now locates the paired .h file and inserts the generated declaration into the relevant class. Now detects the parent class name correctly (previously relied on the classname and filename matching).
6.01	Significantly improved exception (throw) parsing. AtomineerUtils can now detect and handle most throws including exceptions thrown via variables and rethrown exceptions. Added a preference: When padding is enabled (default), each entry can now be started with a tab character (default) or a space. Using a space reduces the whitespace in comments at the cost of the start column of each entry not being guaranteed to line up on a tab column. Block top/bottom separator lines can now be made up of multiple lines of text by including \n within the text to represent newlines. Note that the block matching algorithm only uses the first line of the top separator and last line of the bottom separator to match any existing comment block in the code, so these must be unique (and different from each other) for AtomineerUtils to correctly detect and replace existing comment blocks. Bugfix: Doxygen property comments were not being correctly updated to contain the appropriate "gets or sets" text for the type of property being updated. Fixed a tiny bug. File/namespace headers that included templated text containing embedded XML elements would not expand %fileDescription% or %namespaceDescription% variables.
6.00	Sorry, no major features for 6.00 - I simply ran out of version numbers in 5.xx! Bugfix. AtomineerUtils was not reading the Text Editor options in Visual Studio correctly, so under some circumstances tabs were used instead of spaces regardless of the user preferences. Bugfix: If the first code element immediately followed a file header, and that header was using the same format as the doc comments, it would be replaced. File headers are now correctly preserved.
5.99	Refactored OutlineDocComments command to work with the new block formats - it previously only supported triple-slash style comments. Added a new preference that controls whether single-line comments (on variables, enum entries, etc) are placed on the previous line (DocXml/Doxygen style) or added to the right of the code element being documented (Doxygen style). Note that although you can use this mode with DocXml, comments must be placed before the code element that they refer to in order to correctly associate the documentation with the element. Now works better if you attempt to document a selected block of text (instead of placing the cursor in the first line of the element to document). Bugfix: %monthOfYear% variable was not returning the correct text. Bugfix: Fixed occasional problem with Add Accessor/Property on generic types. Bugfix: Word-wrap would occasionally break embedded XML commands. Web pages now display correctly under the Chrome browser.

June 2009

5.98	Added DateCulture preference, allowing the date format to be forced to a particular culture rather than using the current OS culture. This is useful for companies that have to document code in English, but have their PCs set up for a non-English culture. Added Template '_blankEntry' attribute. This overrides the standard behaviour of deleting entries such as <param> when there are no parameters, allowing you instead to substitute a plain text comment, to generate an entry like <param>None.</param> for parameterless methods. (Note that this is a custom documentation format that will not be compatible with the DocXml/Doxygen standards, so should only be used with bespoke documentation publishing tools).
5.97	Improvements in parsing of C++ class & function headers. Small improvements to the Pluralise heuristics. Bugfix: (Doxygen) 'return' tags are now removed if you change the return type of a method to void. Bugfix: (Doxygen) Under some circumstances enum/class/interface names were not parsed correctly, causing spurious text to be included in the auto-generated documentation. Bugfix: Commenting the final entry in an enumerated type now works correctly. More rules added
5.96	Significantly updated and improved the rules for auto-documentation of properties. Section prefix/suffix strings now have any contained %variables% expanded. New global variable %containingclass% now provides the name of the class that contains the current code element. If no containing class is found, the file leafname is used instead. (Currently this relies on intellisense information) Bugfix: Exception documentation was not being generated for C++ code.
5.95	File and Namespace comments are now properly supported. The old file header preferences have been removed, and the whole process is entirely controlled from the rules.xml templates. You can either use plain text or an XML template, and new variables and AutoDoc rule sections have been introduced to give you full control of the formatting and auto-doc text that is output into file/namespace headers. Full details can be found in rules.xml Added more comments to rules.xml to make it easier to understand and edit the rules.
5.94	Improved FramedXxxFlowSingle block formatting when an entry is too long to be formatted in 'flow' mode due to the length of its tag. This occasionally caused parameters with long names in single-parameter methods to be formatted poorly (resulting in a line of excessive length). Bugfix: When XML tags were embedded within template elements, newlines were being stripped. These newlines are now preserved. Small improvements were made to the word wrap logic. Fixed the file header preferences - in moving the controls to a new tab, VS created two imposters and hid the original controls in an alternate universe.
5.93	Added a preference to globally enable/disable insertion of blank lines between entries. (The templates in rules.xml still gives finer control of the locations of the blank lines) Added a live preview to the preferences so you can easily see the effect your choices will have Fixed a small bug that stopped Properties picking up base class documentation. Fixed some minor word-wrap artifacts (e.g. joining 'and/or' back together as 'and/ or') Fixed an error that could cause several comments to be gathered into one comment if a rare 'confusing' character sequence was found in the file being documented.
5.92	Tested with Visual Studio 2010 beta - found to work fine. Added a preference for the overall style of each entry, giving 5 new options regarding the way the block is formatted. See block format examples for a pictorial explanation of how the different formats look. Note that the default format has now been changed. To retain the old AtomineerUtils formatting behaviour, set the 'Put tags on the same lines as the entry text' (Flow) mode. An additional option allows you to apply a single formatting options across all entries in a group of similar entries (e.g. params) where it looks messy to use different format styles on each entry Added a global preference allowing the automatic insertion of whitespace between the entry tags and the body text to be suppressed if preferred. Discovered that Express Editions don't support add-ins, so added a note to the download page.

May 2009

5.90

Refactored the word wrap and indentation systems to work much more effectively. AtomineerUtils now handles indentation made up of a mixture of spaces and tabs correctly, and correctly preserves blocks of text at different indent levels, so it handles lists and example code much better. The new engine is also able to correctly parse blocks with no line headers (C style /* ... */ comment blocks), allowing almost any conceivable block comment style to be used with AtomineerUtils
Added _punctuate, _wordwrap, and _verbatim attributes to the Rules.xml templates. These can be used to control the behaviour of AtomineerUtils on a per-entry level. Documentation on these is included in rules.xml.
Fixed a bug in Doxygen handling of interface elements.
Changed Doxygen default tag (in rules.xml) for returns from "retval" to "return" as I discovered I'd mistakenly been using the wrong tag for years! Also removed the dash in doxygen param entries to follw the doxygen standard more correctly.
Property/Indexer "gets or sets" text strings are now set in user variables to support foreign language translations of rules.xml
Added parser support for C++ function type declarations and template classes.
Added support for BOOLEAN type in Rules.xml.
Fixed occasional infinite loop bug when parsing base class doc-comments.
Exposed DateFormat preference in the options window. This can be set to any standard DateTime format string such as "d" or "dddd dd mmmm yyyy"
Doxygen comment update now properly updates the prototype (class, fn, etc) entry and [in,out] parameter descriptions if the function prototype changes
AddAccessMethods handling improved to handle generic types and volatile variables.
Installer now allows the addin install location to be set by the user. This is needed as a workaround for companies that place 'My Documents' on a mapped (server) drive.

April 2009

5.86	Comment-wrap feature now works fully for comments that have no whitespace between the // and the comment text. Small bugfix for enum entry line comments Fixed small bugs in the handling of leading and trailing blank lines for word-wrap and auto-punctuation. Improved updating of comments containing user-defined tags (from Rules.xml templates).
5.85	Improved override documentation harvesting. Added "Check for updates..." menu item.
5.84	Prefs application now supports enforcing of 0 lines above/below DocComments.
5.83	Bugfixes in handling of multiple C# attributes, and for one case of wildcard rule matching. Added %typeBase% variable and <IfNot> rules.xml command. Improved handling of 'a', 'an' and 'the'. Made a significant number of improvements to the default rules.xml
5.82	Added template support for file and namespace comments. In DocXml, this is disabled by default, but can be turned on in Rules.xml to use the Xml format for file and namespace comments. Added more date variables for use in Rules.xml Added project/assembly variables (e.g. %AssemblyName%) for use in Rules.xml
5.81	Upgraded Doxygen code to use the (relatively) new Templating system already in use for DocXml.

March 2009

5.80	Fixed a bug in doxygen indentation processing.
5.79	First widespread public release.