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

Changes
-------
* The default colour scheme has been changed from blue to grey. 
  The blue, olive and silver colour schemes continue to be used on Windows XP
  with themes enabled. 

New Features
------------
* Frame applications now store the window size and position in the registry.
To enable this, use the LoadRegistrySettings function in CMainFrame's constructor.
for example:
  LoadRegistrySettings(_T("CompanyName\\Application"));
  
* Frame applications now provide a Most Recently Used (MRU) list. This list is 
stored in the registry. To enable this, use the LoadRegistryMRUSettings function
in CMainFrame's constructor.

* Extended CWnd
CWnd now includes functions which wrap many of the Win32/Win64 API 
functions pertaining to windows. The new functions added are:
 Close Window
 EnableWindow
 GetClassLongPtr
 GetDlgItem
 GetWindowLongPtr
 GetWindowPlacement
 Invalidate
 InvalidateRect
 InvalidateRgn
 IsChild
 IsIconic
 IsEnabled 
 IsVisible
 IsWindow
 IsZoomed
 MoveWindow
 PostMessage
 RedrawWindow
 SendMessage
 SetActiveWindow
 SetCapture
 SetClassLongPtr
 SetFocus
 SetForegroundWindow
 SetRedraw
 SetWindowLongPtr
 SetWindowPlacement
 SetWindowRgn
 ShowWindow
 UpdateWindow
 ValidateRect
 ValidateRgn
 
 * Added ControlBars sample. 
 This demonstrates the use of a slider, scrollbar and progress bar control. 
 
 
 Notes for users of previous versions:
 -------------------------------------
 The names for the new functions in CWnd are the same as their Windows API
 counterparts. If your application fails to compile as a result of this,
 prepend the Windows API functions in your program with the global scope
specifier '::' (without the quotes).


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

New Features
------------
* 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 CSize struct can be used respectively. In addition:
- The constructors ensure that members are set to reasonable values.
  They also allow a default value to be set when the class is used as a 
  function argument.
- The classes have additional member functions, including operator==
  and operator!= .   
- These classes makes porting code from MFC or WTL a little easier.

* Extended the CRebar, CToolbar and CStatusbar classes.

* Removed CMDIApp
This class is no longer required, since it's functionality has been merged
with CWinApp. All applications (including MDI apps) now use CWinApp to start
Win32++.

* Modified CFrame
- renamed CFrame::GetClientSize to CFrame::GetViewRect

* Extended CWnd
- Added CWnd::GetClientRect
- Added CWnd::GetWindowRect



Notes for users of previous versions:
-------------------------------------
* There are no cpp files as part of Win32++ now, so these files need to be
  removed from your existing project when upgrading.
  
* CRebar, CStatusbar, and CToolbar have been moved to their own header files,
  but this does not require a change to existing user code.
 
* For MDI applications inherit from CWinApp rather than CMDIApp to start 
  Win32++.
  
* GetClientRect and GetWindowRect functions have been added to CWnd. If you
  prefer to use the native Win32/64 functions prefix them with the global
  scope specifier (::), for example ::GetClientRect(hwnd, &rc).

Version 6.02a
=============
Corrects a problem compiling Win32++ with Dev-C++ (or MinGW).

Version 6.02
============

New Features
------------
* 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.


Version 6.01
============
Added    CFrame::SetMenuIcons
Added    CFrame::SetToolbarImages
Removed  CToolbar::SetToolbarImageList
Added    CToolbar::SetBitmap
Moved    CreateDisabledImageList to CFrame::CreateDisabledImageList
Modified CFrame::AddMenuIcons

New Features:
------------
* 32 bit bitmaps are now supported for toolbars (requires XP or Vista)
* SetMenuIcons and AddMenuIcons now also accept a bitmap for disabled icons
   in addition to the bitmap for normal icons.


Bug Fixes: 
* The normal and hot toolbar buttons are now displayed correctly.
* Corrected some VC6 compatibility problems.
* CreateDisabledImageList now supports 32 bit images.


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

New Features
------------
* 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
   samples 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.
   
* Improvements to tracing. It now uses OutputDebugString to send the trace
   output the debug/output pane of the various IDE's. This is now also 
   compatible with debuggers, should you choose to use them. Previously the 
   tracing created a separate window to display text.

* Added an immediate mode to CSplitter. There is now the choice of resizing
   the panes while the splitter bar is being dragged, or defer the resizing
   until the splitter bar drag is complete (as before). CSplitter's 
   constructor now requires no arguments, making the class simpler to use.
   
* Automatically detects the XP theme used (Default, Silver or Olive), and
   adjusts the theme colors accordingly.
   
* Added project files for Borland's Turbo C++ 2006. This is a free compiler
   available from Borland. It can be downloaded here: 
   http://www.codegear.com/downloads/free/turbo

