etlegacy/Update-Installer
0
0
Fork 0
mirror of https://github.com/etlegacy/Update-Installer.git synced 2024-11-25 05:11:49 +00:00
Code Issues Projects Releases Packages Wiki Activity
Update-Installer/external/win32cpp/include/changes.txt

1423 lines
57 KiB
Text
Raw Permalink Normal View History

Add Win++ library to external This is a thin wrapper around the Win32 API used in the Win32 Updater Dialog implementation.
2011-08-23 18:54:52 +00:00
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
Reference in a new issue Copy permalink