{
#ifndef DT_HIDEPREFIX
      const UINT DT_HIDEPREFIX = 0x00100000;
#endif // DT_HIDEPREFIX
      int nTab = -1;
      for( int i = 0; i < ::lstrlen(lpstrText); i++ ) {
         if( lpstrText[i] == '\t' ) {
            nTab = i;
            break;
         }
      }
      dc.SetTextColor(color);
      UINT uFlags = DT_SINGLELINE | DT_VCENTER;
      if( !m_bShowKeyboardCues ) uFlags |= DT_HIDEPREFIX;
      dc.DrawText(lpstrText, nTab, &rc, DT_LEFT | uFlags);
      if( nTab >= 0 ) dc.DrawText(&lpstrText[nTab + 1], -1, &rc, DT_RIGHT | uFlags);
   }

   static void DrawShadowIcon(CDCHandle& dc, HIMAGELIST hImageList, POINT pt, int nImage)
   {
#if (_ATL_VER >= 0x0700)
      HICON hIcon = ImageList_ExtractIcon(ATL::_AtlBaseModule.GetResourceInstance(), hImageList, nImage);
#else
      HICON hIcon = ImageList_ExtractIcon(_Module.GetResouceInstance(), hImageList, nImage);
#endif
      CBrush brush;
      brush.CreateSolidBrush( m_xpstyle.clrShadow );
      SIZE sz = { 0, 0 };
      dc.DrawState( pt, sz, hIcon, DSS_MONO, brush);
      ::DestroyIcon(hIcon);
   }

   static void DrawCheckmark(CDCHandle& dc, RECT rc, bool bSelected, bool /*bDisabled*/, bool /*bRadio*/, bool bChecked)
   {
      ::InflateRect(&rc, -3, -3);
      COLORREF clrBackground = bSelected ? m_xpstyle.clrHighlightDark : m_xpstyle.clrHighlight;
      CBrush brush;
      CPen pen;
      brush.CreateSolidBrush(clrBackground);
      pen.CreatePen(PS_SOLID, 1, m_xpstyle.clrHighlightBorder);
      HPEN hOldPen = dc.SelectPen(pen);
      HBRUSH hOldBrush = dc.SelectBrush(brush);
      dc.Rectangle(&rc);
      dc.SelectPen(hOldPen);
      dc.SelectBrush(hOldBrush);

      if( bChecked ) {
         // Draw checkmark...
         // This is really a job for DrawFrameControl(), but it's a little
         // complex (see atlctrlw.h Draw3DCheckmark()... )
#ifndef OEMRESOURCE
         const UINT OBM_CHECK = 32760;
#endif // OEMRESOURCE
         CBitmap bmp;
         bmp.LoadOEMBitmap(OBM_CHECK);
         SIZE szBitmap = { 0 };
         bmp.GetSize(szBitmap);
         SIZE size = { rc.right - rc.left, rc.bottom - rc.top };
         POINT pt = { rc.left + 1 + ((size.cx - szBitmap.cx) / 2), rc.top + ((size.cy - szBitmap.cy) / 2) };
         dc.SetBkColor(clrBackground);
         dc.DrawState(pt, size, bmp, DSS_NORMAL);
      }
   }

   static void DrawArrow(CDCHandle& dc, RECT rc, bool /*bSelected*/)
   {
      // Draw arrow
      HPEN hOldPen = dc.SelectStockPen( BLACK_PEN );
      HBRUSH hOldBrush = dc.SelectStockBrush( BLACK_BRUSH );
      int xMiddle = rc.left + (rc.right - rc.left) / 2;
      int yMiddle = rc.top + (rc.bottom - rc.top) / 2;
      const int ARROW_SIZE = 2;
      POINT pt[] = {
         { xMiddle - ARROW_SIZE, yMiddle - ARROW_SIZE },
         { xMiddle + ARROW_SIZE, yMiddle - ARROW_SIZE },
         { xMiddle, yMiddle + 1 }
      };
      dc.Polygon(pt, 3);
      dc.SelectPen(hOldPen);
      dc.SelectBrush(hOldBrush);
   }

   // Ownerdrawn toolbar/menubar

   LRESULT OnParentCustomDraw(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandled)
   {
      LRESULT lRet = CDRF_DODEFAULT;
      bHandled = FALSE;

      // Figure out if we're drawing on a known toolbar
      bool bIsMenubar = false;
      bool bKnownToolbar = false;
      if( pnmh->hwndFrom == m_hWnd ) bIsMenubar = true;
      int cnt = m_Toolbars.GetSize();
      for( int i = 0; i < cnt; i++ ) {
         if( m_Toolbars[i] == pnmh->hwndFrom ) {
            bKnownToolbar = true;
            break;
         }
      }
      // Ok, custom draw toolbar then...
      if( bIsMenubar || bKnownToolbar )
      {
         LPNMTBCUSTOMDRAW lpTBCustomDraw = (LPNMTBCUSTOMDRAW) pnmh;
         if( lpTBCustomDraw->nmcd.dwDrawStage == CDDS_PREPAINT )
         {
            lRet = CDRF_NOTIFYITEMDRAW;
            bHandled = TRUE;
         }
         else if( lpTBCustomDraw->nmcd.dwDrawStage == CDDS_ITEMPREPAINT )
         {  
            // Get item information
            CDCHandle dc(lpTBCustomDraw->nmcd.hdc);
            HFONT hOldFont = dc.SelectFont(m_fontMenu);
            _DrawToolbarButton(lpTBCustomDraw, m_dwExtendedStyle, m_bShowKeyboardCues, bIsMenubar);
            dc.SelectFont(hOldFont);
            lRet = CDRF_SKIPDEFAULT;
         }
         bHandled = TRUE;
      }
      // Paint gripper bar
      else if( pnmh->hwndFrom == GetParent() ) 
      {
         LPNMCUSTOMDRAW lpCustomDraw = (LPNMCUSTOMDRAW) pnmh;
         if( lpCustomDraw->dwDrawStage == CDDS_PREPAINT )
         {
            lRet = CDRF_NOTIFYITEMDRAW;
            bHandled = TRUE;
         }
         else if( lpCustomDraw->dwDrawStage == CDDS_ITEMPREPAINT ) 
         {
            CDCHandle dc(lpCustomDraw->hdc);
            RECT rc = lpCustomDraw->rc;
            dc.FillSolidRect(&rc, m_xpstyle.clrMenu);
            ::InflateRect(&rc, -2, -4);
            rc.left += 2;
            if( rc.left < rc.right ) {
               COLORREF clrTextOld = dc.SetTextColor(::GetSysColor(COLOR_BTNSHADOW));
               COLORREF clrBkOld = dc.SetBkColor(::GetSysColor(COLOR_BTNFACE));
               CBrush brDither = _GetGripperBrush();
               dc.FillRect(&rc, brDither);
               dc.SetTextColor(clrTextOld);
               dc.SetBkColor(clrBkOld);
#if (_WIN32_IE >= 0x0500)
               _DrawChevron(pnmh->hwndFrom, lpCustomDraw->dwItemSpec, dc, lpCustomDraw->rc);
#endif //(_WIN32_IE >= 0x0500)
            }
            lRet = CDRF_SKIPDEFAULT;
            bHandled = TRUE;
         }
      }
      return lRet;
   }

   LRESULT OnParentToolbarDropDown(int /*idCtrl*/, LPNMHDR pnmh, BOOL& bHandled)
   {
      LPNMTOOLBAR lptb = (LPNMTOOLBAR) pnmh;
      CToolBarCtrl tb = lptb->hdr.hwndFrom;
      tb.GetItemRect(tb.CommandToIndex(lptb->iItem), &m_rcButton);
      m_bIsMenuDropped = true;
      bHandled = FALSE;
      return 0;
   }

   // Draw helpers

   static CBrushHandle _GetGripperBrush()
   {
      HBRUSH hBrush = NULL;
      WORD grayPattern[8] = { 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00, 0xFF, 0x00 };
      HBITMAP hBitmap = CreateBitmap(8, 8, 1, 1, &grayPattern);
      if( hBitmap != NULL ) {
         hBrush = ::CreatePatternBrush(hBitmap);
         ::DeleteObject(hBitmap);
      }
      return CBrushHandle(hBrush);
   }
   static void _DrawToolbarButton(LPNMTBCUSTOMDRAW lpTBCustomDraw, 
                                  DWORD dwExtendedStyle = 0,
                                  bool bShowKeyboardCues = true, 
                                  bool bIsMenuBar = false)
   {
      CDCHandle dc(lpTBCustomDraw->nmcd.hdc);

      CToolBarCtrl tb = lpTBCustomDraw->nmcd.hdr.hwndFrom;

      TBBUTTONINFO tbi = { 0 };
      TCHAR szText[_nMaxMenuItemTextLength] = { 0 };
      tbi.cbSize = sizeof(TBBUTTONINFO);
      tbi.dwMask = TBIF_TEXT | TBIF_STYLE | TBIF_STATE | TBIF_IMAGE;
      tbi.pszText = szText;
      tbi.cchText = (sizeof(szText) / sizeof(TCHAR)) - 1;
      tb.GetButtonInfo((int)lpTBCustomDraw->nmcd.dwItemSpec, &tbi);

      // Retrieve text string from string pool
      // Thanks to Nicola Tufarelli for fixing this...
      if( ::lstrlen(szText) == 0 ) tb.GetButtonText((int)lpTBCustomDraw->nmcd.dwItemSpec, szText);

      // Get state information

#ifndef ODS_HOTLIGHT
      const UINT ODS_HOTLIGHT = 0x0040;
#endif // ODS_HOTLIGHT
#ifndef BTNS_WHOLEDROPDOWN
      const UINT BTNS_WHOLEDROPDOWN = 0x0080;
#endif // BTNS_WHOLEDROPDOWN
      UINT uItemState = lpTBCustomDraw->nmcd.uItemState;
      bool bSelected = (uItemState & ODS_SELECTED) != 0;
      bool bHotlight = (uItemState & ODS_HOTLIGHT) != 0;
      bool bChecked = (tbi.fsState & TBSTATE_CHECKED) != 0;
      bool bPressed = (tbi.fsState & TBSTATE_PRESSED) != 0;
      bool bDisabled = (tbi.fsState & TBSTATE_ENABLED) == 0;
      bool bDropDown = (tbi.fsStyle & TBSTYLE_DROPDOWN) != 0;
      bool bDropWhole = (tbi.fsStyle & BTNS_WHOLEDROPDOWN) != 0;
      bool bList = ((tb.GetStyle() & TBSTYLE_LIST) == TBSTYLE_LIST);
#if (_WIN32_IE >= 0x0400)
      RECT rcItem = lpTBCustomDraw->nmcd.rc;
#else //!(_WIN32_IE >= 0x0400)
      RECT rcItem;
      tb.GetItemRect(0, &rcItem);
#endif //!(_WIN32_IE >= 0x0400)
      
#ifdef _CMDBAR_EXTRA_TRACE
      ATLTRACE2(atlTraceUI, 0, "CmdBar - DrawToolbarButton State:%ld Style:%ld ItemState:%ld\n", tbi.fsState, tbi.fsStyle, uItemState);
#endif

      // Draw highlight

      if( (bSelected || bHotlight || bPressed || bChecked) && !bDisabled ) {
         if( m_bIsMenuDropped ) {
            CBrush brushIcon;
            brushIcon.CreateSolidBrush(m_xpstyle.clrMenu);
            dc.FillRect(&rcItem, brushIcon);
            dc.DrawEdge(&rcItem, EDGE_RAISED, BF_TOP | BF_LEFT | BF_RIGHT | BF_FLAT | BF_MONO);
            m_bIsMenuDropped = false;
         }
         else if( bDropDown && bIsMenuBar && (bSelected || bPressed) ) {
            // Menu bar button
            CBrush brushIcon;
            brushIcon.CreateSolidBrush(m_xpstyle.clrMenu);
            dc.FillRect(&rcItem, brushIcon);
            dc.DrawEdge(&rcItem, EDGE_RAISED, BF_TOP | BF_LEFT | BF_RIGHT | BF_FLAT | BF_MONO);
         }
         else {
            // Ordinary toolbar or unselected menu
            CBrush brush;
            CPen pen;
            brush.CreateSolidBrush(bSelected ? m_xpstyle.clrPressed : m_xpstyle.clrHighlight);
            pen.CreatePen(PS_SOLID, 1, m_xpstyle.clrHighlightBorder);
            HPEN hOldPen = dc.SelectPen(pen);
            HBRUSH hOldBrush = dc.SelectBrush(brush);
            dc.Rectangle(&rcItem);
            if( bDropDown && !bIsMenuBar ) {
               int cxThumb = s_kcxDropDownArrowWidth;
               RECT rcThumb = rcItem;
               rcThumb.left = rcThumb.right - cxThumb;
               // Draw additional border to separate arrow
               dc.Rectangle(&rcThumb);
            }
            dc.SelectBrush(hOldBrush);
            dc.SelectPen(hOldPen);
         }
      }
      
      if( bDropDown && !bIsMenuBar ) {
         // Paint arrow
         int cxThumb = s_kcxDropDownArrowWidth;
         RECT rcThumb = rcItem;
         rcThumb.left = rcThumb.right - cxThumb;
         DrawArrow(dc, rcThumb, false);
      }
      else if( bDropWhole && !bIsMenuBar ) {
         // Paint arrow
         int cxThumb = s_kcxDropWholeArrowWidth;
         RECT rcThumb = rcItem;
         rcThumb.left = rcThumb.right - cxThumb;
         DrawArrow(dc, rcThumb, false);
      }
      
      // Draw image

      UINT uTextFlags = DT_CENTER;

      if( tbi.iImage >= 0 ) {
         // Get ImageList
         HIMAGELIST hImageList = NULL;
         if( bHotlight ) hImageList = tb.GetHotImageList();
         if( bDisabled ) hImageList = tb.GetDisabledImageList();
         if( hImageList == NULL ) hImageList = tb.GetImageList();
         // Draw icon
         if( hImageList != NULL ) {
            int cxIcon, cyIcon;
            ImageList_GetIconSize(hImageList, &cxIcon, &cyIcon);
            SIZE sizeButton;
            tb.GetButtonSize(sizeButton);
            //SIZE sizePadding;
            //tb.GetPadding(&sizePadding);
            SIZE sizePadding = { (sizeButton.cx - cxIcon)/2, (sizeButton.cy - cyIcon)/2 };
            // Fix by Nicola Tufarelli:
            //   If the button has text to diplay make room for it
            //     on the right of the image if TBSTYLE_LIST is set or
            //     at the bottom of the image if not
            //POINT point = { rcItem.left + sizePadding.cx, rcItem.top + sizePadding.cy + 1 };
            POINT point = { rcItem.left + (bList ? 4 : sizePadding.cx),
                            rcItem.top + (::lstrlen(szText) > 0 ? 4 : sizePadding.cy + 1) };
            // Draw the image
            if( bDisabled ) {
               // Draw disabled icon (shadow, really)
               DrawShadowIcon(dc, hImageList, point, tbi.iImage);
            }
            else if( bHotlight || bSelected ) {
               if( !bSelected ) {
                  // Draw selected icon shadow
                  if( (dwExtendedStyle & CBR_EX_NOWIGGLE) == 0 ) {
                     point.x++;
                     point.y++;
                     DrawShadowIcon(dc, hImageList, point, tbi.iImage);
                     point.x -= 2;
                     point.y -= 2;
                  }
                  else {
                     DrawShadowIcon(dc, hImageList, point, tbi.iImage);
                  }
               }
               // Finally draw the icon above
               ImageList_Draw(hImageList, tbi.iImage, dc, point.x, point.y, ILD_TRANSPARENT);
            }
            else {
               // Draw normal icon
               ImageList_DrawEx(hImageList, tbi.iImage, dc, point.x, point.y, 0, 0, CLR_NONE, CLR_NONE, ILD_TRANSPARENT);
            }

            if( bList ) {
               uTextFlags = DT_LEFT;
               rcItem.left += cxIcon + 8;
            }
            else if( ::lstrlen(szText) > 0 ) {
               rcItem.top += sizePadding.cy + 6;
            }
         }
      }

      // Draw text

      if( ::lstrlen(szText) > 0 ) {
#ifndef DT_HIDEPREFIX
         const UINT DT_HIDEPREFIX = 0x00100000;
#endif // DT_HIDEPREFIX
         COLORREF clrText;
         if( bDisabled ) clrText = m_xpstyle.clrGreyText;
         else if( bHotlight ) clrText = m_xpstyle.clrSelButtonText;
         else clrText = m_xpstyle.clrButtonText;

         uTextFlags |= DT_SINGLELINE | DT_VCENTER;
         if( !bShowKeyboardCues ) uTextFlags |= DT_HIDEPREFIX;
         RECT rcText = rcItem;

         dc.SetBkMode(TRANSPARENT);
         dc.SetTextColor(clrText);
         dc.DrawText(szText, -1, &rcText, uTextFlags);
      }
   }
};

__declspec(selectany) RECT CCommandBarXPCtrlBase::m_rcButton = { 0 };
__declspec(selectany) XPSTYLE CCommandBarXPCtrlBase::m_xpstyle = { 0 };
__declspec(selectany) bool CCommandBarXPCtrlBase::m_bIsMenuDropped = false;


class CCommandBarXPCtrl : public CCommandBarXPCtrlImpl<CCommandBarXPCtrl>
{
public:
   DECLARE_WND_SUPERCLASS(_T("WTL_CommandBarXP"), GetWndClassName())
};

// The _WTL_USE_MDI define takes care of this.
typedef CCommandBarXPCtrl CMDICommandBarXPCtrl;


#endif // __ATLCTRLWXP_H__