Click here to Skip to main content
Click here to Skip to main content
Add your own
alternative version

The Ultimate Toolbox - Updates and User Contributions

, 12 Feb 2013 CPOL
Updates and User Contributions for the Ultimate Toolbox Libraries
Ultimate Grid
Build DLL.dsp
Build DLL.dsw
Ultimate TCP-IP
Ultimate Toolbox
Build DLLs
Build Libs
// ===================================================================================
// 					Class Specification : COXSizeControlBar
// ===================================================================================

// Header file : OXSizeCtrlBar.h

// Version: 9.3

// This software along with its related components, documentation and files ("The Libraries")
// is � 1994-2007 The Code Project (1612916 Ontario Limited) and use of The Libraries is
// governed by a software license agreement ("Agreement").  Copies of the Agreement are
// available at The Code Project (, as part of the package you downloaded
// to obtain this file, or directly from our office.  For a copy of the license governing
// this software, you may contact us at, or by calling 416-849-8900.
// Some portions Copyright (C)1994-5	Micro Focus Inc, 2465 East Bayshore Rd, Palo Alto, CA 94303.
// //////////////////////////////////////////////////////////////////////////

// Properties:
//	NO	Abstract class (does not have any objects)
//	YES	Derived from CControlBar

//	YES	Is a Cwnd.                     
//	YES	Two stage creation (constructor & Create())
//	YES	Has a message map
//	NO  Needs a resource (template)

//	NO	Persistent objects (saveable on disk)      
//	NO	Uses exceptions

// //////////////////////////////////////////////////////////////////////////

// Desciption :         
// This class provides the basic behaviour for control bars that can be resized, 
// both when docked and floating. The resizing is free-form, ie there are no 
// discrete steps, and the bar has difference sizes, depending on whether it is 
// docked vertically, horizontally or floating.
// To implement this feature in your application you must:
// 1.	Derive you main frame window (usually CMainFrame) from either 
//		COXFrameWndSizeDock (instead of CFrameWnd, for SDI apps), or 
//		COXMDIFrameWndSizeDock (instead of CMDIFrameWnd, for MDI apps).
// 2.	Derive any specific control bars you need from COXSizeControlBar, 
//		and/or make use of COXSizeDialogBar and COXSizeToolBar.

// You may combine both sizeable (COXSizeControlBar-derived)  and non-sizeable 
// (CControlBar-derived) controls bars in the same application. To best get to 
// grips with writing to these classes, read the implementation summary and 
// look at the example. In general the steps you�ll go through are pretty
// much the same as with MFC�s CControlBar.

// 1.	Construct the MFC COXSize...Bar object, either using new, or on the stack. 
//		Note that the constructor takes a parameter. If you wish to create an 
//		object on the stack, then you may find it easier to use the 
//		SetSizeDockStyle() function, immediately after constructing the
//		object, than specifying a parameter to the constructor.
// 2.	Use Create() to create the bar. 
// 3.	Use EnableDocking().
// 4.	Float or Dock the bar. Generally, CControlBars don�t work with much 
//		sense until you done this step.

// One feature you may find useful in deriving from COXSizeControlBar, is that 
// WM_COMMAND notifications to be handled locally inside the derived class, 
// as well as via the standard routing mechanism. E.g. if you have a button 
// control on a COXSizeControlBar derived class, you can implement the
// ON_COMMAND handler either in your derived class, OR, in the view, frame, etc. 
// as with normal CControlBars.

// Remark:

// Prerequisites (necessary conditions):
//		***


#ifndef __SIZECTRLBAR_H__
#define __SIZECTRLBAR_H__

#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000

#include "OXDllExt.h"
#include "OXMainRes.h"

#ifdef IsMaximized
#undef IsMaximized

// closing the floating window closes the control bar
#define SZBARF_DESTROY_ON_CLOSE     0x00000001     
// keeps window in an array, so it can be deleted
#define SZBARF_AUTOTIDY    			0x00000002		

// standard mouse handling for the menu
#define SZBARF_STDMOUSECLICKS		0x00000004		

// auto-size dialog bars
#define SZBARF_DLGAUTOSIZE			0x00000008		

// allow bar to float in an MDI window
#define SZBARF_ALLOW_MDI_FLOAT		0x00000010		

// will not display gripper
#define SZBARF_NOGRIPPER			0x00000020		

