Version 8.3
===========

Bug Fixes:
 - Sometimes the view window of an undocked docker wasn't resized.
 - CFileDialog::GetPathName failed on Win98.
 - A dock ancestor didn't support docking unless it was also a top level window.
 - Dockers can now be used as a view window for a tab in CTab and CTabbedMDI.
 - An exception could be thrown when CTab was destroyed.
 - The highlighted menu radio box was out of position on Windows XP and older.
 - The Scribble sample destroyed a pen while it was selected in the device context.

New Features and Enhancements
-----------------------------
* Added PrintPreview sample
   This sample extends the NotePad sample by adding support for Print Preview.
   The techniques demonstrated here can be used in your own applications to 
   provide a print preview.
   
* Added CRibbonDockFrame.
   This class adds docking to a frame window which supports the Ribbon UI.
   A RibbonDockFrame sample has been added to demonstrate CRibbonDockFrame.

* Updated CString
 - CString and the text conversion classes can now be used independently of
   the rest of the framework.
 - Added CString::Assign. This function is used to assign a specified number 
   of characters to a CString. The assigned string can contain NULL characters.    

* Updated CFrame and CMDIFrame
 - SetView can now be used to switch between multiple views for frames
   and MDI children.
 - Added a virtual SetupMenuIcons function. This functions adds the set of
   ToolBar images to the icons used in menus. Override this to add additional
   icons to the menus.
 - Updated MRU support.
   The display of long file names in the MRU uses the same approach as Visual 
   Studio.
 - Modified default theme colors for Windows 8 and Windows 10.
   
* Updated CDocker
  - SetView can now be used to switch between multiple views for CDocker and
    CDockContainer.  
  - Improved the way the active docker is determined. This is now implemented
    without a timer.
  
* Updated CDC
  - Additional overrides for CDC::SelectObject to allow this function to be used 
    with casting. For example:
	  CPen Pen(PS_SOLID, 1, RGB(255, 0, 0));
	  CPen OldPen = dcMem.SelectObject(pen);
  - GDI resources created by CDC are managed better. Old GDI resources are now
    destroyed immediately, rather than when the CDC is de-constructed.

* Updated CPropertyPage
  - OnApply, OnSetActive OnWizardBack, OnWizardFinish and OnWizardNext now return
    a BOOL, making them simpler to use.
  

Changes in detail
-----------------
Added CRibbonDockFrame          class
Added CDateTime::SetTimeNone    member function
Added CDocker::OnMouseActivate	member function
Added CDocker::OnSize			member function
Added CDocker::SetActiveDocker	member function
Added CFrame::GetMRULimit		member function
Added CFrame::SetMRULimit		member function
Added CFrame::SetupMenuIcons    member function
Added CFrame::OnUnInitMenuPopup member function
Added additional overrides for CDC::SelectObject
Added PrintPreview              sample application
Added RibbonDockFrame           sample application		

These functions use references instead of pointers:
Modified CBitmap::CreateBitmapIndirect
Modified CBitmap::CreateDIBitmap 
Modified CBitmap::CreateDIBSection
Modified CBrush::CreateBrushIndirect 
Modified CComboBoxEx::GetItem
Modified CComboBoxEx::InsertItem
Modified CComboBoxEx::SetItem
Modified CDC::CreateBitmapIndirect
Modified CDC::CreateBrushIndirect
Modified CDC::CreateDIBitmap 
Modified CDC::CreateDIBSection
Modified CDC::CreateFontIndirect
Modified CDC::CreatePalette
Modified CDC::CreatePenIndirect
Modified CDC::DrawText
Modified CDC::DrawTextEx
Modified CDC::ExtTextOut
Modified CDateTime::GetRange
Modified CDateTime::GetTime
Modified CDateTime::SetRange
Modified CDateTime::SetTime
Modified CDialog::MapDialogRect
Modified CEdit::GetRect
Modified CEdit::SetRect
Modified CEdit::SetRectNP
Modified CFont::CFont
Modified CFont::CreateFontIndirect
Modified CFont::CreatePointFontIndirect
Modified CFontDialog::CFontDialog  
Modified CHeader::GetItem
Modified CHeader::InsertItem
Modified CHeader::SetItem
Modified CImageList::DrawIndirect
Modified CImageList::GetImageInfo 
Modified CListBox::GetItemRect
Modified CMetaFileDC::CreateEnhanced
Modified CMonthCalendar::GetCurSel
Modified CMonthCalendar::GetMonthRange  
Modified CMonthCalendar::GetRange
Modified CMonthCalendar::GetSelRange
Modified CMonthCalendar::GetToday
Modified CMonthCalendar::HitTest
Modified CMonthCalendar::SetCurSel 
Modified CMonthCalendar::SetDayState
Modified CMonthCalendar::SetSelRange
Modified CMonthCalendar::SetToday
Modified CPageSetupDialog::OnDrawPage
Modified CPageSetupDialog::OnPreDrawPage
Modified CPen::CreatePenIndirect
Modified CPen::ExtCreatePen
Modified CProgressBar::GetRange
Modified CRichEdit::SetRect
Modified CRichEdit::DisplayBand
Modified CRichEdit::FindText
Modified CRichEdit::FormatRange
Modified CRichEdit::GetTextRange
Modified CRichEdit::GetPunctuation
Modified CRichEdit::SetPunctuation
Modified CScrollBar::GetScrollRange
Modified CScrollBar::GetScrollInfo
Modified CScrollBar::SetScrollInfo
Modified CTab::GetItemRect
Modified CToolTip::AddTool 
Modified CToolTip::AdjustRect
Modified CToolTip::GetBubbleSize
Modified CToolTip::GetMargin
Modified CToolTip::GetToolInfo
Modified CToolTip::HitTest
Modified CToolTip::SetMargin
Modified CToolTip::SetToolRect
Modified CToolTip::SetToolInfo 
Modified CWceFrame::GetMenuBar
Modified CWnd::DrawAnimatedRects
Modified CWnd::GetDlgItemInt 
Modified CWnd::InvalidateRect
Modified CWnd::RedrawWindow  
Modified CWnd::ScrollWindow  	
Modified CWnd::ValidateRect