* Enhanced the tutorial. It now also demonstrates file operations and printing.

  
Other Changes:
--------------
* Changed the way windows are created. We no longer use a CBT hook as part of 
   the window creation process. It was this change which allowed Win32++ to
   directly support Windows CE.
   
* CWinApp no longer requires the application's hInstance in its constructor.   

Incompatibilities with previous versions:
-----------------------------------------
* CWinApp now uses a default constructor. This makes this class simpler to use,
   but existing applications will need to remove the hInstance function 
   argument from any class inherited from CWinApp or CMDIApp.

* Frame applications use the CDC class, so GDI.cpp will need to be added
   to existing projects.

* CSplitter now uses a default constructor. This simplifies the use of 
  CSplitter. The following functions can be used to set the CSplitter 
  parameters:
 - SetBarPos	sets the initial splitter bar position (default is 10)
 - SetBarColor   sets the color of the splitter bar (default is rebar color)
 - SetImmediate  sets immediate mode true or false (default is false)
 - SetVertical   sets vertical bar mode true or false (default is true)
 - SetWidth      sets the width of the splitter bar (default is 5)
 
* CWnd::GetCWndObject has been renamed to CWnd::FromHandle


Version 5.6
===========
* Added InitInstance to CWinApp. Code to create windows should now be
   placed in InitInstance instead of the constructor of the CWinApp
   derived class. Doing this allows the CWinApp derived class to be
   fully constructed before attempting to create windows. 
* Property Sheets are now supported. The files PropertySheet.cpp and 
   PropertySheet.h have been added to Win32++. These files define
   the CPropertySheet and CPropertyPage classes. The Property sheet generic 
   demonstrates the following:
  - Modal property sheets.
  - Modeless property sheets.
  - Wizards.
* The owner drawing of menus has been moved from CMenubar to CFrame. This
   has the following advantages:
  - Frames without rebars have themed menus.
  - Other popup menus belonging to CFrame (or CMainFrame) are themed.
  - Functions which customise the appearance of the menus are now located
     in CFrame. They are easily overridden for a different visual effect.     
* The icons used in popup menu items can come from several bitmap resources.
  When an application has several toolbars in a rebar, for example, the icons 
  from each of these can be displayed in popup menus.
* Added a colored rectangle around checkmarks.


Version 5.5
===========
* If a resource for disabled toolbar items isn't provided, an ImageList
   for disabled buttons is created for you. This imagelist is used for
   displaying disabled toolbar buttons, and disabled menu items with an icon.
* Updated Rebar themes
  - Improved rendering of non-toolbar bands during band repositioning
  - Round borders and flat style now supported in Win95, Win98 & WinME
* Updated Toolbar themes
  - Improved layout of images and text on toolbar buttons
  - Themed toolbar now supports TBSTYLE_LIST
* Added XP theme support for Visual Studio 6
* Icons for disabled popup menu items are now greyed
* 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)
* Built in support for multiple toolbars (in rebars) with AddToolbarBand
* Added Forms Sample
* Added Themes Sample


Version 5.3
===========
* Owner drawn drop down menu items with icons.  CMenubar::SetIcons is
   used to determine which menu items display an icon. By default, the
   framework uses the toolbar's bitmap and resource IDs for displaying 
   icons. Override CFrame::SetButtons to change this behavior.
* Automatic subclassing for windows using WinAPI defined window classes.
   Now when a window is based on predefined window classes, like the 
   common controls (e.g. list-view, tree-view, richedit), the window is
   automatically subclassed. There is now no need to call the subclass
   function in use code.   


Version 5.2
===========
* Added a separate HINSTANCE for resources. This provides for multilingual
   support, when resources are loaded via a DLL.
* The thread a CWnd object runs in is now determined when its window is 
   created, rather than when the CWnd object is instantiated.
* Added the Internet Browser Sample. It demonstrates how to host an ActiveX
   control in a Win32++ window. It requires ATL.
* Added the Performance sample. This program now also conducts a simple 
   performance test to measure the efficiency of the message handling. 

   
Version 5.1
===========
* Existing windows can be subclassed and converted to CWnd objects using Attach
* Dialog items 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.
* Improvements to CStatusbar.  
* 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
=========
* 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
=========
* 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.  The first TRACE(...) creates 
   the Trace output window.   
* 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
=========
* Now uses TLS to store our "this" pointer during window creation,
   instead of a global variable for thread safety.
* The code is now Unicode compliant.
* Added debug mode. Exceptions produce a warning in a message box
   if _DEBUG is defined. 
* 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).
* The instance handle of the application is stored as a member variable
   of CWinApp. You can access this via the GetApp global function
   e.g. GetApp()->GetInstanceHandle()
* Simplified window creation:
   The Create function has been added to provide a simple 
   method of creating a window with sensible defaults. Override this
   in your derived class to customise it further.
   Also, if the Window Class name is not provided, one is provided for
   you. The window class name provided is "Win32++ Window"
    

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