AtomineerUtils Development Summary

This program grew from an in-house Visual Studio macro (for a custom comment format in C code) in 1996, and has evolved over the years. Version 2 added C++ support, and version 3 changed to support Doxygen format. Version 4 added support for C# and DocXml format, as well as updating of existing comments. Version 5 was significantly refactored to create an add-in, and became the first public release (Aug 2008). In version 7, Visual Basic, Java and JavaScript support were added. For full details of recent developments, read on...

January 2012

7.48

Live typing aids: When pressing Return/Enter in a comment block, AtominerUtils will extend the comment onto the new line. The behaviour of this feature has been improved - Previously a comment on only a single line was not extended (for convenience) but a comment spanning several lines would be. Now, even single-line comments are automatically extended, locking you into a 'comment editing mode' where AtomineerUtils assists easy commenting. To exit this mode is easy, just press Return twice in a row - the first press will extend the comment onto the new line, but the second will remove the comment header.
Live typing aids: If you press delete (to delete forwards) at the end of a comment line, and the following line is also in the comment block, the delete wil consume the newline all indentation from the second line, and the comment prefix, so that the text of the comment body is concatenated cleanly.
Live typing aids: A few small improvements to the creation of comments when typing /// or '''.
A lot of work on updates and additions to the commenting rules (a 5% increase overall), improving the quality of the generated documentation for some existing cases, and adding support for a large number of new cases.
'Align code into columns' now handles strings in a more intuitive manner.
Significant improvements made to the installer, making it much easier to install/uninstall AtomineerUtils to a custom location. It now only installs itself for versions of Visual Studio that are currently installed on the PC (i.e. if you install a new version you will now need to re-run the AtomineerUtils installer).
Improved handling of templated structs in C++.

December 2011

7.47

A new preference has been added, 'Use simple format for single line entries'. Any doc comment that occupies only one line (e.g. just a short summary/brief description) will now be output without separators or enforcement of blank lines. This is primarily intended for use with member variables, but if you set up templates for Properties, Enums etc to produce only one-line comments, they too can use this briefer format. This preference is enabled by default (for backwards compatibility) but can be disabled if you prefer to use full block formats for every comment. (Note: This option is not applicable if multi-line comment formats are in use)
Member (variable, field) comments are now supported much better: They can now be updated (to word-wrap their description text), and will use the block format determined by the single-line preference described above. In addition, the Templates now contain a '<Members>' element that allows full control of the entries that should be included in Member comment blocks.
A new preference allows you to set the text used to refer to 'this object' in generated documentation. The options are to use 'object', 'instance', or the name of the containing class. Thus, you can now generate documentation like 'Initialises this object' or 'Initialises this VehicleCollection'. The default setting (for backwards compatibility) is 'object'.
Align into columns now respects the Visual Studio tab/space preference.
Improved handling for unnamed parameters.
Fixed a small issue that could cause misidentification of operator !=
Added handling for comma-separated variable declaration lists. Instead of becoming confused, AtomineerUtils now simply comments the first variable in the list.
Fixed a refactoring bug that sometimes caused parsing problems with 'internal' code elements
Some small speed-ups have been made in the formatting engine
Many small improvements to the auto-documentation rules

November 2011

7.46

C#: 'gets or sets' descriptions for properties are now generated correctly if you have set AtomineerUtils to not comment members of particular access levels, and one of the accessors is set to a lower access than the property itself (e.g. If you've configured AtomineerUtils so that 'private' members won't be documented, a property 'public Prop { get; private set;}' will now be commented as 'gets' rather than 'gets or sets', as the set accessor is configured to be invisible for documentation purposes.
Properties and Events that override base class members or implement interfaces can now be documented with <see> entries.
Improved parsing of default/optional parameters using nested bracketed expressions.
XML entity conversions (e.g. '<' becomes '<') are now applied to generic typenames in generated documentation text (as well as being converted when updating existing documentation).
Some improvements to the Align Code into Columns command.
Fixed a smal glitch that recently crept into the Implement Method command when used on parameters with default values.

October 2011

7.45

Added a new command: 'Align code into columns'. This uses a smart algorithm to align text patterns into a column across a block of similar lines. It can be used to align code into columns before/after assignments, commas, arithmetic/logical/bitwise/comparison operators, brackets, strings, numbers, variables and keywords, which serves in some cases to clarify code and make it easier to read and maintain. It not only aligns exact matches, but also 'similar' matches such as mathematical operators, and is able to span non matching lines (e.g. blank lines) so that it can be used to tidy up large tables of Text, CSV or XML data as well as small blocks of code. See the user guide for full details.
Improved handling of single-line comments
Fixed a spurious space displayed in the Options comment preview with word-wrap disabled.
Fixed a spurious space on Class and Interface summaries when all whitespace was being suppressed.
Corrected Property processing, which was generating an incorrect default access level for undecorated properties, suppressing documentaion incorrectly when limited to some access levels.
Improvements and clarifications made to the User Manual.