Modified CWinThread::CreateThread			now returns thread handle.
Modified CPropertyPage::OnApply				now returns BOOL
Modified CPropertyPage::OnOK				now returns void
Modified CPropertyPage::OnSetActive			now returns BOOL
Modified CPropertyPage::OnWizardBack		now returns BOOL
Modified CPropertyPage::OnWizardFinish		now returns BOOL
Modified CPropertyPage::OnWizardNext		now returns BOOL

Removed CDC::GetClipRgn
Removed CDocker::GetDockFromPoint
Removed CFrame::OnExitMenuLoop
Removed CTab::OnDestroy


Version 8.2
===========

New Features and Enhancements
----------------------------- 
* Added support for Common Dialogs
The following common dialogs have been added to the framework:
 - CColorDialog
 - CFindReplacDialog
 - CFileDialog
 - CFontDialog
 - CPrintDialog
 - CPageSetupDialog
 
The CPrintDialog and CPageSetupDialog classes share global memory for 
their hDevMode and hDevNames handles. This global memory persists after
the CPrintDialog and CPageSetupDialog objects are destructed, and is 
managed by CWinApp. There is no need for the user to manually lock,
unlock or free the hDevMode and hDevNames memory.
Note: CFile::OpenFileDialog and CFile::SaveFileDialog have been removed.
Use CFiledDialog for these instead.

* Updated CFrame
 - GetInitValues and SetInitValues have been added to conveniently store
   and retrieve a set of values from the registry or an INI file. These 
   functions replace a set of functions that stored and retrieved these
   values individually.

* Added GetAppDataPath
 - This function returns the path to the AppData folder. Applications 
   can create folders within AppData to store their data. 
   
* Updated samples
 - The INIFrame sample now stores the settings file in the AppData folder.
   It is important for applications to store values in the AppData folder
   on the more modern operating systems (Vista and above) as these don't
   allow the user to write to the "Program Files" folder.
   
* "New Projects" folder
 - This folder has been relocated to the samples folder. It is now more 
   convenient to use this as the starting point for your new projects.
   
* Added messages to retrieve the CWnd pointer. SendMessage can now be used
  to retrieve the window's CWnd pointer as an alternative to GetCWndPtr.
 - UWM_GETCWND returns the CWnd*
 - UWM_GETCFRAME returns the CWnd* for any object inherited from CFrame
 - UWM_GETCMDIFRAME returns the CWnd* for any object inherited from CMDIFrame
 - UWM_GETCDOCKER returns the CWnd* for any object inherited from CDocker
 - UWM_GETCDOCKCONTAINER returns the CWnd* for any object inherited from CDockContainer
 - UWM_GETCTABBEDMDI returns the CWnd* for any object inherited from CTabbedMDI
 - UWM_GETCTOOLBAR returns the CWnd* for any object inherited from CToolBar


Changes in detail
-----------------
Added CCommonDialog 			class
Added CColorDialog  			class
Added CFindReplaceDialog 		class
Added CFontDialog 				class
Added CPageSetupDialog 			class
Added CPrinDialog 				class
Added GetAppDataPath            function
Added CFile::GetFileDirectory	member function
Added CFile::GetFileNameExt		member function
Added CFile::GetFileNameWOExt	member function
Added CFrame::GetInitValues		member function
Added CFrame::SetInitValues		member function
Added UWM_GETCWND 				window message.
Added UWM_GETCFRAME 			window message.
Added UWM_GETCMDIFRAME 			window message.
Added UWM_GETCDOCKER 			window message.
Added UWM_GETCDOCKCONTAINER 	window message.
Added UWM_GETCTABBEDMDI 		window message.
Added UWM_GETCTOOLBAR 			window message.

Modified CWinThread::GetMainWnd				now returns HWND
Modified CWinThread::SetMainWnd				now accepts HWND
Modified CWinThread::GetAcceleratorWindow 	now returns HWND
Modified CWinThread::SetAccelerators		now accepts HWND

Renamed CWinThread::GetAccelerators to CWinThread::GetAcceleratorTable

Removed CFrame::GetShowCmd
Removed CFrame::GetShowStatusBar
Removed CFrame::GetShowToolBar
Removed CFrame::SetShowCmd
Removed CFile::OpenFileDialog
Removed CFile::SaveFileDialog
Removed CException::ReportError
Removed UWM_ISDOCKER		 	window message.
Removed UWM_ISDOCKCONTAINER	 	window message.
Removed UWM_ISFRAME			 	window message.
Removed UWM_ISMDIFRAME		 	window message.
Removed UWM_ISTABBEDMDI		 	window message.
Removed UWM_ISTOOLBAR		 	window message.

The following functions are now public:
CWinApp::GetCWndFromMap
CWinApp::GetTlsData
CWinApp::SetTlsData

Moved The "New Project" folder to samples


Version 8.1
===========

Important
---------
The definition of the following virtual functions have changed. You will 
need to update your code as accordingly. The current definitions are:
- CWnd::OnCreate(CREATESTRUCT& cs)
- CWnd::PreTranslateMessage(MSG& Msg)
- CThread::PreTranslateMessage(MSG& Msg)
Also:
- SDI Frame applications which require docking support should use CDockFrame.
- MDI Frame applications which require docking support should use CMDIDockFrame.
- CArchive and CFile now throw CFileExceptions
- CFile::Open throws a CFileException on failure and returns void.

New Features and Enhancements
----------------------------- 
* Added DDX/DDV
  CDataExchange provides support for Dialog Data eXchange(DDX) and Dialog Data 
  Validation(DDV). The CDataExchange class has a set of DDX and DDV member
  functions which perform the data exchange and validation for different types
  of controls. Typically this is used for controls in dialogs, but controls in
  any window support DDX and DDV.
  
  To use CDataExchange, perform the following steps:
   - Override DoDataExchange and specify the appropriate DDX and DDV functions.
   - Call UpdateData(FALSE) to initialize the controls and assign their values.
     This is typically done in the dialog's OnInitDialog function.
   - Call UpdateData(TRUE) to validate and retrieve the control data.	

  Refer to the DDXDemo sample for a demonstration of how to use CDataExchange

* Extended CString
   CString is now based on the CStringT template.
   CStringA is defined as CStringT<CHAR>. It is an ANSI only version of CString
   CStringW is defined as CStringT<WCHAR>. It is a UNICODE only version of CString.
   CString inherits from CStringT<TCHAR>. In addition to accepting TCHAR when 
   constructed, it also accepts CHAR and WCHAR. It is backwards compatible with
   the previous implementation of CString.
   Additional features added to CStringA, CStringW and CString:   
   - Added operator + support for ints and doubles.
   - Added operator += support for ints and doubles.
   - Added operator = support for ints and doubles.
   
