mathnet-numerics/lib/Gallio_3.0.6.787/samples/MbUnit/libs/WatiN/ReleaseHistory.txt

WatiN 1.2.0.4000 (4 October 2007)

This release includes mainly new features (some only for .Net 2.0). You can now start a new IE instance in its own process, set event properties when firing events on an element, get a specific Ancestor of an element, use your own attribute comparers, implement specific wait logic, evaluatie javascript code, automate the Area element, clean up all IE caches, take snapshots of webpages and much more. Many thanks to all who contributed to this release!

For the full release notes visit http://watin.sourceforge.net/releasenotes-1-2-0-4000.html

-------------------------------
WatiN 1.1.2.4000 (16 May 2007)

This is a hotfix release and fixes an issue resulting in a null value for the srcElement property of the 
eventobject. This is most noted when an event is fired and the JScript in an html page tries to access
the window.event.srcElement property.

-------------------------------
WatiN 1.1.1.4000 (15 May 2007)

This is a hotfix release and fixes SF Bug 1718162: js error when using TypeText method of a TextField in frame. http://sourceforge.net/tracker/index.php?func=detail&aid=1718162&group_id=167632&atid=843727

-------------------------------
WatiN 1.1.0.4000 (2 May 2007)

This release adds some new features and many bugfixes. You can now use the not operator when searching for an element, automate the  SaveAs dialog, and WaitUntil some attribute of an element has some value. Most of the development time has been put into fixing bugs reported by users. Thanks to all who contributed to this release!

For the full release notes visit http://watin.sourceforge.net/releasenotes-1-1-0-4000.html

-------------------------------
WatiN 1.0.0.4000 (1 March, 2007)

This release adds may new features like using multiple attributes to search for an element, full support for the Style attribute, casting an Element instance to a more specialized element type, support for changing the default settings used by WatiN, added support for tbody elements and improvements to SelectList and Table. 

For the full release notes visit http://watin.sourceforge.net/releasenotes-1-0-0-4000.html

-------------------------------
WatiN 0.9.5.4000 (31 December, 2006)

This release adds new features to support testing of websites which make use of AJAX technology. Many other feature requests and bug fixes are included as well.

For the full release notes visit http://watin.sourceforge.net/releasenotes-0-9-5-4000.html

-------------------------------
WatiN 0.9.0.4000 (31 October, 2006)

** Changes in general **

* Added an extensible model for handling IE dialogs through the DialogWatcher instance 
  of each DomContainer (IE and HTMLDialog). If no specific handling of a dialog (type) 
  is needed, DialogWatcher will automatically close any dialog that pops up.  
  
  Use ie.AddDialogHandler(handler) to add a dialog handler.  
  Use ie.RemoveDialogHandler(handler) to remove a dialog handler. 
  Use ie.DialogWatcher to get access to all the properties and methods of the 
  DialogWatcher instance.

  This release contains the following dialog handlers: 
  + Added support for Logon dialog handling (thanks to Bruce McLeod for the initial implementation). 
    Some of the constructors of the IE class accept an instance of LogonDialogHandler 
    to automatically logon to a website.
  + Improved support for handling alert and confirm dialogs in various ways through 
    AlertAndConfirmDialogHandler, AlertDialogHandler, ConfirmDialogHandler and SimpleJaveDialogHandler.
  + Added support for handling Certificate warning dialog.

  See the API Change section below to read some more details about the available 
  dialog handlers. A more complete explanation on how to use the different dialog 
  handlers will be available on the website soon. 

* Added support for automating a frames page which shows websites from different 
  domains (thanks to Ken Herman for the initial implementation).
* Added support for IFrame element(s) using the ie.Frames syntax (thanks to Gaurav 
  Jayal for supplying some good iframe web pages to test with).
* Added support for file upload (input element of type upload) through 
  ie.FileUpload.Set(MyFile).
* Added support for ie.Element() and ie.Elements to get any or all elements in a 
  document (or elements container like the div element). This way elements not natively 
  supported by WatiN can also be accessed through the WatiN API. The following 
  example shows how to get the text of an LI html element.

  Element li = ie.Element(Find.ById("LI1"));
  Debug.Writeline li.Text;

  If an element can contain elements, like the <pre /> html element, the return value of 
  ie.Element can be casted to ElementsContainer.

* Added basic support for <button /> tags through ie.Button() and ie.Buttons. Use 
  ie.Element() or ie.Elements instead if access to the inner elements is required.