September 2011

7.44

Improvements in handling of prefixes on names embedded within C# event handlers.
Improvements in generated exception documentation text.
Added support for C++ exception specifiers on methods.
Checked compatibility with and added support where necessary for C++11 features: constexpr, =default, =delete, auto, override, final, explicit, trailing return type, constructor delegation, enum class, enum struct, using (as typedef).
Improved handling of C++/CLI constructs and modifiers.
Attempts to document 'using' statements (apart from C++ aliases) are now ignored.
Fixed a case where complex casting operators were misidentified and documented incorrectly
Added a template block for unions to the rules.
A lot of new rules and abbreviation expansions added.
Added some extra exception handling code to 'Open Source Or Header' after discovering some undocumented exceptions that can be thrown by the Visual Studio APIs.

August 2011

7.43

Improved support for prefix removal. A new <Prefixes> section in the rules allows substitutions to be made (just like WordExpansions) but only for the first word of a name. The default rules use this feature to now auto-remove common prefixes (lpsz, afx, etc). A new variable is available, %nameNP% (for 'no prefix') which provides the symbol name with the prefix removed, to allow clean documentation to be generated from prefixed names.
Further work on the optional see-also processing has improved the quality of the see-also reference generation overall. In addition, 'see also' entries are now generated for interfaces, implemented interface methods and properties.
Quite a lot of behind the scenes work on improving the website, and a new look for our web pages and customer notification emails.
Made some improvements to the handling of override and overload documentation handling
Improvements to the rules
'Open Source or Header' and 'Implement Method' now support .hxx as well as .hpp and .h files.
Fixed an irritating issue in the last Trial version that caused it (when expired) to report trial expiry every time VS was launched instead of only when an attempt was made to use AtomineerUtils commands.

July 2011

7.42

Documenting only those members with specified access levels has now been extended to include member variables.
The default author and date entries can now be suppressed easily from within the AtomineerUtils Options - previously this required customising the templates XML.
Fixed a small glitch in 'Open Source File' in C projects
The word abbreviations dictionary can now be used to delete unwanted words (such as library method prefixes). Just add an abbreviation entry that returns desc="-" to delete any matching word.
Some small improvements to the pluralisation algorithm.
Live typing aids were interfering with intellisense auto-completion (when pressing return within XML doc comments - pressing TAB or ctrl+space to autocomplete was not affected). The live aids system now allows the default VS or Resharper auto-completion behaviour to operate as normal.
Live typing aids now auto-continue numbered and lettered lists starting with numbers in forms like 1 2 3 - 1. 2. 3. - 1) 2) 3) - a: b: c: - a) b) c) etc.
Resolved an issue where Outline Doc Comments did no always work properly with comments if they had no top/bottom separator lines.
Improved handling of generic class declarations
Fixed the 'see' entries generated (if configured) for overloads. (Note: In this version implemented interface methods and properties are not commented with 'see' entries. This feature will be added soon).

June 2011

7.41