* Updated CArchive
   - Added the ability to archive char and wchar character arrays. The abilty
     to archive TCHAR character arrays is retained.
   - Added the ability to archive CStringA and CStringW. The ability to
     archive CString is retained.	   
   
* Added CDockFrame.
   Inherit your CMainFrame from CDockFrame to add docking capabilities to normal
   Single Document Interface (SDI) frames. Frames which don't require docking 
   capabilities should inherit from CFrame. The use of CFrame instead of
   CDockFrame results in as smaller executable file size.
   Refer to the Dock, DockContainer, DockTabbeedMDI and Splitter samples for
   a demonstration of CDockFrame.

* Added CMDIDockFrame
   Inherit your CMainMDIFrame from CMDIDockFrame to add docking capabilities to
   Multiple Document Interface (MDI) frames. MDI Frames which don't require docking
   capabilities should inherit from CMDIFrame. The use of CMDIFrame instead of
   CMDIDockFrame results in a smaller executable file size.
   Refer to the DockMDI sample for a demonstration of CMDIDockFrame.
   
* Updated the exception handling
   - Added CException             ( inherits from std::exception )
   - Added CFileException         ( inherits from CException ) 
   - Added CNotSupportedException ( inherits from CException )
   - Added CUserException         ( inherits from CException )
   - Updated CWinException        ( inherits from CException )

   CFileExceptions are thrown under the following circumstance
    - CArchive fails to create the archive file
	- CArchive fails to read from or write to the archive file
	- CFile fails to create the file
	- CFile fails to read from or write to the file.
   
   CNotSupportedExceptions are thrown under the following circumstances:
    - An attempt is made to run more than one instance of CWinApp.
	- CWinApp is prevented from starting the framework.
	- CSocket fails to load the WS2_32.DLL.
	- CSocket fails to initialize the use of WS2_32.DLL.	
	
   CResourceExceptions are thrown under the following circumstances:
    An attempt to create a GDI resource fails. Applies to:
	   - device contexts
	   - bitmaps
	   - brushes
	   - fonts
	   - palettes
	   - pens
	   - regions
   
   CWinExceptions are now thrown under the following circumstances:
    * A failure to create a thread
    * A failure to create a window, including:
	   - generic windows
	   - dialogs
	   - property sheets
	   - task dialogs
	 
   CUserExceptions are thrown under the following circumstances:
    - A CDataExchange DDX or DDV function fails validation
	- A CUserException is typically the exception thrown in user code. 
   
   Notes:
    - Exceptions should be thrown by value, and caught by const reference.   
	- Catch CExceptions to catch all exceptions inherited from CException.
	- CException is an abstract class. CExceptions can't be thrown.
    - A failure to create a GDI resources occurs when too many GDI resources
      are allocated to the process. A GDI resource leak can cause this.  
	  
* Updated CWnd
   - Added OnPaint virtual function. OnPaint calls OnDraw for generic windows,
     but not for window controls. Users can now override OnPaint to draw to
	 window controls as an alternative to custom draw or owner draw.	 
   - Added DoDataExchange and UpdatedData to support CDataExchange. 	
  
* Updated CCriticalSection
  All critical sections are now guaranteed to be released when the
  CCriticalSection's destructor is called.
  
* Updated the documentation
   - Added 'Dialog Data Exchange (DDX and DDV)	to Using Win32++
   - Added 'Doc View Model'               		to Using Win32++
   - Added 'Serialization with CArchive'  		to Using Win32++
   - Extended 'CString'                  	 	in Using Win32++   


Changes in detail
-----------------
Split wxx_winutils.h into several header files as follows:
Added wxx_rect.h
Added wxx_textconv.h
Added wxx_themes.h
Removed wxx_winutils.h

Split wxx_wincore into several header files as follows:
Added wxx_appcore0.h
Added wxx_appcore.h
Added wxx_exception.h
Added wxx_wincore0.h
Retained wxx_wincore.h

Added CDataExchange class.
Added CDockFrame class.    Inherits from CFrame and CDocker
Added CMDIDockFrame class. Inherits from CMDIFrame and CDocker

Added DDXDemo Sample

Added UWN_TABCLOSE windows message notification
Added CTabbedMDI::OnTabClose
Added CWnd::DoDataExchange
Added CWnd::OnPaint
Added CWnd::SetDlgCtrlID
Added CWnd::UpdateData

Added CStringT class template
Added CStringA typedef
Added CStringW typedef
Modified CString. 	Now inherits from CStringT<TCHAR>
Added CStringT::GetWindowText

Added CException
Added CFileException
Added CNotSupportedException
Added CResourceException
Added CUserException

Added CArchive::GetFile
Added CArchive::ReadStringA
Added CArchive::ReadStringW
Added CArchive::WriteStringA
Added CArchive::WriteStringW
Added CArchive::operator<<(const CStringA& string);
Added CArchive::operator<<(const CStringW& string);
Added CArchive::operator>>(CStringA& s);
Added CArchive::operator>>(CStringW& s);

Added DirectX11 sample
Renamed the DirectX sample to DirectX9
Added project files for Visual Studio Community 2015

Modified CDC::CreateCompatibleDC 		returns HDC
Modified CDC::CreateDC 					returns HDC
Modified CDC::CreateIC 					returns HDC
Modified CFile::Open 	throws a CFileException on failure

These function no longer use a pointer:
Modified CMenu::GetMenuInfo
Modified CMenu::SetMenuInfo
Modified CMenu::GetMenuItemInfo
Modified CMenu::SetMenuItemInfo
Modified CMenu::InsertMenuItem
Modified CResizer::Initialize
Modified CToolBar::GetButton
Modified CToolBar::InsertButton
Modified CToolTip::RelayEvent
Modified CThread::PreTranslateMessage
Modified CWnd::OnCreate
Modified CWnd::IsDialogMessage
Modified CWnd::PreTranslateMessage

Modified CDocker::GetAllDockChildren		returns const ref
Modified CDocker::GetDockChildren			returns const ref
Modified CDocker::GetAllDockers				returns const ref
Modified CDockContainer::GetAllContainers	returns const ref
Modified CMDIFrame::GetAllMDIChildren		returns const ref
Modified CTab:: GetAllTabs					returns const ref