// will not display close button (close button will be displayed unless 
// SZBARF_NOGRIPPER style is specified)
#define SZBARF_NOCLOSEBTN			0x00000040		

// will not display resize button (resize button will be displayed unless 
// SZBARF_NOGRIPPER style is specified)
#define SZBARF_NORESIZEBTN			0x00000080		

// will not display bar caption on the gripper (caption will be displayed unless 
// SZBARF_NOGRIPPER style is specified)
#define SZBARF_NOCAPTION			0x00000100		

// displays the gripper as window caption bar (filled with solid color defined
// for standard windows caption bars)
#define SZBARF_SOLIDGRIPPER			0x00000200		

// Provide Visual Studio .NET style of docking - detachable tab windows, etc.
#define SZBARF_VS7STYLEDOCKING		0x00000400

#define CBRS_MOVED_BY_USER  		0x0001L    // set if dragged by user 

#define ID_CONTAINER_GAP			5
#define ID_BUTTON_SIDE				11
#define ID_TEXT_OFFSET				6

class COXDockbarSkin;
class COXSizeDockBar;

class OX_CLASS_DECL COXSizeControlBar : public CControlBar
	friend class COXDockbarSkinClassic;
	friend class COXDockbarSkinXP;
	friend class COXDockbarSkin2003;
	friend class COXSizableMiniDockFrameWnd;
	friend class COXDockTabCtrl;
	friend class COXSkin2003;


// Data members -------------------------------------------------------------

	CSize           m_FloatSize;			// size when floating
   	CSize			m_HorzDockSize;			// size when docked horizontal
	CSize			m_VertDockSize;			// size when docked vertical
	//  - size reflects the current docked size of the window (I do nothing clever for stretched)
	//  - height is generally shared across the rows
   	CSize			m_SavedDockSize;			// size before maximizing

    CPoint			m_FloatingPosition;		// floating position
	DWORD			m_dwAllowDockingState;  // saved enable style for allow docking on/off
    int             m_Style;                // style flags
    CSize           m_PrevSize;
    BOOL            m_bPrevFloating;		// Indicates if control bar is floating
	BOOL			m_bDragging;			// Indicates if the control is currently being dragged
	BOOL			m_bOkToDrag;			// Indicates if it is okay to start dragging
	int				m_iLastTabPosition;		// Position in the tab control when last tabbed

	CRect			m_rectGripper;			// gripper rect
	CRect			m_rectCloseBtn;			// close button rect
	CRect			m_rectResizeBtn;		// Resize button rect
	CPoint			m_ptOffset;
	BOOL			m_bDelayRecalcLayout;
	BOOL			m_bClientBorder;		// determines whether a client border should be drawn

	typedef enum _tagSIZEBARBTN

	SIZEBARBTN m_pressedBtn;

	BOOL m_bMaximized;

	BOOL m_bActive;

private :

	static CObArray* m_parrAllocBars;		// array of dynamically allocated bars
	CPoint m_ptLButtonDown;	
	COXDockbarSkin* m_pDockbarSkin;
	COXDockbarSkin* GetDockbarSkin();
	static LRESULT CALLBACK MouseProc(int nCode, WPARAM wParam, LPARAM lParam);
	static HHOOK m_hMouseHook;
	static HWND m_hwndPrevMouseMoveWnd;

