Follow us on Twitter

Atomineer Pro Documentation Development History

January 2021

  • Added C# 9 support, including records and positional records, and property init accessors

December 2020

  • Some minor tweaks and improvements.

October 2020

  • Added support for C++ defaulted and deleted constructors, destructors and operators.
  • Fixed issues with skipping attributes when commenting at the very top of a Visual Basic file, and within enums.
  • Doc this Project/Solution now detect and skip additional forms of designer-generated files.
  • Doc this Project/Solution will not document partial classes unless they match the filename.

August 2020

  • The batch-processing commands are now able to process methods and members implemented in the @code section within Blazor '.razor' files, as well as inserting HTML header comments for these files if required.
  • #pragma directives immediately prior to code elements are now treated like attributes.
  • Upgraded a portion of the argument parser to improve handling of optional parameter defaults for strings, which could occasionally cause the parser to produce partial results.
  • Fixed an uncommon issue in emitted doxygen function declarations
  • Fixed a batch processing issue in Doc all in File when intellisense is unavailable, which could lead to processing being skipped rather than the built in parser fallback being used.
  • Where updating a partial documentation comment, if the 'returns' entry is missing this will now be duplicated from base class information when possible (as is already the case for param/tparam entries)

June 2020

  • Unnamed parameters in C++ methods are documented by Atomineer as (e.g.) 'parameter1'. When prototypes for these methods are inserted they are now corrected to use the generated parameter name so that the prototype reflects the parameters as documented.
  • Fixed a rare bug in 'Delete all Doc Comments' which could cause the command to abort with an error.
  • Corrected a small problem in live typing aid indentation handling when splitting a line immediately after an XML tag.
  • Improved handling for regular multiline comments, including a fix for converting them into doc comments (a case where a new comment could be inserted inside the existing one rather than replacing it)
  • Improved the processing of attributes to handle additional nested code cases, such as C# object initialisers
  • Small update for Atomineer Spelling

May 2020

  • If file header comments are configured using XML templates (rather than verbatim text), Atomineer will now treat them as doc comments, and will update them in the same way as for normal doc comments.
  • When formatted as doc comments, file header comments can now be edited in the Documentation Editor view.
  • Breaking change: XML Docs 'cref' entries no longer use the type prefix letter (T:, M:, P: etc) by default. Although this is the documented standard, the .net compiler adds these to the output automatically, and the recently introduced CA1200 code analysis rule complains if the type prefix is specified in the source comment. In the 'Doc General' preferences there is now an option to control whether XML cref references include the type prefix letter, should you need to turn this back on.
  • When duplicating SeeAlso entries, Atomineer will now strip off type prefixes if the 'use type prefix' preference is disabled.
  • In C# if the namespace for a cref is defined in a 'using' or 'namespace' statement it will no longer be included in the cref. Note that to avoid having to scan the entire file, Atomineer will only look for usings/namespaces near the top of the file.
  • Atomineer now recognises .razor files as containing C# so the code in them can be documented.

April 2020

  • Improvements to the Live Typing Aid when pasting into comments.
  • (C++) Doc all in Chosen Files can now optionally include/exclude namespace comments. The default is not to document namespaces, to align C++ processing with all other languages, and avoid documenting namespaces more than once.
  • (C++) the 'specialType' variable is now set to 'final' when appropriate for the current method.
  • copydoc, copydetails and copybrief Doxygen entries are now treated in the same way as inheritdoc (they are preserved, and no documentation will be generated for code elements carrying these documentation commands)
  • Added a preference for controlling the indentation prefix for lists of items (e.g. param entries) in NaturalDocs comments.
  • Several small updates to the preferences dialog.
  • Reviewed and updated the User Manual and Website.

March 2020

  • Fixed an issue in inheritdoc support that was inadvertently caused by the new documentation duplication algorithm.
  • Further improvements to documentation duplication (improvements to Property and Interface support, and gathering docs from additional sources).
  • Added word-wrap support for doxygen/natural tables where '|' characters are used to delimit cells.
  • Improved handling of an indentation case to ensure that indentation is correctly preserved.

February 2020

  • Rewrote the documentation duplication algorithm to improve matching of related documentation entries. In particular this enables discovery of documentation from more complex inheritance trees and chains of derived interfaces.
  • Performance optimisations
  • Resolved an issue with auto-punctuation being incorrectly applied to some prototypes in Doxygen docs
  • Added :UnixDir command for expanding %variables%, which converts windows directory separators into unix style separators, e.g. %filePath:UnixDir%
  • Added :Match(regex) command which returns the part of the variable text that is matched by the regex between the brackets. :MatchIC(regex) does the same but is case insensitive. See Page 77 of the user manual for full details and examples.
  • Added :Strip(regex) command which removes all matches for the regex between the brackets from the variable text. :StripIC(regex) does the same but is case insensitive. See Page 77 of the user manual for full details and examples.

January 2020

  • Minor service release.

November 2019

  • Added 'Build New Doc Comment' command (ctrl+shift+A, ctrl+shift+N), which generates a completely new doc comment to replace an existing one. This can be very useful when changing interfaces, overrides and overloads, to copy updated documentation from the base interface/implementation to the derived ones.
  • Similarly, 'Doc all in Chosen Files' now has a 'build new' option that allows you to forcibly overwrite all processed doc comments with newly generated descriptions.
  • Documentation Editor: Improved the bullet list support and added editing of numbered lists. The existing bullet character markup has been extended to allow numbered list items, with each line prefixed in the style '1)', '2)' etc. In addition, support has been added for three more markup formats: XML doc '<list>', simple XML '<list>', and HTML '<ul>'/'<ol>' markup support. (Both XML formats support the type='bullet' and type='number' styles, and XML-doc supports term & definition which are then separated in the editor by ' - '). Choose your preferred list markup style on the Live Aids tab of the preferences ... See pages 91-96 of the user manual for full details.
  • Doc All... commands: Improved parsing and comment insertion logic. Fixed some edge cases where comments were not generated and inserted as expected.
  • Doc All in File now handles missing intellisense better, falling back to Doc All in Scope more reliably when Intellisense information for the project is unavailable.
  • Align into Columns now supports more operator symbols.
  • Closing tags for XML elements are now word wrapped by default. There's a new preference on the Doc Formatting tab of the options that can be used to restore the previous (non-wrapping) behaviour if you prefer not to use those extra lines of source code.
  • Fixed an issue in the preferences dialog that could sometimes lead to custom per-language settings not being shown.
  • Updated and improved the custom preprocessing extension example for VS2019. This is now able to produce XMLDoc, JavaDoc or QDoc formatted comments for Atomineer to ingest, making legacy conversion even easier.
  • Resolved an issue in Doxygen format where one combination of the 'InOutFollowsName ' and 'AlignInOut' options caused in/out generation to become disabled.
  • Improved blank line enforcement following #pragma directives.
  • Fixed a small bug in the documentation editor where the character after an embedded XML element was sometimes lost.
  • Corrected English (US) spellings for 'specialize', 'normalize'.
  • Fixed a handling issue for multi-line attributes in VB code.

October 2019

  • Added a formatting preference ('Doc Style' tab) that allows the first entry in the comment to start on the leading line of the comment block, i.e. 'on the end' of the top separator line. This allows multiline /** comments to be more compact by removing the need for the opening /** to be on its own line.
  • Improvements to VB declaration parsing for methods, properties and enumerated types.
  • NaturalDocs: Improved generation of NaturalDocs comments and fixed a regression ("Function" being emitted as "fn")
  • Added a preference option (in prefs.xml only - <DocViewer><DefaultToReadOnly>) to allow the default read-only state of the documentation editor to be pushed to PCs along with other preferences.
  • Resolved a small issue in new generic typeparam parsing code that could cause typeparams to be lost from comments under some circumstances.

September 2019

  • Resolved a small regression and made further improvements in Visual Basic attribute handling.
  • Added _createOnly attribute for template entries. This marks an entry as one that should only be added when creating new comments, and not when updating existing comments - this can be used to insert 'to do' reminders into comments, which are preserved if present but can be permanently deleted when the work is done.
  • Improved support for Unreal 'attribute' macros (UFUNCTION and UPROPERTY), and added support for UCLASS.
  • Added support for per-language preprocessing rules.
  • Extended the reach of preprocessing rules to more code element types.
  • Reviewed and updated the preprocessing sections of the user manual, and added more example preprocessing code links.
  • Reworked a key part of the parsing engine to unlock improvements in parsing around enum members, complex generic/template parameters, embedded expressions, and remove some edge cases involving code with multiple concatenated statements on a single line.
  • Added namespace comment support for Visual Basic.
  • Improved handling of attributes in C++
  • Added handling for C++ 'noexcept' specifiers.
  • Fixed an issue in parsing of C++ operator templates.

August 2019

  • (Limited beta release)

July 2019

  • Word Wrap Comment now removes trailing space from the last line of the comment.
  • Added support for C++ trailing return types using ->.
  • Added support for C++ "type const" parameter-type syntax.
  • Added C++20 support for three way comparison operators.
  • 'Create C# Property' now has an additional conversion stage, which converts an expression-bodied auto-property into a WPF/Prism BindableBase implementation using SetProperty().
  • Adding a file header comment now creates one rather then two undo steps.

May 2019

  • Added word-wrap support for multiline comments - /*...*/ in C-style languages and <!--...--> in XML and XAML.
  • Added support for Unreal 'attribute' macros (UFUNCTION and UPROPERTY)
  • Attribute matches using defined="..." now set the %match% variable so the matched attribute name can be used in the generated description.
  • Added the variable %newline%, which allows a newline to be more easily inserted into the description text that's output.
  • Doc All in Scope now handles C# usings inside namespace scopes correctly.
  • Small fixes to the trial version.

April 2019

10.01 (+9.50)
  • Tested Atomineer Pro Doc and Atomineer Spelling in the final Visual Studio 2019 release.
  • Special update to v9.50 for visual studio addin for VS 2005-2013 - Fixes issues with the trial version. (No change to the VS Extension for VS 2015-2019)