Updated theme colors for Windows 8, Windows 8.1 and Windows 10


Version 8.0.1
==============

New Features and Enhancements
----------------------------- 
* Win32++ is now system DPI (Dots Per Inch) aware.
  The manifest for each sample has been updated to support DPI aware.
  The size of the CFrame status bar and menu elements are now adjusted to
  accommodate the system's DPI settings. 
  
  Users may wish to detect the current DPI and their GUI layout accordingly
  to support different DPIs. Refer to:
  https://msdn.microsoft.com/en-us/library/windows/desktop/dn469266%28v=vs.85%29.aspx


Version 8.0
===========

New Features and Enhancements
----------------------------- 
* Added CArchive.
  CArchive provides a convenient means of saving and restoring an application's
  data, by streaming the data to and from a file.
  
* Added CObject
  CObject provides the Serialize virtual function which is used by CArchive. 
  Any class inherited from CObject can override Serialize to customize the
  way its data is saved in the archive. CWnd and CWinThread inherit from
  CObject. Classes created by the user can inherit from CObject as well.  
  
* Added CRegKey.
  CRegKey is a wrapper for functions used to access and modify the registry.  

* Added CTime and CTimeSpan
  CTime manages the display of date and time.
  CTimeSpan calculates the interval between times and dates.

* Added  GetCommandLineArgs
  This function provides access to the command line arguments. They are
  returned in a vector of CString.

* Added VERIFY macro
  In debug mode, VERIFY asserts if the expression evaluates to zero
  In release mode, VERIFY evaluates the expression, but doesn't assert
  
* Renamed Header files
  The header files located in the include directory have been prefixed 
  with wxx_ . This was done to avoid potential name conflicts with header
  files from other libraries.  

* Updated CFile
  - The nOpenFlags used in CFile::Open, and CFile's constructor continue to
    support the same file creation modes as before, but now support additional
	modes as well.
  	Possible nOpenFlag values: CREATE_NEW, CREATE_ALWAYS, OPEN_EXISTING, 
	    OPEN_ALWAYS, TRUNCATE_EXISTING
	 Default value: OPEN_EXISTING | modeReadWrite
	 The following modes are also supported:
	- CFile::modeCreate			Same as CREATE_ALWAYS.
	- CFile::modeNoTruncate		Same as OPEN_ALWAYS.
	- CFile::modeRead			Requests read access only.
	- CFile::modeWrite			Requests write access only.
	- CFile::modeReadWrite		Requests read and write access.
	- CFile::shareExclusive		Denies read and write access to all others.
	- CFile::shareDenyWrite		Denies write access to all others.
	- CFile::shareDenyRead		Denies read access to all others.
	- CFile::shareDenyNone		No sharing restrictions.
  - CFile now throws an exception under the following circumstances
    - Failure to read from a file.
    - Failure to write to a file.
    - Failure to open the file in CFile's constructor.
	

Changes in detail
-----------------
Added CArchive
Added CObject
Added CRegKey
Added CTime
Added CTimeSpan
Added CDocker::LoadContainerRegistrySettings
Added CFrame::SaveRegistryMRUSettings
Added CFrame::SetAccelerators
Added CMenu::FindMenuItem
Added CMenu::InsertPopupMenu
Added CWinException::GetText
Added CWinThread::PostThreadMessage
Added CWinThread::operator HANDLE()
Added ::GetCommandLineArgs

Added VERIFY macro
Added _WIN32XX_VER macro
Added INIFrame sample
Added TimeDemo sample

Modified CFile::CFile   	now throws an exception on fail to open file
Modified CFile::Read    	now	throws an exception on fail to read file
Modified CFile::Write       now throws an exception on fail to write file

Modified ::GetApp                          	now returns a reference
Modified CDockContainer::GetView            now returns a reference
Modified CDockContainer::GetViewPage        now returns a reference
Modified CDocker::GetView                   now returns a reference
Modified CDocker::GetAllDockChildren        now returns a reference
Modified CDocker::GetDockChildren           now returns a reference
Modified CDocker::GetAllDockers             now returns a reference
Modified CDockContainer::GetAllContainers   now returns a reference
Modified CMDIChild::GetMDIFrame             now returns a reference
Modified CMDIChild::GetView                 now returns a reference
Modified CTab::GetAllTabs                   now returns a reference
Modified CTabbedMDI::GetTab                 now returns a reference


Renamed the header files. They are prefixed with wxx_


Version 7.9
===========

Overview
--------
This version of Win32++ moves away from the use of pointers. Where before we 
would use pointers to objects in Win32++ function calls, we now use the objects
directly. The USE_OBSOLETE_CODE macro has been provided in this version to make
code migration easier. Even with this macro defined, you will need to use 
non-pointer arguments in Win32++ function calls.

New Features and Enhancements
-----------------------------
* The FromHandle method of creating temporary CWnds has been obsoleted. 
The FromHandle approach has been replaced. CWnd member functions which 
previously returned a CWnd pointer(CWnd*) now return CWnd. 
Coding examples: (The GetParent function now returns a CWnd)
 GetParent().SendMessage(SomeMessage, wParam, lParam);
 HWND hWnd = GetParent(); // retrieve the parent window's HWND
 
* The FromHandle for the other types has been obsoleted as well. This includes:
  - CBitmap::FromHandle
  - CBrush::FromHandle
  - CDC::FromHandle
  - CFont::FromHandle
  - CPalette:: FromHandle
  - CPen::FromHandle
  - CRgn::FromHandle
 
* Many functions which previously used a CWnd* argument now use a HWND
argument. This has the following advantages:
 - These functions can be used directly for a HWND, CWnd or CWnd pointer.
 - We no longer have to needlessly create temporary CWnds.
Coding examples: (the Create function now has a HWND argument)
 CWnd MyCWnd;
 MyCWnd.Create(Some_CWnd);	 // Another CWnd called Some_CWnd is the parent window 
 MyCWnd.Create(*this);       // This CWnd is the parent window. (dereferenced pointer)
 MyCWnd.Create(GetHwnd());   // This CWnd is the parent window.
 MyCwnd.Create(GetParent()); // The parent of this CWnd is the parent window
 MyCWnd.Create(Some_HWND);   // A window with the specified HWND is the parent window 
 MyCWnd.Create();            // The created window has no parent window
 
 Note: CWnd has operator overloading. We can use the CWnd object in place
 of its corresponding HWND anywhere in code.  