// Member functions ---------------------------------------------------------
	BOOL IsShown();
	COXDockTabCtrl* GetDockTabCtrl();
	void ShowBar(BOOL bShow);

    COXSizeControlBar(int nStyle = SZBARF_STDMOUSECLICKS);

   	// --- In  :
	// --- Out : 
	// --- Returns :
	// --- Effect : Clears array of dynamically allocated bars
	static void TidyUp(CFrameWnd* pTopLevelFrame);

	// --- In  : nStyle : the look and feel of the controlbar
	//				SZBARF_DESTROY_ON_CLOSE	When set, clicking the close button on 
	//										the floating frame causes the control bar 
	//										to be closed and destroyed. Normally, 
	//										the control bar would just be hidden.
	//				SZBARF_AUTOTIDY			MFC CControlBar objects cannot be deleted 
	//										from PostNCDestroy(). Normally CControlBar 
	//										objects are allocated within another object 
	//										(e.g. CMainFrame) so the destructors are 
	//										called when that object is deleted. 
	//										If you allocate control bars dynamically 
	//										(as is often useful with sizeable control 
	//										bars), then you will get memory leaks. 
	//										Setting this flag causes all allocated 
	//										COXSizeControlBars to be tracked, and 
	//										deleted automatically when the frame window
	//										is destroyed. 
	//				SZBARF_STDMOUSECLICKS	The control bar will respond to standard 
	//										mouse events, such as double click on the 
	//										title bar to dock, pop up a context menu
	//										to hide or enable/disable docking.  
	//				SZBARF_DLGAUTOSIZE		Use in conjunction with dialog bars. The 
	//										gadgets on the dialog bar will resize to 
	//										fit the new window. This is a simple linear
	//										mapping based on the original sizes & 
	//										positions in the dialog resource, but it 
	//										does work surprisingly well. 
	//				SZBARF_ALLOW_MDI_FLOAT	When set, the context menu will allow the 
	//										user to float the bar as an MDI child 
	//										window.
	// --- Out : 
	// --- Returns :
	// --- Effect : Constructor of object
	//				It will initialize the internal state.
	virtual BOOL Create( LPCTSTR lpszClassName, LPCTSTR lpszWindowName,
		DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID, 
		CCreateContext* pContext = NULL);

   	// --- In  : pParent : Points to the parent frame window of the control. Should be derived
	//					   from either COXMDIFrameWndSizeDock, or COXFrameWndSizeDock.
	//			 lpszTitle : Specifies the control�s caption - used in the floating frame window,
	//						 when the bar is undocked.
	//			 nID : the window ID of the controlbar
	//			 dwStyle : The styles of the controlbar (See CControlBar for styles)
	//			 rect : the initial size and placement of the controlbar (in client coordinates)
	// --- Out : 
	// --- Returns : succeeded or not
	// --- Effect : Creates the control bar.  You should use the WS_VISIBLE style when creating
	//				your toolbar, otherwise the initially size may be incorrect.
	BOOL Create(CWnd* pParent, LPCTSTR lpszTitle, UINT nID = 1,
                DWORD dwStyle = WS_CHILD | WS_VISIBLE | CBRS_BOTTOM,
                const RECT& rect = CFrameWnd::rectDefault);

   	// --- In  : dwStyle : the new style(s) for the controlbar (See constructor for styles)
	// --- Out : 
	// --- Returns :
	// --- Effect : Sets the internal style flag for the control bar. Use this as an alternative
	//				to specifing a parameter on the constructor (except where specifying
	//				SZBARF_AUTOTIDY), and call it immediately after construction, but before Create().
	void SetSizeDockStyle(DWORD dwStyle);

   	// --- In  : dwDockStyle : See CControlBar::EnableDocking
	// --- Out : 
	// --- Returns :
	// --- Effect : This function is equivalent to CControlBar::EnableDocking(), but applies to sizeable
	//				control bars. Note that this function is NOT virtual, so you must take care that you
	//				do not inadvertently call CControlBar::EnableDocking() on a COXSizeControlBar object.
    void EnableDocking(DWORD dwDockStyle);

   	// --- In  :
	// --- Out : 
	// --- Returns : TRUE if the control bar is floating (inside a floating frame window).
	//				 Unlike CControlBar::IsFloating(), it returns TRUE if the bar is in
	//				 transition between floating and non-floating. This function proves more
	//				 useful inside the OnSizedOrDocked() overridable.
	// --- Effect : Indicates if control bar is floating
	BOOL IsProbablyFloating();

	// command handlers for standard menus

   	// --- In  :
	// --- Out : 
	// --- Returns :
	// --- Effect : Called when controlbar is to be hidden
	void OnHide();

   	// --- In  :
	// --- Out : 
	// --- Returns :
	// --- Effect : called when docking state is switched
	void OnToggleAllowDocking();

   	// --- In  :
	// --- Out : 
	// --- Returns :
	// --- Effect : called when controlbar is floated in an MDI frame
	void OnFloatAsMDI();

	inline BOOL IsGripper() const { return (m_Style & SZBARF_NOGRIPPER)==0; }
	inline BOOL IsCloseBtn() const { return (m_Style & SZBARF_NOCLOSEBTN)==0; }
	inline BOOL IsResizeBtn() const { return (m_Style & SZBARF_NORESIZEBTN)==0; }
	inline BOOL IsCaption() const { return (m_Style & SZBARF_NOCAPTION)==0; }
	inline BOOL IsSolidGripper() const { return (m_Style & SZBARF_SOLIDGRIPPER)!=0; }
	inline void SetClientBorder(BOOL bDrawBorder) { m_bClientBorder = bDrawBorder; }

	inline BOOL IsMaximized() const { return m_bMaximized; }
	inline void SetMaximized(BOOL bMaximized) 

	void SetActive(BOOL bActive, BOOL bResetAllCtrlBars=FALSE);
	inline BOOL IsActive() const { return m_bActive; }

	virtual BOOL CanResize() const;

	virtual void EraseNonClient();