March 2019

  • Tested Atomineer Pro Doc and Atomineer Spelling in Visual Studio 2019 preview 3.0 and RC.
  • Improved the documentation editor, adding handling for <para> and <p> markup. Paragraph options have been added to the preferences 'Live Aids' tab to control whether edited text paragraphs are written back to source code using double newlines, or enclosed in para/p markup. Paragraph markup is not added within 'example' entries.
  • Improved parsing and round-tripping of description text between source code and the documentation editor, producing more consistent formatting results
  • Fixed an issue where edited documentation was not always written back to the source code after editing if the doc editor view was floating rather than docked.
  • Resolved a parsing problem that could sometimes cause fragments of xml markup to be shown in the editor.
  • Resolved an issue with reinserting edited comments with some /* ...*/ block styles that resulted in a spurious extra column of indentation.

January 2019

  • Major update: Atomineer Pro Documentation and Atomineer Spelling both now support Visual Studio 2019 Preview (tested with preview versions 1 and 2). Please let us know if you find any issues with Atomineer in this new version of Visual Studio.
  • The old installer for Atomineer for Visual Studio verisons 2005-2013 has now been frozen at version 9.49. In future we only expect to update these old versions if required to resolve serious bugs.
  • Added a <templatemethod> template, to independently control the documentation output for C++ templates.
  • Fixed an issue that could cause markup < characters to be displayed in the document viewer.

December 2018

  • Improved the documentation generated for C# Func<...,TResult> types.
  • Variable replacement in separators now supports all variables available for the code element being processed, rather than just the specialised separator variables previously available.
  • Added a new processing command that can be used when expanding variables. Adding a ':default(TEXT)' command will replace any variable that has become an empty string with a given default value ('TEXT' in this example). The default text can include any character except : or %.
  • Corrected generic casting operators being documented with a spurious typeparam entry.
  • Fixed an incorrect default value in the exception preferences that could cause unexpected behaviour when processing exception entries.
  • Extended the handling of OS environment variables in the rules search path.
  • Improvements in parsing of member variable assignments.
  • Fixed a bug in the handling of aliases in doxygen templates which sometimes caused duplicate entries to be generated
  • Fixed a bug in the handling of 'returns' entries in doxygen templates which could cause it to emit an incorrect alias tag.
  • Corrected _blankEntry handling, which was not always picking up _blankEntry values from the <EntrySettings> section.
  • Fixed a regression that caused #define macros to be incorrectly documented.

November 2018

  • Fixed a processing issue for some operator rules due to a change in the parser output.
  • Update for Atomineer Spelling. Visual Studio 2017 was sometimes causing new and unnecessary instances of the spelling engine to be created and never cleaned up. Under some circumstances after editing many documents this could cause sporadic messages from VS about slowdowns. The fix works around this behaviour of Visual Studio 2017 to ensure that only one spelling engine is ever active at any time.
  • Fixed a bug in Doc All in Scope when processing C++ templates, which caused the code scanner to identify incorrect starting lines for some code elements, causing comments to be generated within the templated declaration rather than above.
  • Added a preference in the Misc section of prefs.xml, EditXmlWithVerb. The default operating system 'verb' is value="edit" which typically runs Notepad for editing XML files, or you can set it to value="open" to use the double-click file association instead.
  • Fixed a conversion issue where typeparam/tparam conversions failed, causing Atomineer to generate spurious new '@tparam' entries in Doxygen comments.
  • Fixed an issue in Suffix removal where merged preference sets were ignored, resulting in configured suffixes not being removed.

October 2018

  • The documentation editor now supports 'see' markup - the references are highlighted in the viewer, and the reference text can be edited. Committing blank text to the reference will remove the 'see' markup from the doc comment when it is updated, and new 'see' references can be inserted into the text from the right-click context menu.
  • The documentation viewer/editor (VS2015/2017) now has a 'lock' mode that switches it between editable and view-only modes, so it can be used without any risk of changing the comments it views. It also has improved icons, supporting high DPI monitors.
  • 'Create C# Property' now supports a 'this.varName' form of property get/set, which can be combined with 'varName' or 'VarName' member format. (Enabled in the 'Other Features' tab in the options)
  • 'Create C# Property' now supports emitting of expression-bodied (lambda) property get/set syntax. (Enabled in the 'Other Features' tab in the options)
  • 'Add C++ Accessors' now supports a 'this->varName' form of property get/set, which can be combined with 'varName' or 'VarName' member format. (Enabled in the 'Other Features' tab in the options)
  • Fixed a parsing issue in 'Add C++ Accessors' where access modifier prefixes are on the same line as a member declaration.
  • Added protection around an API call which was found to (rarely) fail unexpectedly.
  • Added context menu items for the Add Property/Accessor commands.

September 2018

  • More work on extension initialisation to best support changes in Visual Studio startup.
  • Improved C++ parsing to address an issue with access modifier prefixes on the same line as a member declaration.
  • Fixed an issue with code element identification and indentation when parsing member variables preceded by attributes on the same line.

July 2018

  • Under-the-bonnet changes and testing to ensure Atomineer Pro Documentation is compatible with some changes that are coming in Visual Studio 2017 (15.8) and future versions, and testing of these changes in older versions.
  • Updates to Atomineer Spelling for similar forwards compatibility issues.
  • Improvements in Atomineer Spelling's word detection, and a fix for a regression that caused symbols with underscores to be handled as if they were separate words.
  • Fixed an issue in Delete Documentation which could cause single-line comments to not be deleted for some comment block configurations.
  • Fixed a parser categorisation issue that caused incorrect documentation to be generated for some enum entries.

May 2018

  • Updated Atomineer for Atmel Studio 7.0
  • Improvements to the Align Code Into Columns behaviour for C# 7.0 syntax
  • Tested against Visual Studio 15.7 release and 15.8 prerelease builds

April 2018

  • Improvements to text formatting within the Doc Editor view, with better handling of tall narrow aspect layouts and ne template settings for controlling maximum column widths.
  • Improved handling of embedded XML/HTML elements within the Doc Editor
  • Fixed a parsing error that could cause multi-line C++/C# declarations to be incorrectly classified as enum entries
  • Added support for documenting within .cshtml files
  • Addressed a report of unknown failures in Extensions. We could not confirm an actual problem in Atomineer, but have added more exception checks to minimise the risk that Atomineer might cause such reports from Visual Studio.
  • Some changes to our website for renewals, and our company policy information has been updated in light of the introduction of GDPR across Europe.

March 2018

  • Improvements to Typescript/Javascript support. As there is a loit of variation in the syntax of these languages, if you spot anything that Atomineer doesn't handle well, please let us know so we can ensure it's fully supported.
  • More work on Atomineer Spelling, as recent updates (presumably .net/roslyn) have also retroactively affected older Visual Studio installs, causing the 2015 Spelling to cease working. We have now back-ported the fixes that were required for VS2017 into the previous version and tested in VS 2013 and 2015. The new implementation no longer requires roslyn/intellisense to operate, so also works on non-compiling code.
  • Spelling 2017: Fixed an issue that caused spelling corrections to be suggested occasionally on text outside of doc comments. The new implementation no longer requires roslyn/intellisense to operate, so also works on non-compiling code.
  • Spelling: Improvements to default custom dictionary.
  • Fixed a small bug in the new declaration parser that caused problems for enum members using UPPER_CASE naming style.
  • Internal: improved reporting mechansim for errors and notifications.

February 2018

  • Rewrote the Atomineer Spelling extension to resolve issues in Visual Studio 2017. Several recent changes to the Roslyn engine and some other internals of Visual Studio caused problems with the installer and then the spelling highlighting. In addition, switched the suggestions menu over to use the new Visual Studio 'lightbulb' suggestion system.
  • Improved handling of enum members in the new declaration parser implementation.
  • Improvements to parsing relating to some old C style syntax cases.
  • Fixed an edge case in handling of templated classes
  • Adjusted 'asSee' generated crefs to use double rather than single quotes.
  • Fixed an issue caused by a software update on our web host, which affected some non-essential featues on the account management web page (such as the last downloaded version not being reported correctly).