* Many functions which previously used pointers to other Win32++ classes
now also use the relevant handle instead. These include member functions for
CDC, CBitmap, CBrush, CFont, CPalette, CPen, CRgn, CImageList and CMenu.
Each of these classes have operator overloading, so the class object can be
used instead of the handle.

* CDC, CBrush, CBitmap, CFont, CPalette, CPen, CRgn, CMenu and CImageList.
 - These classes destroy the resource they manage when their destructor is
   called, but only if Win32++ created it. This allows us to attach resources
   provided by the operating system (HDCs, HFONTS, HIMAGELISTS etc.) without
   having to detach them later to prevent them from being destroyed.
 - These classes can be re-used. There is no need to detach the current
   handle before assigning a new one.
 - These classes use reference counting, so they can be safely copied. This
   allows them to be returned by value from functions.
   

Version 7.8
===========

New Features and enhancements
-----------------------------
* Updated CDC
   - Added palette support.
   - Added path support.
   - Added MaskBlt and TransparentBlt functions
   - Now able to retrieve GDI objects currently selected in the device context.

Version 7.7
===========

New Features and Enhancements
-----------------------------
* Frames now directly support docking
   Previously CFrames implemented docking through the view window. Now CFrame 
   inherits from CDocker and implements docking directly. Users can now add
   dockers to a frame that doesn't use a docker as the view window. 
   Alternatively users can implement docking through the view window as before.   

* MDI Frames directly support docking
   Dockers can now be added to classic MDI Frames. Code to add dockers to a
   MDI frame might look like this:
   
	void CMainMDIFrame::OnInitialUpdate()
	{
		// Add some dockers
		DWORD dwStyle = DS_CLIENTEDGE; // The style added to each docker
		int DockWidth = 150;
		AddDockedChild(new CDockFiles, DS_DOCKED_LEFT | dwStyle, DockWidth);
		AddDockedChild(new CDockFiles, DS_DOCKED_RIGHT | dwStyle, DockWidth);
		
		// Add some MDI children
		AddMDIChild(new CSimpleMDIChild);
		AddMDIChild(new CSimpleMDIChild); 		
	}
	
* Windows created by CWnd::Create can now be initially created as maximized or
   minimized by specifying the WS_MAXIMIZE or WS_MINIMIZE styles in PreCreate,
   even though this is not supported by the CreateWindowEx Windows API function.
   
* Frames now load the save state (maximized or normal) from the registry.   
	
* Added DockMDI sample.	
  This sample demonstrates adding Dockers to MDI Frames.
	
* Dockers now default to fixed size resizing instead of proportional size 
   resizing for dock children. The DS_FIXED_RESIZE style has been replaced with
   DS_NO_FIXED_RESIZE.	
	

Version 7.6
===========

New Features and Enhancements
-----------------------------
* Added StatusBar themes.
   StatusBars can fill the background with a color gradient. The two 
   colors can be specified by SetStatusBarTheme.
   
* Switching between views is now supported, using SetView
  The following classes support switching views:
   - Frames
   - MDI Children
   - Dockers
   - DockContainers
   
* Updated Frames
   - IDW_INDICATOR_CAPS, IDW_INDICATOR_NUM and IDW_INDICATOR_SCRL string
      resources are used to define the status indicators. These string
	  resources should be added to the resource script (resource.rc). Refer
	  to resource.rc in the frame sample for an example.
   
* Updated Dockers
   - Dock targets invalidated by DS_NO_DOCKCHILD_XXXX are hidden or greyed.
   - Click and drag tab swaps to swap them for DockContainers and TabbedMDIs.
   - Parent dockers have a minimum size.
   - Added support for DS_FIXED_RESIZE. Normally dock children are resized 
      proportionally, but with this style the size of dock children is fixed.
   - Dock containers with a single tab can hide the tab.
   - Improved hinting for container within container docking.
 
* Added support for vertical ToolBars and ReBars
   - Vertical ToolBars and ReBars can be themed by CFrame. These are 
      demonstrated in the ReBar and ToolBar samples. 
   
* Updated the samples
   - Added DateTime sample to demonstrate CDateTime and CMonthCalendar. 
   - Added ToolBar sample. It demonstrates customizing ToolBars by dynamically
      adding or removing ToolBar buttons. It also demonstrates an additional
	  ToolBar which can be positioned at the top, bottom, left or right of the
	  view window.
   - Added ReBar sample. It demonstrates an additional ReBar which contains 
      a ToolBar and can be positioned at the top, bottom, left or right of the
      view window.
   - Added StatusBar sample. It demonstrates a colored StatusBar with a
      hyperlink, a progress bar, an icon and an owner drawn part.	  
   - A window menu has been added to the DockTabbedMDI sample.
   - The Themes sample demonstrates how to save a rebar's band sizes and 
      positions in the registry.
   - The Themes sample demonstrates StatusBar themes.
   - The Dock sample demonstrates various dock styles including:
     - Proportional Resize
	 - 3D Border
	 - Disable Undocking
	 - Disable Resizing
	 - Disable Dock closing
	 - Disable docking on the left or right
	 

Version 7.5
===========
Bug Fixes:
* The drop-down lists for combo boxes are now displayed correctly.
* Fix for ToolBars on Win95

New Features and Enhancements
-----------------------------
* Added CRichEdit. This class provides support for Rich Edit controls
* Updated the approach to using threads
   - CWinThread is used in place of CThread.
   - CWinApp now inherits from CWinThread.
   - GUI threads are now implemented without multiple inheritance. Refer to
     the Threads and DirectX samples for an example of how to create GUI
	 threads.
   - CWinThread provides a constructor to facilitate worker threads. This 
     constructor allows users to specify the thread's callback function and
     a LPVOID pParams parameter.
   - The thread is now created using the CreateThread member function rather
     than being automatically created in the constructor. This provides more
	 control over if and when the thread is created.
* Updated CWinApp
   - CWinApp now inherits from CWinThread. Some member functions were moved
     from CWinApp to CWinThread.
   - Added wrapper functions for loading and setting the cursor, and loading 
	 icons.	   
* Updated CFrame
   - A keyboard hook is used to retrieve keyboard indicators (NUM, CAPS, SCRL),
     removing the need for a timer. 
   - If the co-ordinates retrieved from registry would place the frame off
     screen, the frame is repositioned.
   - Added GetTitle, SetTitle, GetStatusText and SetStatusText functions.	  