* Improved the speed of the Table.FindRow implementation. It uses a special 
  TableRowFinder instead of looping through all kinds of collections. The 
  TableRowFinder is a good example on how to create a specialized attribute class to 
  find some kind of html element.
* Speed is improved when closing an IE instance. This is because all IE instances in the 
  same process share one instance of DialogWatcher. Also disposing DialogWatcher is 
  speed up by terminating the watcher thread earlier.
* WatiN allows the use of regular expressions in some more situations. See the API 
  change for the overloaded methods.
* Removed all constructors of the IE class that had autoclose as an argument. Use the 
  ie.AutoClose property if you need to change the auto close behaviour of an IE 
  instance. The default value of AutoClose is true.
* Made a change to the new IE implementation to better support using WatiN on Vista 
  with User Account Control (UAC) turned on. (Thanks to Bruce McLeod for testing on 
  Vista and supplying this change).
* Made extending and reusing some parts of the WatiN API easier:  
  By exposing some new methods in the ElementsSupport class it's possible to more 
  natively access the code which finds html elements in a webpage. Together with the 
  changes of the constructors of some elements and of all element collection classes, 
  this makes it possible to create your own customized wrappers for your own or third 
  party web controls. A more complete example on how to do this will be available on 
  the website soon.
* Made some changes and additions to the WatiN API documentation.




** API Changes **

Namespace WatiN.Core:

All element collection classes like ButtonCollection, TextFieldCollection etc..:
* Changed constructor. It now accepts an Arraylist with objects of type IHTMLElement 
  instead of an IHTMLElementCollection. 

Attribute class (and subclasses)
* Added an overload for Compare which excepts an object of type IHTMLElement. This 
  method is called when an HTML element is searched for.
* Added a protected method GetAttribute which returns the value for the given 
  attributename and IHTMLElement. Throws an exception if the attributename isn't valid 
  for the IHTMLElement instance.
* Added a protected method GetElement which casts and returns an object to 
  IHTMLElement. An ArgumentException is thrown if the object isn't of type IHTMLElement. 

Document class
* Added an overload for ContainsText which excepts a regular expression to match against.

DomContainer class [inherits Document]
* Added AddDialogHandler method to register a specific dialog handler.
* Added RemoveDialogHandler method to de-register a specific dialog handler.
* Added DialogWatcher property which gives access to the full DialogWatcher object.
* Added StartDialogWatcher method which should be called by all objects that inherit 
  DomContainer as soon as a processid can be determined.
* Added an abstract hWnd property which should be implemented by all objects that 
  inherit DomContainer.
* Added ProcessId property which returns the process id the DomContainer is running in.
* Removed MainDocument property. This was marked obsolete since the WatiN 0.8 release.

Element class (and subclasses)
* Added Complete property. Returns false if the element is not fully loaded by the 
  Internet Explorer Dom, true if it is.

ElementCollection class
* Contains all Elements of a Document, of an Element which implements 
  IElementsContainer or of an Element inheriting from ElementsContainer. Can be called 
  like this: ElementCollection elements = ie.Elements;

ElementsContainer class (and sub classes)
* Renamed, was SubElementsContainer.
* Added Element(elementId) method to get any type of html element by it's Id.
* Added Element(findBy) method to get any type of html element by the given findBy instance.
* Added Elements property to get all elements.
* Added FileUpload(elementId) method to get an input element of type=upload. 
* Added FileUpload(findBy) method to get an input element of type=upload by the given findBy instance.
* Added FileUpload property to get all input elements of type=upload.

ElementsSupport class
* Renamed, was SubElementsSupport
* Added FindAllElements which returns an ArrayList with all matching IHTMLElement instances.
* Added FindFilteredElements which returns an ArrayList with all matching IHTMLElement instances.
* Added FindFirstElement which returns an a matching IHTMLElement instance, null or 
  throws an ElementNotFoundException.

FileUpload class
* New class to support setting the file to upload on an input element of type=upload.
 
FileUploadCollection class
* Contains all FileUpload elements of a Document, of an Element which implements 
  IElementsContainer or of an Element inheriting from ElementsContainer.

Find class
* Added an overload for ByFor which accepts an Element as argument.

IE class [Inherits DomContainer]
* Removed all constructors with the autoclose argument. Use ie.AutoClose if you want 
  to change the autoclose value (default is true).
* Added new constructors which accept an LogonDialogHandler instance as an argument.
* Renamed AutoCloseIE property to AutoClose.

Image class [Inherits Element]
* Marked Href property as obsolete. Use Src property instead.
* Added Name property.

