MFC Feature Pack and Ribbon UI

Analogy categoryAnalogies

From CFrameWnd to CFrameWndEx

The Feature Pack, released as a free add-on for Visual Studio 2008 and later folded into Visual Studio 2010's box product, introduced CFrameWndEx as an extended replacement for the classic CFrameWnd/CMDIFrameWnd, adding built-in support for docking panes, ribbon bars, and the new visual-manager theming system without requiring the developer to hand-roll owner-drawn toolbars. An existing MFC application migrates by changing its main frame's base class to CFrameWndEx (and CMDIChildWndEx for MDI children), which unlocks member functions like CreateDockingPane and EnablePaneMenu that simply don't exist on the legacy frame classes. Because the Feature Pack was designed to coexist with older MFC UI code, a CFrameWndEx-based application can still keep a conventional CToolBar and CStatusBar alongside the new ribbon and docking infrastructure during an incremental migration.

🏏

Cricket analogy: Migrating a main frame from CFrameWnd to CFrameWndEx is like a franchise upgrading from a wooden pavilion to a modern stadium complex with hospitality boxes - the pitch and rules stay the same, but a whole new tier of features becomes available.

Building a Ribbon Bar

A ribbon is assembled in code as a CMFCRibbonBar owned by the main frame, populated with CMFCRibbonCategory objects (the ribbon's tabs, e.g. 'Home' or 'View'), each containing CMFCRibbonPanel groups, which in turn hold individual command elements such as CMFCRibbonButton, CMFCRibbonEdit, or CMFCRibbonGallery, all wired to the same command IDs and update-handler mechanism (ON_COMMAND/ON_UPDATE_COMMAND_UI) that classic toolbars and menus already used, so a single command ID can simultaneously drive a ribbon button, a keyboard accelerator, and a legacy toolbar button. The Visual Studio Ribbon Designer (available once a project references the Feature Pack) lets a developer lay out categories, panels, and buttons visually and generates the corresponding C++ construction code, though many real projects still hand-tune the CMFCRibbonBar::AddCategory/AddButton calls for precise control over grouping and gallery content. Quick Access Toolbar customization and the Application Button (the round button in the top-left replacing the classic File menu) are both built on the same CMFCRibbonBar infrastructure and require minimal extra wiring once the base ribbon exists.

🏏

Cricket analogy: CMFCRibbonCategory tabs like 'Home' and 'View' are like a broadcast's separate camera-feed tabs for 'Live Match', 'Replays', and 'Stats' - each a distinct, organized grouping of related tools for the viewer to switch between.

Docking Panes and Visual Managers

CDockablePane is the Feature Pack's base class for tool windows like a Solution Explorer-style tree or an Output window, created with CDockablePane::Create and attached to the frame with CFrameWndEx::DockPane, after which the pane can be dragged, docked to any edge, tabbed together with other panes, or auto-hidden by the user exactly like panes in Visual Studio itself. Visual appearance across the ribbon, toolbars, and docking panes is centralized through CMFCVisualManager and its subclasses (CMFCVisualManagerOffice2007, CMFCVisualManagerWindows7, CMFCVisualManager2013, etc.), selected once at startup with CMFCVisualManager::SetDefaultManager so the whole application's chrome switches theme consistently rather than requiring per-control styling code. Because the visual manager owns drawing for nearly everything - ribbon, menus, toolbars, panes, even the property grid control CMFCPropertyGridCtrl - switching from, say, the Office 2007 look to the Windows 7 look is typically a one-line change rather than a UI rewrite.

🏏

Cricket analogy: CDockablePane behaving like Visual Studio's own panes - draggable, dockable, auto-hidable - is like a broadcast production's customizable overlay panels that a director can reposition or minimize on the fly without redesigning the whole graphics package.

cpp

// CMainFrame : public CFrameWndEx
BOOL CMainFrame::OnCreate(LPCREATESTRUCT lpCreateStruct)
{
    if (CFrameWndEx::OnCreate(lpCreateStruct) == -1) return -1;

    // Choose the visual theme once for the whole app
    CMFCVisualManager::SetDefaultManager(RUNTIME_CLASS(CMFCVisualManagerWindows7));

    m_wndRibbonBar.Create(this);
    m_wndRibbonBar.LoadFromResource(IDR_RIBBON);

    if (!m_wndOutputPane.Create(_T("Output"), this, CRect(0, 0, 200, 100),
                                TRUE, ID_VIEW_OUTPUTWND,
                                WS_CHILD | WS_VISIBLE | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | CBRS_LEFT))
        return -1;

    m_wndOutputPane.EnableDocking(CBRS_ALIGN_ANY);
    DockPane(&m_wndOutputPane);

    return 0;
}

A single command ID drives every UI surface in the Feature Pack: the same ON_COMMAND/ON_UPDATE_COMMAND_UI handlers written for a classic menu item automatically light up, gray out, or check a corresponding CMFCRibbonButton with zero extra code.

Mixing an unmigrated CToolBar-based command routing scheme with a ribbon can produce inconsistent enabled/disabled states if update handlers assume they'll only ever be asked about a classic toolbar button; always verify ON_UPDATE_COMMAND_UI handlers behave correctly when invoked from ribbon elements too.

The Feature Pack (VS2008 add-on, later part of VS2010) introduced CFrameWndEx/CMDIChildWndEx as extended replacements for the classic frame classes.
A ribbon is built from CMFCRibbonBar > CMFCRibbonCategory (tabs) > CMFCRibbonPanel (groups) > individual command elements like CMFCRibbonButton.
Ribbon elements reuse the existing ON_COMMAND/ON_UPDATE_COMMAND_UI infrastructure, so one command ID drives ribbon, menu, and toolbar consistently.
The Application Button and Quick Access Toolbar are built on the same CMFCRibbonBar infrastructure as the rest of the ribbon.
CDockablePane provides Visual-Studio-style draggable, dockable, tabbable, auto-hidable tool windows attached via CFrameWndEx::DockPane.
CMFCVisualManager and its subclasses centralize theming across ribbon, toolbars, panes, and CMFCPropertyGridCtrl.
SetDefaultManager lets an entire application's visual theme switch with a single line of code at startup.