* Updated CDocker and CTab
   - CTabs and CDockers now support the WS_EX_LAYOUTRTL extended style. This
     style creates a window whose horizontal origin is on the right edge to 
	 better suite Arabic and Hebrew languages.
* Updated CDialog
   - Added support for OnIdle in modal dialogs. Modeless dialogs already have
     OnIdle support.  	 
* Updated FromHandle for CWnd, CDC, CBitmap, CBrush, CFont, CPalette, CPen, CRgn, 
   CImageList and CMenu. They have been moved from global to their classes.
* CWnd::FromHandlePernament has been added to retrieve a known CWnd for a HWND.
   Unlike CWnd::FromHandle, this function never creates a new CWnd. It returns
   NULL if the window handle is not found in the map of permanent CWnds.
* Updated the TabDemo and DockTabbedMDI samples. These now demonstrate using a
   dialog as the view window for the tab or docker.   



Version 7.4
===========
	 
New Features and Enhancements
-----------------------------
* Added CImageList. CImageList manages a collection of images (Image List).
* Added ToolBarDemo Sample. 
   - demonstrates ToolBar customization.
   - demonstrates adding and removing ToolBar buttons.
   - demonstrates saving and restoring ToolBar layout.
   - demonstrates changing the ToolBar's image list.
* Updated CWnd:
   - Modified OnCreate. It now provides a LPCREATSTRUCT. Any function overriding
      OnCreate will need to be modified too. 
   - Added OnAttach. It is called when a window is attached to a CWnd.
   - Added OnClose. It is called when a window asks to be closed (WM_CLOSE).
   - Added OnDestroy. It is called when a window is destroyed (WM_DESTROY).
   - CreateWindowEx now uses HMENU or UINT instead of CMenu*. This allows 
      the menu parameter to specify a menu for a parent window, or a window ID
      for a child window.   
* Updated CFrame:
   - Frames now use the IDW_READY resource for the "Ready" string.
   - CFrame no longer requires the number of images in the ToolBar bitmap to 
      equal the number of ToolBar buttons. The width of the button bitmap is
      now assumed to be equal to its height or a minimum of 16.
   - The code for ToolBar and MenuBar themes has been moved to CFrame, making it
      easier to customize. Also, the notifications (from WM_NOTIFY) are handled in
	  virtual functions, making them easier to override.   
   - ToolBars for DockContainers automatically use the Frame's ToolBar theme.
   - We can now specify the index of the image in AddToolbarButton.
* Updated CFile:
   - CFile functions are now virtual.
   - OpenFileDialog and SaveFileDialog allow the dialog's title to be specified.
* Updated CToolBar
   - SetButtonInfo can now be used to change a ToolBar button's image and 
      command ID.
   - Functions now use CImageList* instead of HIMAGELIST
   - Added support for ToolBar customization.
   - AddButton now also allows us to specify the image's index.
* Updated CDialog
   - Added GetDefID, GotoDlgCtrl, MapDialogRect, NextDlgCtrl, PrevDlgCtrl
	  and SetDefID.
   - The constructor no longer sets the dialog's parent. The parent of the dialog 
      (if any) is set when the dialog is created (with DoModal or DoModeless).  
* Updated CTab.
   - CTab now provides wrapper functions for all the Tab control macros.


Version 7.3
===========

New Features and Enhancements
-----------------------------
* Adjusted the frame's appearance
	- Updated the visual appearance of popup menus on systems using Windows Aero. On 
	  systems with Aero, popup menus are rendered with Windows Visual Styles. Systems
	  without Aero continue to use the Win32++ theme for popup menus.
	- Frames now honour the current window theme's menu and status fonts.
	- the frame's appearance changes dynamically to reflect changes to the window theme.
	- minor adjustment to the ReBar theme colours for the "Modern" theme.
* Added the following controls
   - CDateTime
   - CHeader
   - CHotKey
   - CIPAddress
   - CMonthCalendar
   - CTooltip

Version 7.2
===========

New Features and Enhancements
-----------------------------
* Added CString class
   The CString class is intended to provide much of the same functionality
   as the CString class provided with MFC/ATL.
* Added CMenu
   The CMenu class is intended to provide much of the same functionality
   as the CMenu class provided with MFC. The library now standardises on
   using pointers to CMenu, instead of HMENU.	
* Added CFile
   This class provides a convenient wrapper for functions dealing with files.
* Added Idle processing.
   The Idle processing is also available for use by users, and is used in much
   the same way as OnIdle processing in MFC.

Version 7.1
===========

New Features and Enhancements
-----------------------------
* Added support for Task Dialogs
* Added the following set of GDI classes: CBitmap, CBrush, CFont, CPalette, 
   CPen and CRgn. These work in cooperation with the existing CDC class.
* Added a set of new Text conversion functions based on classes.
   The complete set of functions are:
	A2BSTR		ANSI  to BSTR
	A2OLE		ANSI  to OLE
	A2T			ANSI  to TCHAR
	A2W			ANSI  to WCHAR
	OLE2A		OLE   to ANSI
	OLE2T		OLE   to TCHAR
	OLE2W		OLE   to WCHAR
	T2A			TCHAR to ANSI
	T2BSTR		TCHAR to BSTR
	T2OLE       TCHAR to OLE
	T2W			TCHAR to Wide
	W2A			WCHAR to ANSI
	W2BSTR		WCHAR to BSTR
	W2OLE		WCHAR to OLE
	W2T			WCHAR to TCHAR
   Refer to the help documentation for instructions on using these functions.

Version 7.0
===========

New Features and Enhancements
-----------------------------
* Added CThread class to simplify the task of using threads and creating
   windows in different threads. CThread can be used for both worker threads
   and GUI threads. Refer to the Thread and DirectX samples for examples of 
   how to use CThread to create windows in a different thread. The DirectX
   sample also uses a customized message loop for the thread.   
* Added the following control wrappers: CAnimation, CComboBox, CComboBoxEx,
   CProgressBar, CScrollBar, CSlider, and CSpinButton.  
* Added support for re-sizable dialogs. The CResizer class has been added
   to dialog.h to facilitate dialog resizing. Refer to the forms sample for
   an example of how to put CResizer to use.