January 2018

  • Added handling for C-style structs, unions and enums (as in: struct S function() {}).
  • Documentation Editor Improvements
    • Added a new "Add Entry" button. This allows optional entries (e.g. remarks) to be inserted into the documnetation.
    • You can now navigate to the Next/Previous code element using Alt+Down and Alt+Up. (The Alt key binding is used to avoid clashes with Visual Studio's built in bindings)
    • Next/Previous navigation now places the input focus in the first editable field so that you can now fully document an entire file through the editor without needing to use the mouse.
    • Some other small improvements.
  • Fixed a regression in live typing aids that could extend a comment incorrectly if return was pressed on the final line of a /* */ comment.

December 2017

  • Tested with Visual Studio 2017 (15.5). We recommend users of Atomineer Spelling update to this version of VS 2017 as it resolves issues with the underlining highlights for misspelled words.
  • Added <paramref> support to the documentation editor. New paramrefs can be added from the context menu on any editable field. Existing paramrefs are shown as the parameter name with a highlighted background colour - just click the parameter name to change the reference.
  • Improved parsing of typescript declarations, fixing a case that was handled incorrectly
  • Fixed a rare edge case where Atomineer was not detecting doc comments in single-line /* ... */ comments, causing duplicate comments to be added.

November 2017

  • Added support for C# 7 expression-bodied members in the new method declaration parser, which was unfortunately missed due to some unit tests not being applied to the new code.

October 2017

  • Rewrote the method declaration parser to fully handle inline syntax in C++ and C# declarations, as there were edge cases that the previous parser did not handle correctly.
  • Documentation editor: Improved bullet-list support.
  • Fixed a parsing glitch in Natural Docs exception entries.
  • A large behind the scenes upgrade to our website.

September 2017

  • Documentation editor now has next/previous buttons. These advance the cursor to the next/previous code element and if necessry, executes Add Doc Comment to create a comment, which can then be adjusted in the editor. This allows you to easily step through a file and document it directly in the editor.
  • Documentation editor: Added simple bullet-list support.
  • Documentation editor now automatically snaps its toolbar to the top or left side of the view
  • Documentation editor: some general improvements and under-the-bonnet work to support planned future features.
  • Fixed an issue that could sometimes stop the new template system's EntrySettings being correctly applied. This could cause several symptoms (e.g. optional entries such as seealso being incorrectly deleted from comments while updating them, punctuation being applied to entries that should have had the feature disabled).
  • Added an option for Doxygen-style comments to place in/out specifiers before or after the parameter name.
  • Improved C# 7.0 support for expression-bodied properties and added support for tuple parameters.
  • Fixed a small bug in the preferences app relaing to the 'enforce blanks' settings which worked correctly, but were not being displayed properly when reopening the preferences.
  • Fixed: Word wrapping engine could sometimes break URLs containing minus characters.
  • Improved parsing of C# generics
  • Added support for C++11 brace-initialisation syntax.
  • 'Reformat Doc Comment' will no longer duplicate documentation for parameters.
  • Some more support for projects
  • Small tweaks to the installer to support VS2017 better.

July 2017

  • For Visual Studio 2017/2015, the Documentation Viewer has been upgraded to a Documentation Editor. Edits made in this view will be written back to your source code automatically when the input focus moves out of any entry (i.e. if you switch to editing a different entry, or move the input focus back to your source code, or to another application). The editor supports some basic markup (<b> <i> <code> ) and has been tested primarily with XML documentation; it is being relessed now as a beta feature so that more users can feed back to us if they find any issues with the many variations of documentation styles and formats in the wild, to allow us to develop the feature forwards more quickly. Please note that the editor does not currently support a full set of markup features - markup such as inheritdoc, see, paramref, bullet lists and tables, as well as special doxygen markup (@ commands) will be supported in upcoming releases.
  • Resolved a regression in reformatting of indentation (a poor interaction with specific formatting options), which was introduced by an attempted fix for code block indentation in the 9.34 release. The fix was rolled back and a new fix implemented which does not introduce any side effects.
  • Added a new 'Reformat Doc Comment' command. This reformats a doc comment exactly as Add/Update Doc Comment does, but without adding any new entries to it.
  • The 'convert to entities' option has been expanded, so that < > & can be converted to XML entities &lt; &gt; & or now into more human readable { } + characters.
  • Further small improvements to the C# 7.0 parser.
  • Fixed an edge-case which could adversely affect parsing of attributes embedded within method parameter lists.
  • Fixed a minor parsing issue that was caused by unrecognised macros with 1-character names applied after parameter declarations.
  • Fixed an issue in Doc All in File where some code constructs were not correctly located when intellisense was unavailable, resulting in failure to document some code elements.
  • Fixed a small bug in the preferences that meant generation of 'inheritdoc' rather than 'seealso' was not persisted and had to be set manually.
  • Fixed an issue in the new template system that caused DocXml settings to be applied to Doxygen entries when they used a custom tag name.

May 2017

  • Improvements to the C# 7.0 parser, including a bug fix for misidentified constructors.
  • Fixed cases where exceptions outside the scope of C# 7.0 expression-bodied members were being inadvertently documented.
  • Several improvements to the typescript/javascript parser.
  • Fixed an issue in chained constructors.
  • Fixed a very rare case where documentation background colouring would be missed out for a comment.
  • Improved reformatting of indented example code in a few cases.

April 2017

  • Out-of-band release to fix a small but significant parsing bug introduced in the last release which interfered with processing of member variables.
  • Found and fixed a generic method declaration syntax that was not being correctly handled
  • Added support for C# 7.0 features:
    • Tuple return types
    • Tuple deconstructor member-methods and extension-methods
    • 'ref' method return values
    • Expression bodied members, and exceptions thrown from within them.
    • Auto-properties with default values
  • Improved C# lambda support
  • Improved C# Async support
  • Fixed an indentation issue on duplicated documentation.
  • Optimisations to improve speed of some parsing cases.
  • Added preference for JSDoc (Java, JavaScript, Typescript) documentation format. Although the options are the same as those for Doxygen, this mode now enables the output of JSDoc {type} markup in parameter entries.

February 2017

  • Don't forget to join in with the Visual Studio 2017 launch on March 7!
  • Added support for NaturalDocs format doc comments. Due to the large number of formatting options available, please consider this a public beta at this stage, and let us know if you spot any formatting issues.
  • Updated the core templating system with a new global entry style system so it is no longer necessary to repeat the same settings on each templated entry. This significantly simplifies the templates and ensures consistent formatting across all code element types. The change rationalises the alias mechanism to better support conversion from legacy comment content, and significantly improves the handling of custom entry 'tag' names for built-in entry types. While this is a largely internal change it allows Atomineer to be much more flexible while improving a number of edge cases.
  • Fixed a small but elusive bug in comment updating that occasionally caused entries that should have been deleted to be preserved.
  • Improved extraction of author names from a wider variety of login name styles.
  • Fixed an abbreviation expansion issue when using embedded variables.
  • Fixed a formatting issue when updating a comment containing an <inheritdoc> and overridden doc entries.
  • Live typing aids: Comment auto completion now allows multi-line comments to be missing the closing */
  • Added a new <Suffixes> section in the rules to improve the handling of parameters and members that include custom suffixes like _u32

January 2017

  • New build with additional improvements in the support for Visual Studio 2017 and its new Extension format.
  • Updated copyright dates.

December 2016

  • Added BETA support for Visual Studio 2017 RC. Please let us know if you notice any problems with Atomineer in 2017 RC.
  • Tested with Visual Studio 2017 RC.
  • Improvements to Doc All in Scope, and Doc All progress reporting.
  • Internal improvements to file header comment handling.
  • Fixed 'check for updates', which had been broken by our https website conversion.

October 2016

  • You can now choose to place comments after the code element declaration rather than before it. This is primarily intended for languages like Python where this is the standard documentation approach, but can be applied to any language. (Be aware that most external documentation tools don't support docs in these locations, or may require specific markup to relate comment to the code element). In C-style languages Atomineer allows the comment to be inserted between the declaration and the { scope brace, or after the opening { scope brace.
  • The Atomineer website now uses secure https connections throughout.
  • Fixed a bug in the documentation merge process where summary entries using a 'details' custom tag were not correctly merged with the generated summary, causing the original details to be marked as a deleted entry rather than being properly preserved.
  • Added a new attribute for template entries, _minTagLength="12", which allows doxygen users to control the extra padding added to the @commands to line them up into tidy columns. This attribute overrides the global MinTagLength preference on a per-entry basis for finer control.
  • The suppressInOut now works properly if set to 'true' rather than 'y'.
  • Testing with Visual Studio '15' preview 5.

September 2016

  • Document All... and Process All... commands will all now process C++ header files. (This feature was previously disabled due to difficulties in the way Visual Studio intellisense system works in headers. Atomineer now uses its built-in parser to handle headers, automatically working around the Intellisense issues)
  • Document All in this Scope now descends into child scopes of 'containers' such as classes and interfaces so it will now document entire files.
  • Fixed a small issue with the names for re-thrown exceptions in C++.
  • Improved handling of duplicated documentation containing embedded markup.
  • Resolved an issue that occasionally caused the first character of a description to be generated in lowercase.
  • Improvements to 'Delete Documentation from this File'.
  • Some important under-the-bonnet upgrades to our website.

August 2016

  • Improved alignment of [in,out] attributes on Doxygen entries. (The previous alignment behaviour can be reinstated by adding a preference to the <Doxygen> section, <AlignInOut value="false">)
  • Preference option <Doxygen><MinTagLength value="12"> can now be used to set a minimum width in characters for doxygen command tags. This can be used to achieve a columnar layout of doxygen comment blocks.
  • Added an option to remove seeAlsos from existing comments when updating them.
  • Improvements to Doc All in Scope.
  • Fixed a small regression in live typing aids when applied to the first line of /** ... */ comments.
  • Fixed a problem with removing entries marked as 'deleted' (###) from some comment block formats.
  • Addition/Removal of '(Optional)' prefixing now ensures correct casing of the following character.
  • Small improvement to parameter parsing logic for C++.
  • Doxygen: Atomineer no longer adds auto-punctuation to @copybrief entries.
  • When configured with auto-insert #region/#endregion directives, 'Delete Docs from this File' now correctly removes the corresponding #endregion.
  • Tested on Windows 10 version 1607.

July 2016

  • Tested against Visual Studio 2015 Update 3.
  • (Visual Studio 2015 only) Added an option (see the new 'Live Aids' tab in the preferences, and the updated user manual) to highlight /// documentation comments by filling the background of the comment with a subtle colour (the defaults are beige for light colour themes and navy blue for dark themes). This can be used in addition to or instead of top/bottom separator lines to visually distinguish code form comments.
  • 'Doc All in this Scope' will now document any #define macros discovered in the processed source code.
  • Fixed two regressions in parsing of #define macro declarations which would cause incorrect output to be generated if a rare combination of preference options were configured.
  • Added an option to change the behaviour of typedef to better match C and C++ variations of usage, and improved handling of C-style unnamed types.
  • Fixed a bug in live typing aids that could leave spurious characters behind when generating a DocComment using a 3-character prefix which was not configured as the primary comment style's prefix.
  • Added the ability to emit a type attribute on return values. Added the preference option <DocComment><EmitParamType value="true"/> to force parameter/return types to be emitted in XMLDoc/JavaDoc/QDoc comments if desired (previously this feature was only available for JavaDoc/JSDoc/JSDuck commenting). Added <DocComment><EmitParamTypeWithBrace value="true"/> preference to control whether these types are written as MyType or {MyType}
  • A small improvement to bullet-list continuation.
  • Added the ability for templates to be applied only to specific filetypes.
  • Improvements to handling of one-line and two-line doxygen/JavaDoc/QDoc comments.
  • Improvements to pre-processing replacements when applied to #define macro definitions.
  • In cases where a VS Project is not being used (e.g. when using makefiles), project-relative roots can now be set by adding a <DocComment><RootPaths value="..."/> preference entry. This contains a semicolon-separated list of folder path names that you wish to treat as project root(s) to be stripped off any project-relative pathnames that you use.

June 2016

  • Parameter attributes can now be used in rules to generate documentation for parameters.
  • Added support for more attributes (most notably, the NotNull/CanBeNull resharper annotations for methods and parameters, and nUnit Fixture and Test attributes)
  • Added 'suffix=...' syntax to rules to allow additional comments to be appended to the generated description.
  • Improvements to Align into Columns. If a block is processed which contains a mixture of comment lines and code lines, only the lines matching the type of the line containing the cursor (code/comment) will be processed, so that comment lines can be skipped during the processing.
  • (Xml Documentation) Base class documentation references for overrides can now generate 'inheritdoc' rather than 'seealso' references. This new option can be set on the 'Doc General' preferences tab.
  • The Documentation Viewer will now view inherited documentation for methods/properties with valid <inheritdoc> references.
  • Exception documentation auto-deletion behaviour can now be enabled/supressed (on the 'Doc General' preferences tab).
  • Exception documentation will no longer be auto-deleted from comments in C++ header files.
  • Fixed cases where the (optional) prefix would be not be added as expected to parameter documentation.
  • Fixed a rare 'index out of range' bug in non-splittable-word handling.
  • Live typing aids now support creation of comments by typing '/**'

April 2016

  • Improvements to 'Delete Documentation' commands - Whitespace is now compacted after deletion, and end-of-line documentation comments (in standard // and /*...*/ formats) are now also removed. Also fixed a problem that could occur when processing single-line /**...*/ comments.
  • C++: Added support for 'final' and 'override' keywords.
  • Improved handling of rarely-used integral types (such as 'long long int')
  • Improved handling of <content> entries.
  • 'Document All in Chosen Files' has been renamed to 'Process All in Chosen Files' to better reflect its operation (it can be used to delete docs as well as create/update them).
  • 'Process All in Chosen Files' now has filtering options to allow you to control which types of code elements will be processed, so for example you can process all methods and/or skip all properties.
  • A small improvement to handling of some forms of end-of-line comments.
  • Tested against Visual Studio 2015 Update 2.

March 2016

  • Updated the installers to work around code signing issues. As of 1 January 2016 code signing must use SHA256 rather than SHA1 encryption. This means Visual Studio 2015 and Windows 10 may refuse to install extensions/applications unless they are SHA256 signed, yet earlier versions of Windows and Visual Studio may fail to regocnise the new signing. After considerable research we have been unable to find a solution that works in all cases, so we have had to take the unfortunate choice of providing multiple installers that target different versions of Visual Studio and Atmel Studio. We hope that eventually a solution can be found and the installers can be re-integrated.
  • Added more supported filetypes for Python code.
  • Fixed Indentation settings in VS2015 - After 2015 Update 1 Atomineer would always use spaces due to a change in the way the text editor option needed to be read. It will now use tabs if they are configured.
  • The spelling of "Initialise" (UK) or "Initialize" (US) now uses the %initialise% variable, which can be set for US or UK English using a new check box in the preferences. The default is now the US spelling. (Note that this does not affect the spelling used in Style-cop compatible comments, which must always use the US English variation).
  • The Documentation Viewer is now able to process XML <include> directives (as long as they are well formed and redirect to a valid XML element in a valid external documentation file - as described here). Includes can be placed as root-level items (providing a full or partial documentation comment) or be embedded within entries (providing a fragment of documentation text).
  • Improved parser to allow plain-text documentation comments prefixed with /// to be converted into fully formed doc comments.
  • Fixed a parsing problem on nested templates/generics which could cause declarations to become truncated.
  • C++: Fixed an issue on namespaced function-pointer parameters. (Name cleanup sometimes left additional text appended to the name).
  • Resolved a regression that caused types like 'const int' to be reported as 'int' in method returns %type% variable.
  • Resolved rare issues that could occur where end-of-line text after a #region directive was not being ignored by the parser, causing it to become confused.
  • Resolved an issue when generating a new end-of-line comment by typing /// would leave the /// in place.
  • Ported 'Hide Doc Comments using Outlining' command to VS2015 and re-enabled it.

January 2016

  • Atomineer now supports Atmel Studio 7.0 (Just run the .vsix installer to install into it)

December 2015

  • Improved Python support. In particular, classes and their member functions are now supported, documentation is generated for all known 'magic' functions, and the Doc All... commands all now support Python projects/solutions.
  • Implemented a workaround for the Visual Studio 2015 bug that caused Atomineer Spelling to become non-functional in the 2015 RTM.
  • Added %lang% variable, which can be used to apply rules only to certain coding languages.
  • Fixed a preferences bug that could cause custom PrefSets.xml files to grow each time the prferences were edited. (The fix will also correct any existing files when writing back preferences to ensure they are no larger than they should be)

November 2015

  • First public release of Python language support. Atomineer can now create and update documentation comments for Python function 'def's. Doc All in Scope/File can be used to automate documentation of a python source file (The other Doc All... commands are not yet supported, but are coming soon). Live typing Aids work within Python comment blocks much as for other languages (although there are some features yet to be implemented). The preferences also support language-specific preference sets for Python. (We'll continue to roll out additional features for Python next month. Please let us know if there is anything you'd particularly like to see in Atomineer's Python support)
  • Improved live typing aids. After going to a new line in a doc comment, Atomineer will usually add auto-indentation, but this is now removed automatically if you start typing a new documentaiton entry command, so that new doc entries are pulled back to the left of the comment block automatically.
  • Fixed separator clipping when used on multiline comments, which could sometimes clip away the closing */ of the comment block..
  • Improved handling of multi-word prefix removals.
  • Improved auto-punctuation control on exception entries.
  • Fixed a glitch with exception entries which rarely caused the exception entries to move to the bottom of the comment block rather than obeying the layout template.
  • Added a preference <DocComment><PunctuateBlankDescs value="false"/> which can be set to disable the auto-punctuation feature in cases where the description part of a doc entry is blank. (Atomineer usually adds punctuation in these cases to higlight the missing field of the doc entry and ensure that it's valid)
  • Improvements and clarifications for the user manual.
  • (Limited release beta build)

October 2015

  • Finished porting 'Add Property' and 'Add Access Method' into the Visual Studio 2015 extension.
  • Updated the user manual for Windows 10.
  • Added support for C# Code Contracts.Requires() statements - these now generate/update exception entries in a similar way to throw statements.
  • Improved parsing of C++ exception 'throw' statements to cover a previously unsupported syntax.
  • Fixed a rare glitch in parsing doxygen multiline comments.
  • Significantly improved the entry aliasing system. This previously allowed you to easily convert legacy formats to the Atomineer format (by adding an _aliases='name1,name2,...' attribute on template entries) so that legacy entry names (e.g. 'throws') could be converted to the Atomineer form ('exception'). However, you can now set a custom tag name so that Atomineer will work natively with the legacy format. For example, add _tagName='throws' to an <exception> template to make Atomineer generate 'throws' rather than 'exception' entries, while retaining all the built-in support for auto-generating and updating these entries.
  • Improved handling of Doxygen entries with optional descriptions.
  • Please note: This month we have discovered two serious bugs in Visual Studio 2015 (both introduced in the final release version and not present in the preview versions) which unfortunately affect Atomineer. (1) under some circumstances intellisense information is unavailable (this primarily affects generics and classes defined in external assemblies, but can affect other cases), so duplication of base class documentation (and sometimes document all in... commands) do not always work as expected. (2) causes Atomineer Spelling to cease highlighting of spelling mistakes. We hope that these bugs will both be resolved by Visual Studio 2015 Update 1 (expected to be available soon). However, in case this does not happen we are investigating a revised implementation of the spelling checker to work around the bug. In the meantime we apologise for any inconvenience this may cause.

September 2015

  • A quick release to resolve an issue in VS2013 and earlier where some users were unable to open the preferences. This was due to a small installation change required to support VS2015. Many apologies to those who were affected by this issue.
  • Fixed an issue with parsing of C++ variadic function arguments.
  • Resolved problems with VS2015 installation due to the way the Microsoft VSIX installation/upgrade system and version numbering work.

    We have unfortunately had to make a breaking change to the extension GUID to fully resolve the install problems. If you have already installed Atomineer into VS 2015, please uninstall it from the Tools > Extensions and Updates menu, and then double-click the new AtomineerProDocumentation.vsix file to install the new version. It will not be necessary to do this for future releases. This need to fully re-install does not apply to Atomineer installed into Visual 2013 or earlier. Please accept our apologies for this inconvenience.
  • The Atomineer version number has been incremented from 9.04 to 9.15 to resolve issues with some websites which do not handle our old version numbering system well.
  • Resolved 'Rules file not found' errors in Visual Studio 2015 after uninstalling and reinstalling Atomineer.
  • Improvements to parser robustness when presented with malformed XML comments.
  • Added preference to describe a class in either the form 'Class' or 'Namespace.Class'
  • Added prefix-removal support for prefixes that include numerical values, e.g. 'u32'
  • Added %solution% variable, which expands to the name of the Solution containing the file being documented.

August 2015

  • Upgraded our development systems to TFS 2015 & VS 2015 on Windows 10.
  • Tested and updated all Atomineer apps for Windows 10 compatibility.
  • Fixed a DPI scaling issue in the setup Wizard.
  • Improved the vsix installer for Visual Studio 2015.
  • Fixed a signing problem that caused the 2015 trial to expire immediately on some PCs.

July 2015

  • Updated Atomineer release for Visual Studio 2015 (now out of beta).
  • Released trial version of Atomineer for Visual Studio 2015.
  • Updated Atomineer Spelling to support Visual Studio 2015.
  • Significant improvements to the 'Word Wrap Comment' implementation to support more languages and also to allow it to process Documentation Comments. While Add Doc Comment includes word-wrapping in its processing, it also adds/removes entries and specialised line formatting for different entry types. Sometimes you may just want to simply word-wrap the text in a doc comment, and this is now possible by executing 'word wrap comment' on the doc comment instead of 'add doc comment'. The word-wrapping behaviour of Add Doc Comment itslef is unchanged (i.e. if you execute it on a regular comment, it drops down to executing 'word wrap comment' on it for convenience)
  • Fixed a parsing glitch when processing Typescript member variables.
  • Fixed a problem with Implement/Declare Method when applied to operator declarations.

June 2015

  • Performance improvements when commenting methods.
  • Added new template attribute: _tagName="name" allows you to specify a custom tag to represent an existing entry (for example, <exception _tagName="throws"/> will cause Atomineer to use the name 'throws' instead of 'exception' for its entries.
  • Added new template attribute: _aliases="name,name,name..." which allows you to specify additional tags that Atomineer will read as being the same (e.g. <exception _aliases="exceptions,throw,throws"/> will allow Atomineer to convert any of those entry names to 'exception').
  • For foreign language documentation, added new user variable, %except-passprefix%. Set this to the text you normally use as a prefix on exception descriptions when they are passed through a method from a subroutine, so that Atomineer can detect these 'passed' exceptions and preserve the desriptions even when it can't see the exception being thrown in the method body. The default value is 'pass' to handle cases like 'passed if' and 'passed when'. e.g. for German, you might use 'Wird weitergeleitet'.
  • Added new commands for variable expansion. %variable:SafeGen% converts template/generic <> characters in the variable into {} characters so they can be safely embedded in XML comments. %variable:AsSee% wraps the variable value in a <see cref='xxx'/> block.
  • C++ #define macros are no longer commented if they merely define a symbol without assigning a value to it. This stops Atomineer documenting macros used to provide 'include only once' functionality in headers.
  • More improvements to TypeScript/JavaScript parsing, in particular for more complex forms of parameter declarations.

May 2015

  • Improvements to the support for Typescript & JavaScript
  • Rewrote the user manual into a PDF format, integrating the tutorials and other information to form a single document

March 2015

  • Apologies for skipping the February release. This was due to the work we had to put in to support new tax laws in January, and the considerable work and testing needed to bring Atomineer to Visual Studio 2015.
  • Major Upgrade: This is the first release of the Atomineer Beta for Visual Studio 2015 (compatible with CTP 5 and 6). In order to support 2015 the Atomineer Add-in has been rewritten as an Extension, which also affects the installation process. The existing installer is used as normal for versions of Visual Studio up to and including VS 2013, but for VS 2015 (onwards) there is now a separate installer which uses Microsoft's standard 'VSIX' Extension installer system. To install this into VS 2015 please double-click the 'Atomineer Pro Documentation.vsix' file in your downloaded .zip file. An updated User Guide covering this new version in more detail will appear on our website soon.
  • Performance and accuracy improvements in the parser's code-type recognition system.
  • Improvements to the Visual Basic sub/function/property declaration parsers.
  • Small improvements to prefix stripping algorithm.
  • Fixed a problem in live typing aids where tabs were sometimes interpreted as newline characters.
  • Improved C++ handling of 'extern' scopes, which were interfering with the operation of comment creation when typing '///'

January 2015

  • Improvements to parsing and handling of C++ templates.
  • Fixed a small regression that affected the parsing of C++ function-call operators.
  • Improvements in the operation of Align Into Columns when used at the start of lines.
  • Single-line doc comments are now word-wrapped if you update them.
  • The 'Convert Entities' preference is now saved in language-specific pref sets.
  • Our conversion from an Addin to an Extension (to support Visual Studio 2015) has been completed, and is now undergoing testing.
  • Some changes to our website and pricing necessitated by changes to European tax law.

December 2014

  • Tested with Visual Studio 2013 Community. No compatibility problems were found.
  • Live typing aids are now available in Typescript, JavaScript and JScript files.
  • New live typing aid: Atomineer can now optionally override tab and shift-tab to navigate the cursor quickly to the next/previous documentation entry within a doc comment. See the 'Other Features' tab of the preferences (Live Typing Aids section) if you wish to try this new option.
  • Improved updating of end-of-line doc comments
  • Improved conversion from end-of-line comments to regular doc comments
  • Improved handling of type="" attributes for optional parameters.
  • Added support for the optional (header reference) elements in doxygen '\class' entries. There is a new preference (on the 'Doc General' tab) to enable this additional information.
  • Added rules for WPF dependency properties.
  • Many small improvements to the Atomineer website, including support for high DPI displays.

November 2014

  • Improved the generation of operator descriptions for explicit operators.
  • Improved handling of [in,out] tags on parameter descriptions, and added processing variables to allow the output to be controlled more easily.
  • Fixed a small issue in the preferences which stopped settings from the Quick-Set wizard being picked up when returning to the prefs dialog.
  • A small tweak to improve the handling of global-scoped parameter types in C++.
  • Improved switching between different preference sets for diffferent projects and solutions.
  • Description attributes are now picked up from interfaces.
  • Fixed a case where class comments could be auto-punctuated with a double full-stop.
  • VB: Improved comment updating when a doc comment joins directly onto a single-line comment.
  • We've also tested against VS 2013.4 and have been working on support for Visual Studio 2015, which necessitates conversion of Atomineer from an Addin to an Extension.

October 2014

  • Improved the generated descriptions for enums and bitfields, and added an <Enums> rules section. As for other types, the preferences 'Doc Advanced' section now also includes a button to allow you to easily edit the enum rules.
  • When documenting within an enum, the %containingClass% variable will now contain the enum name, if it is available from intellisense. (In this context 'containingClass' is not a terribly accurate name any more, but has been retained for backwards compatibility)
  • Added the %namespace% variable.
  • Attributes applied to Classes and Structs are now available for use in rules, in the same way as they already were for Methods.
  • Classes and Structs tagged with [Description] attributes will now use the description text as the summary for generated comments.
  • Methods, Properties, Classes and Structs tagged with [GeneratedCode] attributes are no longer documented by Atomineer.
  • Typing '///' within an enum scope now adds doc comments to enum-members.
  • Improved handling of covariant/contravariant generic type parameters.
  • Fixed a parsing issue on enum entries which could result in the wrong style of comment being inserted.
  • Fixed a minor problem in end-of-line comment insertion which could occasionally cause it to incorrectly truncate the line of code.
  • Fixed location of the inserted namespace comment when cursor was immediately inside the namespace's opening brace.
  • Improved documentation of casting operators.
  • Logic for DocXml <remarks> was interfering with Doxygen processing of @remarks. This has been corrected.
  • Improved documentation output for PHP methods.
  • Auto-conversion of < and > into XML entities (&lt;, &gt;) now supports embedded XML comments and CDATA sections.
  • Atomineer Spelling: Improved performance on extremely long words. Fixed an error reported when deleting all text from a file. Additions to the coding jargon dictionary.

September 2014

  • Preferences now uses friendly dedicated editors for user variable, non-splittable word and replacement word lists.
  • Added support for Visual Basic 'properties with parameters'. Additional params are now added as <param> entries. (if a parameter is named 'value', it is ignored as this special parameter is already documented by the <value> entry)
  • Improvements to parsing of VB code (special cases added to handle more syntax variations).
  • Updated the installer and preferences windows, which could appear blurry on high DPI monitors in Windows 8.1.
  • Added support for using /*...*/ delimiters on single-line doc-comments.
  • Fixed an issue in the preferences where switching between Language preference sets could lose some Doxygen (JavaDoc) settings.
  • Improved handling of method access levels (public members of an internal class are now considered internal)
  • A number of improvements to exception parsing and class rules.
  • NotImplementedExceptions are no longer documented.
  • Added a preference to force Atomineer to always preserve all exception documentation. This is not currently supported in the Options dialog, but can be added to the Prefs.xml manually if needed.
  • Param 'type' attribute now support generic/template types.
  • Improvements to duplication of base-class or overload documentation.

August 2014

  • Added 'Non-Splittable terms' to the rules. This informs Atomineer of special terms like 'IPv4' and 'PowerPoint', which Atomineer's generalised heuristics would normally break into several words, so that the correct formatting and capitalisation is retained for these special terms. A new button has been added to the Atomineer Options ('Doc Advanced' Tab) to allow custom terms to be added. Please let us know if you discover any common terms that ought to be added to the default dictionary, and we'll add them to the master Rules.
  • Upgraded 'Doc all in Chosen Files' to be capable of deleting doc comments from processed files, allowing entire solutions to be processed in batch mode.
  • Improved reporting of skipped source files in 'Doc all in Chosen Files' in cases where intellisense is unavailable for a file (this is usually because the file has not been successfully compiled).
  • Fixed a special-case failure in the Delete Doc Comments command when using an embedded 'end of comment' sequence */ in the separator of a doc comment, e.g. a top separator of the form /****//**. Atomineer would see this as the end of the comment, and incorrectly leave the second 'part' of the doc comment undeleted.
  • Fixed a refactoring glitch that caused 'tparam' and 'typeparam' entry tags to be emitted incorrectly (tparam incorrectly appearing in DocXml, and typeparam in doxygen)
  • Fixed an issue that caused 'type' attributes to be added to param entries for languages other than TypeScript/JavaScript under some circumstances. Although this is now disabled by default, if you wish to have type attributes for your param entries, there is now a preference to enable this behaviour.

July 2014

  • Improvements to the TypeScript and JavaScript language syntax support.
  • TypeScript, JavaScript, and JScript code: Added initial support for JSDoc and JSDuck documentation syntax, in particular for parameter and returns markup. Atomineer now supports {types}, [optional] and [optional=default] syntaxes in these entries. In addition, if types are specified in Typescript code, Atomineer now incorporates them into generated documentation.
  • Added a 'parent class type' variable that indicates if a parent structure is a class, struct or interface during rules processing.
  • Small improvements to stylecop support and rules.

June 2014

  • Added initial support for TypeScript, JavaScript, JScript and PHP. We've tried to test against a wide range of scripts, but please let us know if you find any syntax variations that our parser struggles with. We'll be working on additional documentation entries/attributes to further support documenting these languages in upcoming releases.
  • Atomineer Spelling: Performance improvements for check-as-you-type functionality (particularly when undoing/redoing typing), and some dictionary improvements.
  • Added support for Atmel .ino files (which are now treated as C++).
  • Improved <Set> Rules commands. These used to only be able to set 'desc', but now can set any variable (other than continue or abortComment) to a new value. Usually this is combined with 'continue', e.g. <Set isOptional="y" continue="y"/> to alter the flow of or output from following rules.
  • Parameter In/Out and Optional description generation can now be disabled in the default rules by setting the variable suppressInOut="y" in your custom parameter rules.
  • Fixed a regression (caching bug) that meant new custom entries added to the rules were not fully picked up until the next restart.
  • Improved handling when a group of several custom elements of the same type are used in a comment.
  • Improved support for end-of-line comments in VB.
  • Fixed an errant event handler in the preferences that stopped the Doc Formatting tab updating correctly when switching between different language preference-sets.
  • Small improvement to parsing of attribute content.

May 2014

  • Added support for C# generic covariance and contravariance. The <TypeParameters> rules can now use the variables %isIn% and %isOut% to produce more meaningful documentation if desired.
  • Rules for Classes can now use the variables %isStatic%, %isPartial%, %isSealed%, %isAbstract%, %isGeneric%, and %isTemplate%, which are set to 'y' or 'n' as appropriate)
  • Rewrote a portion of the Visual Basic parser to fix some parsing glitches and add support for a few additional keywords. Improved documentation generation for VB event handlers.
  • Some small improvements to C/C++/C#/Java parsing
  • 'Doc All in Project/Solution' commands will now process C++ files with .cc and .cxx filename extensions.
  • The Preferences dialog will now warn if it is unable to expand environment variables on the Prefs Storage Search Path.

April 2014

  • Atomineer now includes the new Atomineer Spelling extension (Beta) for Visual Studio 2010, 2012, and 2013. This provides spell checking as you type in comments. Follow the link above for more information on installation and usage.
  • Auto-punctuation now detects and cleans up accidental double periods ('..') at the end of a comment.
  • Improvements to conversion of legacy JavaDoc comments.
  • Improvements to StyleCop compatibility mode (Atomineer now ensures a blank line prior to single-line and enum-entry comments; A <content> entry is now used on partial class declarations that don't match their filename - this ensures that all partial class parts except for the main one have an XML doc comment to satisfy StyleCop, but do not contribute chaff to the generated documentation. The main part of the partial class is documented as normal).
  • Improved the undo experience after insertion of comments when typing /// or '''.
  • Fixed a regression that stopped Interface documentation being correctly duplicated.
  • Fixed a glitch in generation of seealso entries for methods with optional parameters.
  • Added 'see' as an accepted alias for 'sa' in Doxygen comments.
  • Fixed duplicated interface name in seealso when generated from an explicitly implemented interface member.
  • Fixed a few rules that used an incorrect matching pattern and thus produced unexpected descriptions.
  • Stopped '\commands' being split across two lines in doxygen comments if the \ happened to occur on the last usable character column in the first line during word wrapping.
  • Fixed a poorly reported error when attempting to update a file header comment during debugging.

March 2014

  • Inheritdoc support. Updating doc comments containing 'inheritdoc' entries now disables duplication of documentation from base classes and auto-generation of new doc entries, so that the inheritance is correctly preserved.
  • Added an option to the 'restrict documentation by access level' feature. Previously, comments that were not allowed under this restriction were automatically deleted. This option can now be disabled (via the check-box at the bottom of the Doc General tab of the Options), in which case Atomineer will simply ignore any existing comment on restricted code elements.
  • Fixed an issue in 'Document All in This Solution' where sub-projects were sometimes skipped during processing. Some improvements to Output window reporting during processing.
  • Fixed a broken help link in the preferences dialog.
  • Fixed a case where %containingclass% could lose generic suffixes from the classname.
  • Fixed a parsing glitch in seealso generation for generics, which could add junk entries for the 'where' clauses in cases where intellisense data was unavailable.
  • The documentation rules no longer generate '[in,out]' or '(optional)' in StyleCop compatibility mode.
  • Tested and updated for compatibility with Atmel Studio 6.2.

February 2014

  • The Atomineer rules now support user-configurable text for 'true', 'false', 'null' and 'nullptr'. To configure different text from the default (true, false, null, nullptr), go to the Atomineer options, Doc Advanced tab, and click the 'User %variables%' button. Edit the variables for true/false/null/nullptr - e.g. to output 'true' as "<c>true</c>" use "&lt;c"gt;true"lt;/c"gt;"
  • Exceptions thrown within properties are now documented.
  • Resolved a rare installation situation where VS would not pick up the addin after installation.
  • Fixed a tiny bug in conversion of // comments into summary documentation, which could cause parts of URLs to be 'lost' during the conversion.
  • Fixed a failure caused by a regression in parsing a C# code element when preceded by an attribute on a single line
  • Fixed incorrect use of tabs rather than spaces (when configured in Visual Studio editor settings) in C++ accessor generation and end-of-line comments.
  • Fixed a case with single-line enum value comments in DocXml format when using a multiline C++ comment style, where the documentation entry was emitted without comment /* ... */ delimiters.
  • Fixed a glitch that could occur in handling of parameters after some forms of regex pre-processing.
  • We suffered a catastrophic hardware failue this month and it took a lot of time to resurrect our systems from our backups and then test our new builds to be sure that everything still works. We were hoping to deliver a major new feature for this release, but this has unfortunately had to be deferred for a bit... watch this space!

January 2014

  • Happy New Year! We wish you all the best for a great 2014!
  • Added Attribute auto-doc support. For each attribute applied to the code element being documented, Atomineer now creates an 'attr-???' variable for use in the Rules, containing the parameter-list for the attribute (e.g. [Conditional("DEBUG")] will generate a variable 'attr-conditional' with the value 'DEBUG'). To support this in Rules, you can now use tests of the form <If defined="attr-name"...> to test if a variable is defined. This is used by new rules to extract data from attributes and include it in the generated documentation text. For example, if the conditional attribute above is assigned, Atomineer will now prefix the summary documentation with '(Only available in DEBUG builds)'
  • General improvements to conversion of double-slash comments into doc summaries. In addition, double-slash comments are no longer converted into summaries if they appear to be commented-out code.
  • Popup reports will no longer be split across screens on mulit-monitor systems.

December 2013

  • Added new 'Doc All in Chosen Files' command. This offers a front-end user-interface for the other Doc All commands which allows you to set a number of additional options before the documentation process begins, including file filtering and greater control over what documentation is generated. It also provides a new documentation mode, to document all open files.
  • Updated preferences now allow you to customise Atomineer Menus. This allows you to remove unwanted items from the Tools > Atomineer menu and also to show extra commands on the Text Editor's context menu if you wish. These new options are in the 'General Settings' tab of the preferences.
  • Doc All... and Delete Documentation commands now report information on the projects, files and code elements they have processed. This is shown in the Visual Studio 'Output' window (choose 'Atomineer Pro Documentation' entry in the 'Show output from' combo box to see this output)
  • Doc All... commands now report completion using a temporary "tooltip" style window, which disappears automatically after a few seconds or if it is dismissed with a click.
  • Changed the way Atomineer inserts text into the document in some cases to work around a problem in VS 2013 where certain other addins were occasionally found to interfere with the insertion process.
  • Added 'ClassDecl' regular-expression preprocessing, which works exaclty like the existing 'MethodDecl' preprocessing, but for class/struct/interface members.
  • Fixed a glitch in derived documentation duplication that sometimes caused a param entry to be added twice.

November 2013

  • Fixed a bug introduced in v8.10 when handling C++ projects. A small additional check added in the menu-item state code in 8.10 was requesting Intellisense information from Visual Studio, sometimes causing an Intellisense loading-progress dialog to be shown momentarily, which in turn closed the menu, making it impossible to open the Atomineer menu. This check has been removed and the menu now operates correctly once more.

October 2013

  • Added 'Doc all in Project' and 'Doc all in Solution' commands. These allow you to update documentation for thousands of code elements in a single pass, which is particularly useful when converting legacy documentation to a new style. Note that this processing can take a considerable amount of time on a large project/solution, and is not undoable.
  • New algorithm for 'Doc All In Scope/File/Project/Solution' processing: Under some circumstances the Visual Studio Intellisense information used by these commands could become slightly out of step with the source code during processing, causing Atomineer to miss occasional code elements out. The core processing algorithm has been completely rewritten to resolve this issue.
  • Significant speed-ups to all 'Doc All in...' commands.
  • 'Doc All in Scope/File' commands all now create a single undo step for their processing rather than an undo step for each code element documented.
  • Improved 'Doc All in...' handling of enum entries.
  • Improved 'Doc All in...' status line progress handling.
  • Added 'Delete Documentation from this File' command. To be used with care, this command deletes all documentation comments from a source code file. This can be useful for stripping away legacy documentation or forcing a complete regeneration of documentation (when used with Doc all in File)
  • Added support for __declspec() on classes in C++
  • The Documentation Viewer window now reopens on startup if it was open when Visual Studio last quit.

September 2013

  • Added a tutorial to the website, Making the Most of Atomineer.pdf which offers a number of hints and tips about how to get the best results out of Atomineer.
  • Upgraded the 'word wrap comment' feature to detect most forms of 'separator' line at the top and bottom of comments and exclude them from the word wrapping pass.
  • A small improvement to the auto-punctuation feature to suppress spurious punctuation in one rare case
  • A small improvement to generation of file header comments in 'Doc All in this File'
  • Began adding support for MVC code. If you use MVC and find examples of MVC-specific classes or methods that Atomineer does not document well, please let us know so we can improve our coverage of these cases.
  • Many improvements to the rules, especially in cases where generic/template types are used.
  • Improved the a/an autocorrection algorithm.
  • Added two 'inverted' (white on black) colour schemes for the documentation viewer.
  • Added a preference (not exposed in user interface) that allows Atomineer to correct the behaviour of other addins that incorrectly add their menu items into the Atomineer menu. If you experience this problem, please contact us for details of how to enable the workaround.

August 2013

  • Atomineer has now been verified compatible with Visual Studio 2013 Preview. (But please let us know if you find any unexpected behaviour in VS2013). To get Atomineer working in 2013, just run the 8.05 installer to update as normal - there is no need to uninstall first.
  • The installer now displays the version number (and '(Trial)' for trial versions) in its title bar so you can easily see which version you are about to install.
  • The installer will now warn you if you attempt to install over a full version with a trial version.
  • Fixed a loophole in the installer that allowed users to inadvertently install two or more copies of Atomineer (when changing the install location without uninstalling first). This could lead to Visual Studio running the old version, and the installer no longer appearing to update anything.
  • Some refactoring of the installer code.
  • (Limited Beta release)

July 2013

  • Atomineer is now fully code-signed to provide proper company information in UAC prompts during installation, and confidence that the addin has not been tampered with since leaving Atomineer.
  • Updated the 'configuring Atomineer' tutorial to describe the new preferences user interfaces.
  • Shuffled a couple of preference items to more logical places in the preferences dialog.
  • Fixed a small glitch in backwards compatibility for VB preferences
  • Added a 'clip column' preference for the separator lines, allowing them to be clipped at an absolute column so that indentation of the comment block does not cause the right hand side of the block to extend any further to the right. By default clipping is disabled, but if enabled it is usually set to the same column as the word wrap column to give a consistent block layout and ensure that none of the comment flows out of the desired display/print boundaries - but some users may prefer to extend the separators a couple of characters beyond the word wrapping column.
  • Fixed a rare bug in the word wrapping (on the first line of flowed entries, when the previous entry text started with a blank line, too much text to be added to the first line, causing it to flow past the wrap column)
  • Fixed a minor parsing glitch when commenting operator<= and operator<<, which caused them to be incorrectly treated as a generic in one processing pathway.

June 2013

  • Significantly redesigned the Atomineer preferences window layout, exposing a couple of new preferences, adding a welcome page and embedded help links to the Atomineer website.
  • Documentation system, formatting and layout preferences can now be configured separately for each code language directly within the preferences dialog. (This was possible in the past using per-solution/project Rules Paths, but is now considerably faster and easier to set up, and applies on a per-source-file basis so you can work in mixed codebases much more easily).
  • Reskinned the preferences and wizard forms to the new Atomineer graphical design.
  • Fixed a generic parameter parsing glitch in Visual Basic.
  • Improvements to the parsing of properties and exceptions in Visual Basic
  • Added optional support for converting Doxygen ///< or /*!< ... */ end-of-line comments on enum entries and variables into regular XML documentation comments. (If you would like to use this conversion, please email us for details of how to enable the feature)

May 2013

  • Oops! Removed a debugging behaviour that slipped into the last release, which was causing the documentation viewer to reopen whenever Add Doc Comment was executed, if you had previously closed the view.
  • Added handling for '@' prefixed strings in parameter attributes.
  • Added the Documentation Viewer. This displays documentation comments in a human readable style (similar to the sort of output you can generate with tools like Sandcastle, Doxygen, and JavaDoc) so that documentation can be easily browsed as cursor moves through source code.

April 2013

  • Added support for inline ReSharper code-inspection suppression comments. Atomineer will no longer convert comments of the form '// ReSharper disable RedundantThisQualifier' into DocComments. Instead, the code element will be considered undocumented and a new comment will be inserted without consuming the ReSharper command.
  • Added support for per-parameter attribute decorations as used by ExcelDNA. Atomineer will now correctly handle these attributes embedded within the method declaration. In addition, if a 'Description="..."' attribute value is present it is assumed to be a description of the parameter, and used as the default text for the parameter description that Atomineer generates.
  • Fixed the missing menu separators in VS 2010 and 2012.
  • Fixed a problem with parsing one very special case: single-line auto-brief Doxygen/Javadoc/QDoc comments. Atomineer would classify this particular case as a 'separator line' rather than a documentation comment due to the lack of any documentation entry syntax in the line. It now recognises this particular case and updates it as expected.
  • Declare/Implement method: updated to correctly process method declarations occurring on the same line as the access specifier, and removed a problem with C++/CLI handles (^) in return values.
  • Added support for constructor-style member variable initialisation syntax.

March 2013

  • Improved conversion of /** ... */ comments when they are not configured as the primary Atomineer format. This increases the number of common documentation styles that Atomineer can convert automatically (without needing any explicit tweaking of conversion settings).
  • A few small improvements to the setup Wizard application.
  • Fixed a small issue in the uninstaller that caused it to silently fail in rare circumstances.
  • Tested Atomineer for compatibility with the Atmel Studio 6.1 Beta, added installation support for this new version of Atmel Studio, and launched Atomineer on the Atmel Gallery.
  • Implemented a small but important missing feature - updating parameter descriptions to include or exclude auto-generated (Optional) tags as appropriate when default values are added or removed, or when documentaiton is copied from other same-named parameters.
  • Fixed an update problem with [in, out] parameter tagging.
  • Removed a minor caching issue that meant documentation updates did not work properly until after a restart of Visual Studio when changing between JavaDoc and QDoc style comments
  • Added conversion support for end of line comments (on parameters and member variables). If a parameter or member variable is followed by an end-of-line comment (a // comment, or a documentation comment prefixed with ///< or //!<), Atomineer will now merge the text of the comment into the documentation block. The original comment will be removed (This is added as a separate undo step so you can undo through the history of changes after converting a code element's comment). This can be used to convert EOL comments into entries within doc comment blocks, or (if Atomineer is configured to generate EOL comments for single-line entries) to convert EOL comments into the configured Atomineer format. This feature also promotes consistent behaviour when reapplying Atomineer to code elements that are already documented.
  • Added conversion support for single line /** ... */ documentation comments that occur prior to a code element. (Previously Atomineer would only pick up this style of comment if the closing */ occurred on a different line to the opening /**).
  • Implemented support for editing custom preference files in solution-relative and project-relative rules paths. Creating new custom rules files now reports the filename of the generated file to make troubleshooting easier.
  • Adjusted Atomineer to work around a minor compatibility issue introduced in the latest version of Atmel Studio 6, which was causing blank doc comments to be generated.
  • Improved handling in the case where Add Doc Comment was executed on the last line of a scope preceeding the code element to be commented. This would incorrectly insert the new comment just inside the previous scope, but now handles this case correctly.

February 2013

  • Member variables and enum members are now commented properly if decorated with attributes.
  • Fixed a failure that could occur when trying to document during debugging under conditions that made the source file read-only (e.g. edit and continue unavailable).
  • Fixed a small parsing error in C++ exception specifiers that could cause an invalid exception entry to be added under rare circumstances.
  • Improvements to the 'stylecop compatibility' mode, which now provides MSDN-like descriptions for more common .Net cases, even though these are not actually checked by StyleCop.
  • Improvements to the generated documentation for operators, including handling of explicit and implicit operators.

January 2013

  • Improved documentation for enumerated type members. When processing the <Variables> rules, the %type% variable is now set to 'enum' for members of enumerated types, and 'bitfield' for members of enums marked with FlagsAttribute. These special types are now used to generate improved documentation specific to enumerated values (enum) and binary constants (bitfield).
  • Added 'camel' and 'pascal' commands for use when expanding variables (e.g. %name:Camel%). This outputs the name in the form 'camelCasedName' or 'PascalCasedName' respectively. This will of course only be useful for names in a multi-word format (multi_words or MultiWords)
  • Fixed a small glitch in the C++ parser that could stop Atomineer from generating a comment when the user typed ///. (This problem did not occur with ctrl+shift+D)
  • Existing documentation is no longer duplicated for event handler 'EventArgs' parameters

December 2012

  • Optimised and improved the code that searches for base class documentation that can be re-used. This can significantly improve performance in cases where complex class hierarchies are encountered (in both user code, and underlying/system libraries).
  • Tested Atomineer with Visual Studio 2012 Update 1.
  • A few small improvements to generic and template parsing.
  • Fixed a problem in 'Doc all in File' caused by C++ macros that inject methods into a class. These 'non existent' methods could be returned by the Visual Studio intellisense system, causing Atomineer to try to document members that didn't exist in the source code. They are now ignored.
  • For convenience the preferences dialog can now be minimised to the TaskBar.
  • Small improvements to the installer/uninstaller.

November 2012

  • A slightly new look for our website.
  • Fixed an unexpected bug introduced in 7.61 - this caused problems when attempting to document code in C++ header files. If you have 7.61 and wish to document C++ headers, please update to the latest version (for those with a single-download copy of version 7.61, please contact us and we'll send you a free upgrade to 7.62)
  • Added a mechanism for conditonally marking documentation entries as 'optional'. This allows entries to be added to a documentation block for some cases (e.g. overrides) but not others. The conditions use the same expressions as available in <If> commands. See the description of _optional in the Rules Guide for details.
  • Moved our web hosting to new servers to provide improvements to our online service, and freshened up the website look and feel.
  • Atomineer now has a Facebook page and a Twitter account, so please look us up, Like us, and Follow us for announcements about new releases etc.

October 2012

  • If 'Add Doc Comment' is executed within the body of a method or property, Atomineer will now move the cursor out of the top of the method/property and document it. Note that this relies on the Intellisense information provided by Visual Studio, so it may not work if the code is in a non-compiling state or a language for which Visual Studio doesn't provide this information.
  • Improvements to the Live Typing Aids when typing and pasting into comment blocks. (Atomineer will no longer break a comment if you type a double-newline in the middle of it. This was intended to be useful behaviour but has been found to work poorly in practice. Typing /// in illegal places such as within method bodies will no longer attempt to insert doc comments. Pasting within multiline comments now pastes verbatim)
  • Improved 'Implement/Declare C++ method' command - as well as reading the text from single-line (//) comments from declarations and using them as summary text for the implemented method, it can now read fully blown doc comments and duplicate them onto the implemented method. It now also handles existing comments in the target source file.
  • Fixed a localisation issue (only affecting Visual Studio 2012 in a few non-English language locales) where the Atomineer main-menu items were not appearing.
  • Improved handling of seealso entries for Generics/Templates when updating existing comments.
  • Fixed a small problem that sometimes interfered with correct handling of [in,out] parameter entries.
  • Fixed a breakage in the handling of namespaced MyClass::operator= in C++
  • Corrected handling of Doxygen AutoBrief comments when using /// comments without top/bottom separators.
  • Fixed a bug from 7.59 that caused Atomineer to fail sometimes when documenting member variables
  • Improved handling of XML entities within cref attributes
  • Improved handling of C# generic typeparams using 'where T : ...' clauses

September 2012

  • By default, Atomineer will now assume that // comments that contain plain text are to be converted into a fully-blown doc comment (it assumes that the comment body represents the summary/brief description to be used in the new doc comment). If this conversion is unwanted, it can be disabled in prefs.xml - contact us for details of how to do this.
  • Improved compatibility with different Atmel Studio versions
  • The Installer now registers Atomineer in the Programs And Features control panel, so it can now be uninstalled directly from Programs and Features as well as by running the original installer and choosing the Uninstall option.
  • Anywhere a %variable% can be used in Atomineer and the Atomineer preferences (e.g. Rules Search paths), it is now possible to use OS environment variables (An Atomineer variable will take precedence over any environment variable of the same name)
  • Xml Documentation: By adding a <prototype _punctuate='false'/> element to your templates you can now cause the method signature to be added to the comment, just as for Doxygen comments. This element will be named 'signature' (currently a fixed name, but contact us if you would like this name to be configurable).
  • Improved handling of generic classes in the new class parser.
  • Fixed a some minor parsing glitches in C++ (relating to array parameters, namespaced parent class names, and array-member initialisation lists).

August 2012

  • Added support for UnrealScript (.uc) code syntax.
  • When updating interface and abstract methods, exception descriptions are no longer removed.
  • Added a preference (on the Doc Comment Style tab, Automatic Tidying section) that controls removal of 'invalid' entries. By default, if Atomineer finds an unknown doc entry during a comment update (such as a description for a parameter or exception that is no longer present in the method), it prepends the entry with '###'. This allows you to see what Atomineer intends to remove, so you can choose to re-use the description text, or you can execute Add Doc Comment a second time to clean up the comment and remove all the invalid entries. The new preference allows you to turn off this safety measure, so Atomineer will silently remove all invalid entries.
  • (Related to the previous change) The 'Doc All' commands now force immediate deletion of invalid doc comment entries, rather than leaving them with a prefix of '###'. This avoids having to update a large batch of comments twice to clear away invalid entries.
  • Added support for optional 'inheritdoc' entries.
  • A couple of small improvements to C++/CLI code handling.
  • Added handling for __declspec() on methods in C/C++.
  • Fixed a case in C++ where seealso entries were being duplicated.

July 2012

  • Extensive testing with Visual Studio 2012 RC. Found and fixed an occasional problem where incorrect documentation was being generated. (This was due to a breaking change in Visual Studio's internal 'find' operations, which now interpret regular expressions using .NET regex syntax)
  • Fixed a side effect of improved 'optional' template entry handling, which had inadvertently supressed seealso output.
  • Fixed a problem with adding seealso entries in C++.
  • Improved handling of 'optional' template entries, which had not been extended to all entry types.
  • Now supports Atmel Studio 6.0.
  • Some small performance optimisations.

June 2012

  • Significant performance improvement when updating existing comments.
  • Rewrote the code-element detection parser. (This is used to determine what kind of code element is being processed before a more-specific parser is used to actually document that element). This has provided the following improvements:
    • More efficient processing of code elements.
    • Better handling of complex multi-line declarations
    • Less likely to be 'confused' by different coding styles, especially when handling class/module/struct/union/interface code elements.
    • TypeParams for Generic/Template classes are now supported.
  • When adding <seealso> entries to a comment or if <see> entries are being added to description text (%docBasesWithSee% is true), Atomineer will now add seealso/see entries for all base classes/interfaces rather than only the primary base.
  • When restricting generation of documentation to certain access levels, the default behaviour is now to only apply the restriction to the commands that generate multiple comments (i.e. Doc All In Scope/File)- if you deliberately try to document a code element with 'Add Doc Comment' it will allow the comment to be added. There is a new preference (on the General preferences tab) that extends the restriction to the Add Doc Comment command as well. The reason for this change to the default behaviour is that it can be very confusing (e.g. if you type /// and that text is simply deleted without any obvious explanation).
  • Fixed an issue with updating single-line comments when using certain comment-block styles.
  • Improved the support for duplicating documentation for parameters from elsewhere in a class. Previously this feature copied appropriate documentation from other parameters in the class, but it now also considers documentation from Properties and Member Variables as well. In the case of properties, the <value> documentation will be used if available, or the <summary> if not (any 'gets or sets' text is stripped in this case to make the generated parameter description coherent).
  • Duplication of parameter documentation is now applied when updating a comment as well as when creating a new one. This allows the documentation to be duplicated onto parameters that are subsequently added to methods.
  • Hotkeys are no longer assigned to Atomineer commands if they have been bound to other commands in the 'Global' key context. (Hotkeys used to be assigned only in the 'Text Editor' context, but this meant they could override global hotkeys)
  • Added handling for foreign characters (É, Ø, ß etc.) in code-element names.

May 2012

  • Added support for user-defined acronym and general text replacements. As a variable (such as a parameter name) is expanded, separate words within it can be selectively replaced. The primary use is for converting words like 'html' or 'Html' to uppercase 'HTML', but it can be used to apply any replacement required (e.g. 'atomineer' with 'At*mineer'). This replacement system is enabled by default but can be disabled in the Doc Comment General tab of the preferences. The list of acronyms and replacements can be customised by clicking the 'Acronyms & Replacements' button on the Advanced Customisation tab.
  • 'Create C# or C++/CLI property' can now generate auto-properties in a single-line or multi-line format. The default is a single-line implementation, but this can be changed to multi-line in the Misc tab of the Atomineer Options.
  • 'Create C# or C++/CLI property' can now convert the multi-line auto-properties into a property-with-backing-field.
  • Improved handling of custom preferences files in the Options dialog.
  • Improved 'Doc All in This File' with a preference (on the 'Misc' tab) that controls whether or not file header comments are added (if not already present).
  • Fixed an oversight in 'Doc All in This File' that could sometimes lead to unexpected code elements being documented (such as 'using' directives and some parameters) depending on the version of Visual Studio in use.
  • Fixed a problem with <seealso> entries referencing base classes, where Atomineer could incorrectly remove the seealso when updating an existing comment, and very rarely enter an infinite loop. As a result part of the XML comment parser was rewritten and is now more efficient and robust.
  • Fixed a scoping issue with C++ that was interfering with handling of copy constructors and operators.
  • Added support for C++ iostream << and >> operators
  • A number of other small tweaks to the code and rules

April 2012

  • Added 'Document All in this File' command. Unlike 'Doc all in this Scope', this command relies on the Intellisense CodeModel information in Visual Studio, so is not available in some languages. However, it can be used in .net languauges where a file contains multiple classes/enums, to process everything in a single pass, whereas each class would have to be processed individually with Doc All In Scope.
  • Added an unattended command-line mode to the installer. See the Installation section of the user guide for details.
  • Fixed a small bug in the processing of exceptions that could cause junk text to be reported in place of the exception name under some circumstances.
  • Improved handling for read-only files (code logic dating back to VS2005/2008 has been updated to take advantage of improvements in 2010/11). Visual Studio now correctly prompts, allows editing, or checks-out read-only files from source control as it is configured to do.
  • Added a new attribute for template-entry xml elements, '_style="multiline"'. This can be used to force individual entry types to use a multiline format even when they could fit on a single line. (This can be used to make entries like 'summary' always use a multiline format, while still allowing short entries like 'returns' to use the more compact single-line format. Details can be found here.
  • Added a new set-up tutorial to the User Guide.
  • Fixed an interaction with the Visual Assist X addin that caused incorrect indentation of the cursor in a few specific circumstances when VAX was injecting code snippets.
  • C#: Added handling for '@' to allow reserved words to be used as names for class, parameters, etc.
  • Improved StyleCop handling for properties where users want to allow private members to be documented, but still don't want private property accessors to be documented (i.e. 'gets' rather than 'gets or sets').

March 2012

  • Changed the name of the addin from "AtomineerUtils" to "Atomineer" (it had 'utils' in the name purely for historical reasons). Please also note that 'Subscription' has been renamed to 'Support and Update Plan' - it works exactly as before, and has simply been renamed for clarity.
  • A lot of work went into improving the website, with easier to read typography, reduced text descriptions, improved section separation, etc.
  • Reworked the installer and preferences app to use the new Atomineer graphics.
  • Removed most of the documentation that was embedded in Rules.xml, replacing it with links to the online documentation. This has reduced the download size and helped to improve startup times.
  • Atomineer now considers 'value' and 'returns' to be aliases. This allows a method to be converted to a property (or vice versa) and updating the documentation will automatically migrate the description of the return value across to the appropriate entry in the new comment.
  • Improved C# indexer support. Indexer parameters are now fully documented, and the return value is now documented as a 'returns' rather than 'value' entry, for StyleCop compatibility.
  • Added access-level detection for enum entries, which were inadvertently being removed if Atomineer was configured not to comment private members.
  • Added a new rules attribute that can be used to stop Atomineer from generating a documentation comment for any given code element. This works much as the access-level system already did, but with much finer-grained control over exactly which code element(s) you apply the restrictions to (for example, to all member variables, or to all methods that start with the word 'On', etc).
  • Doc all in scope now reports a more helpful error message when CodeModel information isn't available (usually when the project requires a rebuild).
  • Now supports the Visual Studio 11 Beta.
  • Visual Basic: Fixed a regression that caused some methods and properties to be commented as constructors.
  • Visual Basic: Fixed a small issue that meant that single-line doc comments would not be updated in some circumstances.

February 2012

  • AtomineerUtils now detects and ignores single-line 'separator' comments that happen to start with /// or ''' (VB).
  • Made improvements to live typing aids (better handling of bullet-lists, better behaviour when pressing return at the end of a doc comment block if separators are disabled, improved the handling of pasting text into comment blocks).
  • Typing /// to insert a comment with the 'ensure blank lines above comment' preference disabled now retains the line spacing correctly (previously it 'inserted' a surplus blank line)
  • Small improvements to constructor handling.
  • Fixed a problem in the Align into Columns command that could occur if it was the first AtomineerUtils command executed after starting up Visual Studio.
  • Fixed a word wrap infinite loop that could occur if a line with excessive (more than a full line of) indentation whitespace was encountered.
  • Fixed a glitch that left the cursor in the wrong location after inserting a few types of comments.
  • Improvements in the installer's detection of old versions of Visual Studio.
  • When suppressing auto-generation of author/date entries, AtomineerUtils now treats these entries (or remarks in DocXml) as 'optional', so that any existing entries are not considered 'illegal' and removed.

January 2012

  • 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

  • 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

  • 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 '&lt;') 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • Fixed a tiny bug that caused Properties to be misidentified and documented incorrectly.
  • 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

  • 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

  • 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

  • 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

  • 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

  • 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

  • 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.
  • When updating documentation, AtomineerUtils can now optionally convert <, > and & characters into the XML/HTML entities &lt; &gt; and &amp; 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

  • 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

  • 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.
  • 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

  • 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.
  • 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

  • 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 &lt;, &gt; and &quot; 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

  • 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.
  • 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

  • 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.
  • 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

  • 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.
  • 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

  • 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

  • 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 ^%)
  • 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

  • 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.
  • 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 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.
  • Major bugfix - An obfuscation glitch stopped the block formatting options working properly, leaving users stuck in 'FramedFlush' mode.

August 2009

  • 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
  • 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.
  • 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).
  • 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

  • "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).
  • 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.
  • 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.
  • 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

  • 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).
  • 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
  • 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.
  • 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.
  • 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.
  • 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.
  • 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

  • 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

  • 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).
  • Improved override documentation harvesting.
  • Added "Check for updates..." menu item.
  • Prefs application now supports enforcing of 0 lines above/below DocComments.
  • 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
  • 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
  • Upgraded Doxygen code to use the (relatively) new Templating system already in use for DocXml.

March 2009

  • Fixed a bug in doxygen indentation processing.
  • First widespread public release.
Copyright © 1996-2024 Atomineer. All Rights Reserved. Any trademarks reproduced in this text are the property of their respective owners - Contact us - Company Info