Extended the support for StyleCop compatibility. On the General tab of the Options there is now a checkbox that enables StyleCop compatibility. This sets the variable 'stylecop' to true, causing StyleCop-compatible comments (file headers, constructors, finalisers, etc) to be generated instead of the AtomineerUtils defaults.
AtomineerUtils can now document derived classes and override methods/properties by adding <see> or <seealso> entries.
- To add <seealso> entries, go to the Advanced Customisation tab of the preferences, and tick the options for derived classes and/or override method/properties.
- Alternatively, to add a <see> reference within the <summary> entry itself, edit the UserVariables and set <Variable name="docBasesWithSee" value="true"/> and/or <Variable name="docBasesWithSee" value="true"/>.
In addition, there are two new checkboxes in the Advanced Customisation tab that can be ticked to suppress the other documentation generated for overrides, so that they are simply documented as references to their base class/method/property.
(Note that these options rely on the Visual Studio Intellisense (Code Model) information, the availability of which varies with language and VS version).
Added a new preference to the Advanced Customisation tab to optionally disable the automatic duplication of existing documentation (from base classes, interfaces, overloads and other parameters in a class). If disabled, the documentation text will be auto-generated rather than being copied from existing 'best match' documentation.
Added a new variable (in the User Variables in the Advanced Customisation tab), 'docOverridesWithSee'. If set to true, this changes the documentation generated for overrides in C# and VB to use a <see cref='BaseClass.Method'> reference instead of a textual description.
UserVariables can now be set in the Prefs.xml. As long as the UserVariables in rules.xml are conditional (using ifSet="false") they can be overridden in the Prefs.
Added new variables for use in rules: %time% and (for C#/V/Java methods) %access%.
Improved the word wrapping algorithm, which will no longer split XML elements or URLs across lines.
Added support for optional parameters, which are now documented with the text '(optional)'.
C# Implement Property now handles virtual/override auto properties correctly.
Fixed a couple of subtle bugs in the new (7.36) text formatter that caused paramrefs and root-level seealso elements to be removed if they occurred at the very start of a line.
Improved parsing of templated class constructors when the declaration has been split across multiple lines.
Fixed a rare infinite loop that could occur when generating a class comment for a file containing fewer than 4 lines of code.
Made some minor improvements to the installer.
A lot of work also went into improving the website this month.

May 2011

7.40

Improved 'Document all in this Scope' to handle C/C++ better - The most significant improvement is that header files are now supported and class declarations can be documented.
When adding a file header, any existing file header comment is now replaced by the new header comment, making it much easier to update file headers to a new style. (Note that file headers are still treated as plain text (i.e. not parsed and reformatted) - they are simply replaced)
Improved formatting of [in], [out] and [in,out] param entries.
Fixed a sneaky bug (it only occurred in the formatting of Javadoc comments in Auto-brief mode with long top separators), where a portion of the separator text could be repeated in the start of the brief description.

April 2011

7.39

Fixed a tiny bug that caused Properties to be misidentified and documented incorrectly.

7.38

Improved 'Document all in this Scope Block': It now supports Visual Basic, and documents more code elements in C# (the most significant additional support being for members in interfaces).
(In C#, Visual Basic & Java code) the access level of a code element (public, protected private, internal etc) can now be used to control whether documentation comments are required. By limiting Doc Comments in this way, it is now possible to use 'Doc all in scope' to automate documentation conversion/generation across an entire class without any private members being documented. (The new preference setting can be found on the General tab of the AtomineerUtils Options)
Improved handling of [in], [out] and [in,out] param entry prefixes. [in] and [out] will no longer be removed if the user explicitly set them.
AtomineerUtils can now be used in Atmel AVR Studio 5.0, a custom IDE based on Visual Studio 2010.
Fixed an issue that interfered with method classification, resulting in event handlers sometimes not being correctly documented.

March 2011

7.37

The search paths used for AtomineerUtils Rules can now include %solutionPath%, %solutionName%, %projectPath% or %projectName% variables. These are expanded to the full path of the active solution/project folder or their leafname as appropriate. This allows every Visual Studio project to optionally contain AtomineerUtils rules/prefs xml files that are project-specific, and as you comment your code the appropriate settings will be used for the active document. This makes it much easier to use different comment formats or rules for different languages (for example, a common use of this is to use Doxygen commenting for C++ and DocXml for C# code). Please see here for full details.
Added support for executing user-defined macros to preprocess the active document before AtomineerUtils tries to parse the code. For example, when AtomineerUtils has found an existing comment format in the 'alternate' style, and is ready to convert it to the new AtomineerUtils format, it can call a user macro with the coment selected so that user-defined transformations can be applied to convert the comment into an AtomineerUtils-compatible (XmlDoc or Doxygen) form. For more information, see the preprocessing manual page.
When parsing method declarations, AtomineerUtils can now apply optional regular-expression replacements to the text before it is parsed. This does not change the code in the document being processed, but just the view AtomineerUtils has of it. This allows users to convert in-house types, typedefs and macros into a form that AtomineerUtils can handle better. For more information, see the preprocessing manual page.
Added the ability to wrap commented code elements in regions. Comment styles can now be set up with '#region' or '#pragma region' top separators but no matching #endregion in the bottom separator. In this special case, AtomineerUtils will automatically add the #endregion or #pragma endregion (as appropriate) after the scope of the code element, thus wrapping the entire element in its own region. Parsing of existing comments with #region/#endregion separators has also been slightly improved.
Added support for C++ TR1 Move Constructors and Move Assignment Operators
Added the Rules Guide to the distribution zip file to make this information easier to find. Clicking the 'user guide' button in the preferences dialog now also shows the rules guide rather than the general user manual page if the Advanced Customisation tab is active.
A small improvement to the insert-blanks-before logic.
Fixed a small issue that caused Doxygen tparams to be emitted with the wrong tag ('typeparam')
Improved the efficiency of the abbreviation expansion rules

February 2011

7.36

Reworked the DocComment entry formatting approach. This simplifies the options and in conjunction with the Quick-setup Wiozard, makes it much easier to configure AtomineerUtils to achieve the style you want, while at the same time making it possible to format entries in ways that were not previously possible. The quick-setup wizard and preferences have been significantly updated to support the new options and provide better previews.
The preferences now have a lot of help built in as tool-tips. Hover over items to get a lot more information on what the options control and how to get the best out of them.
'Document All In Scope' now understands what you want if you place the cursor on the open brace of a scope rather than the declaration for the scope.
File and File-footer comments can now be targetted to specific file extensions, to allow different headers to be added to (for example) .cpp and .h files, and adding a file header can optionally add a file footer at the same time. The default templates now contain an example that can be used to add a #ifndef ... #endif 'include once' mechanism to header files using these features.
Fixed a small glitch in the uninstaller when removing files from a custom installation folder, which could unintentionally leave some of the folder structure behind.

January 2011

7.35

Added the ability to insert file footer comments. Just place the cursor in whitespace at the end of the document and execute 'Add Doc Comment' to insert a footer. The format of this footer is set in the <filefooter> Rules Template, and supports all the features of the <file> template.
File headers and footers as well as basic 'catch all' doc comments can now be inserted into files of any type. The comment block formats used are configured in prefs.xml (a number of common programming file formats are pre-configured - variants of html, xml, resources, sql, lua, python, perl, ruby, powershell and batch files - but you can add any more you require). For file types that are not explicitly mentioned in this list, the default AtomineerUtils C-style comment format will be used (which covers a great number of additional code formats). Note that <file> comments ideally need to be defined using an xml template rather than free text template to ensure that a legal comment is output in all such cases. The auto-generated documentation for these comments can be customised by using a <CatchAll> block in your custom rules xml and a <catchall> custom template used to control the layout of the general comments inserted in this way. Examples of both are now included in the default Rules.xml file.
Auto-punctuation can now be disabled on doxygen brief entries.
Added '_tagName' property to the templates, allowing entries such as 'exception' to be generated with a custom name such as 'throws'.
Many small improvements to the rules and abbreviations.

December 2010

7.34

Updated the installer to provide an Uninstall option. (This approach was taken rather than registering with the 'Add/Remove Programs' control panel to avoid the need for UAC elevation on Vista/Win7, making the install/uninstall process easier and faster).
Added the Quick-Setup Wizard to help new users chose a basic commenting format and style quickly and easily.
Added support for generic typeparams in class and interface documentation.
Improved handling of scopes (methods) with unmatched braces. In large files, an 'unterminated method' could lead AtomineerUtils to process a lot of text, which would succeed, but could take a long time. This was only a problem with broken code in massive source files, so a very rare occurrence.

November 2010

7.33

Added a minimum comment column preference for end-of-line comments on single-line code elements. This ensures that eol comments are always placed at least at that column, which can help to line a block of these comments into a single column to the right of a ragged list of items.
Made some improvements to the comment-typing/indentation helper.
Extended support for the _separators='false' attribute to all templates, to allow seprators to now be suppressed individually for any comment-block type if you so wish.
The code element name variables (%name%, %sName%, %sNameRaw%) can now be used within template blocks.
Improved the Options dialog, and added explicit support for JavaDoc (instead of it being treated as a subset of Doxygen format).
Updated template handling of <_/> elements to allow newlines to be added at the start or end of a template body (previously leading/trailing blanks were formatted away)
Fixed a small bug that caused a failure when documenting a parameterless method called Append().
Fixed a small bug that stopped the 'no bottom line separator' functioning correctly.

October 2010

7.32

Renamed parameters and typeparams are now detected and updated automatically where possible. (Previously these were marked as 'deleted' entries and a new entry created, as it is impossible to always determine the difference between simple refactorings and certain patterns of adding/deleting parameters. However, simple refactorings, additions and removals are the most common forms of update, so these are now supported by the new behaviour to make AtomineerUtils more convenient in typical situations). Renaming is detected primarily based on the location of a parameter relative to others - therefore if you wish to replace a parameter with a new one, the best approach is to delete it, update the documetation, and add the new parameter as a separate 'step'. If AtomineerUtils is unable to make the correct choice, you could end up with old documentation applied to a new parameter, so (as always) check that the results are correct and complete after updating a comment.
Improved commenting on Constructors. Where avaialble, documentation is duplicated from method overrides, which in most cases works very well. However, in the case of constructors this could cause a description like 'Default constructor' to be duplicated onto a normal or copy constructor. AtomineerUtils now detects these "short" constructor descriptions and does not duplicate them, allowing the regular auto-doc rules to supply the correct description instead.
'Create C# or C++/CLI Property' now retains internal/protected access permissions from auto-properties when converting to a property with backing field.
Several improvements to 'Add C++ accessors' - it now handles namespaces better, and some glitches with const and pointer member variables were ironed out.

7.31

When updating documentation, AtomineerUtils can now optionally convert <, > and & characters into the XML/HTML entities < > and & so that XML/HTML remains valid when code snippets containing less than, greater than, AND operations, generic types or Visual Basic attributes are used. This conversion is enabled by default, but can be disabled in the general DocComment Options.
Eliminated a small but unnecessary delay when processing header declarations.
Fixed capitalisation of a/an/the when corrected in the first word of a description
Added rules for handling C#/VB enumerators, C++/CLI finalisers, and quite a few small improvements to the rules

September 2010

7.30

Added support for Java source code. Please let me know if you find any Java constructs that AtomineerUtils has problems documenting properly.
Added a Windows 7 compatibility manifest to the installer to stop Win7 occasionally asking if AtomineerUtils installed correctly.
Options: Improved handling of the Advanced Customisation preferences. If you hold down Shift while clicking a custom-rules button, it now opens the folder containing that custom xml file, making it much easier to locate the files.
Options: under some circumstances, custom prefs would fail to overwrite the default preferences when opening the Options window, so it could 'revert' the options to old settings. This has been fixed.
Fixed an indentation glitch that occured with some JavaDoc auto-brief style comments.
Improved parsing of nested XML elements. The parser included code to improve resilience when presented with poorly formed XML, but this produced incorrect results in the case of <paramrefs> nested within <params>. The code has been rewritten to eliminate this flaw.
Made some small improvements to the live editing handling within comment blocks.
'Document all in Scope' now shows a progress bar in the Visual Studio status line. In VS2005 and VS2008 the progress is obvious as you can see the comments as they are generated, but in VS2010 the IDE doesn't display anything while it is processing, so appears to 'lock up' for large code files. The progress bar makes it much easier to see what is going on. (Also remember that you can press Esc to abort processing at any time)
A small improvement to property get/set parsing
More rules improvements.

August 2010

7.24

AtomineerUtils can now optionally track changes within comments and doc comments, and offers the following enhancements to the basic Visual Studio support:
1. Type /// or ''' above a code element, and AtomineerUtils will automatically add documentation for it. Although Visual Studio does this (for VB and C#), it only creates an empty skeleton comment, while AtomineerUtils fills everything in for you as usual. In addition, the generated comment block will be in the configured AtomineerUtils style. This feature also applies to all supported languages - i.e. it also works for C++ and C.
2. When your cursor is inside a block comment made of single line comments (// in C# and C++ or ' in Visual Basic), or inside a doc comment block (whatever you have configured as the AtomineerUtils style, for example /// or ''') and you press Enter to insert a new line, AtomineerUtils will create the blank line for you, automatically adding your configured line header and then indenting the cursor within the comment so that it lines up directly under the comment text on the preceeding line. In addition, if the current line of your comment seems to start with a bullet-point (-, *, +), AtomineerUtils will duplicate it to automatically continue the bulleted list. To use the default Visual Studio behaviour when pressing Enter, hold down Shift (add a newline) or Ctrl (add a newline before the current line) at the same time.
See this page for full documentation on these new features. Note that there are new preference options to disable these extensions if they are not desired.
It appears that the code-model information for C functions (which worked well in VS2005, VS2008) sometimes returns incorrect information within VS2010. This tricked AtomineerUtils into using the wrong template for the resulting documentation. AtomineerUtils now detects and corrects this issue to produce the correct documentation block.
Added support for C/C++ unions.
Fixed a small glitch in generic-method name handling that caused incorrect commenting to be generated for operators like < and <=.
Fixed a small problem that could sometimes cause word expansions to be repeated. This only showed up with the few 'recursive' expansions such as 'y' => 'y coordinate'
Entry lines that end with the text <br/> (note: with no spaces in the element) are no longer word-wrapped.

7.23

A lot of work on the website; primarily a lot of new documentation on customising the rules.
Improved parsing of generic function names to handle nested generics.
Fixed a glitch in the new conversion code that sometimes interfered with the removal of deleted parameters.
Hid the menu items for SuppressUI/AllowUI in Visaul Studio 2010 RTM, which is ignoring the command's options.

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.