* Added IPv6 support to CSocket. The network samples have been updated to
   take advantage of IPv6 support. IP version 6 is supported on Vista 
   operating systems and newer.
* Added Shared_Ptr class. Note that a "shared_ptr" will be available for the
   updated C++ standard. It is already available with some modern compilers,
   and also for users of the Boost library. The "Shared_Ptr" class is intended
   as an alternative for those users who would like to use a "shared_ptr", but
   don't have access to one yet. Unlike auto-ptr's, shared_ptr's can be used
   to safely store pointers in vectors and other STL containers.
* Added the GDIPlus sample to demonstrate how to use the GDIPlus library 
   provided with modern Windows operating systems (XP and above).
* Win32++ can now be run from inside a DLL. The "DLL" sample demonstrates how to
   put a Win32++ dialog in a dll, and run it from a test program.  


Version 6.9
===========

New Features and Enhancements
-----------------------------
* Added a WebBrowser class called CWebBrowser.  This class provides a web 
   browser in a window. This class can be used as a view window anywhere 
   view windows are used, such as in frames, dockers, MDI Children, 
   Tabbed MDIs etc.  It has no dependence on ATL, greatly simplifying the 
   approach to adding a browser window to any application.  It can be compiled
   by any of the supported compilers including Dev-C++, MinGW and the Borland 
   compilers as well as the compilers from Microsoft.  
* Added an ActiveX host class called CAXWindow.  
* Modified the Browser sample to use the new CWebBrowser class. It also 
   demonstrates how to use an event sink to get notification of browser events.
* Added a Tray sample which demonstrates how to create an application 
   which can be minimised to the system tray, and restored.  


Version 6.8
===========

New Features and Enhancements
-----------------------------
* Support has been added for the Windows Ribbon Framework available on 
   Windows 7 operating systems. The RibbonFrame and RibbonSimple samples 
   demonstrates how to implement the ribbon. RibbonFrame reverts back to 
   using the traditional Toolbar and Menubar if the operating system doesn't
   support the ribbon framework.  
* Helper classes have been added for the standard controls, namely the Button,
   Edit, Listbox, and Static controls.
* Dockers can now be hidden and unhidden. Refer to the Splitter sample for a
   demonstration of this feature.
* Modal dialogs now support pretranslated messages.          


Version 6.7
===========

New Features and Enhancements
-----------------------------
* A set of tools is now provided in the tools folder. They include a set of 
   batch files for compiling the examples and batch files to "clean" them.
* Support has been added for Right to Left languages which include Hebrew and 
   Arabic. The CFrame and CDocker classes now honour the WS_EX_LAYOUTRTL 
   extended style used by these languages. To take advantage of this feature,
   use PreCreate to set this extended when using CFrame, CMDIFrame, CTab, 
   CTabbedMDI, and CDocker.  
* OnInitialUpdate is now called after Attach or AttachDlgItem.   


Version 6.6
===========

New Features and Enhancements
-----------------------------
* Enhancements to docking, containers and tabs.
  - By default the dockers are immediately resized while the splitter bar is 
     being dragged. To defer resizing until the splitter bar is released, use
     SetDragAutoResize(FALSE).
  - The close and list buttons now indicate when they are hot and pressed.
  - Added SetTabText, SetTabImage and SwapTabs to the CTab class.
  - Minor improvements to the painting of tabs, containers and dockers.
* Enhancements to GDI graphics support.
  - The CDC class has been extended. It now includes wrapper functions for 
     the Device Context related functions.
  - Added the CBitmapInfoPtr class. This simplifies the use of the BITMAPINFO
     structure in functions like GetDIBits and SetDIBits.
  - Added GrayScaleBitmap function to gdi.h. It converts a colored bitmap to
     to gray-scale.     
* Enhancements to frames
  - When a menu is about to be displayed, OnUpdateMenu is called to provide
     an opportunity to modify the check state of the menu items.
  - The style of the rebarband is now specified in AddToolbarBand. This 
     facilities saving and restoring ToolBar settings from the registry (as 
     demonstrated in the Themes example.)  
  - The Frame's ShowToolbar and ShowStatusbar states are now saved in the
     registry.  
   

Version 6.5
===========

New Features and Enhancements
-----------------------------
* Precompiled Headers
   Samples now demonstrates the use of Precompiled Headers. More experienced
   users might prefer this approach as it provides for much faster compile times.
* Added CTab class. 
   This class is used by CContainer and CTabbedMDI, and can also be used as a
   view window.
* Added TabDemo example.
   Refer to the TabDemo example for a demonstration of how CTab class is
   used as a view window in a frame. TabDialogDemo also uses CTab. 
* Added CTabbedMDI class.
   A TabbedMDI can be used as a view window for a Frame or a Dockable. As the 
   name suggests, it provides tabs for a MDI window. 
* Added TabbedMDI example within docking.
   Refer to the docking TabbedMDI example for a demonstration of how CTabbedMDI
   class is used.
   
   
Version 6.4
===========

New Features and Enhancements
-----------------------------
* Docking:
  - Added tabbed docking container with optional ToolBar
  - Added close button to the caption of docked windows
  - Added 'outer' docking  i.e. docking at the side of the frame rather 
      than inside another Docker.
  - Added a second docking example demonstrating containers
  - Added save/restore dock layout to docking examples
  - Added Close All Dockables and Default Dock Layout to docking examples
  - Added Win98 and WinME support for docking. 
* Added Region support to CDC class.
* Updated the Notepad sample to handle Unicode text.
* Themes example now demonstrates a ComboBoxEx control in its ToolBar  
 

Version 6.3
===========

New Features and Enhancements
-----------------------------
* Added support for docking.
* Added the Fast GDI demo. This demonstrates the use of the TintBitmap function.
* MDI child windows now require a view window. The use of a view window is 
   now the same for Frames, MDI children, and dockables. The MDI demo example
   has been extended to include ListView and TreeView views.
* Added message translation. This allows modeless dialogs and propertysheets
   to process the tab (and other) keys.
* Added a CWnd::Destroy function. This returns a CWnd back to its default
   state ready to be reused.
* The Frame now stores which child window had focus before it is de-activated,
   and returns focus to this child when the frame application is reactivated.    
     

Version 6.2
===========