// Overrides
	// ClassWizard generated virtual function overrides

    virtual CSize CalcFixedLayout(BOOL bStretch, BOOL bHorz);
    virtual void OnUpdateCmdUI(CFrameWnd* pTarget, BOOL bDisableIfNoHndler);

	// --- In  :
	// --- Out : 
	// --- Returns :
	// --- Effect : Destructor of object
    virtual ~COXSizeControlBar();

    // Overridable functions
   	// --- In  : cx : New width of the control bar.
	//			 cy : New height of the control bar.
	//			 bFloating : TRUE if the bar is now floating.
	//			 flags : Reserved.
	// --- Out : 
	// --- Returns :
	// --- Effect : This overridable is called whenever the control bar is sized or docked/undocked.
	//				It is probably the easiest place to respond to resizing the control.
	virtual void OnSizedOrDocked(int cx, int cy, BOOL bFloating, int flags);

	virtual void DrawGripper(CDC* pDC); 
	virtual void DrawCloseBtn(CDC* pDC); 
	virtual void DrawResizeBtn(CDC* pDC);
	void RecalcLayout();
	void SaveMouseOffset(CPoint point);
	void RedrawCloseBtn();
	void RedrawResizeBtn();

    afx_msg void OnWindowPosChanged(WINDOWPOS* lpwndpos);
    afx_msg BOOL OnEraseBkgnd(CDC* pDC);
	afx_msg void OnContextMenu(CWnd* pWnd, CPoint point);
	afx_msg BOOL OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message);
	afx_msg void OnNcCalcSize(BOOL, NCCALCSIZE_PARAMS*);
    afx_msg void OnNcPaint();
    afx_msg void OnPaint();
#if _MSC_VER >= 1400
	afx_msg LRESULT OnNcHitTest(CPoint point);
	afx_msg UINT OnNcHitTest(CPoint point);
	afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
	afx_msg void OnLButtonUp(UINT nFlags, CPoint point);
	afx_msg void OnMouseMove(UINT nFlags, CPoint point);
	afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
	afx_msg void OnDestroy();
	afx_msg void OnLButtonDblClk(UINT nFlags, CPoint point);

    virtual LRESULT WindowProc(UINT nMsg, WPARAM wParam, LPARAM lParam);

	// v9.3 - update 03 - 64-bit - changed these to LRESULT, WPARAM, LPARAM 
	afx_msg LRESULT OnAddContextMenuItems(WPARAM wParam, LPARAM lParam);
	afx_msg LRESULT OnAfterFloatMessage(WPARAM, LPARAM);

	void RedrawButtons();

#endif // __SIZECTRLBAR_H__

By viewing downloads associated with this article you agree to the Terms of Service and the article's licence.

If a file you wish to view isn't highlighted, and is a text file (not binary), please let us know and we'll add colourisation support for it.


This article, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)


About the Author

The Ultimate Toolbox
Web Developer
Canada Canada
In January 2005, David Cunningham and Chris Maunder created, a new group dedicated to the continued development, support and growth of Dundas Software’s award winning line of MFC, C++ and ActiveX control products.
Ultimate Grid for MFC, Ultimate Toolbox for MFC, and Ultimate TCP/IP have been stalwarts of C++/MFC development for a decade. Thousands of developers have used these products to speed their time to market, improve the quality of their finished products, and enhance the reliability and flexibility of their software.
Group type: Organisation

394 members

| Advertise | Privacy | Terms of Use | Mobile
Web01 | 2.8.141216.1 | Last Updated 13 Feb 2013
Article Copyright 2008 by The Ultimate Toolbox
Everything else Copyright © CodeProject, 1999-2014
Layout: fixed | fluid