PopUpWatcher class
* Removed. Use DialogWatcher and/or AlertAndConfirmDialogHandler instead.

SelectList class
* Added an overload for Select which accepts a regular expression as argument.
* Added an overload for SelectByValue which accepts a regular expression as argument.

StringComparer class [Implements ICompare]
* Added a protected property valueToCompareWith.

StringContainsAndCaseInsensitiveComparer class [Inherits StringComparer]
* Inherits StringComparer.

StringEqualsAndCaseInsensitiveComparer class [Inherits StringComparer]
* New class inherits StringComparer.

Table class [Inherits ElementsContainer]
* Added an overload for FindRow which accepts a regular expression as argument.
* Added an overload for FindRow which accepts a TableRowFinder instance as argument.

TableRowFinder class [Inherits Text]
* New finder class to find a TableRow


Namespace WatiN.Core.DialogHandlers:
* New namespace which contains the dialog handler classes.

AlertAndConfirmDialogHandler [Inherits BaseDialogHandler]
* This dialog handler handles alert and confirm dialogs by placing their message on a queue 
  and closing the dialog. You can access the queue, pop messages etc. through the 
  properties and methods exposed by this class. This dialog handler gives you the same 
  functionality as the PopUpWatcher class of WatiN 0.8 and older.

AlertDialogHandler [Inherits JavaDialogHandler]
* With this dialog handler you can handle alert dialogs and clicked the OK button after  the 
  dialog is shown.

BaseDialogHandler [Implement IDialogHandler]
* Inherit this class if you write your own dialog handlers.

CertificateWarningHandler [Inherits BaseDialogHandler]
* With this dialog handler you can handle Certificate warning dialogs. You should decide 
  which button to press when creating an new instance.

ConfirmDialogHandler [Inherits JavaDialogHandler]
* With this dialog handler you can handle confirm dialogs and decide which button is clicked 
  after  the dialog is shown.

DialogWatcher
* This class watches for Internet Explorer dialogs popping up, loops through the registered 
  dialog handlers and if no handler has handled the dialog it closes the dialog automatically. 
  You can add, remove dialog handlers through the properties and methods exposed by 
  this class. You should be aware that DialogWatcher watches for Internet Explorer dialogs 
  created by all Internet Explorer instances in a process.

FileUploadHandler [Inherits BaseDialogHandler]
* With this dialog handler the FileUpload class handles setting the file to upload. Use 
  ie.FileUpload("upload1").Set(MyFile) instead of using this dialog handler.

IDialogHandler
* Implement this interface if you want to write your own dialog handler and don't want to 
  inherit from BaseDialogHandler. Return true if the handler was able to handle the dialog, 
  otherwise return false.

JavaDialogHandler [Inherits BaseDialogHandler]
* Used by AlertDialogHandler and ConfirmDialogHandler. Use these classes instead.

LogonDialogHandler [Inherits BaseDialogHandler]
* With this dialog handler a logon dialog will be filled out and submitted. You can pass an 
  instance of this class to some overloaded constructors of the IE class to handle logging 
  on to a website.

SimpleJavaDialogHandler [Inherits BaseDialogHandler]
* With this dialog handler an alert or confirm dialog can be handled. You should decide 
  which button to press when creating an new instance. When an alert or confirm dialog is 
  shown it stores the message 

WinButton 
* Wrapper class for a button on a dialog. This can be used in custom dialog handlers to 
  access buttons on the dialog.

Window 
* Wrapper class for a window which is passed to a dialog handler through 
  IDialogHandler.HandleDialog(window).


Namespace WatiN.Core.Exceptions:

ReferenceCountException 
* Thrown if DialogWatcher.DecreaseReferenceCount method is called more then 
  DialogWatcher.IncreaseReferenceCount.


Namespace WatiN.Core.Interfaces:

IElementsContainer
* Renamed, was ISubElements.


** SourceForge Trackers **

* Added Feature requests:
1553099	Cross-domain scripting security
1562743	Support for Iframes
1562745	Support for BUTTON elements
1581521	Support confirm dialogs

* Fixed Bugs:
1578611	DomContainer not disposing of DialogWatcher
1587075	On Vista new IE() spawns two Internet Explorers


-------------------------------
WatiN 0.8.0.4000 (31 August, 2006)

** Changes in general **

* WatiN is now available in a .Net 1.1 and .Net 2.0 distribution
* IE and HTMLDialog now support all functionality which in 0.7.0 was only 
  accessible by using IE.MainDocument.xxx. The MainDocument property has been 
  marked obsolete. You are encouraged to change your code because the MainDocument 
  property will be removed is the next release. To make this new syntax possible 
  some code breaking changes are introduced(see API Changes).
