开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 界面编程 > 菜单 > 查看源码
FlatPopupMenu.cpp
资源名称：FlatPopUpMenu_demo.zip　[点击查看]
上传用户：szcanmei
上传日期：2007-01-02
资源大小：48k
文件大小：26k
源码类别：

菜单

开发平台：

Visual C++

FlatPopupMenu.cpp：源码内容
  1. // A flat popup menu for controls
  2. // Copyright (c) 1999 Andy Brown <andy@mirage.dabsol.co.uk>
  3. // You may do whatever you like with this file, I just don't care.
  6. #include "stdafx.h"
  7. #include "FlatPopupMenu.h"
  10. // initialise the static member
  12. bool CFlatPopupMenu::m_bClassRegistered=false;
  14. // stub window procedure
  16. static LRESULT CALLBACK stubWindowProc(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam);
  17.  
  19. /***************/
  20. /* Constructor */
  21. /***************/
  23. CFlatPopupMenu::CFlatPopupMenu()
  24. {
  25. // default colors
  27.   m_Colors[colorBorder]=GetSysColor(COLOR_MENUTEXT);
  28.   m_Colors[colorBackground]=GetSysColor(COLOR_MENU);
  29.   m_Colors[colorText]=GetSysColor(COLOR_MENUTEXT);
  30.   m_Colors[colorGrayedText]=GetSysColor(COLOR_GRAYTEXT);
  31.   m_Colors[colorHighlight]=GetSysColor(COLOR_HIGHLIGHT);
  32.   m_Colors[colorHighlightText]=GetSysColor(COLOR_HIGHLIGHTTEXT);
  33.   m_Colors[colorIconTransparent]=RGB(255,0,255);    // bright pink (mmm, nice...)
  34.   m_Colors[colorLightShadow]=GetSysColor(COLOR_3DHILIGHT);
  35.   m_Colors[colorDarkShadow]=GetSysColor(COLOR_3DSHADOW);
  37. // default font and size
  39.   m_strFont="MS Sans Serif";
  40.   m_FontSize=8;
  42. // 400ms is the default submenu delay
  44.   m_PopupDelay=400;
  46. // GDI objects
  48.   m_hFont=NULL;
  49.   m_hBoldFont=NULL;
  50.   m_hBorderPen=NULL;
  51.   m_hBackBrush=NULL;
  52.   m_hLightShadowPen=NULL;
  53.   m_hDarkShadowPen=NULL;
  54.   m_hBackPen=NULL;
  55.   m_hSelectedBrush=NULL;
  56.   m_hTextPen=NULL;
  57.   m_hSelectedTextPen=NULL;
  58.   m_hBitmap=NULL;
  60. // other internal variables
  62.   m_bChild=false;
  63.   m_pPrevious=NULL;
  64.   m_State=stateInactive;
  65.   m_hWnd=NULL;
  66. }
  69. /**************/
  70. /* Destructor */
  71. /**************/
  73. CFlatPopupMenu::~CFlatPopupMenu()
  74. {
  75. // if we're tracking, release it
  77.   if(m_State==stateTrack)
  78.     ReleaseCapture();
  80. // clean up the window
  82.   if(m_hWnd)
  83.     DestroyWindow(m_hWnd);
  85. // clean up the GDI objects
  87.   Cleanup();
  88. }
  91. /***********************/
  92. /* Cleanup GDI objects */
  93. /***********************/
  95. void CFlatPopupMenu::Cleanup(void)
  96. {
  97.   if(m_hFont)
  98.   {
  99.     DeleteObject(m_hFont);
  100.     DeleteObject(m_hBoldFont);
  101.     DeleteObject(m_hBorderPen);
  102.     DeleteObject(m_hBackBrush);
  103.     DeleteObject(m_hLightShadowPen);
  104.     DeleteObject(m_hDarkShadowPen);
  105.     DeleteObject(m_hBackPen);
  106.     DeleteObject(m_hSelectedBrush);
  107.     DeleteObject(m_hTextPen);
  108.     DeleteObject(m_hSelectedTextPen);
  109.     DeleteObject(m_hBitmap);
  111.     m_hFont=NULL;
  112.     m_hBoldFont=NULL;
  113.     m_hBorderPen=NULL;
  114.     m_hBackBrush=NULL;
  115.     m_hLightShadowPen=NULL;
  116.     m_hDarkShadowPen=NULL;
  117.     m_hBackPen=NULL;
  118.     m_hSelectedBrush=NULL;
  119.     m_hTextPen=NULL;
  120.     m_hSelectedTextPen=NULL;
  121.     m_hBitmap=NULL;
  122.   }
  123. }
  126. /**********************/
  127. /* Create GDI objects */
  128. /**********************/
  130. void CFlatPopupMenu::CreateObjects(void)
  131. {
  132.   LOGFONT    lf;
  133.   HDC        hDC;
  134.   HGDIOBJ    hOldFont;
  135.   TEXTMETRIC tm;
  137. // cleanup any previous
  139.   Cleanup();
  141. // create normal menu font
  143.   ZeroMemory(&lf,sizeof(lf));
  145.   hDC=CreateIC("DISPLAY",NULL,NULL,NULL);
  146.   lf.lfHeight=-MulDiv(m_FontSize,GetDeviceCaps(hDC,LOGPIXELSY),72);
  148.   lf.lfWeight=FW_NORMAL;
  149.   lf.lfCharSet=ANSI_CHARSET;
  150.   lf.lfOutPrecision=OUT_DEFAULT_PRECIS;
  151.   lf.lfClipPrecision=CLIP_DEFAULT_PRECIS;
  152.   lf.lfQuality=DEFAULT_QUALITY;
  153.   lf.lfPitchAndFamily=FF_DONTCARE | DEFAULT_PITCH;
  154.   lstrcpyn(lf.lfFaceName,m_strFont.c_str(),sizeof(lf.lfFaceName)/sizeof(TCHAR));
  156.   m_hFont=::CreateFontIndirect(&lf);
  158. // create bold menu font
  160.   lf.lfWeight=FW_BOLD;
  161.   m_hBoldFont=::CreateFontIndirect(&lf);
  163. // get the font heights
  165.   hOldFont=SelectObject(hDC,m_hFont);
  166.   GetTextMetrics(hDC,&tm);
  167.   m_FontHeight=tm.tmHeight;
  169.   SelectObject(hDC,m_hBoldFont);
  170.   GetTextMetrics(hDC,&tm);
  171.   m_BoldFontHeight=tm.tmHeight;
  172.   SelectObject(hDC,hOldFont);
  174. // finished with the DC
  176.   DeleteDC(hDC);
  178. // create pens and brushes
  180.   m_hBorderPen=CreatePen(PS_SOLID,1,m_Colors[colorBorder]);
  181.   m_hBackBrush=CreateSolidBrush(m_Colors[colorBackground]);
  182.   m_hSelectedBrush=CreateSolidBrush(m_Colors[colorHighlight]);
  183.   m_hLightShadowPen=CreatePen(PS_SOLID,1,m_Colors[colorLightShadow]);
  184.   m_hDarkShadowPen=CreatePen(PS_SOLID,1,m_Colors[colorDarkShadow]);
  185.   m_hBackPen=CreatePen(PS_SOLID,1,m_Colors[colorBackground]);
  186.   m_hTextPen=CreatePen(PS_SOLID,1,m_Colors[colorText]);
  187.   m_hSelectedTextPen=CreatePen(PS_SOLID,1,m_Colors[colorHighlightText]);
  189. // create the bitmap
  191.   if(m_BitmapID!=(UINT)-1)
  192.     m_hBitmap=LoadBitmap(m_hInstance,MAKEINTRESOURCE(m_BitmapID));
  193. }
  196. /*************/
  197. /* Create it */
  198. /*************/
  200. bool CFlatPopupMenu::Create(HINSTANCE hInstance,const UINT bitmap_id)
  201. {
  202. // save variables
  204.   m_hInstance=hInstance;
  205.   m_BitmapID=bitmap_id;
  207. // register the class
  209.   if(!m_bClassRegistered)
  210.   {
  211.     if(!RegisterClass())
  212.       return false;
  214.     m_bClassRegistered=true;
  215.   }
  217. // remove any previous items
  219.   m_Items.clear();
  221. // create GDI objects
  223.   CreateObjects();
  224.   return true;
  225. }
  228. /*****************************/
  229. /* Register the window class */
  230. /*****************************/
  232. bool CFlatPopupMenu::RegisterClass(void)
  233. {
  234.   WNDCLASS wc;
  236.   wc.style=0;
  237.   wc.lpfnWndProc=stubWindowProc;
  238.   wc.cbClsExtra=0;
  239.   wc.cbWndExtra=0;
  240.   wc.hInstance=m_hInstance;
  241.   wc.hIcon=NULL;
  242.   wc.hCursor=LoadCursor(NULL,IDC_ARROW);
  243.   wc.hbrBackground=NULL;
  244.   wc.lpszMenuName=NULL;
  245.   wc.lpszClassName="fpmMenuClass";
  247.   return ::RegisterClass(&wc)!=FALSE;
  248. }
  251. /**********************/
  252. /* Append a menu item */
  253. /**********************/
  255. bool CFlatPopupMenu::AppendItem(const DWORD dwFlags,LPCTSTR pszName,const UINT itemid,const int icon)
  256. {
  257.   CItem item;
  259.   item.m_dwFlags=dwFlags;
  261.   if(pszName)
  262.     item.m_strName=pszName;
  264.   item.m_ItemID=itemid;
  265.   item.m_IconIndex=icon;
  266.   item.m_pPopup=NULL;
  268.   m_Items.push_back(item);
  269.   return true;
  270. }
  273. /******************/
  274. /* Append a popup */
  275. /******************/
  277. bool CFlatPopupMenu::AppendPopup(const DWORD dwFlags,LPCTSTR pszName,CFlatPopupMenu& popup,const int icon)
  278. {
  279.   CItem item;
  281. // the separator flag is not allowed
  283.   if((dwFlags & itemSeparator)!=0)
  284.     return false;
  286. // add the item
  288.   item.m_dwFlags=dwFlags;
  289.   item.m_strName=pszName;
  290.   item.m_ItemID=0;
  291.   item.m_IconIndex=icon;
  292.   item.m_pPopup=&popup;
  294.   popup.m_bChild=true;
  295.   popup.m_pPrevious=this;
  297.   m_Items.push_back(item);
  298.   return true;
  299. }
  302. /******************/
  303. /* Track the menu */
  304. /******************/
  306. UINT CFlatPopupMenu::Track(int x,int y,HWND hWnd,const bool bModal,const bool bPopup)
  307. {
  308.   HDC hDC;
  309.   std::vector<CItem>::iterator it;
  310.   SIZE size;
  311.   int maxw,top;
  312.   HGDIOBJ hOldFont;
  313.   MSG msg;
  314.   RECT rcScreen;
  316. // get an information context for the screen
  318.   hDC=CreateIC("DISPLAY",NULL,NULL,NULL);
  320. // get the greatest item width
  322.   maxw=0;
  323.   top=3;
  325.   for(it=m_Items.begin();it!=m_Items.end();it++)
  326.   {
  327.     it->m_Top=top;
  329.     if(!(it->m_dwFlags & itemSeparator))
  330.     {
  331.       hOldFont=SelectObject(hDC,(it->m_dwFlags & itemBold)==0 ? m_hFont : m_hBoldFont);
  332.       GetTextExtentPoint32(hDC,it->m_strName.c_str(),it->m_strName.length(),&size);
  333.       maxw=max(size.cx,maxw);
  334.       SelectObject(hDC,hOldFont);
  336.       top+=17;
  337.       it->m_Height=17;
  338.     }
  339.     else
  340.     {
  341.       top+=5;
  342.       it->m_Height=5;
  343.     }
  344.   }
  346. // finished with the DC
  348.   DeleteDC(hDC);
  350. // get the screen dimensions and adjust x and y if necessary
  352.   m_Width=1+2+18+2+maxw+18+1;
  353.   m_SelectedItem=-1;
  354.   m_SelectedID=0;
  356.   SystemParametersInfo(SPI_GETWORKAREA,0,&rcScreen,0);
  357.   
  358.   if(x+m_Width>rcScreen.right)
  359.     x=max(0,rcScreen.right-m_Width);
  361.   if(y+top+2>rcScreen.bottom)
  362.     y=max(0,rcScreen.bottom-(top+2));
  364. // create the window
  366.   m_hWnd=::CreateWindowEx(WS_EX_TOOLWINDOW,         // prevent button appearing on taskbar
  367.                           "fpmMenuClass",
  368.                           "",
  369.                           WS_POPUP | WS_VISIBLE,
  370.                           x,
  371.                           y,
  372.                           m_Width,
  373.                           top+2,
  374.                           NULL,
  375.                           NULL,
  376.                           m_hInstance,
  377.                           (LPVOID)this);
  379. // check created OK
  381.   if(m_hWnd==NULL)
  382.     return false;
  384.   if(bPopup)
  385.   {
  386.   // already in the menu, no need to wait for any buttons
  388.     m_bWaitLeftButton=false;
  389.     m_bWaitRightButton=false;
  390.     m_State=stateShow;
  391.   }
  392.   else
  393.   {
  394.   // enter tracking state
  396.     SetCapture(m_hWnd);
  397.     m_State=stateTrack;
  399.   // we wait for any already-down buttons to come up
  401.     m_bWaitLeftButton=(GetKeyState(VK_LBUTTON) & 0x8000)!=0;
  402.     m_bWaitRightButton=(GetKeyState(VK_RBUTTON) & 0x8000)!=0;
  403.   }
  405. // remember modal setting and command window handle
  407.   m_bModal=bModal;
  408.   m_hWndCommand=hWnd;
  410.   if(m_bModal)
  411.   {
  412.   // go into a modal loop
  414.     while(GetMessage(&msg,NULL,0,0)==TRUE && IsWindow(m_hWnd))
  415.     {
  416.       TranslateMessage(&msg);
  417.       DispatchMessage(&msg);
  418.     }
  420.     return m_SelectedID;
  421.   }
  423.   return 0;
  424. }
  427. /*************************/
  428. /* stub window procedure */
  429. /*************************/
  431. static LRESULT CALLBACK stubWindowProc(HWND hWnd,UINT uMsg,WPARAM wParam,LPARAM lParam)
  432. {
  433.   CFlatPopupMenu *pClass;
  435. // the usual window procedure...
  437.   switch(uMsg)
  438.   {
  439.     case WM_CREATE:
  440.       SetWindowLong(hWnd,GWL_USERDATA,(LONG)((LPCREATESTRUCT)lParam)->lpCreateParams);
  441.       break;
  442.   
  443.     case WM_ERASEBKGND:
  444.       pClass=reinterpret_cast<CFlatPopupMenu *>(GetWindowLong(hWnd,GWL_USERDATA));
  445.       pClass->OnEraseBkgnd(hWnd,(HDC)wParam);
  446.       return TRUE;
  447.   
  448.     case WM_LBUTTONDOWN:
  449.       pClass=reinterpret_cast<CFlatPopupMenu *>(GetWindowLong(hWnd,GWL_USERDATA));
  450.       pClass->OnLButtonDown(hWnd,LOWORD(lParam),HIWORD(lParam));
  451.       break;
  453.     case WM_RBUTTONDOWN:
  454.       pClass=reinterpret_cast<CFlatPopupMenu *>(GetWindowLong(hWnd,GWL_USERDATA));
  455.       pClass->OnLButtonDown(hWnd,LOWORD(lParam),HIWORD(lParam));
  456.       break;
  458.     case WM_LBUTTONUP:
  459.       pClass=reinterpret_cast<CFlatPopupMenu *>(GetWindowLong(hWnd,GWL_USERDATA));
  460.       pClass->OnLButtonUp(hWnd,LOWORD(lParam),HIWORD(lParam));
  461.       break;
  463.     case WM_RBUTTONUP:
  464.       pClass=reinterpret_cast<CFlatPopupMenu *>(GetWindowLong(hWnd,GWL_USERDATA));
  465.       pClass->OnRButtonUp(hWnd,LOWORD(lParam),HIWORD(lParam));
  466.       break;
  468.     case WM_MOUSEMOVE:
  469.       pClass=reinterpret_cast<CFlatPopupMenu *>(GetWindowLong(hWnd,GWL_USERDATA));
  470.       pClass->OnMouseMove(hWnd,LOWORD(lParam),HIWORD(lParam));
  471.       break;
  473.     case WM_TIMER:
  474.       pClass=reinterpret_cast<CFlatPopupMenu *>(GetWindowLong(hWnd,GWL_USERDATA));
  475.       pClass->OnTimer(hWnd,wParam);
  476.       break;
  478.     case WM_CHAR:
  479.       pClass=reinterpret_cast<CFlatPopupMenu *>(GetWindowLong(hWnd,GWL_USERDATA));
  480.       pClass->OnChar(hWnd,(char)wParam);
  481.       break;
  483.     case WM_PAINT:
  484.       {
  485.         PAINTSTRUCT ps;
  486.         
  487.         BeginPaint(hWnd,&ps);
  488.         pClass=reinterpret_cast<CFlatPopupMenu *>(GetWindowLong(hWnd,GWL_USERDATA));
  489.         pClass->OnPaint(hWnd,ps.hdc);
  490.         EndPaint(hWnd,&ps);
  491.       }
  492.       break;
  494.     case WM_DESTROY:
  495.       pClass=reinterpret_cast<CFlatPopupMenu *>(GetWindowLong(hWnd,GWL_USERDATA));
  496.       pClass->OnDestroy(hWnd);
  497.       break;
  498.   }
  500.   return DefWindowProc(hWnd,uMsg,wParam,lParam);
  501. }
  504. /***********/
  505. /* WM_CHAR */
  506. /***********/
  508. void CFlatPopupMenu::OnChar(HWND hWnd,TCHAR c)
  509. {
  510.   std::vector<CItem>::const_iterator it;
  511.   std::string::size_type pos;
  513. // convert to lower case
  515.   c=(TCHAR)CharLower((LPTSTR)c);
  517. // search the menu items
  519.   for(it=m_Items.begin();it!=m_Items.end();it++)
  520.   {
  521.     if((it->m_dwFlags & (itemSeparator | itemGrayed | itemNotSelectable))==0)
  522.     {
  523.       if((pos=it->m_strName.find('&'))!=std::string::npos && it->m_strName.length()>pos+1 && c==(TCHAR)CharLower((LPTSTR)it->m_strName[pos+1]))
  524.       {
  525.       // set return value and exit
  527.         SetReturn(it->m_ItemID);
  528.         return;
  529.       }
  530.     }
  531.   }
  532. }
  535. /************/
  536. /* WM_TIMER */
  537. /************/
  539. void CFlatPopupMenu::OnTimer(HWND hWnd,unsigned short timerid)
  540. {
  541.   POINT p;
  543. // stop the timer
  545.   KillTimer(hWnd,timerid);
  547. // show the popup menu
  549.   if(m_SelectedItem!=-1 && m_Items[m_SelectedItem].m_pPopup)
  550.   {
  551.   // get the display position
  553.     p.x=m_Width-5;
  554.     p.y=m_Items[m_SelectedItem].m_Top-3;
  555.     ClientToScreen(hWnd,&p);
  557.   // track it
  559.     if(m_Items[m_SelectedItem].m_pPopup->Track(p.x,p.y,NULL,true,true))
  560.       DestroyAll();
  561.   }
  562. }
  565. /**********************/
  566. /* Draw a single item */
  567. /**********************/
  569. void CFlatPopupMenu::DrawItem(HWND hWnd,HDC hDC,const int index,const CItem& item)
  570. {
  571.   bool    bSelected=index==m_SelectedItem;
  572.   HGDIOBJ hOldPen,hOldBrush,hOldFont;
  573.   POINT   p[3];
  574.   int     i,x,y,h,nColor;
  575.   RECT    rect;
  577. // test if a separator
  579.   if((item.m_dwFlags & itemSeparator)!=0)
  580.   {
  581.     DrawSeparator(hDC,item.m_Top);
  582.     return;
  583.   }
  585. // get the top left of the item area
  587.   x=3;
  588.   y=item.m_Top;
  590. // is there an icon?
  592.   if(item.m_IconIndex!=-1)
  593.   {
  594.   // draw or erase the frame
  596.     p[0].x=p[1].x=x;
  597.     p[0].y=y+16;
  598.     p[1].y=p[2].y=item.m_Top;
  599.     p[2].x=x+17;
  600.     hOldPen=SelectObject(hDC,bSelected ? m_hLightShadowPen : m_hBackPen);
  601.     Polyline(hDC,p,3);
  603.     p[0].x=p[1].x=x+17;
  604.     p[0].y=item.m_Top;
  605.     p[1].y=p[2].y=y+16;
  606.     p[2].x=x;
  607.     SelectObject(hDC,bSelected ? m_hDarkShadowPen : m_hBackPen);
  608.     Polyline(hDC,p,3);
  609.     SelectObject(hDC,hOldPen);
  611.   // draw the bitmap
  613.     DrawTransparentBitmap(hDC,item.m_IconIndex*16,x+1,item.m_Top+1);
  615.   // update co-ordinate
  617.     x+=18;
  618.   }
  620. // draw/clear the selection rectangle
  622.   hOldBrush=SelectObject(hDC,bSelected ? m_hSelectedBrush : m_hBackBrush);
  623.   hOldPen=SelectObject(hDC,GetStockObject(NULL_PEN));
  625.   Rectangle(hDC,x,item.m_Top,m_Width-2,item.m_Top+18);
  627.   SelectObject(hDC,hOldPen);
  628.   SelectObject(hDC,hOldBrush);
  630. // draw the item text
  632.   if((item.m_dwFlags & itemBold)!=0)
  633.   {
  634.     h=m_BoldFontHeight;
  635.     hOldFont=SelectObject(hDC,m_hBoldFont);
  636.   }
  637.   else
  638.   {
  639.     h=m_FontHeight;
  640.     hOldFont=SelectObject(hDC,m_hFont);
  641.   }
  643.   SetBkMode(hDC,TRANSPARENT);
  645.   if(bSelected)
  646.     nColor=colorHighlightText;
  647.   else
  648.   {
  649.     if((item.m_dwFlags & itemGrayed)!=0)
  650.       nColor=colorGrayedText;
  651.     else
  652.       nColor=colorText;
  653.   }
  655.   rect.left=1+2+18+2;
  656.   rect.top=item.m_Top+((17-h)/2);
  657.   rect.bottom=rect.top+1000;
  658.   rect.right=rect.left+1000;
  660.   SetTextColor(hDC,m_Colors[nColor]);
  661.   DrawText(hDC,item.m_strName.c_str(),item.m_strName.length(),&rect,DT_LEFT | DT_TOP | DT_NOCLIP);
  662.   SelectObject(hDC,hOldFont);
  664. // draw a subitem arrow
  666.   if(item.m_pPopup)
  667.   {
  668.     hOldPen=SelectObject(hDC,bSelected ? m_hSelectedTextPen : m_hTextPen);
  670.     p[0].x=p[1].x=m_Width-7;
  671.     p[0].y=item.m_Top+8;
  672.     p[1].y=item.m_Top+9;
  674.     for(i=0;i<4;i++)
  675.     {
  676.       Polyline(hDC,p,2);
  677.       p[0].x--;
  678.       p[1].x--;
  679.       p[0].y--;
  680.       p[1].y++;
  681.     }
  683.     SelectObject(hDC,hOldPen);
  684.   }
  685. }
  688. /********************/
  689. /* Draw a separator */
  690. /********************/
  692. void CFlatPopupMenu::DrawSeparator(HDC hDC,int top)
  693. {
  694.   POINT   p[2];
  695.   HGDIOBJ hOldPen;
  697.   p[0].x=0;
  698.   p[1].x=m_Width;
  699.   p[0].y=p[1].y=top+2;
  700.   hOldPen=SelectObject(hDC,m_hBorderPen);
  701.   Polyline(hDC,p,2);
  702.   SelectObject(hDC,hOldPen);
  703. }
  706. /**************/
  707. /* WM_DESTROY */
  708. /**************/
  710. void CFlatPopupMenu::OnDestroy(HWND hWnd)
  711. {
  712.   std::vector<CItem>::const_iterator it;
  714. // any active popups must also be destroyed
  716.   for(it=m_Items.begin();it!=m_Items.end();it++)
  717.     if(it->m_pPopup && it->m_pPopup->m_State!=stateInactive)
  718.       DestroyWindow(it->m_pPopup->m_hWnd);
  720.   if(m_State==stateTrack)
  721.     ReleaseCapture();
  723.   m_State=stateInactive;
  724.   m_hWnd=NULL;
  726.   if(!m_bModal && m_SelectedID && !m_bChild)
  727.     PostMessage(m_hWndCommand,WM_COMMAND,m_SelectedID,0);
  728. }
  731. /****************/
  732. /* WM_MOUSEMOVE */
  733. /****************/
  735. void CFlatPopupMenu::OnMouseMove(HWND hWnd,short x,short y)
  736. {
  737.   RECT            rect;
  738.   HDC             hDC;
  739.   HWND            hPointWnd;
  740.   int             item,newitem;
  741.   POINT           p;
  742.   TCHAR           szClass[100];
  743.   CFlatPopupMenu *pClass;
  745. // get a DC and the window rectangle
  747.   GetClientRect(hWnd,&rect);
  748.   hDC=GetDC(hWnd);
  750. // shift tracking if we're over another menu
  752.   p.x=x;
  753.   p.y=y;
  754.   ClientToScreen(hWnd,&p);
  756.   if((hPointWnd=WindowFromPoint(p))!=NULL && GetClassName(hPointWnd,szClass,sizeof(szClass)/sizeof(TCHAR)) && !lstrcmp(szClass,"fpmMenuClass"))
  757.   {
  758.     pClass=reinterpret_cast<CFlatPopupMenu *>(GetWindowLong(hPointWnd,GWL_USERDATA));
  760.     if(pClass!=this)
  761.     {
  762.       ReleaseCapture();
  763.       m_State=stateShow;
  765.       SetCapture(pClass->m_hWnd);
  766.       pClass->m_State=stateTrack;
  768.       return;
  769.     }
  770.   }
  772. // get new selected item, if any
  774.   newitem=GetItem(x,y,rect);
  776. // remove previous selection?
  778.   if(m_SelectedItem!=-1 && newitem!=m_SelectedItem)
  779.   {
  780.   // kill any ongoing timer
  782.     KillTimer(m_hWnd,1);
  784.   // remove any popups associated with the last active item
  786.     if(m_Items[m_SelectedItem].m_pPopup && m_Items[m_SelectedItem].m_pPopup->m_State!=stateInactive)
  787.       DestroyWindow(m_Items[m_SelectedItem].m_pPopup->m_hWnd);
  789.   // deselect the old item
  791.     item=m_SelectedItem;
  792.     m_SelectedItem=-1;
  793.     DrawItem(hWnd,hDC,item,m_Items[item]);
  794.   }
  796. // new selected item?
  798.   if(newitem!=-1 && m_SelectedItem!=newitem)
  799.   {
  800.   // draw the new item
  802.     m_SelectedItem=newitem;
  803.     DrawItem(hWnd,hDC,m_SelectedItem,m_Items[m_SelectedItem]);
  805.   // start a timer if this is a popup
  807.     if(m_Items[m_SelectedItem].m_pPopup)
  808.       SetTimer(m_hWnd,1,m_PopupDelay,NULL);
  809.   }
  810. }
  813. /************************/
  814. /* Get item at position */
  815. /************************/
  817. int CFlatPopupMenu::GetItem(short x,short y,const RECT& rect)
  818. {
  819.   int newitem;
  820.   std::vector<CItem>::size_type i;
  822.   if(x<=2 || y<=2 || x>rect.right || y>rect.bottom)
  823.     newitem=-1;
  824.   else
  825.   {
  826.     for(i=0;i<m_Items.size();i++)
  827.       if(y>m_Items[i].m_Top && y<m_Items[i].m_Top+m_Items[i].m_Height)
  828.         break;
  830.     newitem=i==m_Items.size() ? -1 : i;
  831.     if(newitem!=-1 && (m_Items[newitem].m_dwFlags & itemNotSelectable)!=0)
  832.       newitem=-1;
  833.   }
  835.   return newitem;
  836. }
  839. /********************/
  840. /* a button is down */
  841. /********************/
  843. void CFlatPopupMenu::ButtonDown(HWND hWnd,short x,short y,const bool bLeft)
  844. {
  845.   RECT rect;
  847. // check for click outside menu
  849.   GetClientRect(hWnd,&rect);
  850.   if(CheckOutsideMenu(hWnd,rect,x,y))
  851.     return;
  853. // check for click on popup
  855.   if(m_SelectedItem!=-1 && m_Items[m_SelectedItem].m_pPopup && m_Items[m_SelectedItem].m_pPopup->m_State==stateInactive)
  856.     OnTimer(hWnd,1);
  857. }
  860. /****************/
  861. /* WM_LBUTTONUP */
  862. /****************/
  864. void CFlatPopupMenu::OnLButtonUp(HWND hWnd,short x,short y)
  865. {
  866.   RECT rect;
  868.   if(m_bWaitLeftButton)
  869.   {
  870.     m_bWaitLeftButton=false;
  871.     return;
  872.   }
  874.   GetClientRect(hWnd,&rect);
  875.   if(CheckOutsideMenu(hWnd,rect,x,y))
  876.     return;
  878.   if(m_SelectedItem!=-1 && m_Items[m_SelectedItem].m_ItemID)
  879.     SetReturn(m_Items[m_SelectedItem].m_ItemID);
  880. }
  883. /****************/
  884. /* WM_RBUTTONUP */
  885. /****************/
  887. void CFlatPopupMenu::OnRButtonUp(HWND hWnd,short x,short y)
  888. {
  889.   RECT rect;
  891.   if(m_bWaitRightButton)
  892.   {
  893.     m_bWaitRightButton=false;
  894.     return;
  895.   }
  897.   GetClientRect(hWnd,&rect);
  898.   if(CheckOutsideMenu(hWnd,rect,x,y))
  899.     return;
  901.   if(m_SelectedItem!=-1 && m_Items[m_SelectedItem].m_ItemID)
  902.     SetReturn(m_Items[m_SelectedItem].m_ItemID);
  903. }
  906. /************************/
  907. /* Set the return value */
  908. /************************/
  910. void CFlatPopupMenu::SetReturn(const UINT id)
  911. {
  912.   CFlatPopupMenu *pMenu;
  914. // find the root
  916.   for(pMenu=this;pMenu->m_pPrevious;pMenu=pMenu->m_pPrevious);
  917.   pMenu->m_SelectedID=id;
  918.   DestroyAll();
  919. }
  922. /*************************/
  923. /* Check if outside menu */
  924. /*************************/
  926. bool CFlatPopupMenu::CheckOutsideMenu(HWND hWnd,const RECT& rect,short x,short y)
  927. {
  928.   if(x<=2 || y<=2 || x>rect.right || y>rect.bottom)
  929.   {
  930.   // clicked outside the window
  932.     m_SelectedItem=-1;
  933.     m_SelectedID=0;
  934.     DestroyAll();
  936.     return true;
  937.   }
  939.   return false;
  940. }
  943. /*****************/
  944. /* WM_ERASEBKGND */
  945. /*****************/
  947. void CFlatPopupMenu::OnEraseBkgnd(HWND hWnd,HDC hDC)
  948. {
  949.   RECT    rect;
  950.   HGDIOBJ hOldBrush,hOldPen;
  952.   GetClientRect(hWnd,&rect);
  953.   hOldBrush=SelectObject(hDC,m_hBackBrush);
  954.   hOldPen=SelectObject(hDC,m_hBorderPen);
  955.   
  956.   Rectangle(hDC,rect.left,rect.top,rect.right,rect.bottom);
  958.   SelectObject(hDC,hOldBrush);
  959.   SelectObject(hDC,hOldPen);
  960. }
  963. /***************************/
  964. /* Assign item to src item */
  965. /***************************/
  967. void CFlatPopupMenu::CItem::Assign(const CItem& src)
  968. {
  969.   m_dwFlags=src.m_dwFlags;
  970.   m_strName=src.m_strName;
  971.   m_ItemID=src.m_ItemID;
  972.   m_IconIndex=src.m_IconIndex;
  973.   m_Top=src.m_Top;
  974.   m_Height=src.m_Height;
  975.   m_pPopup=src.m_pPopup;
  976. }
  979. /*****************************/
  980. /* Draw a transparent bitmap */
  981. /*****************************
  983. This function is borrowed and slightly modified from an MSDN sample */
  985. void CFlatPopupMenu::DrawTransparentBitmap(HDC hdc,const int xSrcOffset,const int xStart,const int yStart)
  986. {
  987.   BITMAP    bm;
  988.   COLORREF  cColor;
  989.   HBITMAP   bmAndBack,bmAndObject,bmAndMem,bmSave;
  990.   HBITMAP   bmBackOld,bmObjectOld,bmMemOld,bmSaveOld;
  991.   HDC       hdcMem,hdcBack,hdcObject,hdcTemp,hdcSave;
  992.   POINT     ptSize;
  994.   hdcTemp=CreateCompatibleDC(hdc);
  995.   SelectObject(hdcTemp,m_hBitmap);      // Select the bitmap
  997.   GetObject(m_hBitmap,sizeof(BITMAP),(LPSTR)&bm);
  998.   ptSize.x=bm.bmWidth;                // Get width of bitmap
  999.   ptSize.y=bm.bmHeight;               // Get height of bitmap
  1000.   DPtoLP(hdcTemp,&ptSize,1);          // Convert from device
  1001.                                       // to logical points
  1002. // Create some DCs to hold temporary data
  1004.   hdcBack=CreateCompatibleDC(hdc);
  1005.   hdcObject=CreateCompatibleDC(hdc);
  1006.   hdcMem=CreateCompatibleDC(hdc);
  1007.   hdcSave=CreateCompatibleDC(hdc);
  1009. // Create a bitmap for each DC. DCs are required for a number of GDI functions
  1011. // Monochrome DC
  1013.   bmAndBack=CreateBitmap(ptSize.x,ptSize.y,1,1,NULL);
  1015. // Monochrome DC
  1017.   bmAndObject=CreateBitmap(ptSize.x,ptSize.y,1,1,NULL);
  1019.   bmAndMem=CreateCompatibleBitmap(hdc,ptSize.x,ptSize.y);
  1020.   bmSave=CreateCompatibleBitmap(hdc,ptSize.x,ptSize.y);
  1022. // Each DC must select a bitmap object to store pixel data
  1024.   bmBackOld=(HBITMAP)SelectObject(hdcBack,bmAndBack);
  1025.   bmObjectOld=(HBITMAP)SelectObject(hdcObject,bmAndObject);
  1026.   bmMemOld=(HBITMAP)SelectObject(hdcMem,bmAndMem);
  1027.   bmSaveOld=(HBITMAP)SelectObject(hdcSave,bmSave);
  1029. // Set proper mapping mode
  1031.   SetMapMode(hdcTemp,GetMapMode(hdc));
  1033. // Save the bitmap sent here, because it will be overwritten.
  1035.   BitBlt(hdcSave,0,0,ptSize.x,ptSize.y,hdcTemp,0,0,SRCCOPY);
  1037. // Set the background color of the source DC to the color.
  1038. // contained in the parts of the bitmap that should be transparent
  1040.   cColor=SetBkColor(hdcTemp,m_Colors[colorIconTransparent]);
  1042. // Create the object mask for the bitmap by performing a BitBlt
  1043. // from the source bitmap to a monochrome bitmap.
  1045.   BitBlt(hdcObject,0,0,ptSize.x,ptSize.y,hdcTemp,0,0,SRCCOPY);
  1047. // Set the background color of the source DC back to the original color
  1049.   SetBkColor(hdcTemp,cColor);
  1051. // Create the inverse of the object mask
  1053.   BitBlt(hdcBack,0,0,ptSize.x,ptSize.y,hdcObject,0,0,NOTSRCCOPY);
  1055. // Copy the background of the main DC to the destination
  1057.   BitBlt(hdcMem,xSrcOffset,0,16,15,hdc,xStart,yStart,SRCCOPY);
  1059. // Mask out the places where the bitmap will be placed
  1061.   BitBlt(hdcMem,0,0,ptSize.x,ptSize.y,hdcObject,0,0,SRCAND);
  1063. // Mask out the transparent colored pixels on the bitmap
  1065.   BitBlt(hdcTemp,0,0,ptSize.x,ptSize.y,hdcBack,0,0,SRCAND);
  1067. // XOR the bitmap with the background on the destination DC
  1069.   BitBlt(hdcMem,0,0,ptSize.x,ptSize.y,hdcTemp,0,0,SRCPAINT);
  1071. // Copy the destination to the screen
  1073.   BitBlt(hdc,xStart,yStart,16,15,hdcMem,xSrcOffset,0,SRCCOPY);
  1075. // Place the original bitmap back into the bitmap sent here
  1077.   BitBlt(hdcTemp,0,0,ptSize.x,ptSize.y,hdcSave,0,0,SRCCOPY);
  1079. // Delete the memory bitmaps
  1081.   DeleteObject(SelectObject(hdcBack,bmBackOld));
  1082.   DeleteObject(SelectObject(hdcObject,bmObjectOld));
  1083.   DeleteObject(SelectObject(hdcMem,bmMemOld));
  1084.   DeleteObject(SelectObject(hdcSave,bmSaveOld));
  1086. // Delete the memory DCs
  1087.   
  1088.   DeleteDC(hdcMem);
  1089.   DeleteDC(hdcBack);
  1090.   DeleteDC(hdcObject);
  1091.   DeleteDC(hdcSave);
  1092.   DeleteDC(hdcTemp);
  1093. }
  1096. /************************/
  1097. /* Change the menu text */
  1098. /************************/
  1100. bool CFlatPopupMenu::SetMenuItemText(const UINT itemid,LPCTSTR pszName,const bool bByPosition)
  1101. {
  1102.   CItem *pItem;
  1104. // get the item
  1106.   if((pItem=GetItem(itemid,bByPosition))==NULL)
  1107.     return false;
  1109. // adjust the name
  1111.   pItem->m_strName=pszName;
  1112.   return true;
  1113. }
  1116. /*************************/
  1117. /* Change the menu flags */
  1118. /*************************/
  1120. bool CFlatPopupMenu::SetMenuItemFlags(const UINT itemid,const DWORD dwFlags,const bool bByPosition)
  1121. {
  1122.   CItem *pItem;
  1124. // get the item
  1126.   if((pItem=GetItem(itemid,bByPosition))==NULL)
  1127.     return false;
  1129. // adjust the flags
  1131.   pItem->m_dwFlags=dwFlags;
  1132.   return true;
  1133. }
  1136. /**************************/
  1137. /* Get a menu item's text */
  1138. /**************************/
  1140. bool CFlatPopupMenu::GetString(const UINT itemid,LPTSTR pszText,const UINT cchText,const bool bByPosition)
  1141. {
  1142.   CItem *pItem;
  1144. // get the item
  1146.   if((pItem=GetItem(itemid,bByPosition))==NULL)
  1147.     return false;
  1149.   if(pItem->m_strName.length()+1>cchText)
  1150.     return false;
  1152.   lstrcpy(pszText,pItem->m_strName.c_str());
  1153.   return true;
  1154. }
  1157. /*************************/
  1158. /* Change the menu flags */
  1159. /*************************/
  1161. bool CFlatPopupMenu::SetMenuItemIcon(const UINT itemid,const int icon,const bool bByPosition)
  1162. {
  1163.   CItem *pItem;
  1165. // get the item
  1167.   if((pItem=GetItem(itemid,bByPosition))==NULL)
  1168.     return false;
  1170. // adjust the icon
  1172.   pItem->m_IconIndex=icon;
  1173.   return true;
  1174. }
  1177. /****************/
  1178. /* Find an item */
  1179. /****************/
  1181. CFlatPopupMenu::CItem *CFlatPopupMenu::GetItem(const UINT itemid,const bool bByPosition)
  1182. {
  1183.   std::vector<CItem>::iterator it;
  1185.   if(bByPosition)
  1186.   {
  1187.     if(itemid>=m_Items.size())
  1188.       return false;
  1190.     return &m_Items[itemid];
  1191.   }
  1192.   else
  1193.   {
  1194.     for(it=m_Items.begin();it!=m_Items.end();it++)
  1195.       if(it->m_ItemID==itemid)
  1196.         return &(*it);
  1198.     return NULL;
  1199.   }
  1200. }