////////////////////////////////////////////
// ___ ____ _________________ //
// / _/_ _// _______________/ //
// / _/ / / / / ___ ___ ____ //
// /__/ /_/ / / / // _/_ _/ //
// _________/ / / / // _/ / / //
// (c) 1998-2000_/ /___//_/ /_/ //
// //
////////////////////////////////////////////
// all rights reserved //
////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// ETSLayoutDialog
//
// A class for smart layouting of Dialogs and such
//
// USAGE: See LayoutMgr.html
//
// AUTHOR: Erwin Tratar <tr@et-soft.de>
//
// DISCLAIMER:
//
// This Sourcecode and all accompaning material is �1998-1999 Erwin Tratar.
// All rights reserved.
//
// The source code may be used in compiled form in any way you desire
// (including usage in commercial applications), providing that your
// application adds essential code (i.e. it is not only a wrapper) to the
// functionality found here
//
// Redistribution of the sourcecode itself, publication in any media or
// inclusion in a library requires the authors expressed written consent.
// You may not sale this code for profit.
//
// THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT EXPRESS OR IMPLIED WARRANTY. USE IT
// AT YOUR OWN RISK! THE AUTHOR ACCEPTS NO LIABILITY FOR ANY DAMAGE/LOSS OF
// BUSINESS THAT THIS PRODUCT MAY CAUSE.
#if !defined(ETS_LAYOUTMGR_INCLUDED_)
#define ETS_LAYOUTMGR_INCLUDED_
#if _MSC_VER >= 1000
#pragma once
#endif // _MSC_VER >= 1000
// DialogMgr.h : header file
//
namespace ETSLayout
{
#ifdef CS_HELP
typedef ETSCSHelpDialog CBaseDialog;
typedef ETSCSHelpFormView CBaseFormView;
typedef ETSCSHelpDlgBar CBaseDialogBar;
typedef ETSCSHelpPropPage CBasePropertyPage;
#else
typedef CDialog CBaseDialog;
typedef CFormView CBaseFormView;
typedef CDialogBar CBaseDialogBar;
typedef CPropertyPage CBasePropertyPage;
#endif
}
// Support for CBCGDialogBar instead of CDialogBar available:
// you just have to change the typedef to CBaseDialogBar
#ifndef ETSGUI_EXT_CLASS
#define ETSGUI_EXT_CLASS
#endif
#include <afxtempl.h>
// Support for CBCGDialogBar instead of CDialogBar
/**
* Controls whether the Icon is automatically set to IDR_MAINFRAME
*/
#define _AUTO_SET_ICON
/**
* Forward class declarations
*/
class ETSLayoutDialog;
class ETSLayoutDialogBar;
class ETSLayoutFormView;
class ETSLayoutMgr;
class ETSLayoutPropertyPage;
class ETSLayoutPropertySheet;
/**
* These are NOOPs now
*/
#define DECLARE_LAYOUT()
#define IMPLEMENT_LAYOUT()
/**
* This is the default border size between the panes. You
* may override it in Pane constructor, but it is the
* fixed border around the root pane
*/
const int nDefaultBorder = 5;
/**
* The minimum size for not ABSOLUTE_XXX items
*/
const int nMinConstrain = 5;
class ETSGUI_EXT_CLASS ETSLayoutMgr
{
public:
enum layResizeMode {
GREEDY = 0, // Will eat up as much as it can
ABSOLUTE_HORZ = 1 << 0, // Horizontal size is absolute
RELATIVE_HORZ = 1 << 1, // Horizontal size in percent
ABSOLUTE_VERT = 1 << 2, // Vertical size is absolute
RELATIVE_VERT = 1 << 3, // Vertical size in percent
NORESIZE = ABSOLUTE_HORZ | ABSOLUTE_VERT,
SIZE_MASK = NORESIZE,
ALIGN_LEFT = 1 << 4, // following only for NORESIZE
ALIGN_RIGHT = 1 << 5,
ALIGN_TOP = 1 << 6,
ALIGN_BOTTOM = 1 << 7,
ALIGN_HCENTER = ALIGN_LEFT | ALIGN_RIGHT,
ALIGN_VCENTER = ALIGN_TOP | ALIGN_BOTTOM,
ALIGN_CENTER = ALIGN_HCENTER | ALIGN_VCENTER,
ALIGN_FILL_HORZ = 1 << 8,
ALIGN_FILL_VERT = 1 << 9,
ALIGN_FILL = ALIGN_FILL_HORZ | ALIGN_FILL_VERT,
/* TRACKER_LEFT = 1 << 10, // not yet. May allow tracking of borders
TRACKER_RIGHT = 1 << 11, // between items in the future
TRACKER_TOP = 1 << 12,
TRACKER_BOTTOM = 1 << 13,
*/
};
enum layOrientation {
HORIZONTAL,
VERTICAL
};
/**
* This is the base class for all kind of panes.
*/
class ETSGUI_EXT_CLASS PaneBase {
friend class ETSLayoutMgr;
friend class CPaneBase;
friend class CPane;
public:
/**
* Informs the caller how much of the given space this pane would
* like to receive in horizontal direction
*/
virtual int getConstrainHorz(int sizeParent) = 0;
/**
* Informs the caller how much of the given space this pane would
* like to receive in vertical direction
*/
virtual int getConstrainVert(int sizeParent) = 0;
/**
* Informs the caller how much of the given space this pane
* minimally need. This would be an absolute Value if
* the mode contains ABSOLUTE_HORZ or an explicit minimum
* value, else nMinConstrain
*/
virtual int getMinConstrainHorz() = 0;
/**
* Informs the caller if there is an restriction for maximum
* space this pane needs. Return -1 for unrestricted (GREEDY
* or RELATIVE)
*/
virtual int getMaxConstrainHorz() = 0;
/**
* Informs the caller how much of the given space this pane
* minimally need. This would be an absolute Value if
* the mode contains ABSOLUTE_VERT or an explicit minimum
* value, else nMinConstrain
*/
virtual int getMinConstrainVert() = 0;
/**
* Informs the caller if there is an restriction for maximum
* space this pane needs. Return -1 for unrestricted (GREEDY
* or RELATIVE)
*/
virtual int getMaxConstrainVert() = 0;
/**
* This will do the actual resize operation after the
* caller computed a new area for this pane
*/
virtual bool resizeTo(CRect& rcNewArea) = 0;
/**
* Constructor needed pointer to LayoutManager
*/
PaneBase( ETSLayoutMgr* pMgr ) { m_pMgr = pMgr; };
/**
* Virtual destructor needed in Container operations
*/
virtual ~PaneBase() {};
/**
* Returs the Resize Mode of this pane
*/
DWORD modeResize() { return m_modeResize; };
protected:
/**
* How this Item will be resized, a combination of the flags above
*/
DWORD m_modeResize;
/**
* A pointer to the holding LayoutManager derivate
*/
ETSLayoutMgr* m_pMgr;
};
/**
* CPaneBase represents an autopointer to a PaneBase. Use this and you won't have to worry
* about cleaning up any Panes. Also this autopointer lets you return Pane objects
* from function without using pointers (at least you won't see them :) )
*/
struct ETSGUI_EXT_CLASS PaneHolder
{
PaneHolder(PaneBase* pPane );
~PaneHolder();
void AddRef();
void Release();
PaneBase* m_pPane;
long m_nRefCount;
};
class ETSGUI_EXT_CLASS CPaneBase
{
protected:
PaneHolder* m_pPaneHolder;
public:
// Standardconstructor
CPaneBase( );
CPaneBase( PaneBase* pPane );
CPaneBase( const CPaneBase& other );
~CPaneBase();
void operator=( PaneBase* pPane );
void operator=( const CPaneBase& other );
PaneBase* operator->() const;
PaneBase* GetPaneBase() { return operator->(); }
bool IsValid() { return (m_pPaneHolder != 0); }
operator !() { return (m_pPaneHolder == 0); }
};
class Pane;
class ETSGUI_EXT_CLASS CPane : public CPaneBase
{
public:
// Standardconstructor
CPane( );
CPane( Pane* pPane );
CPane( const CPane& other );
~CPane();
void operator=( Pane* pPane );
void operator=( const CPane& other );
Pane* operator->() const;
Pane* GetPane() { return operator->(); }
CPaneBase ConvertBase() const;
CPane& operator<< ( const CPane pPane );
CPane& operator<< ( const CPaneBase pItem );
};
/**
* PaneItem represents a single control
*/
class ETSGUI_EXT_CLASS PaneItem : public PaneBase {
friend class ETSLayoutMgr;
friend class Pane;
protected:
/**
* Creates a new PaneItem from an Control. If sizeX or sizeY are 0
* and modeResize is ABSOLUTE will copy the current dimensions of
* the control to m_sizeX/Y. So the appearance does not change
* from the Dialog Editor
*/
PaneItem( CWnd* pWnd, ETSLayoutMgr* pMgr, layResizeMode modeResize = GREEDY, int sizeX=0, int sizeY=0, int sizeXMin=0, int sizeYMin=0);
/**
* If your control is not mapped you can name it by its ChildID. Pass
* the pMgr to receive the CWnd* of nID.
* The rest as stated above
*/
PaneItem( UINT nID, ETSLayoutMgr* pMgr, layResizeMode modeResize = GREEDY, int sizeX=0, int sizeY=0, int sizeXMin=0, int sizeYMin=0);
public:
/**
* see PaneBase
*/
virtual int getConstrainHorz(int sizeParent);
virtual int getConstrainVert(int sizeParent);
virtual int getMinConstrainHorz();
virtual int getMinConstrainVert();
virtual int getMaxConstrainHorz();
virtual int getMaxConstrainVert();
virtual bool resizeTo(CRect& rcNewArea);
bool isDummy() { return (m_hwndCtrl == 0); }
protected:
friend class ETSLayoutPropertySheet;
/**
* The horizontal size of the control (see m_modeResize)
*/
int m_sizeX;
int m_sizeXMin;
/**
* The vertical size of the control (see m_modeResize)
*/
int m_sizeY;
int m_sizeYMin;
/**
* Child Control pointer
*/
HWND m_hwndCtrl;
/**
* Combo box needs special treatment
*/
bool m_bComboSpecial;
};
/**
* This class encapsulates a Subpane (and indeed the root Pane too)
* it is a container of PaneBase* which it will recursivly resize
*/
class ETSGUI_EXT_CLASS Pane : public PaneBase {
friend class ETSLayoutMgr;
friend class CPaneBase;
friend class CPane;
friend class ETSLayoutPropertySheet;
protected:
/**
* Tell the pane in which direction it is positioned. A HORIZONTAL pane
* arranges it's subpanes from left to right, a VERTICAL from top to bottom
*/
Pane( ETSLayoutMgr* pMgr, layOrientation orientation, int sizeBorder = nDefaultBorder, int sizeExtraBorder = 0 );
public:
/**
* If your control is not mapped you can name it by its ChildID. Pass
* the pMgr to receive the CWnd* of nID.
* The rest as stated above
*/
bool addItem( UINT nID, layResizeMode modeResize = GREEDY, int sizeX=0, int sizeY=0, int sizeXMin=-1, int sizeYMin=-1);
/**
* Creates a new PaneItem from an Control. If sizeX or sizeY are 0
* and modeResize is ABSOLUTE will copy the current dimensions of
* the control to m_sizeX/Y. So the appearance does not change
* from the Dialog Editor
*/
bool addItem( CWnd* pWnd, layResizeMode modeResize = GREEDY, int sizeX=0, int sizeY=0, int sizeXMin=-1, int sizeYMin=-1);
/**
* Add a whitespace Item (paneNull) of variable size with
* a minimum size of 0
*/
bool addItemGrowing();
/**
* Add a whitespace Item (paneNull) with fixed size
*/
bool addItemFixed(int size);
/**
* Add a whitespace Item (paneNull) of fixed size based on the
* current layout (as in the dialog template). Based on the layout
* of the pane vertical or horizontal spacing is considered
*
* First argument is the left (top) item for a HORIZONTAL (VERTICAL) pane
*/
bool addItemSpaceBetween( CWnd* pWndFirst, CWnd* pWndSecond );
bool addItemSpaceBetween( UINT nIDFirst, UINT nIDSecond );
/**
* Add a whitespace Item (paneNull) of fixed size based on the
* size of another item
*/
bool addItemSpaceLike( CWnd* pWnd );
bool addItemSpaceLike( UINT nID );
/**
* Add an item to the pane, appending at the end. This may be either obtained
* by a call to ETSLayoutMgr::item() or one of the ETSLayoutMgr::paneXXX() calls
*/
bool addPane( CPaneBase pItem );
bool addPane( CPane pSubpane, layResizeMode modeResize, int sizeSecondary /* = 0 */);
virtual int getConstrainHorz(int sizeParent);
virtual int getConstrainVert(int sizeParent);
virtual int getMinConstrainHorz();
virtual int getMinConstrainVert();
virtual int getMaxConstrainHorz();
virtual int getMaxConstrainVert();
virtual bool resizeTo(CRect& rcNewArea);
/**
* The destructor takes care of destroying all Subpanes and items
*/
virtual ~Pane();
/**
* Access to the orientation of this pane
*/
layOrientation getOrientation() { return m_Orientation; };
protected:
int resizeToAbsolute(int& availSpace, CArray<int,int>& sizePrimary,
CArray<int,int>& sizeMin, CArray<int,int>& sizeMax);
bool resizeToRelative(int& availSpace, CArray<int,int>& sizePrimary,
CArray<int,int>& sizeMin, CArray<int,int>& sizeMax);
bool resizeToGreedy( int& availSpace, int nGreedy, CArray<int,int>& sizePrimary,
CArray<int,int>& sizeMin, CArray<int,int>& sizeMax);
/**
* The orientation of the pane. Keep in mind that all subpanes
* must have the complementary orientation, i.e. a VERTICAL
* pane must have all HORIZONTAL SubPanes (or normal Items
* of course)
*/
layOrientation m_Orientation;
/**
* This array holds the pointers to the Items/SubPanes
*/
CArray<CPaneBase, CPaneBase> m_paneItems;
/**
* The secondary constrain
*/
int m_sizeSecondary;
/**
* Size of gap between childs
*/
int m_sizeBorder;
int m_sizeExtraBorder;
};
/**
* This class encapsulates a Subpane which is a Tab
* it will use calls to AdjustRect to position it's
* childs
*/
class ETSGUI_EXT_CLASS PaneTab : public Pane
{
friend class ETSLayoutMgr;
protected:
/**
* Tell the pane in which direction it is positioned. A HORIZONTAL pane
* arranges it's subpanes from left to right, a VERTICAL from top to bottom
*/
PaneTab( CTabCtrl* pTab, ETSLayoutMgr* pMgr, layOrientation orientation, int sizeBorder = nDefaultBorder, int sizeExtraBorder = 0 );
public:
virtual int getConstrainHorz(int sizeParent);
virtual int getConstrainVert(int sizeParent);
virtual int getMinConstrainHorz();
virtual int getMinConstrainVert();
virtual int getMaxConstrainHorz();
virtual int getMaxConstrainVert();
virtual bool resizeTo(CRect& rcNewArea);
private:
CTabCtrl* m_pTab;
};
/**
* This class encapsulates a Subpane which is a Static
* it will use calls to AdjustRect to position it's
* childs
*/
class ETSGUI_EXT_CLASS PaneCtrl : public Pane
{
friend class ETSLayoutMgr;
protected:
/**
* Tell the pane in which direction it is positioned. A HORIZONTAL pane
* arranges it's subpanes from left to right, a VERTICAL from top to bottom
*/
PaneCtrl( CWnd* pCtrl, ETSLayoutMgr* pMgr, layOrientation orientation, int sizeBorder = nDefaultBorder, int sizeExtraBorder = 0, int sizeTopExtra = 0);
PaneCtrl( UINT nID, ETSLayoutMgr* pMgr, layOrientation orientation, int sizeBorder = nDefaultBorder, int sizeExtraBorder = 0, int sizeTopExtra = 0 );
public:
virtual int getConstrainHorz(int sizeParent);
virtual int getConstrainVert(int sizeParent);
virtual int getMinConstrainHorz();
virtual int getMinConstrainVert();
virtual int getMaxConstrainHorz();
virtual int getMaxConstrainVert();
virtual bool resizeTo(CRect& rcNewArea);
private:
HWND m_hwndCtrl;
int m_sizeTopExtra;
};
ETSLayoutMgr(CWnd* pWnd) { m_pWnd = pWnd; m_sizeRootBorders = CSize(5,5); };
virtual ~ETSLayoutMgr();
virtual CRect GetRect() { CRect r; m_pWnd->GetClientRect(r); return r; };
CWnd* m_pWnd;
CWnd* GetWnd() { return m_pWnd; };
void setRootBorders(int cx, int cy) { m_sizeRootBorders = CSize(cx,cy); };
/**
* Pass this for a pseudo Pane with no content
*/
static CWnd* paneNull;
/**
* Loads the current position and size from the registry using a supplied
* key. Will be loaded with AfxGetApp()->WriteProfileXXX(). You may
* specify a subfolder (e.g. Load( _T("MyDialog\\Layout") ); ). Will
* load the following keys:
*
* - lpstrRegKey+"SizeX";
* - lpstrRegKey+"SizeY";
* - lpstrRegKey+"PosX";
* - lpstrRegKey+"PosY";
*
* Is automatically called during OnActivate() if key specified in
* constructor.
*/
bool Load(LPCTSTR lpstrRegKey);
/**
* Store the current position and size to the registry using a supplied
* key. Will be stored with AfxGetApp()->WriteProfileXXX(). You may
* specify a subfolder (e.g. Save( _T("MyDialog\\Layout") ); ). Will
* create the following keys:
*
* - lpstrRegKey+"SizeX";
* - lpstrRegKey+"SizeY";
* - lpstrRegKey+"PosX";
* - lpstrRegKey+"PosY";
*
* Is automatically called during DestroyWindow() if key specified in
* constructor.
*/
bool Save(LPCTSTR lpstrRegKey);
/**
* Updates the layout after you specify the new
* layout
*/
virtual void UpdateLayout();
virtual void UpdateLayout(CPane p) {
if(m_RootPane.IsValid())
{
// free old root
m_RootPane = 0;
}
m_RootPane = p;
UpdateLayout();
}
/**
* Does the actual Layout, called from OnSize()
* Default implementation does nothing, use
* IMPLEMENT_LAYOUT in your derived class (see above)
*/
virtual void Layout(CRect& rcClient);
/**
* Erasing only the these parts of the client area where
* there is no child window. Extra-code for group-boxes
* included!
*/
void EraseBkgnd(CDC* pDC);
/**
* Helperfunctions for the stream-interface. For usage see sample Application
* and/or documentation.
*/
/**
* Create a new Pane. You may specify the resize
* mode for both directions. If you add modes for the secondary direction
* (i.e. *_VERT for a HORIZONTAL pane) then sizeSecondary is used as it's
* size. If you do not specify sizeSecondary and the mode is ABSOLUTE_VERT
* it will be computed as the maximum Height of all SubPanes (the same is
* true for VERTICAL panes and subpanes with *_HORZ)
*/
CPane pane( layOrientation orientation, layResizeMode modeResize = GREEDY, int sizeBorder = nDefaultBorder, int sizeExtraBorder = 0, int sizeSecondary = 0);
/**
* Create one of the special control panes. Parameter are like pane(). For
* additional information see documentation
*/
CPane paneTab( CTabCtrl* pTab, layOrientation orientation, layResizeMode modeResize = GREEDY, int sizeBorder = nDefaultBorder, int sizeExtraBorder = 0, int sizeSecondary = 0);
CPane paneCtrl( UINT nID, layOrientation orientation, layResizeMode modeResize = GREEDY, int sizeBorder = nDefaultBorder, int sizeExtraBorder = 0, int sizeTopExtra = 0, int sizeSecondary = 0);
CPane paneCtrl( CWnd* pCtrl, layOrientation orientation, layResizeMode modeResize = GREEDY, int sizeBorder = nDefaultBorder, int sizeExtraBorder = 0, int sizeTopExtra = 0, int sizeSecondary = 0);
/**
* Creates a new PaneItem for an Control. If sizeX or sizeY are 0
* and modeResize is ABSOLUTE will copy the current dimensions of
* the control to m_sizeX/Y. So the appearance does not change
* from the Dialog Editor. size*Min = -1 means: do not make smaller
* than in Dialog Template.
*/
CPaneBase item(UINT nID, layResizeMode modeResize = GREEDY, int sizeX =0, int sizeY =0, int sizeXMin =-1, int sizeYMin =-1);
CPaneBase item(CWnd* pWnd, layResizeMode modeResize = GREEDY, int sizeX =0, int sizeY =0, int sizeXMin =-1, int sizeYMin =-1);
/**
* Add a whitespace Item (paneNull) of variable size with
* a minimum size of 0
*/
CPaneBase itemGrowing(layOrientation orientation);
/**
* Add a whitespace Item (paneNull) with fixed size
*/
CPaneBase itemFixed(layOrientation orientation, int sizePrimary);
/**
* Add a whitespace Item (paneNull) of fixed size based on the
* current layout (as in the dialog template). Based on the layout
* of the pane vertical or horizontal spacing is considered
*
* First argument is the left (top) item for a HORIZONTAL (VERTICAL) pane
*/
CPaneBase itemSpaceBetween( layOrientation orientation, CWnd* pWndFirst, CWnd* pWndSecond );
CPaneBase itemSpaceBetween( layOrientation orientation, UINT nIDFirst, UINT nIDSecond );
/**
* Add a whitespace Item (paneNull) of fixed size based on the
* size of another item
*/
CPaneBase itemSpaceLike( layOrientation orientation, CWnd* pWnd );
CPaneBase itemSpaceLike( layOrientation orientation, UINT nID );
protected:
/**
* This holds the root pane. Fill in InitDialog()
*/
CPane m_RootPane;
/**
* Create a root pane
*/
CPane CreateRoot(layOrientation orientation, int sizeBorder = nDefaultBorder, int sizeExtraBorder = 0 )
{
if(m_RootPane.IsValid())
{
// free old root
m_RootPane = 0;
}
m_RootPane = new Pane( this, orientation, sizeBorder, sizeExtraBorder);
return m_RootPane;
}
/**
* Key in Registry where to store Size
*/
CString m_strRegStore;
/**
* Borders around root
*/
CSize m_sizeRootBorders;
};
inline ETSLayoutMgr::layResizeMode operator|(const ETSLayoutMgr::layResizeMode m1,
const ETSLayoutMgr::layResizeMode m2)
{ return (ETSLayoutMgr::layResizeMode)( (DWORD)m1|(DWORD)m2); }
/**
* Base class for the Layout function. Derive your own class
* from this or derive it from CDialog and modify _all_
* references to CDialog to ETSLayoutDialog
*/
class ETSGUI_EXT_CLASS ETSLayoutDialog : public ETSLayout::CBaseDialog, protected ETSLayoutMgr
{
// Construction
public:
ETSLayoutDialog(UINT nID, CWnd* pParent = NULL, LPCTSTR strName = NULL, bool bGripper = true); // standard constructor
// Dialog Data
//{{AFX_DATA(ETSLayoutDialog)
//}}AFX_DATA
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(ETSLayoutDialog)
//}}AFX_VIRTUAL
// Implementation
protected:
// Generated message map functions
//{{AFX_MSG(ETSLayoutDialog)
afx_msg void OnSize(UINT nType, int cx, int cy);
afx_msg void OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI);
afx_msg BOOL OnEraseBkgnd(CDC* pDC);
virtual BOOL OnInitDialog();
afx_msg void OnDestroy();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
virtual CRect GetRect();
bool m_bGripper;
CStatusBar m_StatusBar;
};
/**
* Base class for the Layout function. Derive your own class
* from this or derive it from CDialog and modify _all_
* references to CFormView to ETSLayoutFormView
*/
class ETSGUI_EXT_CLASS ETSLayoutFormView : public ETSLayout::CBaseFormView, public ETSLayoutMgr
{
// Construction
DECLARE_DYNAMIC(ETSLayoutFormView)
public:
ETSLayoutFormView(UINT nID, LPCTSTR strName = NULL); // standard constructor
virtual ~ETSLayoutFormView();
// virtual void UpdateLayout();
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(ETSLayoutDialog)
//}}AFX_VIRTUAL
// Implementation
protected:
// Generated message map functions
//{{AFX_MSG(ETSLayoutDialog)
afx_msg void OnSize(UINT nType, int cx, int cy);
afx_msg BOOL OnEraseBkgnd(CDC* pDC);
afx_msg void OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI);
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
/**
* Base class for the Layout function. Derive your own class
* from this or derive it from CBCGDialogBar/CDialogBar and
* modify _all_ references to CBCGDialogBar/CDialogBar to
* ETSLayoutDialogBar
*/
class ETSGUI_EXT_CLASS ETSLayoutDialogBar : public ETSLayout::CBaseDialogBar, protected ETSLayoutMgr
{
// Construction
public:
#ifdef CS_HELP
ETSLayoutDialogBar(UINT nID);
#else
ETSLayoutDialogBar();
#endif
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(ETSLayoutDialogBar)
virtual CSize CalcDynamicLayout(int nLength, DWORD dwMode);
//}}AFX_VIRTUAL
/**
* Override this to define Layout
*/
virtual BOOL Initialize() { return false; };
virtual void UpdateLayout();
// Implementation
protected:
// Generated message map functions
//{{AFX_MSG(ETSLayoutDialogBar)
afx_msg void OnSize(UINT nType, int cx, int cy);
afx_msg void OnDestroy();
afx_msg BOOL OnEraseBkgnd(CDC* pDC);
//}}AFX_MSG
LRESULT OnInitDialog(WPARAM, LPARAM);
DECLARE_MESSAGE_MAP()
virtual CRect GetRect();
bool m_bInitialized;
};
/**************************************************
** ! the code is only tested for modal sheets ! **
**************************************************/
/**
* Resizable PropertySheet. Use this class standalone
* or as your base class (instead CProptertySheet)
*/
class ETSGUI_EXT_CLASS ETSLayoutPropertySheet : public CPropertySheet, protected ETSLayoutMgr
{
DECLARE_DYNAMIC(ETSLayoutPropertySheet)
// Construction
public:
ETSLayoutPropertySheet(UINT nIDCaption, CWnd *pParentWnd = NULL, UINT iSelectPage = 0, LPCTSTR strName=NULL, bool bGripper=true);
ETSLayoutPropertySheet(LPCTSTR pszCaption, CWnd *pParentWnd = NULL, UINT iSelectPage = 0, LPCTSTR strName=NULL, bool bGripper=true);
// Operationen
public:
void SetAutoDestroy() { m_bAutoDestroy = true; }
void SetAutoDestroyPages() { m_bAutoDestroyPages = true; }
void ModelessWithButtons() { m_bModelessButtons = true; }
// Overrides
virtual void AddMainArea(CPane paneRoot, CPaneBase itemTab);
virtual void AddButtons(CPane paneBottom);
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(ETSLayoutPropertySheet)
public:
virtual BOOL OnInitDialog();
virtual void PostNcDestroy();
//}}AFX_VIRTUAL
// Implementation
public:
virtual ~ETSLayoutPropertySheet();
// Generated message map functions
protected:
//{{AFX_MSG(ETSLayoutPropertySheet)
afx_msg int OnCreate(LPCREATESTRUCT lpCreateStruct);
afx_msg void OnSize(UINT nType, int cx, int cy);
afx_msg void OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI);
afx_msg void OnDestroy();
afx_msg BOOL OnEraseBkgnd(CDC* pDC);
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
void Resize(int cx, int cy);
friend class ETSLayoutPropertyPage;
void Init(LPCTSTR strName, bool bGripper);
CRect m_rcStart;
CRect m_rcPage;
bool m_bGripper;
CStatusBar m_StatusBar;
CPaneBase m_ItemTab;
bool m_bAutoDestroy;
bool m_bAutoDestroyPages;
bool m_bModelessButtons;
};
/**
* Base class for the Layout function. Derive your own class
* from this or derive it from CPropertyPage and
* modify _all_ references to CPropertyPage to
* ETSLayoutPropertyPage
*/
class ETSGUI_EXT_CLASS ETSLayoutPropertyPage : public ETSLayout::CBasePropertyPage, protected ETSLayoutMgr
{
friend class ETSLayoutPropertySheet;
DECLARE_DYNCREATE(ETSLayoutPropertyPage)
// Konstruktion
public:
ETSLayoutPropertyPage( );
ETSLayoutPropertyPage( UINT nIDTemplate, UINT nIDCaption = 0 );
ETSLayoutPropertyPage( LPCTSTR lpszTemplateName, UINT nIDCaption = 0 );
~ETSLayoutPropertyPage();
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(ETSLayoutPropertyPage)
public:
virtual BOOL OnSetActive();
//}}AFX_VIRTUAL
// Implementation
protected:
// Generated message map functions
//{{AFX_MSG(ETSLayoutPropertyPage)
afx_msg void OnSize(UINT nType, int cx, int cy);
afx_msg void OnGetMinMaxInfo(MINMAXINFO FAR* lpMMI);
virtual BOOL OnInitDialog();
afx_msg BOOL OnEraseBkgnd(CDC* pDC);
afx_msg void OnWindowPosChanging( WINDOWPOS* lpwndpos );
afx_msg void OnDestroy();
afx_msg void OnWindowPosChanged(WINDOWPOS FAR* lpwndpos);
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
virtual CRect GetRect();
bool m_bLockMove;
bool m_bResetBuddyOnNextTimeVisible;
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Developer Studio will insert additional declarations immediately before the previous line.
#endif // !defined(ETS_LAYOUTMGR_INCLUDED_)
Submit an article or tip