* Added support for finding elements with a regular expression.
* Added support for finding an Image by its Src (source) attribute and added 
  functionality to the Image class.
* Improved IE.HTMLDialog behaviour.
* Added support to get the active element (element with the focus) in a document.
* Added IE.PressTab which sends a Tab key to IE. This allows tabbing through the 
  elements (and address bar). Combined with Document.ActiveElement this makes it 
  possible to do some usability testing.
* IE constructors throw a InvalidThreadState exception if code is not executed on 
  a single threaded apartment. Read the 'WatiN and Thread.ApartmentState' article 
  on http://watin.sourceforge.net for more information.
* Added 2 new constructors to WatiN.Core.IE that accept an System.Uri instance.
* Added support for firing events on elements with no id (only for elements not 
  shown in an HtmlDialog).
* Added IE.GetWindowStyle to determine the window style (normal, minimized, maximized, etc).
* Updated documentation (all class have an explanation about their purpose)
* Updated build file to support building both a .Net 1.1 and .Net 2.0 version.
* Updated and added (many) unit tests.
* Added Microsoft.mshtml.dll to the distribution files.


** API Changes **

Attribute class (and subclasses)
* Renamed AttributeValue to Attribute. All subclasses are renamed accordingly (BREAKING CHANGE).
* Added Regex support for Attribute and it's subclasses.
* Attribute class now overrides ToString which returns the same as the Value property.
* Attribute constructor now allows for empty Value parameter.

Document class
* Added support to get the active element (element with the focus) of a document
* Added Document.Uri which returns a System.Uri instance of the Document.Url.
* throws an InvalidAttributException when searching for an element by an invalid attribute.

DomContainer class [inherits Document]
* Inherits Document class.
* Property HtmlDocument now returns IHTMLDocument2 instead of HtmlDocument(BREAKING CHANGE).
* Dispose method changed from public to internal (BREAKING CHANGE).

Find class
* Added Regex factory methods.
* Added support for finding an Image by its Src (source) attribute.

IE class [Inherits DomContainer]
* Url property is now inherited from Document instead of returning the url in the 
  navigation bar. Result should be the same although the encoding of the url might 
  be a bit different. (BREAKING CHANGE).
* Added 2 new constructors to WatiN.Core.IE that accept a System.Uri instance.
* Added IE.PressTab which sends a Tab key to IE. This allows tabbing through the 
  elements (and address bar). Combined with Document.ActiveElement this makes it 
  possible to do some usability testing.
* Added IE.GetWindowStyle to determine the window style (normal, minimized, maximized, etc).

Image class [Inherits Element]
* Added Src, Alt and Href properties.

Src class [Inherits Attribute]
* New class to support finding an Image by its Src (source) attribute.


** SourceForge Trackers **

* Added Feature requests:
1543115  Throw exception when Thread has invalid ApartmentState
1535932  Access elements like ie.TextField
1530889  Upgrade to .net 2.0

* Fixed Bugs:
1549329  Google's redirect to localized Google fail tests  
1549145  ie.HTMLDialog(...) doesn't WaitForComplete  
1549138  SelectList.Select doesn't WaitForComplete  
1543108  Image with an empty Src hangs WatiN/IE  
1530876  Unit tests fail on W2K3 SP1 due to IE local machine lockdown  
1530874  Core.Element.ClickNoWait throws an unhandled exception  
1530859  Exceptions are thrown from Watin.Core.IE.findHtmlDialog  


-------------------------------
WatiN 0.7.0.4000 (8 July, 2006)

* In the previous release running the unittests from the binary watin.unittest.dll resulted in 
  a lot of open IE windows because the HTML files were not distributed in the right place.
  This problem is solved in this distribution. The logic to find the location of the HTML files
  is also changed so the test can be both run by the binary and in de VS2003 IDE 
  using "Test Driven.net"
* Added documentation and examples to the source code resulting in beter support by intellisense when
  using WatiN during your development. There's also a helpfile available (WatiN.chm). 
  Although the most important parts are documented to get you started with WatiN, there is still 
  a lot to be documented.
* Removed microsoft.mshtml.dll from the distribution because it's unclear if it's legal to 
  distribute it this way. WatiN now references the version registered in the GAC.
* Improved the build file.

-------------------------------
WatiN 0.6.3.3007 (31 May, 2006)
* Initial release at Sourceforge