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 used by the Win32++ library for some internal processing. It is also available for use by users, and is used in much the same way as OnIdle processing in MFC. * Enhanced the CDC class, and added CWindowDC, CClientDC, CMemDC, CPaintDC and CMetaFileDC. The creation of the various different types of CDCs has been simplified, and the CDC functions now use CDC pointers instead of HDCs. These changes improve the compatibility between Win32++ and MFC. * Enhanced the various GDI object classes, namely CBitmap, CBrush, CFont, CPalette, CPen and CRgn, and added CGDIObject. The library now standardises on using pointers to theses classes instead of raw GDI handles (like HPEN). These changes improve the compatibility between Win32++ and MFC. Changes in detail ----------------- - Added CustomControl sample - Added CMenu - Added CString - Added CFile - Added CClientDC - Added CMemDC - Added CPaintDC - Added CWindowDC - Added CMetaFileDC - Added BSTR2A - Added BSTR2T - Added BSTR2W - Added FromHandle. Several global functions. They return pointers for: - CBitmap - CBrush - CFont - CPalette - CPen - CDC - CMenu - CWnd - Added CDC::Destroy - Added CDC::GetDCBrushColor - Added CDC::SetDCBrushColor - Added CDC::SelectObject (several versions) - Added CDC::SelectPalete - Added CDC::SelectClipRgn - Added CDC::SelectStockObject - Added CDocker::GetActiveDocker - Added CDocker::SetCaptionColors - Added CTab::SetTabIcon - Added CWinApp::GetAccelerators - Added CWinApp::OnIdle - Added CWinApp::PreTranslateMessage - Added CWinException::GetError - Added CWnd::ChildWindowFromPoint - Added CWnd::WindowFromPoint - Modified LoadString now returns CString - Modified CBrush::CreatePatternBrush now accepts a CBitmap pointer - Modified CDC::BitBlt now accepts a CDC pointer - Modified CDC::CreateCompatibleDC now accepts a CDC pointer and attaches the DC - Modified CDC::CreateDC now attaches the DC - Modified CDC::CreateIC now attaches the DC - Modified CDC::CreateCompatibleBitmap now accepts a CDC pointer - Modified CDC::CreateDIBitmap now accepts a CDC pointer - Modified CDC::CreateDIBSection now accepts a CDC pointer - Modified CDC::StretchBlt now accepts a CDC pointer - Modified CDocker::IsChildOfDocker now accepts a CWnd pointer instead of HWND - Modified CDocker::IsRelated now accepts a CWnd pointer instead of HWND - Modified CWnd::CreateEx now accepts a CMenu pointer - Modified CWnd::GetAncestor now accepts a gaFlags parameter - Modified CWnd::GetFont now returns a CFont pointer - Modified CWnd::GetMenu now accepts a CMenu pointer - Modified CWnd::GetNextDlgGroupItem now accepts a CWnd pointer - Modified CWnd::GetNextDlgTabItem now accepts a CWnd pointer - Modified CWnd::GetSystemMenu now accepts a CMenu pointer - Modified CWnd::GetUpdateRgn now accepts a CRgn pointer - Modified CWnd::GetWindowDC now returns a CDC pointer - Modified CWnd::HiliteMenuItem now accepts a CMenu pointer - Modified CWnd::InvalidateRgn now accepts a CRgn pointer - Modified CWnd::OnEraseBkgnd now accepts a CDC pointer - Modified CWnd::RedrawWindow now accepts a CRgn pointer - Modified CWnd::ReleaseDC now accepts a CDC pointer - Modified CWnd::ScrollWindowEx now accepts a CRgn pointer - Modified CWnd::SetFont now accepts a CFont pointer - Modified CWnd::SetMenu now accepts a CMenu pointer - Modified CWnd::SetWindowRgn now accepts a CRgn pointer - Modified CResizer::AddChild now accepts a CWnd pointer - Removed CLoadString - Removed CDC::AttachBitmap - Removed CDC::AttachBrush - Removed CDC::AttachFont - Removed CDC::AttachPalette - Removed CDC::AttachPen - Removed CDC::DetachBitmap - Removed CDC::DetachBrush - Removed CDC::DetachFont - Removed CDC::DetachPalette - Removed CDC::DetachPen - Removed CTab::SetTabImage - Removed GetWindowType for all CWnd classes - Renamed CDocker::GetDockTopLevel to CDocker::GetTopmostDocker - Renamed CWnd::OnPaint to CWnd::OnDraw - Extended the help documentation to describe the new features. - Added an index to the help documentation. Incompatibilities with previous versions ---------------------------------------- * The Win32++ now uses Run Time Type Information (RTTI). Older Microsoft compilers (Visual Studio 2003 and earlier) may need to enable the option to support RTTI. * LoadString now returns a CString. * CWnd::OnEraseBkgnd has changed. This function now uses a CDC pointer instead of a CDC reference. This change will need to be made for any function that overrides OnEraseBkgnd in order for it to get called. * CWnd::OnPaint has been removed and replaced with OnPaint. Code that previously overrode OnPaint will now need to override OnPaint instead. OnPaint uses a CDC pointer, not a CDC reference. * Changes made to the CDC class (and the addition of CClientDC, CWindowDC, CMemDC, etc.) are rather likely to affect existing code. - CDC functions now use a CDC pointer argument instead of a HDC. - CWnd functions like GetDC return a pointer to a CDC instead of a HDC. - use CClientDC for client window DCs instead of CDC MyDC = GetDC(). - use CWindowDC for window DCs instead of CDC MyDC = GetWindowDC(). - use CMemDC for memory DCs instead of CDC MyDC = CreateCompatibleDC(dc). - use CDC::FromHandle to conveniently convert a HDC provided to us by say CustomDraw to a CDC pointer. Coding example: CClientDC dcClient(this); // Create a client window DC for this CWnd CMemDC dcMem(&dcClient); // Create a Memory DC from the Client DC. CMemDC.CreatePen(PS_SOLID, 1, RGB(255,0,0); CMemDC.MoveTo(0, 0); CMemDC.LineTo(50, 50); dcClient.BitBlt(0, 0, cx, cy, &CMemDC, 0, 0); Version 7.1.3 ============= This version has some additional bug fixes: * Fixed a thread safety issue in CWinApp::SetTLSIndex introduced in version 7.1.2. * Added CWinApp::PreTranslateMessage to simplify overloading CWinApp::MessageLoop. * The Explorer sample now ends without throwing an exeption on Win2000. * CResizer now preserves the tab order in a dialog. Version 7.1.2 ============= This version has some additional bug fixes: * CDC Attach and CDC(HDC hDC) now succeed when the HDC is already attached to another CDC. * Fixed a resource leak in CTab::Paint which affected CTab, CTabbedMDI and CDockContainer * Tabs without owner draw now display their icons. * A CDC can now be reused after its HDC has been detached. * CBrush::CBrush(COLORREF crColor) now works as expected. * CResize now supports controls that issue WM_HSCROLL and WM_VSCROLL messages. Version 7.1.1 ============= Version 7.1.1 has some minor bug fixes for 7.1, namely: * Corrected an incorrect dock size when docking a docker. * Corrected a drawing error in the tutorials and scribble sample which occurred when dragging the mouse over the view window with the left button down. * Added a missing typedef for BSTR2T. 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. * Added CLoadString (and LoadString) to return a string resource. * OnEraseBkgnd is now called automatically when a CWnd's background needs erasing. Return TRUE to prevent default erasure. * Scribble Tutorial now demonstrates the use of command line arguments * Enhanced CResizer. - The anchor points are now fixed instead of proportional - Scrollbars are now added when required. - Added the DialogResizing sample to demonstrate CResizer's new features. * Create now use a CWnd pointer instead of a HWND when specifying the parent window. * Dialogs and Property Sheets now use a CWnd pointer instead of a HWND when specifying the parent window. * CTab has been enhanced. The TCS_FIXEDWIDTH and TCS_OWNERDRAWFIXED styles are now optional. * Extended the CSize, CPoint and CRect classes * Extended CMDIFrame and CMDIChild. CMDIChild::SetHandles is now used to set the MDI child's menu and accelerator table. * A docker can now be resized while docked using CDocker::SetDockSize. * Extended the "Using Win32++ section of the Win32++ help documentation. Changes in detail ----------------- - Added CBitmap - Added CBrush - Added CFont - Added CPalette - Added CPen - Added CRgn - Added CTaskDialog - Added CLoadString - Added LoadString (uses CLoadString, replaces CWnd::LoadString) - Added tStringStream typedef (a TCHAR stringstream) - Added A2BSTR - Added A2OLE - Added A2T - Added A2W - Added OLE2A - Added OLE2T - Added OLE2W - Added T2A - Added T2BSTR - Added T2OLE - Added T2W - Added W2A - Added W2BSTR - Added W2OLE - Added W2T - Added CDC::AttachPalette - Added CDC::CreatePalette - Added CDC::CreateHalftonePalette - Added CDC::DetachPalette - Added CDC::GetBitmap - Added CDC::GetBitmapInfo - Added CDC::GetBrusg - Added CDC::GetBrushInfo - Added CDC::GetFont - Added CDC::GetFontInfo - Added CDC::GetPen - Added CDC::GetPenInfo - Added CDC::ExtSelectClipRgn - Added CDC::ExcludeClipRect - Added CDC::GetClipBox - Added CDC::GetClipRgn - Added CDC::GetRgn - Added CDC::IntersectClipRect - Added CDC::OffsetClipRgn - Added CDC::PtVisible - Added CDC::RectVisible - Added CDC::SelectClipRgn - Added CDialog::AttachItem - Added CDockContainer::SetActiveContainer - Added CDocker::Close - Added CDocker::SetCaptionHeight - Added CFrame::GetFrameAccel - Added CFrame::ShowMenu - Added CMDIChild::GetMDIFrame - Added CMDIChild::SetHandles - Added CMDIFrame::GetMDIClient - Added CMDIFrame::MDICascade - Added CMDIFrame::MDIIconArrange - Added CMDIFrame::MDIMaximize - Added CMDIFrame::MDINext - Added CMDIFrame::MDIPrev - Added CMDIFrame::MDIRestore - Added CMDIFrame::MDITile - Added CResizer::GetMaxRect - Added CResizer::GetMinRect - Added CResizer::HandleMessage - Added CTab::GetListMenu - Added CTab::SetFixedWidth - Added CTab::SetOwnerDraw - Added CTabbedMDI::GetListMenu - Added CWinApp::SetAccelerators - Added CWnd::BeginPaint - Added CWnd::ClientToScreen - Added CWnd::CheckRadioButton - Added CWnd::DlgDirList - Added CWnd::DlgDirListComboBox - Added CWnd::DlgDirSelectEx - Added CWnd::DlgDirSelectComboBoxEx - Added CWnd::DrawAnimatedRects - Added CWnd::DrawCaption - Added CWnd::EndPaint - Added CWnd::GetDesktopWindow - Added CWnd::GetNextDlgGroupItem - Added CWnd::GetNextDlgTabItem - Added CWnd::GetSystemMenu - Added CWnd::GetUpdateRect - Added CWnd::GetUpdateRgn - Added CWnd::HiliteMenuItem - Added CWnd::IsDialogMessage - Added CWnd::IsDlgButtonChecked - Added CWnd::MapWindowPoints - Added CWnd::OnEraseBkgnd - Added CWnd::Print - Added CWnd::ScreenToClient - Added CWnd::SendNotifyMessage - Modified CDialog now takes a CWnd pointer instead of HWND - Modified CResizer::AddChild now takes a CWnd reference - Modified CWnd::Create now takes a CWnd pointer instead of HWND - Modified CWnd::CreateEx now takes a CWnd pointer instead of HWND - Moved CWnd::LoadBitmap to LoadBitmap - Removed CDC::AttachClipRgn - Removed CDC::DetachClipRgn - Removed CMDIChild::SetChildMenu - Renamed CDocker::GetDockWidth to CDocker::GetDockSize - Renamed CDocker::SetDockWidth to CDocker::SetDockSize - Renamed CDC::AttachClipRegion to CDC::AttachClipRgn - Renamed CDC::DetachClipRegion to CDC::DetachClipRgn - Replaced CharToWide with A2W - Replaced CharToTChar with A2T - Replaced TCharToChar with T2A - Replaced TCharToWide with T2W - Replaced WideToChar with W2A - Replaced WideToTChar with W2T - Replaced CWnd::LoadString with CLoadString (and ::LoadString) - Added several functions to CPoint - Added several functions to CSize - Added many functions to CRect The problem with the previous the text functions ------------------------------------------------ While the previous text conversion functions generally worked well, there were ambiguities about usage, and corner cases where they produced undesirable results. For example: // Problem 1 // This worked well ExampleFunction(CharToTChar(pAnsi1)); // But this failed to produce expected results ExampleFunction(CharToTChar(pAnsi1), CharToTChar(pAnsi2)); Problem 2 // This worked as expected LPCTSTR pStr = CharToTChar(pAnsi1); // But this fails to work as expected LPCTSTR pStr1 = CharToTChar(pAnsi1); LPCTSTR pStr2 = CharToTChar(pAnsi2); The new text conversion functions (classes) resolve problem 1 and render all of problem 2's usage invalid (making usage less ambiguous). Refer to the "Text Conversions" topic in the "Using Win32++" section of the help documentation that ships with Win32++ for information on how to use the new functions. Incompatibilities with previous versions ---------------------------------------- * The old text conversion functions have been replaced with a set of new functions which look and behave more like the functions used in MFC, ATL and WTL. * Windows, dialogs and property sheets now use a CWnd pointer instead of a HWND to specify the parent window. * CTab defaults to not using the CS_FIXEDWIDTH and TCS_OWNERDRAWFIXED styles. The SetFixedWidth and SetOwnerDraw functions can be used to change these styles. * Users of Borland's C++ compiler version 5.5 will need to install the compiler's service pack 2 for stringsteam support. * MDI Children use SetHandles instead of SetChildMenu to set the menu. SetHandles also sets the MDI child's accelerator table (if any). * LoadString now returns a tString instead of a LPCTSTR. Version 7.0.2 ============= * Fix for a memory leak in CDC * Fix for accelerators in WinCE * Fix for menu check marks when themes are disabled * Fix for OnMessageReflect in dialogs Version 7.0.1 ============= * Supports the latest version of MinGW compiler * DialogProc now returns INT_PTR instead of BOOL * Fixed several x64 warnings * Fixed DragAcceptFiles error when WIN32_LEAN_AND_MEAN is defined * Added OnPaint to CDialog and CPropertyPage * Minor update to the documentation * Added targetver.h to samples * Supports VS2010's resource editor Incompatibilities with previous versions ---------------------------------------- DialogProc now returns INT_PTR instead of BOOL. This change will be required in user code as well. Version 7.0 =========== New Features and Enhancements ----------------------------- * The following function now return CWnd* instead of HWND: GetActiveWindow, GetAncestor, GetCapture, GetFocus, GetDlgItem, GetWindow, GetLastAtivePopup, GetParent, GetTopWindow, SetActiveWindow, SetCapture, SetFocus, and SetParent. This helps the framework to be more object orientated, by allowing the programmer to work more directly with CWnds. It also reduces the need to convert between CWnds and HWNDs in user code. If a CWnd object for the HWND doesn't already exist, Win32++ creates a temporary CWnd. The pointers returned by these functions should not be stored and used later, as they might not be valid then. * 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. * Renamed CToolbar to CToolBar, CStatusbar to CStatusBar, CRebar to CReBar and CMenubar to CMenuBar. This matches the MFC names, and is also more consistent with Win32++'s naming conventions. * 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. * Extended the CToolbar class. * 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. * Dialogs and Property Sheets now use DWLP_MSGRESULT to automatically handle the value returned by notifications in their message handling. This allows a dialog's controls to use custom draw. * Improved the appearance of frames without themes. The frame sample demonstrates how override CMainFrame::OnCreate to customize the frame's appearance. * Asserts are used more liberally to test for programming errors. Any message sent to a non-existent window, for example, will now assert. More asserts are intended to help users write code that is more robust. Note that asserts are only evaluated in Debug mode, and have no effect in Release mode. * Exceptions are thrown less often. They are now thrown to indicate a critical problem, outside the programmer's control. Throwing fewer exceptions results in slightly smaller executables, and gives users more flexibility and control over their own exception methodology. They are thrown when: - a window creation fails. - a critical dll cannot be loaded. - a window message cannot be routed to a CWnd object. - an attempt to read from or write to the registry fails unexpectedly. * Vectors are now used as a replacement for all dynamically allocated arrays, ensuring the arrays are automatically deleted when they go out of scope. Creating an array with "new" runs the risk of causing a memory leak, particularly when an exception is thrown. Using a vector to create the array guarantees that it will be deleted properly under all circumstances. * The OnPaint function now uses a CDC reference as its argument instead of a HDC. This simplifies the task of using a CDC when overriding OnPaint. * Extended the help documentation. Changes in detail ----------------- Added CAnimation Added CComboBox Added CComboBoxEx Added CProgressBar Added CResizer Added CScrollBar Added CSlider Added CSpinButton Added Shared_Ptr Added CThread Updated CSocket to support IPv6 Added CMDIChild::MDIActivate Added CMDIChild::MDIDestroy Added CMDIChild::MDIMaximize Added CMDIChild::Restore Added CPropertySheet::SetIcon Added CPropertyPage::SetWizardButtons Added CPropertyPage::QuerySiblings Added CRebar::SizeToRect Added CSocket::IsIPV6Supported Added CSocket::FreeAddrInfo Added CSocket::GetAddrInfo Added CSocket::GetLastError Added CTabbedMDI::SetActiveMDITab Added CToolBar::AddButtons Added CToolBar::AddString Added CToolBar::AutoSize Added CToolBar::CheckButton Added CToolBar::DeleteButton Added CToolBar::GetButton Added CToolBar::GetButtonSize Added CToolBar::GetButtonText Added CToolBar::GetDisabledImageList Added CToolBar::GetHotItem Added CToolBar::GetImageList Added CToolBar::GetPadding Added CToolBar::GetRect Added CToolBar::GetRows Added CToolBar::GetTextRows Added CToolBar::GetToolTips Added CToolBar::HideButton Added CToolBar::Indeterminate Added CToolBar::InsertButton Added CToolBar::IsButtonHidden Added CToolBar::IsButtonHighlighted Added CToolBar::IsButtonIndeterminate Added CToolBar::IsButtonPressed Added CToolBar::MapAccelerator Added CToolBar::MarkButton Added CToolBar::MoveButton Added CToolBar::PressButton Added CToolBar::SaveRestore Added CToolBar::SetDisabledImageList Added CToolBar::SetDrawTextFlags Added CToolBar::SetExtendedStyle Added CToolBar::SetHotImageList Added CToolBar::SetHotItem Added CToolBar::SetImageList Added CToolBar::SetIndent Added CToolBar::SetMaxTextRows Added CToolBar::SetPadding Added CToolBar::SetToolTips Added CWinException::what Added CWnd::DragAcceptFiles Added CWnd::GetActiveWindow Added CWnd::GetCapture Added CWnd::GetFocus Added CWnd::GetFont Added CWnd::GetIcon Added CWnd::GetLastActivePopup Added CWnd::GetTopWindow Added CWnd::GetWindowTextLength Added CWnd::OpenIcon Added CWnd::SetFont Added CWnd::SetIcon Added CWnd::SetWindowTheme Added CWnd::ShowOwnedPopups Added CWnd::ShowWindowAsync Added CWnd::WindowFromDC Added ::IsAeroThemed Modified CPropertyPage::Apply now returns int Modified CPropertyPage::OnKillActive now returns BOOL Modified CPropertyPage::OnOK now returns int Modified CPropertyPage::OnSetActive now returns int Modified CPropertyPage::OnWizardBack now returns int Modified CPropertyPage::OnFinish now returns BOOL Modified CPropertyPage::OnWizardBack now returns int Modified CPropertyPage::OnWizardFinish now returns BOOL Modified CPropertyPage::OnWizardNext now returns int Modified CSocket::Bind now uses TCHAR instead of char Modified CSocket::Connect now uses TCHAR instead of char Modified CSocket::Receive now uses TCHAR instead of char Modified CSocket::ReceiveFrom now uses TCHAR instead of char Modified CSocket::Send now uses TCHAR instead of char Modified CSocket::SentTo now uses TCHAR instead of char Modified CWinException::what now outputs text to debugger Modified CWnd::OnPaint now takes a CDC& argument instead of HDC Renamed CMenubar to CMenuBar Renamed CRebar to CReBar Renamed CStatusbar to CStatusBar Renamed CToolbar to CToolBar Renamed RebarTheme to ReBarTheme Renamed ToolbarTheme to ToolBarTheme Renamed CToolBar::AddToolbarButton to CToolBar::AddButton Moved CWnd::CharToTChar to ::CharToTChar Moved CWnd::CharToWide to ::CharToWide Moved CWnd::TCharToChar to ::TCharToChar Moved CWnd::TCharToWide to ::TCharToWide Moved CWnd::WideToChar to ::WideToChar Moved CWnd::WideToTChar to ::WideToTChar Removed CWinException::MessageBox Removed CPropertySheet::QuerySiblings Added DS_NO_CLOSE style to suppress the closing of docked dockers Added DS_FIXED_RESIZE style to perform a fixed (not proportional) resize on dock children Added WM_PAINT handler to CDialog::DialogProcDefault Added WM_PAINT handler to CPropertyPage::DialogProcDefault Added GDIPlus sample Updated Network samples Updated FormDemo sample Incompatibilities with previous versions ---------------------------------------- * The OnPaint function definition has changed to: virtual void OnPaint(CDC& dc); The older OnPaint function will be ignored. * The stricter testing with asserts might reveal previously hidden errors in user's code. * Some CSocket functions take TCHAR as an argument instead of char. * CFrame::LoadRegistrySettings, CFrame::LoadRegistryMRUSettings and CFrame::SaveRegistrySettings return BOOL. * CPropertySheet.m_PSH is now private. Use SetIcon to set the icon. * CPropertyPage change the return types of several functions. * Replace all instances of "Menubar" with "MenuBar" * Replace all instances of "Rebar" with "ReBar" * Replace all instances of "Statusbar" with "StatusBar" * Replace all instances of "Toolbar" with "ToolBar" * The following functions now return a CWnd pointer instead of a HWND: GetActiveWindow, GetAncestor, GetCapture, GetFocus, GetDlgItem, GetWindow, GetLastAtivePopup, GetParent, GetTopWindow, SetActiveWindow, SetCapture, SetFocus, and SetParent. 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. * The CTab, CMDITab, CDocker and CDockContainer classes are now flicker free, providing a more professional look during resizing and docker moving. * Improved the dock targeting and dock hinting. * Introduced a new set of text conversion functions to convert between Ansi, Unicode and Wide characters. * CWnd objects can now report their type with GetWindowType. * 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. * The visual editor that ships with VS2008 and VS2010 can now be used to modify the resource files (Resource.rc and resource.h) without mangling them. Changes in detail ----------------- Added CAXWindow Added CWebBrowser Added CWnd::CharToWide Added CWnd::WideToChar Added CWnd::TCharToWide Added CWnd::WideToTChar Added CWnd::CharToTChar Added CWnd::TCharToChar Added CWnd::GetClassName Added CWnd::GetDlgItemText Added CWnd::GetWindowText Added CWnd::GetWindowType Added CWnd::KillTimer Added CWnd::SetTimer Added GetSizeofMenuItemInfo Removed CharToTString Removed TCharToString Removed TCharToWide Removed CWnd::GetWindowString Removed CWnd::GetClassString Removed CWnd::GetDlgItemString Removed CWnd::IsContainer Removed CWnd::IsDocker Removed CWnd::IsFrame Removed CWnd::IsMenubar Removed CWnd::IsMDIChild Removed CWnd::IsMDIFrame Removed CWnd::IsRebar Removed CWnd::IsStatusbar Removed CWnd::IsTab Removed CWnd::IsTabbedMDI Removed CWnd::IsToolbar Renamed CContainer to CDockContainer Modified Browser Sample Added MDIFrameSplitter demo Added Tray demo Incompatibilities with previous versions ---------------------------------------- * CContainer has been renamed to CDockContainer * The global string functions CharToTString, TCharToString and TCharToWide have been replaced with CWnd::CharToWide, CWnd::WideToChar, CWnd::TCharToWide, CWnd::WideToTChar, CWnd::CharToTChar and CWnd::TCharToChar. Version 6.8 =========== New Features ------------ * 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. Changes ------- Added CButton class Added CEdit class Added CListBox class Added CRibbon class Added CRibbonFrame class Added CStatic class Removed CSplitter class Added CDocker::Dock Added CDocker::DockInContainer Added CDocker::Hide Added CDocker::Undock Added CDocker::UndockContainer Added CFrame::GetRebarTheme Added CFrame::GetToolbarTheme Added CFrame::GetMRUEntries Renamed ThemeMenu to MenuTheme Renamed ThemeRebar to RebarTheme Renamed ThemeToolbar to ToolbarTheme Renamed CFrame::GetThemeMenu to CFrame::GetMenuTheme Added UWM_GETMENUTHEME message Added UWM_GETREBARTHEME message Added UWM_GETTOOLBARTHEME message Added RibbonFrame sample Added RibbonSimple sample Added 'Compile VS2005 Express' tool Added 'Compile VS2008 Express' tool Added 'Compile VS2010 Express' tool Added PreTranslate Message support for modal dialogs Bug Fixes --------- - Fixed TCharToString - Dockers can now be used as the view for CMDIChild Version 6.7 =========== Bug fixes: - Fixed dialog destruction - Fixed thread safety when creating multi-threaded windows simultaneously - Fixed TintBitmap for 16 bit colours - The close button on docked dockers now works. - Fixed PreTranslateMessage Changes ------- * The directory layout of Win32++ has changed. It now contains the following folders: help The help for Win32++ include The Win32++ library for typical use lib The static library files when they are build Library Projects The project files used to build the static library new projects A set of projects to be used in your new projects src The Win32++ library for building the static library tests A directory which contains the output of some tools tools A set of useful batch files for Win32++ * The Win32++ include directory is specified within the project rather than hard coded into the source files. To specify a different location for the Win32++ files in a project, specify the "Additional Include Directories" for both "C/C++" and "Resources". * The projects now provide the option of compiling with a static library or directly from the file in Win32++\include. To build the static libraries, see below. * A set of projects have been supplied to build the Win32++ into a static library. These projects are contained within the Win32++\Library Projects folder. The lib file created is placed within the lib directory. * The projects are now configured to take advantage of precompiled headers. * 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. * The CDC class has been extended. Several functions have been added, and CDC::GetDC has been renamed to CDC::GetHDC. * 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. * IsChild now takes a HWND argument. * Win32++ is now available as a single download, rather than a collection of files. * Each program example now has a Readme.txt file which describes what it does, and the features it demonstrates. Version 6.6 =========== Changes ------- * The number of arguments have changed for WndProc and WndProcDefault. - The HWND parameter has been dropped in both of these functions. It's presence was redundant and possibly confusing. Users will need to modify their WndProc and WndProc functions accordingly. If needed, the m_hWnd member variable can be used in place of hwnd within the WndProc function. * The number of arguments have changed for DialogProc and DialogProcDefault. - The HWND parameter has been dropped in both of these functions. It's presence was redundant and possibly confusing. Users will need to modify their WndProc and WndProc functions accordingly. If needed, the m_hWnd member variable can be used in place of hwnd in the WndProc function. * 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. * Automated menu updating. - When a menu is about to be displayed, OnUpdateMenu is called to provide an opportunity to modify the check state of the menu items. * Enhancements to frames - 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. * Modification to CRect class - The various function now use references instead of naked pointers. * Updated the Themes example. - Added check boxes for the various rebar theme option - Added Hide/Show option for the additional toolbars - Save/Load the theme options in the registry - Save/Load the rebar band positions and styles in the registry * Replaced the Form example with the DocViewForm example. - This example now demonstrates a form using a Doc/View architecture, much like the traditional Doc/View of MFC. - Added OnUpdateMenu handling. * Updated the FastGDI example. - Added gray-scale transformation - Added file save. - Added Scroll bars. * Updated the picture example. - Added Scroll bars. * Updated the DockContainer and DockTabbedMDI examples - These examples now demonstrate how to theme a container's toolbar. Incompatibilities with previous versions ---------------------------------------- - WndProc now takes 3 arguments, not 4: WndProc(UINT uMsg, WPARAM wParam, LPARAM lParam); - WndProcDefault now takes 3 arguments, not 4: WndProcDefault(UINT uMsg, WPARAM wParam, LPARAM lParam); - DialogProc now takes 3 arguements, not 4: DialogProc(UINT uMsg, WPARAM wParam, LPARAM lParam); - DialogProcDefault now takes 3 arguements, not 4: DialogProcDefault(UINT uMsg, WPARAM wParam, LPARAM lParam); - CFrame::AddToolbarBand now requires three arguements - The various CRect functions use references to RECT rather than pointers - CWnd::IsVisable has been renamed to CWnd::IsWindowVisible - CWnd::IsEnabled has been renamed to CWnd::IsWindowEnabled Version 6.5 =========== Major Changes ------------- * Added StaticLibrary example This example has the code to build Win32++ into a a static library, and also 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. * Enhancements to docking. - Dockers can now be docked into, and undocked from all other dockers, including those that are undocked. - Containers can also be docked into and undocked all from containers, including those that are undocked. - Containers can display their tabs at the top or bottom of the window. - Containers can also display a tab list button. - Docker and container objects are destroyed when their window is closed. - CContainer::SetupToolbar can be used to specify the toolbar's resource IDs. - Dockers and containers can save their layout in and load their layout from the registry. * Improvements to toolbars - Resource IDs should be specified in SetupToolbar, rather than CMainFrame's constructor. - Other configurations for the toolbar such as disabled buttons and alternate bitmaps should be specified in SetupToolbar, rather than in OnCreate. - Configuration of additional toolbars if any should also be done in SetupToolbar. Refer to the Themes example for a demonstration of this. - CToolbar now holds the vector of Resource IDs, which can be retrieved with the GetToolbarData function. There is no need to specify a vector when adding additional toolbars. - There is now no need to specify the number of toolbar buttons in the AddBitmap, ReplaceBitmap, SetBitmap and SetImages functions. - The AddToolbarButton can now add a toolbar button which is initially disabled. - There is no need to call SetButtons when adding additional toolbars. - Tooltips for all toolbars in the rebar are now displayed. * MIN and MAX macros have been defined and can be used in place of min and max. This avoids incompatibilities between the way different compliers support these macros. It also avoids clashes between the macro definitions of min and max, and the STL definitions of min and max. All Changes ----------- Added CTab class Added CTabbedMDI class Added TabDemo example Added Docking TabbedMDI example Added CFrame::SetupToolbar Added CFrame::m_bUseToolbar Added CContainer::SetupToolbar Added CDocker::GetDockTopLevel Added CDocker::GetContainer Added CDocker::GetTabbedMDI Added CDocker::IsRelated Added CDocker::LoadRegistrySettings Added CDocker::NewDockerFromID Added CDocker::SaveRegistrySettings Added CToolbar::GetToolbarData Added CWnd::GetClassString Added CWnd::IsFrame Added CWnd::IsMenubar Added CWnd::IsRebar Added CWnd::IsTabbedMDI Added CWnd::IsToolbar Changed CFrame::SetToolbarImages Changed CToolbar::SetImages Changed CToolbar::SetBitmap Changed CToolbar::AddBitmap Changed CToolbar::ReplaceBitmap Renamed CDockable to CDocker Renamed CDocker::CheckDockables to CDocker::VerifyDockers Renamed CFrame::OnFrameDrawItem to CFrame::OnDrawItem Renamed CFrame::OnFrameExitMenuLoop to CFrame::OnExitMenuLoop Renamed CFrame::OnFrameInitMenuPopup to CFrame::OnInitMenuPopup Renamed CFrame::OnFrameMeasureItem to CFrame::OnMeasureItem Renamed CFrame::OnFrameClose to CFrame::OnClose Renamed CFrame::OnFrameNotify to CFrame::OnNotify Renamed CFrame::OnFrameSetFocus to CFrame::OnSetFocus Renamed CFrame::OnFrameSysColorChange to CFrame::OnSysColorChange Renamed CFrame::OnFrameTimer to CFrame::OnTimer Removed OnFrameCommand Incompatiblities with previous versions --------------------------------------- - Many of the functions associated with adding toolbars to frames have changed. CFrame::SetupToolbar should be overridden to perform toolbar configuration. Refer to the Themes example for a demonstration of how to add multiple toolbars to a frame. - The renaming of the CFrame::OnXXXX may affect overloading. Calling the base function may now be required particularly for CFrame::OnNotify. - The OnCommand handlers for OnViewStatusbar and OnViewToolbar have been removed from CFrame, and should be added to CMainFrame::OnCommand if required. - CDocker has been renamed to CDocker - dockable.h has been renamed to docking.h Version 6.4.1 ============= This release has the following bug fixes: - Assertions in CContainer reported by VS2005(express) and VS2008(express) - Definition of OPENFILENAME_SIZE_VERSION_400 added for VS6 Version 6.4 =========== Major Changes ------------ * Docking: - Added tabbed docking container with optional toolbar - Added close button to the caption of docked windows - Added 'outer' docking ie. 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. * Notepad example enhancements: - Now capable of handling Unicode text * Themes example now demonstrates a ComboBoxEx control in its toolbar Fixes ----- Various fixes to docking, including: - Fixed Z order of undocked windows - Fixed focus for child windows - Improved undocking - Reduced flicker - Better sizing of docked windows Incompatibilities with previous versions ---------------------------------------- * CWnd::m_hWndParent has been removed. Use GetParent() in its place. * Some functions have been added to CWnd which have the same name as their Win32 counterparts. Prefix functions with the global scope specifier '::' to use the original Win32 API function instead of the Win32++ version. * CSplitter has been superseded by CDocker. Use a CDocker with the DS_NO_UNDOCK and DS_NO_CAPTION styles to duplicate the behaviour of CSplitter. CSplitter will be retained for backwards compatibility, as well as for those who require its 'immediate' mode. More About Docking Containers ----------------------------- A container can be used is a view window for a frame, MDI child, dockable etc. It has a tab control, and is capable of containing and displaying other containers. Each container will in turn have a view window of its own. The view for each container as well as it's toolbar (if any) is displayed in the tab's page. When used as the view window of a dockable, the container also permits docking and undocking of it's containers. In Summary: * Any CWnd object inherited from CContainer is capable of containing other CWnd objects inherrited from CContainer. There is no theoretical limit as to the number of containers that can be contained. * A child container (a container contained within another) can not in turn contain other containers. * Containers have a View window, just like Frames, MDI children and dockables. * Containers can set an icon and text for the tab, as well as text for the docking caption. * Containers can optionally include a toolbar. * When a container contains other containers, each container's view is displayed in a separate tab. * When a container is the view window for a dockable, any container children can be individually undocked from their parent container. * When used a the view for a docker, a container with child containers can be undocked as a group. * An undocked container group (container with children) can be docked as a group inside another docked container. Version 6.3 =========== Major Changes ------------- * Added support for docking. See below for more information on Docking - Note: CDocker is now recommended over CSplitter for splitter apps. * 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. * SetView can now be used to change the frame's view from one CWnd to another. * 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. Fixes ----- * CFrame now supports Extra Large fonts in the menu and status bar. Also, font size can be changed while the application is running. * 16Bit colours (and grey-scale) are now rendered properly * Tabbing now works for modeless dialogs and property sheets (uses PreTranslateMessage). Incompatibilities with previous versions ---------------------------------------- * MDI Child windows now require a view. Refer to the MDI Demo example for an example of how to add views to a MDI child. * Some functions have been added to CWnd which have the same name as their Win32 counterparts. Prefix functions with the global scope specifier '::' to use the original Win32 API function instead of the Win32++ version. More About Docking ------------------ * Any CWnd object inherited from CDocker is capable of docking other CWnd objects inherrited from CDocker. * Dockables can be docked in any of the 4 sides. Any number of windows can be docked on a side. * A dockable could be docked inside another dockable which in turn is docked inside another. There is no theoretical limit as to depth of dockables within dockables. * Dockables have a View window, just like the Frame, and MDI children. * Dockables are separated by a movable splitter bar. * Dockables use a modern style of dock targeting and dock hinting (the same as Visual Studio 2005 and 2008). * Dockables can have styles including: - DS_NOTDOCKED - DS_DOCKED_LEFT - DS_DOCKED_RIGHT - DS_DOCKED_TOP - DS_DOCKED_BOTTOM - DS_NODOCKCHILD_LEFT - DS_NODOCKCHILD_RIGHT - DS_NODOCKCHILD_TOP - DS_NODOCKCHILD_BOTTOM - DS_NO_RESIZE - DS_NO_CAPTION - DS_NO_UNDOCK * CDocker is now the recommended alternative to CSplitter (being much simpler to implement - see the example below). The DS_NO_CAPTION and DS_NO_UNDOCK styles should be specified if docking and undocking are not required. Example of how to dock 8 dockables inside a dockable view: ---------------------------------------------------------- void CMainFrame::OnInitialUpdate() { // CTextDockable in inherited from CDocker CDocker* pDockLeft = m_DockView.AddDockedChild(new CTextDockable, DS_DOCKED_LEFT, 100); CDocker* pDockRight = m_DockView.AddDockedChild(new CTextDockable, DS_DOCKED_RIGHT, 100); CDocker* pDockTop = m_DockView.AddDockedChild(new CTextDockable, DS_DOCKED_TOP, 100); CDocker* pDockBottom = m_DockView.AddDockedChild(new CTextDockable, DS_DOCKED_BOTTOM, 100); // Dock 4 dockables inside other dockables pDockLeft->AddDockedChild(new CTextDockable, DS_DOCKED_BOTTOM, 100); pDockRight->AddDockedChild(new CTextDockable, DS_DOCKED_BOTTOM, 100); pDockTop->AddDockedChild(new CTextDockable, DS_DOCKED_RIGHT, 100); pDockBottom->AddDockedChild(new CTextDockable, DS_DOCKED_RIGHT, 100); } (Refer to the Docking example for an example of to use CDocker.) 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, 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 ------------ * 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. Version 6.0.2 ============= 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.0.1 ============= 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. 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 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. * 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. Version 5.6 =========== * 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. 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) * Built in support for multiple toolbars (in rebars) with AddToolbarBand * Added Forms example * Added Themes example 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 Windows API 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 user code. Version 5.2 =========== * Added a separate HINSTANCE for resources. This provides for multilingual support, when resources are loaded via a DLL. * Added the Internet Browser example. It demonstrates how to host an ActiveX control in a Win32++ window. It requires ATL. * Added the Performance example. 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 ========= * 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