New Features and Enhancements
-----------------------------
* Frame applications now store the window size and position in the registry.
   To enable this, set the m_KeyName member variable in CMainFrame's 
   constructor. This member variable can be used to reflect the company name
   and application name, for example:  m_KeyName = _T("SomeCompany\\SomeApp");
* Frame applications now provide a Most Recently Used (MRU) list. This list is 
   stored in the registry.
* Extended CWnd
   CWnd now includes functions which wrap many of the Windows API functions
   that affect to windows. 


Version 6.1
===========

New Features and Enhancements
-----------------------------
* All Win32++ code has been moved to header files.
   This simplifies the use of Win32++. To add Win32++ to a project, simply 
   include the appropriate Win32++ header files in your code. There is no
   longer any need to add the Win32++ files to the project, although doing so
   may still prove useful under some circumstances. Depending on the 
   compiler/IDE used, adding the Win32++ header files to the project may add
   the various Win32++ classes to the class view.
* Added CListView class.
   This class encapsulates the various messages and macros used by the Win32/64 
   API to manage the List-View common control. You can inherit from this class
   when creating your own List-View control in a window, or attaching a 
  List-View control from a dialog.
* Added CTreeView class.
   This class encapsulates the various messages and macros used by the 
   Win32/64 API to manage the Tree-View common control. You can inherit from
   this class when creating your own Tree-View control in a window, or 
   attaching a Tree-View control from a dialog.
* Added CPoint CRect and CSize classes
   The CPoint, CRect and CSize classes can be used anywhere a POINT, RECT
   or SIZE struct is used.
* Added support for x64 applications.
   Win32++ can now be used to build 64 bit applications. The manifest file has 
   been modified to support both 32bit and 64bit applications. The new manifest
   should be used for any 64 bit applications that use common controls. Users
   are encouraged to use the modern Win64 API functions like:
   GetWindowLongPtr, SetWindowLongPtr, GetClassLongPtr and SetClassLongPtr.
   Win32++ will convert these back to their Win32 API counterparts if required.
* 32 bit bitmaps are now supported for toolbars (requires XP or Vista)


Version 6.0
===========

New Features and Enhancements
-----------------------------
* Win32++ now also directly supports the Windows CE operating systems. 
   Windows CE is the operating system used on such things as Pocket PCs, 
   embedded systems and SmartPhones. The Win32++ examples for Windows CE
   include the project files for eMbedded Visual C++ 4.0, and Visual 
   Studio 2005. 
* Added Networking support. Win32++ now includes a CSocket class which
   encapsulates much of the Winsock API. This class is capable of monitoring
   network events, such as connection requests from clients, and notification
   that the socket has data ready to be received. Command line and dialog
   examples are provide to demonstrate how the class can be used to create
   TCP/IP (and UDP/IP) servers and clients.
* Added a CDC class. This class simplifies the drawing to device contexts. 
   This class can be used anywhere we would normally use a handle to a 
   device context (HDC). Its features include:
   - Automates the selection of GDI objects into the device context.
   - Automates the destruction of GDI objects.
   - Automates the deletion or release of the device contexts.
* PreRegisterClass can now be used to set the WNDCLASS parameters before the
   window class is registered. This provides a convenient way to set a window's
   background brush or cursor. 
  
Version 5.6
===========
* Property sheets are now supported. Property sheets can be modal, modeless
  or Wizards.

Version 5.5
===========
* Added Menubar theme support
  - Gradient background for hot buttons (any two colors)
  - Gradient background for pressed buttons (any two colors)
  - Gradient Sidebar for menu items based on pressed button colors.
  - A border color for Menubar buttons and selected menu items


Version 5.4
===========
* Added Rebar themes, including:
  - Gradient background for the rebar control (any two colors)
  - Gradient background for the rebar bands (any two colors)
  - The Menubar can be locked in place.
  - The bands can be kept left.
  - Short bands
  - Bands can have rounded borders
  - Bands with rounded borders can have a flat style
* Added Toolbar themes, including:
  - Gradient background for hot buttons (any two colors)
  - Gradient background for pressed buttons (any two colors)
  - Colored outline for hot and pressed buttons (any color)
* CRebar provides built in support for multiple toolbars with AddToolbarBand

Version 5.3
===========
* Owner drawn drop down menu items with icons.  By default, the
   framework uses the ToolBar's bitmap and resource IDs for displaying 
   icons. Override CFrame::SetButtons to change this behavior.
* CreateEx automatically subclasses windows controls such as List-View, 
   ToolBar, Richedit etc.

   
Version 5.2
===========
* Added a separate HINSTANCE for resources. This provides for multilingual
   support, when resources are loaded via a DLL.

   
Version 5.1
===========
* Attach can be used to subclass existing windows and associate them with a CWnd.
* Dialog controls can be sublcassed and converted to CWnd objects, using 
   AttachDlgItem.
* Improvements to CToolbar. The ToolBar uses image lists which support using 
  separate bitmaps for normal, hot and disabled buttons. Text can be added
  to ToolBar buttons, and the style can be set.  
* Notifications from common controls are reflected back to the CWnd object that
  generated them. 
* Messages from old style common controls are reflected back to the CWnd object
  that generated them.
  

Version 5.0
===========
* Added rebars to the frame window
* Added a menubar to the frame window
* Added MDI frame support
* Added splitter window support


Version 4.0
===========
* Changed the method of associating the Window's handle (HWND) and 
   the CWnd pointer.  Previously SetWindowLong was used to store the 
   CWin pointer in the windows data area. Now std::map is used to 
   associate a CWnd pointer with the HWND (i.e. the window's handle).   
* Added the lpParam parameter to both versions of the CWnd::CreateEx
   function.  Users are now free to use lpParam for their own 
   purposes. This parameter defaults to NULL for backwards 
   compatibility.
        

Version 3.0
===========
* Added Tracing. To use tracing, ensure that you are in Debug mode, 
   i.e. the variable _DEBUG is defined, and use the TRACE("xxxxx")
   function to send trace messages.
* Enhanced the error reporting in the event of an exception. The 
   GetLastError information is now decoded and displayed if it 
   provides any additional information.
* Added support for multi-threaded applications.    
    

Version 2.0
===========
* The code is now Unicode compliant.
* Added CWinApp class to start Win32++.
* Added CDialog class to support modal and modeless dialogs as well
   as indirect dialogs (dialogs created from a dialog template in
   memory).
* Added the Create function to simplify window creation.
    

Version 1.0
===========
Initial Release