 |
Platforms, Frameworks & Libraries »
MFC »
The Ultimate Toolbox
Intermediate
License: The Code Project Open License (CPOL)
The Ultimate Toolbox Graphical User Interface ClassesBy The Ultimate ToolboxThe Ultimate Toolbox GUI classes offer a wide range of MFC control extensions. |
VC6Win2K, Win2003, Visual Studio, MFC, Dev
|
|
Advanced Search Add to IE Search |
|
|
|
||||||||||||||||
Visit the Ultimate Toolbox main page for an overview and configuration guide to the Ultimate Toolbox library.
The Graphical User Interface classes have been among the most popular MFC extensions available in the Ultimate Toolbox library.
The COXBackgroundPainter class is designed to simplify the process of window background painting. This class hooks the underlying WindowProc of the attached window and implements WM_ERASEBKGND processing:
int CBackgroundPainterView::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
if (CView::OnCreate(lpCreateStruct) == -1)
return -1;
((CMainFrame*)AfxGetMainWnd())->GetPainter()->Attach(
this,IDB_WALLPAPER); // IDB_WALLPAPER specifies the bitmap
// resource to use
return 0;
}
COXRoundedButton is derived from COXBitMapButton, and can be shaped and shaded to add a bit of splash to your app:
m_btnRound.SetAmbientCoef(m_fAmbient/10,FALSE);
m_btnRound.SetDiffuseCoef(m_fDiffuse/10,FALSE);
m_btnRound.SetLightIntensityCoef(m_fLightIntensityCoef/10,FALSE);
m_btnRound.SetMirrorCoef(m_fMirror/10,FALSE);
m_btnRound.SetPhi(m_fPhi,FALSE);
m_btnRound.SetPhong(m_nPhong,FALSE);
m_btnRound.SetSphereExternalRadius(m_nSphereExtRadius,FALSE);
m_btnRound.SetSphereInternalRadius(m_nSphereIntRadius,FALSE);
m_btnRound.SetThetta(m_fThetta,FALSE);
m_btnRound.SetButtonColor(m_clrButton,FALSE);
m_btnRound.SetLightColor(m_clrLight,FALSE);
m_btnRound.RedrawWindow();
COXColorPickerButton, and COXFontPickerButton are derived from COXBitMapButton as well.
The Font Pickers article shows the use of a bitmap button in in the COXFontPickerButton class.
COXCalculatorPopup and COXCalculatorEdit provide a quick and easy way to add a calculator facility to your app.
void CCalculatorCtrlDlg::OnBnClickedCalculator()
{
UpdateData();
CRect rc;
GetDlgItem(IDC_BUTTON_CALCULATOR)->GetWindowRect(&rc);
if (m_calc.Pick(m_fValue, ID_OXCALCULATOR_ALIGNBOTTOM, rc))
{
// OK was pressed
m_fValue = m_calc.GetCalculatorCtrl()->GetResult();
UpdateData(FALSE);
}
}
COXCaptionPainter provides gradient and text options for Windows title bars.
// Install caption painter
m_Caption.Attach(this);
COXCaptionInfo* pCI=m_Caption.GetCaptionInfo(TRUE);
pCI->SetBackgroundColor(RGB(128,255,255));
pCI=m_Caption.GetCaptionInfo(FALSE);
pCI->SetBackgroundColor(RGB(255,255,128));
SendMessage(WM_NCPAINT);
A customized color picker control.
See the Color Picker article for more information on COXColorPickerCtrl and COXColorPickerButton.
COXHistoryCombo and COXMultiComboBox are CComboBox derived controls.
COXHistoryCombo can track a history of previously entered values.
The COXMultiComboBox defines a combo with a multiple column list. More info on COXMultiComboBox can be found here.
The Ultimate Toolbox also provides for the creation of customized combo boxes through the use of COXBaseSubclassedComboBox, which allows for the specification of the combo, list and edit classes to be used in the resulting control. COXFontComboBox is an example of this usage, which combines an MFC CComboBox with a COXFontListBoxHelper and a standard CEdit in specifying the control.
COXBaseSubclassedComboBox is a templated class declaration taking these components as parameters:
template<class PARENTCOMBOBOX, class PARENTLISTBOX, class PARENTEDIT>
class OX_CLASS_DECL COXBaseSubclassedComboBox : public PARENTCOMBOBOX { ... }
So, for example, you could create a CHistoryMaskedComboBox combining the functionality of the COXHistoryCombo and a COXMaskedEdit in the same control thuswise:
class CHistoryMaskedComboBox :
public COXBaseSubclassedComboBox<COXHistoryCombo, CListBox,
COXMaskedEdit> { ... }
The COXFontComboBox described in the Font Picker article is a COXBaseSubclassedComboBox based class.
The COXContextHelpDialog, COXContextHelpPropertyPage, and COXContextHelpPropertySheet classes provide context sensitive help and tooltip support for all child controls.
The COXContextHelpDialog and COXContextHelpPropertyPage classes provide context sensitive help and tooltip support for all child controls. Classes derived from COXContextHelpDialog or COXContextHelpPropertySheet have a small question mark in the upper right-hand corner of the their caption bars. The user can either press this question mark icon and then click and item for help or press F1 on the child control (when it has the input focus) to get help on an item.COXContextHelpPropertySheet.
To enable context-sensitive help in your application's dialogs, property pages and property sheets, you must derive your classes from COXContextHelpDialogCOXContextHelpPropertyPage and COXContextHelpPropertySheetinstead of CDialogCPropertyPage, and CPropertySheet respectively. Also, you must override the GetHelpIDs pure virtual function to return a pointer to an array of help IDs that correspond to child controls in the window. Moreover, you should override the AdjustToolTips virtual member function to provide the embedded tooltip control with information about each child control.
static const DWORD m_nHelpIDs[];
virtual const DWORD* GetHelpIDs() {return m_nHelpIDs;}
const DWORD CTest2Page::m_nHelpIDs[] =
{
IDC_TESTCHECK1, IDH_TESTCHECK1,
IDC_TESTCOMBO1, IDH_TESTCOMBO1,
IDC_TESTBUTTON2, IDH_TESTBUTTON2,
IDC_LIST1, IDH_LIST1,
IDC_SCROLLBAR1, IDH_SCROLLBAR1,
IDD_COLOR, IDH_COLOR,
0, 0
};
/////////////////////////////////////////////////////////////////////////////
// CTest2Page message handlers
BOOL CTest2Page::AdjustToolTips()
{
//Set up the Tooltip
BOOL rt = m_Tooltip.AddTool(&m_scroll1, _T("A Scroll Bar"));
ASSERT(rt != 0) ;
rt = m_Tooltip.AddTool(&m_combo1, _T("A Combo Box"));
ASSERT(rt != 0) ;
rt = m_Tooltip.AddTool(&m_check1, _T("A Check Box"));
ASSERT(rt != 0) ;
rt = m_Tooltip.AddTool(&m_button2, _T("A Button"));
ASSERT(rt != 0) ;
rt = m_Tooltip.AddTool(&m_list, _T("A List Box"));
ASSERT(rt != 0) ;
return rt;
}
Various controls can be given the 'cool' look with the COXCoolCtrl template class.
Cool toolbars...
Cool combos...
More cool stuff...
Implementing cool controls in your application is as easy as subclassing MFC member variables, and you can elect to apply the template to existing controls or use some of the Ultimate Toolbox's built in implementations:
// Dialog Data
//{{AFX_DATA(CPropertyPageListTree)
enum { IDD = IDD_DIALOG_LISTTREE };
COXCoolCtrl<CTreeCtrl> m_tree;
COXCoolCtrl<CListCtrl> m_list;
COXCoolCtrl<CListBox> m_listbox;
COXCoolButton m_btnDisable;
COXCoolCtrl<CHotKeyCtrl> m_hotKey;
COXCoolSpinButtonCtrl m_spinUnattached;
COXCoolSpinButtonCtrl m_spinRight;
COXCoolSpinButtonCtrl m_spinLeft;
COXCoolCtrl<CRichEditCtrl> m_richeditMultiline;
COXCoolCtrl<CEdit> m_editSpinUnattached;
COXCoolCtrl<CEdit> m_editSpinRight;
COXCoolCtrl<CEdit> m_editSpinLeft;
COXCoolCtrl<CEdit> m_editPlain;
COXCoolCtrl<COXEdit> m_editExtended;
COXCoolCtrl<COXNumericEdit> m_editNumeric;
COXCoolCtrl<CEdit> m_editMultiline;
COXCoolCtrl<COXMaskedEdit> m_editMasked;
COXCoolCtrl<COXCurrencyEdit> m_editCurrency;
COXCoolButton m_btnDisable;
COXCalendar, COXDateTimeControl, and COXMonthCalControl.
See the Date Time Picker article for more on these classes and their usage.
COXBrowseDirEdit16 and COXBrowseDirEdit offer drop down edit controls featuring a directory browser.
COXSHBDropSource and COXSHBDropTarget provide handling of OLE drag/drop operations in any window.
The 'SHB' in the name of these classes stems from the fact that it was originally intended to be used with a short cut bar, specifically the COXSHBListControl and COXShortcutBar classes - its usage has since been extended to apply to any window.
For more on these classes, please see the overviews in the Graphical User Interface | Drag and Drop section of the compiled HTML help documentation.
Dropdown and various specific masked edit classes.
More information can be found in the Edit Extensions, Physical Unit Edit Classes, and Masked Edit articles.
COXBrowseFileEdit implements a dropdown edit control featuring a file browser.
The COXFileViewer class allows COXPreviewDialog to organize the previewing process in a generic way. The COXPreviewDialog class is required to provide the functionality for previewing as many standard file types as possible while giving the flexibility of previewing only designated file types (e.g. only image files or only text files) and allowing a programmer to easily update the functionality of the class in order to preview proprietary file types.
COXPreviewDialog and COXBmpFileDialog allow for thumbnail type previews of bmp and jpeg files.
/////////////////////////////////////////////////////////////////////////////
// CDIBManagerApp commands
CFileDialog* CDIBManagerApp::NewFileDialog(BOOL bOpenFileDialog, DWORD lFlags)
{
// we provide functionality to open more than one file simultenuosly
lFlags|=OFN_ALLOWMULTISELECT;
// create the dialog with Preview capability
return new COXPreviewDialog(bOpenFileDialog,NULL,NULL,
OFN_ALLOWMULTISELECT|OFN_FILEMUSTEXIST|OFN_PATHMUSTEXIST|
OFN_HIDEREADONLY|OFN_OVERWRITEPROMPT);
}
The COXHistoryCtrl class is a COXScrollWnd based class which is designed to provide facilities to display and save log info (history info).
protected:
COXTabViewPage<coxhistoryctrl /> m_build;
COXTabViewPage<coxhistoryctrl /> m_debug;
COXTabViewPage<coxhistoryctrl /> m_find1;
COXTabViewPage<coxhistoryctrl /> m_find2;
COXTabViewPage<coxhistoryctrl /> m_results;
COXTabViewPage<coxhistoryctrl /> m_SQLdebug;
// build page
if(!m_build.Create(NULL,NULL,WS_CHILD,CRect(0,0,0,0),
&m_TabViewContainer,1))
return -1;
m_TabViewContainer.AddPage(&m_build,_T("Build"));
m_build.AddLine(_T("Generating Code..."));
m_build.AddLine(_T("Linking..."));
m_build.AddLine(_T(""));
m_build.SetTextColor(RGB(255,0,0));
m_build.AddLine(_T("VisualStudioLikeDemo.exe - 0 error(s),
0 warning(s)"));
New in version 9.3, the hyperbar control is an MFC control, derived principally from CToolbar, which can be added to any project and which will give the floating toolbar look seen in the Microsoft Expression 'Hyperbar' sample.
See the HyperBar article for more on using this class in your application.
COXGridList, COXEditList, COXImageListBox, COXListBoxEx, and COXFontList MFC extensions.
See the Extended List Box article for more on these classes.
COXLayoutManager can be attached to a container window to manage the layout of its child windows.
m_LayoutManager.TieChild(IDC_OX_GROUP_PAINT_TYPE,
OX_LMS_LEFT|OX_LMS_RIGHT,OX_LMT_SAME);
m_LayoutManager.TieChild(IDC_OX_ALIGN_STRETCH,OX_LMS_RIGHT,OX_LMT_SAME);
m_LayoutManager.TieChild(IDC_OX_ALIGN_TOPRIGHT,OX_LMS_RIGHT,OX_LMT_SAME);
m_LayoutManager.TieChild(IDC_OX_ALIGN_CENTERRIGHT,OX_LMS_RIGHT,
OX_LMT_SAME);
m_LayoutManager.TieChild(IDC_OX_ALIGN_BOTTOMRIGHT,OX_LMS_RIGHT,
OX_LMT_SAME);
See the Layout Manager article for more on structure and usage of this class.
COXBitmapMenu and COXBitmapMenuOrganizer allow for bitmap enhanced menu items.
// Let the menu organizer fix our menus
Organizer.AttachFrameWnd(this);
// Set images from toolbar to use with corresponding menu items
Organizer.AutoSetMenuImage();
// explicitly designate images to use with menu items
Organizer.SetMenuBitmap(ID_TEST_PAGE, MAKEINTRESOURCE(IDB_PAGE));
Organizer.SetMenuBitmap(ID_TEST_HELLO, MAKEINTRESOURCE(IDB_HELLO));
Organizer.SetMenuBitmap(ID_TEST_MARKEDPAGE, MAKEINTRESOURCE(
IDB_MARKEDPAGE));
Organizer.SetMenuBitmap(ID_TEST_DISABLED, MAKEINTRESOURCE(IDB_EXPLORE));
Organizer.SetMenuBitmap(ID_TEST_ENABLED, MAKEINTRESOURCE(IDB_EXPLORE));
COXMenuBarFrame, COXMenuDockBar and COXMenuBar provide a framework of classes that support dockable menu bars.
To automagically enable these menu bars in your application, simply derive your main frame window from COXMenuBarFrame:
class CMainFrame : public COXMenuBarFrame<CFrameWnd,CDockBar>
or
class CMainFrame : public COXMenuBarFrame<CMDIFrameWnd,CDockBar>
COXPopupBarCtrl is a generic class designed specifically as a base class to provide basic functionality of any Popup Bar control.
The Popup Bar control is a top most popup window with items on it that can be chosen using the mouse or keyboard. For example, standard Popup Menu Bar or Color Picker from Word 97 are Popup Bar controls. Below is one example of how our Popup Bar can be graphically represented:
On display, the Popup Bar control captures all mouse messages and hides itself if any mouse button is clicked or the user presses ESC, ENTER or SPACE buttons. If, when clicked the mouse wasn't over any button within the Popup Bar, or the user pressed ESC, then nothing is chosen and the Pick function returns FALSE.
In this handler for the toolbar's TBN_DROPDOWN notification, the specific popup is displayed through a call to the Pick method:
void CMainFrame::OnDropDownCustomizeToolbar(NMHDR* pNotifyStruct,
LRESULT* pResult)
{
CFrameWnd* pFrame=GetActiveFrame();
ASSERT(pFrame);
CPopupBarDoc* pDoc = (CPopupBarDoc*)pFrame->GetActiveDocument();
ASSERT(pDoc);
ASSERT_VALID(pDoc);
// this function handles the dropdown menus from the toolbar
NMTOOLBAR* pNMToolBar = (NMTOOLBAR*)pNotifyStruct;
CRect rect;
COXCoolToolBar* pToolBar=GetCustomizeToolBar();
// translate the current toolbar item rectangle into screen coordinates
// so that we'll know where to pop up the menu
pToolBar->GetItemRect(pToolBar->CommandToIndex(
pNMToolBar->iItem), &rect);
::ClientToScreen(pNMToolBar->hdr.hwndFrom, &rect.TopLeft());
::ClientToScreen(pNMToolBar->hdr.hwndFrom, &rect.BottomRight());
COLORREF clr;
COXColorPickerCtrl colorPicker;
switch(pNMToolBar->iItem)
{
case ID_CUSTOMIZE_TEXT_COLOR:
{
if(::IsWindow(colorPicker.m_hWnd) || colorPicker.Create(pToolBar))
{
clr=pDoc->GetTextColor();
colorPicker.SetSelectedColor(clr);
colorPicker.SetDefaultColor(pDoc->GetDefaultTextColor());
if(colorPicker.Pick(ID_POPUPBAR_ALIGNBOTTOM,&rect))
{
clr=colorPicker.GetSelectedColor();
pDoc->SetTextColor(clr);
}
}
break;
}
case ID_CUSTOMIZE_FILL_COLOR:
...
case ID_CUSTOMIZE_BORDER_COLOR:
...
case ID_CUSTOMIZE_BORDER_STYLE:
...
case ID_CUSTOMIZE_LINE_STYLE:
...
case ID_CUSTOMIZE_DASH_STYLE:
}
pToolBar->InvalidateRect(rect);
pDoc->UpdateAllViews(NULL);
*pResult = TBDDRET_DEFAULT;
}
See the COXPopupBarCtrl class reference for more on the creation and usage of this class.
The COXRollup& classes work together to bring the magic of rollup windows to your MFC application.COXTitleBar
The samples\gui\rollup sample derives CMaxVirtDialog from COXRollup:
void CRoll32View::OnLButtonDblClk(UINT nFlags, CPoint point)
{
UNREFERENCED_PARAMETER(nFlags);
CMaxVirtDialog *pMaxVirt = new CMaxVirtDialog(this);
TCHAR achBuffer[64];
UTBStr::stprintf(achBuffer, 64,_T("MVT: %ld"),::GetTickCount());
pMaxVirt->CreateRollUp(this,15,achBuffer);
ClientToScreen(&point);
pMaxVirt->SetWindowPos(
NULL,point.x,point.y,0,0,SWP_NOZORDER|SWP_NOSIZE);
pMaxVirt->ShowWindow(SW_SHOWNORMAL);
// if you�re searching for the delete, see maxvirtd.cpp PostNcDestroy
// and OnCloseRollup
}
COXRulerBar and COXRulerBarOrganizer allow for the display of horizontal and/or vertical ruler bars in any window.
The samples\graphics\ImageViewer sample shows the ruler bar classes in action, through the COXScrollWnd class:
#ifdef OXSCRLWND_USE_RULER
// --- In : bHorzRuler - horizontal ruler band will be displayed
// bVertRuler - vertical ruler band will be displayed
// --- Out :
// --- Returns: TRUE if COXRulerOrganizer object was successfully
// attached
// --- Effect: attaches to COXRulerOrganizer object which is
// responsible for displaying ruler bars
inline BOOL AttachRuler(BOOL bHorzRuler=TRUE, BOOL bVertRuler=TRUE) {
if(m_ruler.IsAttached())
{
SetShowHorzRulerBar(bHorzRuler);
SetShowVertRulerBar(bVertRuler);
return TRUE;
}
return m_ruler.Attach(this,bHorzRuler,bVertRuler);
}
COXScrollWnd and COXZoomView provide scrolling and scaling functionality.
COXZoomView derived CDIBManagerView view.
COXZoomView features:
Handles MM_ANISOTROPIC.
Scrollsizes now definable in percent of the client area, updated on resizing.
ScrollToPosition allows the anchor to be the upper left corner, or additionally the lower left corner or the center of the window.
Accepts a CRect for the document size, so the origin can be located in the lower left corner or the center or any arbitrary point of the document. You don't need to handle negative y-coords any more !
Zoom level can vary between 10% and 1000%
When zooming, either keeps the upper left window corner, the lower left window corner or keeps the center.
Allows zooming up to a rectangle ( in client coords ).
After zooming, the rectangle can be justified to either the upper left or lower left corner or to the window center.
Allows zooming to the window size (so the scrollbars just disappear).
void CDIBManagerView::OnViewZoomIn()
{
// TODO: Add your command handler code here
// up current zoom level on 100% if it is more than 100% already
// or on 10% otherwise
int nZoomLevel=GetZoomLevel();
if(nZoomLevel"code-string" nmargin="<span" />"nZoomLevel" />=100 ? 100 : 10;
nZoomLevel+=nMargin;
SetZoomLevel(nZoomLevel);
if(GetZoomLevel()>ID_MAX_ZOOM_LEVEL)
{
SetZoomLevel(ID_MAX_ZOOM_LEVEL);
}
// if roll-up ZoomLevel dialog is active then
// notify it that current zoom level is changed
NotifyZoomChanged();
}
}
COXImageViewer class is derived from COXScrollWnd, shown here in action in the samples\graphics\imageviewer example.
COXScrollWnd features mirror some of the features of COXZoomView. COXScrollWnd is a virtual base class designed to provide basic scrolling and scaling functionality.
Supports MM_ANISOTROPIC mapping mode.
Scroll sizes can be defined in percent of the client area
ScrollToPosition() allows the anchor to be the upper left corner, or additionally the lower left corner or the center of the window.
Accepts a CRect for the contents size, so the origin can be located in the lower left corner or the center or any arbitrary point of the control.
You don't need to handle negative y-coords
Zoom level can vary between 10% and 1000%
When zooming, either keeps the upper left window corner, the lower left window corner or keeps the center.
Allows zooming up to a rectangle (in client coords).
After zooming, the rectangle can be justified to either the upper left or lower left corner or to the window center.
Allows zooming to the window size (so the scrollbars just disappear).
Output can be aligned vertically and horizontally.
Supports smooth scrolling which means that the process of scrolling of the contents from one position to another is divided in a number of smaller scrolling processes
Supports 'Always fit to window' option that if set will scale the contents of the control to its size whenever it is resized
Context menu can be displayed that allows a user easily set most used zoom levels
Track zooming option is supported which means that when a user left clicks and drag the mouse cursor the tracker will be displayed so a user can choose the rectangle to which the contents must be zoomed
Scrolling using mouse wheel is supported
COXRulerBarOrganizer class) See the compiled HTML help documentation for complete class references for COXZoomView and COXScrollWnd.
COXSeparator is a simple control that placed in the right position in a dialog or form view can greatly improve the way your applications look.
// setup vertically oriented separators
static CFont fontVertEnabled;
VERIFY(fontVertEnabled.CreatePointFont(120,_T("Times New Roman")));
m_ctlSepVertRight.SetVertOriented();
m_ctlSepVertRight.SetFont(&fontVertEnabled);
m_ctlSepVertPlain.SetVertOriented();
m_ctlSepVertLeft.SetVertOriented();
m_ctlSepVertLeft.SetFont(&fontVertEnabled);
m_ctlSepVertCenter.SetVertOriented();
m_ctlSepVertCenter.SetFont(&fontVertEnabled);
COXSpinCtrlextends, the MFC CSpinButtonCtrl class; it extends the functionality of the common control that MFC wraps. Apart from the two buttons (up and down) it shows a small rectangle (called "the spin thumb") inbetween these two buttons. When the user clicks and holds this rectangle, the mouse cursor will change shape, and the user can drag the mouse to increase or decrease the value.
COXStatic, COXStaticText and COXStaticHyperLink controls.
See the Static Hyperlink and Static Text articles for more on these classes.
An enhanced CStatusBar implementation.
wsprintf(buffer, _T("%02.2d:%02.2d:%02.2d"),
datetime.tm_hour, datetime.tm_min, datetime.tm_sec);
if (datetime.tm_sec == 0 || datetime.tm_sec == 30)
{
m_wndStatusBar.ResetBar(1);
m_wndStatusBar.SetBarProgress(1, TRUE, 30, 0);
}
else
{
m_wndStatusBar.SetBarProgress(1, TRUE, 31, datetime.tm_sec % 30);
}
if((datetime.tm_sec % 2) == 0)
m_wndStatusBar.SetPaneText( 5, (LPCTSTR)buffer, RGB(255,0,0),
TRUE);
else
m_wndStatusBar.SetPaneText( 5, (LPCTSTR)buffer);
}
A popular Outlook style shortcut bar.
// outlook group
sText=_T("Outlook");
shbGroup.nMask=SHBIF_TEXT;
shbGroup.nTextMax=sText.GetLength();
shbGroup.pszText=sText.GetBuffer(shbGroup.nTextMax);
sText.ReleaseBuffer();
m_ctlShortcutBar.InsertGroup(&shbGroup);
// mail group
sText=_T("Mail");
shbGroup.nMask=SHBIF_TEXT;
shbGroup.nTextMax=sText.GetLength();
shbGroup.pszText=sText.GetBuffer(shbGroup.nTextMax);
sText.ReleaseBuffer();
m_ctlShortcutBar.InsertGroup(&shbGroup);
The COXShape class defines an abstract C++ class to encapsulate the Windows SetWindowsRgn API.
for(nID = IDC_0; nID <= IDC_9; nID++)
{
pKey = (CCalcKey*) GetDlgItem(nID);
ASSERT(pKey != NULL);
// Make them star shaped
pKey->SetStarShape();
// Set color to yellow when not pressed, red when pressed
pKey->SetColors(RGB(0,0,0),RGB(255,255,0),RGB(0,0,0),RGB(255,0,0));
}
COXTabViewContainer and COX3dTabViewContainer implements two types of widows supporting multiple tabs.
See the 3D Tab Views article for more on these classes.
COXTabWorkspace and COXTabClientWnd are used to implement a frame work that implements a tabbed MDI architecture.
The samples\gui\CoolToolBar\Multipad2 sample shows the tabbed MDI framework in action.
Implementing a tabbed MDI application is quite simple:
COXTabClientWnd object in your CMDIFrameWnd derived class (usually CMainFrame). // MTI client window
COXTabClientWnd m_MTIClientWnd;
OnCreate() function of your CMDIFrameWnd derived class call the COXTabClientWnd::Attach function m_MTIClientWnd.Attach(this);
That's it! You can learn more about the classes in the compiled HTML help documentation.
COXTreeControl, COXTreeItem, COXOptionTreeControl and COXNetBrowseTree.
See the articles on the Network Browser and Option Tree controls for more information on these extensions.
COXToolTipCtrl is an extended tooltip control that allows multiline tooltips, plus extended tooltip text.
Please see the COXToolTipCtrl article for more information.
COXUserTool provides a way of implementing a special menu in your application where users can insert their own tools.
This class provides a way of implementing a special menu in your application where users can insert their own tools. These tools can then be executed from within your application. (Similar to the Tools menu in the Developer Studio IDE). This class features:
The same set of parameters the VisualC++ IDE uses, like MenuText, Command, Arguments and Initial Directory
Built-in functionality to work with your own symbolic arguments like the $(FileName) or $(FileDir) variables.
Some helper functions to read and write ToolSets to file
To use the COXUserTool class you must determine in which menu the UserTools will be located. This menu can be your CMainFrame menus or a menu from another window. Next, select a range of MenuIDs big enough to cover your maximum number of Usertools so as to enable your CMainFrame (or other window) to route the command messages coming from the menu selections of your usertools.
const UINT ID_TOOLS_USER_1 = 32771;
const UINT MAX_TOOLS_USER = 10;
BEGIN_MESSAGE_MAP(CMainFrame, CMDIFrameWnd)
//{{AFX_MSG_MAP(CMainFrame)
// NOTE - the ClassWizard will add and remove mapping macros here.
// DO NOT EDIT what you see in these blocks of generated code !
ON_WM_CREATE()
ON_COMMAND(ID_TOOLS_CUSTOMIZE, OnToolsCustomize)
ON_COMMAND_RANGE(ID_TOOLS_USER_1, ID_TOOLS_USER_1 + MAX_TOOLS_USER,
OnToolsExecute)
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
The ON_COMMAND_RANGE macro is particularly suitable for catching the complete range of command messages fired by the Usertool menu selections. The OnToolsExecute function has an input parameter nID in which the Command ID of a menu selection is trapped.
void CMainFrame::OnToolsExecute(UINT nID)
{
int iIndex = (int)( nID - ID_TOOLS_USER_1 );
if ( -1 < iIndex && iIndex < m_ToolArray.GetSize() )
{
COXUserTool* pTool = (COXUserTool*)m_ToolArray.GetAt( iIndex );
ASSERT( pTool != NULL );
CStringList Replacements;
// ....(fill up a Replacements list)
BOOL bOk = pTool->Execute( &Replacements );
ASSERT(bOk);
if (!bOk)
AfxMessageBox(
"Could not execute Tool", MB_OK | MB_ICONEXCLAMATION);
}
Usertools are created and initialized by newly selecting and assigning the 4 member variables. Note that to keep track of the tools created, a CObArray is used. This is the preferred method because there are 4 helper functions in COXUserTool that work with a CObArray. Thus the CObArray contains a collection of COXUserTools. More on that later.
// add some user tools to the UserToolArray
COXUserTool* pNewTool = new COXUserTool();
pNewTool->SetMenuText("NotePad");
pNewTool->SetCommand("c:\\winnt35\\NotePad.exe");
pNewTool->SetArgs("README.TXT");
pNewTool->SetDirectory("c:\\decoder");
m_ToolArray.Add(pNewTool);
The 4 helper functions are :
BOOL ReadUserToolFile( LPCTSTR pcszFilename, CObArray& a ) : Gets a reference to a CObArray and name of a diskfile. Reads the diskfile into the CObArray.
BOOL WriteUserToolFile( LPCTSTR pcszFilename, CObArray& a ) : Gets a reference to a CObArray and name of a diskfile. Writes the diskfile while iterating the usertools in the CObArray.
BOOL AppendUserTools( CMenu* pMenu, UINT uiFirstID, const CObArray& a ) : Searches in pMenu for a MenuItem with ID uiFirstID and starts appending all UserTools contained in the CObArray to this MenuItem. CMenu* pMenu = NULL; pMenu = GetMenu(); // get a pointer to the main menu if (pMenu != NULL) { // The tools menu is the fourth menu in the main menu // after File, Edit an View (see resource editor) CMenu* pSubMenu = pMenu->GetSubMenu(3); if (pSubMenu != NULL) AppendUserTools(pSubMenu ,ID_TOOLS_USER_1, m_ToolArray); }
void EmptyUserToolArray( CObArray& a ) : No need for a FOR loop to clean-up the allocated COXUserTools in the CObArray, this function does it for you. See the compiled HTML help documentation for a complete COXUserTool class reference.
COXHookWnd and COXHookWndMap allow for hooking a window's default WindowProc.
COXHookWnd is a generic class to allow you to intercept messages that are targeted at a CWnd. Once hooked, all messages first route through COXHookWnd::WindowProc before going to the window they were originally intended for. Specific subclasses of COXHookWnd can trap messages and perform custom handling for those messages. To use the hook simply follow these steps:
COXHookWnd. COXHookWnd::WindowProc virtual function to handle all the incoming messages. Be sure to call the base class implementation of COXHookWnd::WindowProc if the message is not handled, or the window for which the messages were intended will never be notified of the messages. If you write separate message handlers, you can call COXHookWnd::Default to pass the messages back to the window. COXHookWnd::Default calls the CWnd::Default function to pass the notification back to the CWnd. COXHookWnd::HookWindow function to hook your window, after it has been created. To unhook the window, call COXHookWnd::UnhookWindow. The message hook map (class COXHookWndMap) is derived from CMapPtrToPtr, which associates a pointer with another pointer. It maps an HWND to a COXHookWnd, like the way MFC's internal maps map HWNDs to CWnds. The first hook attached to a window is stored in the map; all other hooks for that window are then chained via COXHookWnd::m_pNext.
The purpose of these classes is to create an effective object oriented solution to the "inheritance message handling problem". Let's assume we have an application with many CView derived objects, such as CFormView, CListView, CTreeView, etc. Furthermore, let's assume that these windows all need to exhibit some common functionality upon receipt of a particular message. Ideally, we would change the CView base class to intercept this message and provide the custom handling. In that case, any CView derived class would exhibit the same functionality for that given message. Unfortunately, however, we cannot change the CView base class as it lies deep within MFC code and would force us to recompile the MFC library. Also, we're not willing to rewrite the CFormView, CListView, CTreeView, etc. classes to use a our own custom CView class. But how do we get the common message handling without intercepting the message in every class? The solution is quite simple using the COXHookWnd class.
To provide this custom handling across all windows, derive a class from COXHookWnd, say CMyCustomHook, and override the COXHookWnd::WindowProc virtual function to handle the message. Then for every window that requires the custom message handling, instantiate a CMyCustomHook object and hook the window to the object using the COXHookWnd::HookWindow function. You will need to instantiate a CMyCustomHook object for every window you wish to hook. Then, every window hooked with the CMyCustomHook hook will first allow that COXHookWnd object to examine the messages before re-routing them to the owned window. Be sure to call COXHookWnd::UnhookWindow when you no longer with to have a window's messages hooked or when the window is being destroyed.
The COXHookWnd class provides the backbone functionality for several of the Ultimate Toolbox's classes. These classes include: COXBackgroundPainter, COXCaptionInfo, COXIntelliMouse, COXItemTip, COXRulerBar, and COXSoundEffectManager. Because of the COXHookWnd & COXHookWndMap classes, these objects can get "first rights" to particular messages. That is, before a window that exploits the sound manager object, for example, the COXSoundEffectManager must determine if a sound file should be played. To do this, The COXSoundEffectManager class overrides the COXHookWnd::WindowProc virtual function to provide its custom handling (playing of a sound file) for those messages registered with the object.
Initial CodeProject release August 2007.
General 
News 
Question 
Answer 
Joke 
Rant 
Admin
|
PermaLink |
Privacy |
Terms of Use
Last Updated: 25 Aug 2007 Editor: Sean Ewington |
Copyright 2007 by The Ultimate Toolbox Everything else Copyright © CodeProject, 1999-2009 Web21 | Advertise on the Code Project |
