src/msw/menuitem.cpp

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // Name:        src/msw/menuitem.cpp
   3 // Purpose:     wxMenuItem implementation
   4 // Author:      Vadim Zeitlin
   5 // Modified by:
   6 // Created:     11.11.97
   7 // RCS-ID:      $Id$
   8 // Copyright:   (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
   9 // Licence:     wxWindows licence
  10 ///////////////////////////////////////////////////////////////////////////////
  11
  12 // ===========================================================================
  13 // declarations
  14 // ===========================================================================
  15
  16 // ---------------------------------------------------------------------------
  17 // headers
  18 // ---------------------------------------------------------------------------
  19
  20 // For compilers that support precompilation, includes "wx.h".
  21 #include "wx/wxprec.h"
  22
  23 #ifdef __BORLANDC__
  24     #pragma hdrstop
  25 #endif
  26
  27 #if wxUSE_MENUS
  28
  29 #include "wx/menuitem.h"
  30 #include "wx/stockitem.h"
  31
  32 #ifndef WX_PRECOMP
  33     #include "wx/app.h"
  34     #include "wx/dcmemory.h"
  35     #include "wx/font.h"
  36     #include "wx/bitmap.h"
  37     #include "wx/settings.h"
  38     #include "wx/window.h"
  39     #include "wx/accel.h"
  40     #include "wx/string.h"
  41     #include "wx/log.h"
  42     #include "wx/menu.h"
  43 #endif
  44
  45 #if wxUSE_ACCEL
  46     #include "wx/accel.h"
  47 #endif // wxUSE_ACCEL
  48
  49 #include "wx/msw/private.h"
  50 #include "wx/msw/dc.h"
  51
  52 #ifdef __WXWINCE__
  53 // Implemented in menu.cpp
  54 UINT GetMenuState(HMENU hMenu, UINT id, UINT flags) ;
  55 #endif
  56
  57 #if wxUSE_UXTHEME
  58     #include "wx/msw/uxtheme.h"
  59 #endif
  60
  61 // ---------------------------------------------------------------------------
  62 // macro
  63 // ---------------------------------------------------------------------------
  64
  65 // hide the ugly cast
  66 #define GetHMenuOf(menu)    ((HMENU)menu->GetHMenu())
  67
  68 // ----------------------------------------------------------------------------
  69 // helper classes for temporarily changing HDC parameters
  70 // ----------------------------------------------------------------------------
  71
  72 namespace
  73 {
  74
  75 // This class just stores an HDC.
  76 class HDCHandler
  77 {
  78 protected:
  79     HDCHandler(HDC hdc) : m_hdc(hdc) { }
  80
  81     const HDC m_hdc;
  82 };
  83
  84 class HDCTextColChanger : HDCHandler
  85 {
  86 public:
  87     HDCTextColChanger(HDC hdc, COLORREF col)
  88         : HDCHandler(hdc),
  89           m_colOld(::SetTextColor(hdc, col))
  90     {
  91     }
  92
  93     ~HDCTextColChanger()
  94     {
  95         ::SetTextColor(m_hdc, m_colOld);
  96     }
  97
  98 private:
  99     COLORREF m_colOld;
 100 };
 101
 102 class HDCBgColChanger : HDCHandler
 103 {
 104 public:
 105     HDCBgColChanger(HDC hdc, COLORREF col)
 106         : HDCHandler(hdc),
 107           m_colOld(::SetBkColor(hdc, col))
 108     {
 109     }
 110
 111     ~HDCBgColChanger()
 112     {
 113         ::SetBkColor(m_hdc, m_colOld);
 114     }
 115
 116 private:
 117     COLORREF m_colOld;
 118 };
 119
 120 class HDCBgModeChanger : HDCHandler
 121 {
 122 public:
 123     HDCBgModeChanger(HDC hdc, int mode)
 124         : HDCHandler(hdc),
 125           m_modeOld(::SetBkMode(hdc, mode))
 126     {
 127     }
 128
 129     ~HDCBgModeChanger()
 130     {
 131         ::SetBkMode(m_hdc, m_modeOld);
 132     }
 133
 134 private:
 135     int m_modeOld;
 136 };
 137
 138 } // anonymous namespace
 139
 140 // ============================================================================
 141 // implementation
 142 // ============================================================================
 143
 144 #if wxUSE_OWNER_DRAWN
 145
 146 #include "wx/fontutil.h"
 147 #include "wx/msw/private/metrics.h"
 148
 149 #ifndef SPI_GETKEYBOARDCUES
 150 #define SPI_GETKEYBOARDCUES 0x100A
 151 #endif
 152
 153 #ifndef DSS_HIDEPREFIX
 154 #define DSS_HIDEPREFIX  0x0200
 155 #endif
 156
 157 #if wxUSE_UXTHEME
 158
 159 enum MENUPARTS
 160 {
 161     MENU_MENUITEM_TMSCHEMA = 1,
 162     MENU_SEPARATOR_TMSCHEMA = 6,
 163     MENU_POPUPBACKGROUND = 9,
 164     MENU_POPUPBORDERS = 10,
 165     MENU_POPUPCHECK = 11,
 166     MENU_POPUPCHECKBACKGROUND = 12,
 167     MENU_POPUPGUTTER = 13,
 168     MENU_POPUPITEM = 14,
 169     MENU_POPUPSEPARATOR = 15,
 170     MENU_POPUPSUBMENU = 16,
 171 };
 172
 173
 174 enum POPUPITEMSTATES
 175 {
 176     MPI_NORMAL = 1,
 177     MPI_HOT = 2,
 178     MPI_DISABLED = 3,
 179     MPI_DISABLEDHOT = 4,
 180 };
 181
 182 enum POPUPCHECKBACKGROUNDSTATES
 183 {
 184     MCB_DISABLED = 1,
 185     MCB_NORMAL = 2,
 186     MCB_BITMAP = 3,
 187 };
 188
 189 enum POPUPCHECKSTATES
 190 {
 191     MC_CHECKMARKNORMAL = 1,
 192     MC_CHECKMARKDISABLED = 2,
 193     MC_BULLETNORMAL = 3,
 194     MC_BULLETDISABLED = 4,
 195 };
 196
 197 const int TMT_MENUFONT       = 803;
 198 const int TMT_BORDERSIZE     = 2403;
 199 const int TMT_CONTENTMARGINS = 3602;
 200 const int TMT_SIZINGMARGINS  = 3601;
 201
 202 #endif // wxUSE_UXTHEME
 203
 204 #endif // wxUSE_OWNER_DRAWN
 205
 206 // ----------------------------------------------------------------------------
 207 // dynamic classes implementation
 208 // ----------------------------------------------------------------------------
 209
 210 // ----------------------------------------------------------------------------
 211 // wxMenuItem
 212 // ----------------------------------------------------------------------------
 213
 214 #if wxUSE_OWNER_DRAWN
 215
 216 namespace
 217 {
 218
 219 // helper class to keep information about metrics and other stuff
 220 // needed for measuring and drawing menu item
 221 class MenuDrawData
 222 {
 223 public:
 224     // Wrapper around standard MARGINS structure providing some helper
 225     // functions and automatically initializing the margin fields to 0.
 226     struct Margins : MARGINS
 227     {
 228         Margins()
 229         {
 230             cxLeftWidth =
 231             cxRightWidth =
 232             cyTopHeight =
 233             cyBottomHeight = 0;
 234         }
 235
 236         int GetTotalX() const { return cxLeftWidth + cxRightWidth; }
 237         int GetTotalY() const { return cyTopHeight + cyBottomHeight; }
 238
 239         void ApplyTo(RECT& rect) const
 240         {
 241             rect.top += cyTopHeight;
 242             rect.left += cxLeftWidth;
 243             rect.right -= cyTopHeight;
 244             rect.bottom -= cyBottomHeight;
 245         }
 246
 247         void UnapplyFrom(RECT& rect) const
 248         {
 249             rect.top -= cyTopHeight;
 250             rect.left -= cxLeftWidth;
 251             rect.right += cyTopHeight;
 252             rect.bottom += cyBottomHeight;
 253         }
 254     };
 255
 256     Margins ItemMargin;         // popup item margins
 257
 258     Margins CheckMargin;        // popup check margins
 259     Margins CheckBgMargin;      // popup check background margins
 260
 261     Margins ArrowMargin;        // popup submenu arrow margins
 262
 263     Margins SeparatorMargin;    // popup separator margins
 264
 265     SIZE CheckSize;             // popup check size metric
 266     SIZE ArrowSize;             // popup submenu arrow size metric
 267     SIZE SeparatorSize;         // popup separator size metric
 268
 269     int TextBorder;             // popup border space between
 270                                 // item text and gutter
 271
 272     int AccelBorder;            // popup border space between
 273                                 // item text and accelerator
 274
 275     int ArrowBorder;            // popup border space between
 276                                 // item accelerator and submenu arrow
 277
 278     int Offset;                 // system added space at the end of the menu,
 279                                 // add this offset for remove the extra space
 280
 281     wxFont Font;                // default menu font
 282
 283     bool AlwaysShowCues;        // must keyboard cues always be shown?
 284
 285     bool Theme;                 // is data initialized for FullTheme?
 286
 287     static const MenuDrawData* Get()
 288     {
 289         // notice that s_menuData can't be created as a global variable because
 290         // it needs a window to initialize and no windows exist at the time of
 291         // globals initialization yet
 292         if ( !ms_instance )
 293         {
 294             static MenuDrawData s_menuData;
 295             ms_instance = &s_menuData;
 296         }
 297
 298     #if wxUSE_UXTHEME
 299         bool theme = MenuLayout() == FullTheme;
 300         if ( ms_instance->Theme != theme )
 301             ms_instance->Init();
 302     #endif // wxUSE_UXTHEME
 303         return ms_instance;
 304     }
 305
 306     MenuDrawData()
 307     {
 308         Init();
 309     }
 310
 311
 312     // get the theme engine or NULL if themes
 313     // are not available or not supported on menu
 314     static wxUxThemeEngine *GetUxThemeEngine()
 315     {
 316     #if wxUSE_UXTHEME
 317         if ( MenuLayout() == FullTheme )
 318             return wxUxThemeEngine::GetIfActive();
 319     #endif // wxUSE_UXTHEME
 320         return NULL;
 321     }
 322
 323
 324     enum MenuLayoutType
 325     {
 326         FullTheme,      // full menu themes (Vista or new)
 327         PseudoTheme,    // pseudo menu themes (on XP)
 328         Classic
 329     };
 330
 331     static MenuLayoutType MenuLayout()
 332     {
 333         MenuLayoutType menu = Classic;
 334     #if wxUSE_UXTHEME
 335         if ( wxUxThemeEngine::GetIfActive() != NULL )
 336         {
 337             static wxWinVersion ver = wxGetWinVersion();
 338             if ( ver >= wxWinVersion_Vista )
 339                 menu = FullTheme;
 340             else if ( ver == wxWinVersion_XP )
 341                 menu = PseudoTheme;
 342         }
 343     #endif // wxUSE_UXTHEME
 344         return menu;
 345     }
 346
 347 private:
 348     void Init();
 349
 350     static MenuDrawData* ms_instance;
 351 };
 352
 353 MenuDrawData* MenuDrawData::ms_instance = NULL;
 354
 355 void MenuDrawData::Init()
 356 {
 357 #if wxUSE_UXTHEME
 358     wxUxThemeEngine* theme = GetUxThemeEngine();
 359     if ( theme )
 360     {
 361         wxWindow* window = static_cast<wxApp*>(wxApp::GetInstance())->GetTopWindow();
 362         wxUxThemeHandle hTheme(window, L"MENU");
 363
 364         theme->GetThemeMargins(hTheme, NULL, MENU_POPUPITEM, 0,
 365                                TMT_CONTENTMARGINS, NULL,
 366                                &ItemMargin);
 367
 368         theme->GetThemeMargins(hTheme, NULL, MENU_POPUPCHECK, 0,
 369                                TMT_CONTENTMARGINS, NULL,
 370                                &CheckMargin);
 371         theme->GetThemeMargins(hTheme, NULL, MENU_POPUPCHECKBACKGROUND, 0,
 372                                TMT_CONTENTMARGINS, NULL,
 373                                &CheckBgMargin);
 374
 375         theme->GetThemeMargins(hTheme, NULL, MENU_POPUPSUBMENU, 0,
 376                                TMT_CONTENTMARGINS, NULL,
 377                                &ArrowMargin);
 378
 379         theme->GetThemeMargins(hTheme, NULL, MENU_POPUPSEPARATOR, 0,
 380                                TMT_SIZINGMARGINS, NULL,
 381                                &SeparatorMargin);
 382
 383         theme->GetThemePartSize(hTheme, NULL, MENU_POPUPCHECK, 0,
 384                                 NULL, TS_TRUE, &CheckSize);
 385
 386         theme->GetThemePartSize(hTheme, NULL, MENU_POPUPSUBMENU, 0,
 387                                 NULL, TS_TRUE, &ArrowSize);
 388
 389         theme->GetThemePartSize(hTheme, NULL, MENU_POPUPSEPARATOR, 0,
 390                                 NULL, TS_TRUE, &SeparatorSize);
 391
 392         theme->GetThemeInt(hTheme, MENU_POPUPBACKGROUND, 0, TMT_BORDERSIZE, &TextBorder);
 393
 394         AccelBorder = 34;
 395         ArrowBorder = 0;
 396
 397         Offset = -14;
 398
 399         wxUxThemeFont themeFont;
 400         theme->GetThemeSysFont(hTheme, TMT_MENUFONT, themeFont.GetPtr());
 401         Font = wxFont(themeFont.GetLOGFONT());
 402
 403         Theme = true;
 404
 405         // native menu doesn't uses the vertical margins
 406         ItemMargin.cyTopHeight =
 407         ItemMargin.cyBottomHeight = 0;
 408
 409         // native menu uses small top margin for separator
 410         if ( SeparatorMargin.cyTopHeight >= 2 )
 411             SeparatorMargin.cyTopHeight -= 2;
 412     }
 413     else
 414 #endif // wxUSE_UXTHEME
 415     {
 416         const NONCLIENTMETRICS& metrics = wxMSWImpl::GetNonClientMetrics();
 417
 418         CheckMargin.cxLeftWidth =
 419         CheckMargin.cxRightWidth  = ::GetSystemMetrics(SM_CXEDGE);
 420         CheckMargin.cyTopHeight =
 421         CheckMargin.cyBottomHeight = ::GetSystemMetrics(SM_CYEDGE);
 422
 423         CheckSize.cx = ::GetSystemMetrics(SM_CXMENUCHECK);
 424         CheckSize.cy = ::GetSystemMetrics(SM_CYMENUCHECK);
 425
 426         ArrowSize = CheckSize;
 427
 428         // separator height with margins
 429         int sepFullSize = metrics.iMenuHeight / 2;
 430
 431         SeparatorMargin.cxLeftWidth =
 432         SeparatorMargin.cxRightWidth = 1;
 433         SeparatorMargin.cyTopHeight =
 434         SeparatorMargin.cyBottomHeight = sepFullSize / 2 - 1;
 435
 436         SeparatorSize.cx = 1;
 437         SeparatorSize.cy = sepFullSize - SeparatorMargin.GetTotalY();
 438
 439         TextBorder = 0;
 440         AccelBorder = 8;
 441         ArrowBorder = 6;
 442
 443         Offset = -12;
 444
 445         Font = wxFont(wxNativeFontInfo(metrics.lfMenuFont));
 446
 447         Theme = false;
 448     }
 449
 450     int value;
 451     if ( ::SystemParametersInfo(SPI_GETKEYBOARDCUES, 0, &value, 0) == 0 )
 452     {
 453         // if it's not supported, we must be on an old Windows version
 454         // which always shows them
 455         value = 1;
 456     }
 457
 458     AlwaysShowCues = value == 1;
 459
 460 }
 461
 462 } // anonymous namespace
 463
 464 #endif // wxUSE_OWNER_DRAWN
 465
 466
 467 // ctor & dtor
 468 // -----------
 469
 470 wxMenuItem::wxMenuItem(wxMenu *pParentMenu,
 471                        int id,
 472                        const wxString& text,
 473                        const wxString& strHelp,
 474                        wxItemKind kind,
 475                        wxMenu *pSubMenu)
 476           : wxMenuItemBase(pParentMenu, id, text, strHelp, kind, pSubMenu)
 477 {
 478     Init();
 479 }
 480
 481 #if WXWIN_COMPATIBILITY_2_8
 482 wxMenuItem::wxMenuItem(wxMenu *parentMenu,
 483                        int id,
 484                        const wxString& text,
 485                        const wxString& help,
 486                        bool isCheckable,
 487                        wxMenu *subMenu)
 488           : wxMenuItemBase(parentMenu, id, text, help,
 489                            isCheckable ? wxITEM_CHECK : wxITEM_NORMAL, subMenu)
 490 {
 491     Init();
 492 }
 493 #endif
 494
 495 void wxMenuItem::Init()
 496 {
 497     m_radioGroup.start = -1;
 498     m_isRadioGroupStart = false;
 499
 500 #if  wxUSE_OWNER_DRAWN
 501
 502     // when the color is not valid, wxOwnerDraw takes the default ones.
 503     // If we set the colors here and they are changed by the user during
 504     // the execution, then the colors are not updated until the application
 505     // is restarted and our menus look bad
 506     SetTextColour(wxNullColour);
 507     SetBackgroundColour(wxNullColour);
 508
 509     // setting default colors switched ownerdraw on: switch it off again
 510     SetOwnerDrawn(false);
 511
 512     //  switch ownerdraw back on if using a non default margin
 513     if ( !IsSeparator() )
 514         SetMarginWidth(GetMarginWidth());
 515
 516 #endif // wxUSE_OWNER_DRAWN
 517 }
 518
 519 wxMenuItem::~wxMenuItem()
 520 {
 521 }
 522
 523 // misc
 524 // ----
 525
 526 // return the id for calling Win32 API functions
 527 WXWPARAM wxMenuItem::GetMSWId() const
 528 {
 529     // we must use ids in unsigned short range with Windows functions, if we
 530     // pass ids > USHRT_MAX to them they get very confused (e.g. start
 531     // generating WM_COMMAND messages with negative high word of wParam), so
 532     // use the cast to ensure the id is in range
 533     return m_subMenu ? wxPtrToUInt(m_subMenu->GetHMenu())
 534                      : static_cast<unsigned short>(GetId());
 535 }
 536
 537 // get item state
 538 // --------------
 539
 540 bool wxMenuItem::IsChecked() const
 541 {
 542     // fix that RTTI is always getting the correct state (separators cannot be
 543     // checked, but the Windows call below returns true
 544     if ( IsSeparator() )
 545         return false;
 546
 547     // the item might not be attached to a menu yet
 548     //
 549     // TODO: shouldn't we just always call the base class version? It seems
 550     //       like it ought to always be in sync
 551     if ( !m_parentMenu )
 552         return wxMenuItemBase::IsChecked();
 553
 554     HMENU hmenu = GetHMenuOf(m_parentMenu);
 555     int flag = ::GetMenuState(hmenu, GetMSWId(), MF_BYCOMMAND);
 556
 557     return (flag & MF_CHECKED) != 0;
 558 }
 559
 560 // radio group stuff
 561 // -----------------
 562
 563 void wxMenuItem::SetAsRadioGroupStart()
 564 {
 565     m_isRadioGroupStart = true;
 566 }
 567
 568 void wxMenuItem::SetRadioGroupStart(int start)
 569 {
 570     wxASSERT_MSG( !m_isRadioGroupStart,
 571                   wxT("should only be called for the next radio items") );
 572
 573     m_radioGroup.start = start;
 574 }
 575
 576 void wxMenuItem::SetRadioGroupEnd(int end)
 577 {
 578     wxASSERT_MSG( m_isRadioGroupStart,
 579                   wxT("should only be called for the first radio item") );
 580
 581     m_radioGroup.end = end;
 582 }
 583
 584 // change item state
 585 // -----------------
 586
 587 void wxMenuItem::Enable(bool enable)
 588 {
 589     if ( m_isEnabled == enable )
 590         return;
 591
 592     if ( m_parentMenu )
 593     {
 594         long rc = EnableMenuItem(GetHMenuOf(m_parentMenu),
 595                                  GetMSWId(),
 596                                  MF_BYCOMMAND |
 597                                  (enable ? MF_ENABLED : MF_GRAYED));
 598
 599         if ( rc == -1 )
 600         {
 601             wxLogLastError(wxT("EnableMenuItem"));
 602         }
 603     }
 604
 605     wxMenuItemBase::Enable(enable);
 606 }
 607
 608 void wxMenuItem::Check(bool check)
 609 {
 610     wxCHECK_RET( IsCheckable(), wxT("only checkable items may be checked") );
 611
 612     if ( m_isChecked == check )
 613         return;
 614
 615     if ( m_parentMenu )
 616     {
 617         int flags = check ? MF_CHECKED : MF_UNCHECKED;
 618         HMENU hmenu = GetHMenuOf(m_parentMenu);
 619
 620         if ( GetKind() == wxITEM_RADIO )
 621         {
 622             // it doesn't make sense to uncheck a radio item -- what would this
 623             // do?
 624             if ( !check )
 625                 return;
 626
 627             // get the index of this item in the menu
 628             const wxMenuItemList& items = m_parentMenu->GetMenuItems();
 629             int pos = items.IndexOf(this);
 630             wxCHECK_RET( pos != wxNOT_FOUND,
 631                          wxT("menuitem not found in the menu items list?") );
 632
 633             // get the radio group range
 634             int start,
 635                 end;
 636
 637             if ( m_isRadioGroupStart )
 638             {
 639                 // we already have all information we need
 640                 start = pos;
 641                 end = m_radioGroup.end;
 642             }
 643             else // next radio group item
 644             {
 645                 // get the radio group end from the start item
 646                 start = m_radioGroup.start;
 647                 end = items.Item(start)->GetData()->m_radioGroup.end;
 648             }
 649
 650 #ifdef __WIN32__
 651             // calling CheckMenuRadioItem() with such parameters hangs my system
 652             // (NT4 SP6) and I suspect this could happen to the others as well,
 653             // so don't do it!
 654             wxCHECK_RET( start != -1 && end != -1,
 655                          wxT("invalid ::CheckMenuRadioItem() parameter(s)") );
 656
 657             if ( !::CheckMenuRadioItem(hmenu,
 658                                        start,   // the first radio group item
 659                                        end,     // the last one
 660                                        pos,     // the one to check
 661                                        MF_BYPOSITION) )
 662             {
 663                 wxLogLastError(wxT("CheckMenuRadioItem"));
 664             }
 665 #endif // __WIN32__
 666
 667             // also uncheck all the other items in this radio group
 668             wxMenuItemList::compatibility_iterator node = items.Item(start);
 669             for ( int n = start; n <= end && node; n++ )
 670             {
 671                 if ( n != pos )
 672                 {
 673                     node->GetData()->m_isChecked = false;
 674                 }
 675
 676                 node = node->GetNext();
 677             }
 678         }
 679         else // check item
 680         {
 681             if ( ::CheckMenuItem(hmenu,
 682                                  GetMSWId(),
 683                                  MF_BYCOMMAND | flags) == (DWORD)-1 )
 684             {
 685                 wxFAIL_MSG(wxT("CheckMenuItem() failed, item not in the menu?"));
 686             }
 687         }
 688     }
 689
 690     wxMenuItemBase::Check(check);
 691 }
 692
 693 void wxMenuItem::SetItemLabel(const wxString& txt)
 694 {
 695     wxString text = txt;
 696
 697     // don't do anything if label didn't change
 698     if ( m_text == txt )
 699         return;
 700
 701     // wxMenuItemBase will do stock ID checks
 702     wxMenuItemBase::SetItemLabel(text);
 703
 704     // the item can be not attached to any menu yet and SetItemLabel() is still
 705     // valid to call in this case and should do nothing else
 706     if ( !m_parentMenu )
 707         return;
 708
 709 #if wxUSE_ACCEL
 710     m_parentMenu->UpdateAccel(this);
 711 #endif // wxUSE_ACCEL
 712
 713     const UINT id = GetMSWId();
 714     HMENU hMenu = GetHMenuOf(m_parentMenu);
 715     if ( !hMenu || ::GetMenuState(hMenu, id, MF_BYCOMMAND) == (UINT)-1 )
 716         return;
 717
 718 #if wxUSE_OWNER_DRAWN
 719     if ( IsOwnerDrawn() )
 720     {
 721         // we don't need to do anything for owner drawn items, they will redraw
 722         // themselves using the new text the next time they're displayed
 723         return;
 724     }
 725 #endif // owner drawn
 726
 727     // update the text of the native menu item
 728     WinStruct<MENUITEMINFO> info;
 729
 730     // surprisingly, calling SetMenuItemInfo() with just MIIM_STRING doesn't
 731     // work as it resets the menu bitmap, so we need to first get the old item
 732     // state and then modify it
 733     const bool isLaterThanWin95 = wxGetWinVersion() > wxWinVersion_95;
 734     info.fMask = MIIM_STATE |
 735                  MIIM_ID |
 736                  MIIM_SUBMENU |
 737                  MIIM_CHECKMARKS |
 738                  MIIM_DATA;
 739     if ( isLaterThanWin95 )
 740         info.fMask |= MIIM_BITMAP | MIIM_FTYPE;
 741     else
 742         info.fMask |= MIIM_TYPE;
 743     if ( !::GetMenuItemInfo(hMenu, id, FALSE, &info) )
 744     {
 745         wxLogLastError(wxT("GetMenuItemInfo"));
 746         return;
 747     }
 748
 749     if ( isLaterThanWin95 )
 750         info.fMask |= MIIM_STRING;
 751     //else: MIIM_TYPE already specified
 752     info.dwTypeData = (LPTSTR)m_text.wx_str();
 753     info.cch = m_text.length();
 754     if ( !::SetMenuItemInfo(hMenu, id, FALSE, &info) )
 755     {
 756         wxLogLastError(wxT("SetMenuItemInfo"));
 757     }
 758 }
 759
 760 #if wxUSE_OWNER_DRAWN
 761
 762 int wxMenuItem::MeasureAccelWidth() const
 763 {
 764     wxString accel = GetItemLabel().AfterFirst(wxT('\t'));
 765
 766     wxMemoryDC dc;
 767     wxFont font;
 768     GetFontToUse(font);
 769     dc.SetFont(font);
 770
 771     wxCoord w;
 772     dc.GetTextExtent(accel, &w, NULL);
 773
 774     return w;
 775 }
 776
 777 wxString wxMenuItem::GetName() const
 778 {
 779     return GetItemLabelText();
 780 }
 781
 782 bool wxMenuItem::OnMeasureItem(size_t *width, size_t *height)
 783 {
 784     const MenuDrawData* data = MenuDrawData::Get();
 785
 786     if ( IsOwnerDrawn() )
 787     {
 788         *width  = data->ItemMargin.GetTotalX();
 789         *height = data->ItemMargin.GetTotalY();
 790
 791         if ( IsSeparator() )
 792         {
 793             *width  += data->SeparatorSize.cx
 794                      + data->SeparatorMargin.GetTotalX();
 795             *height += data->SeparatorSize.cy
 796                      + data->SeparatorMargin.GetTotalY();
 797             return true;
 798         }
 799
 800         wxString str = GetName();
 801
 802         wxMemoryDC dc;
 803         wxFont font;
 804         GetFontToUse(font);
 805         dc.SetFont(font);
 806
 807         wxCoord w, h;
 808         dc.GetTextExtent(str, &w, &h);
 809
 810         *width = data->TextBorder + w + data->AccelBorder;
 811         *height = h;
 812
 813         w = m_parentMenu->GetMaxAccelWidth();
 814         if ( w > 0 )
 815             *width += w + data->ArrowBorder;
 816
 817         *width += data->Offset;
 818         *width += data->ArrowMargin.GetTotalX() + data->ArrowSize.cx;
 819     }
 820     else // don't draw the text, just the bitmap (if any)
 821     {
 822         *width = 0;
 823         *height = 0;
 824     }
 825
 826     // bitmap
 827
 828     if ( IsOwnerDrawn() )
 829     {
 830         // width of menu icon with margins in ownerdrawn menu
 831         // if any bitmap is not set, the width of space reserved for icon
 832         // image is equal to the width of std check mark,
 833         // if bitmap is set, then the width is set to the width of the widest
 834         // bitmap in menu (GetMarginWidth()) unless std check mark is wider,
 835         // then it's is set to std mark's width
 836         int imgWidth = wxMax(GetMarginWidth(), data->CheckSize.cx)
 837                      + data->CheckMargin.GetTotalX();
 838
 839         *width += imgWidth + data->CheckBgMargin.GetTotalX();
 840     }
 841
 842     if ( m_bmpChecked.IsOk() || m_bmpUnchecked.IsOk() )
 843     {
 844         // get size of bitmap always return valid value (0 for invalid bitmap),
 845         // so we don't needed check if bitmap is valid ;)
 846         size_t heightBmp = wxMax(m_bmpChecked.GetHeight(), m_bmpUnchecked.GetHeight());
 847         size_t widthBmp = wxMax(m_bmpChecked.GetWidth(),  m_bmpUnchecked.GetWidth());
 848
 849         if ( IsOwnerDrawn() )
 850         {
 851             heightBmp += data->CheckMargin.GetTotalY();
 852         }
 853         else
 854         {
 855             // we must allocate enough space for the bitmap
 856             *width += widthBmp;
 857         }
 858
 859         // Is BMP height larger than text height?
 860         if ( *height < heightBmp )
 861             *height = heightBmp;
 862     }
 863
 864     // make sure that this item is at least as tall as the system menu height
 865     const size_t menuHeight = data->CheckMargin.GetTotalY()
 866                             + data->CheckSize.cy;
 867     if (*height < menuHeight)
 868         *height = menuHeight;
 869
 870     return true;
 871 }
 872
 873 bool wxMenuItem::OnDrawItem(wxDC& dc, const wxRect& rc,
 874                             wxODAction WXUNUSED(act), wxODStatus stat)
 875 {
 876     const MenuDrawData* data = MenuDrawData::Get();
 877
 878     wxMSWDCImpl *impl = (wxMSWDCImpl*) dc.GetImpl();
 879     HDC hdc = GetHdcOf(*impl);
 880
 881     RECT rect;
 882     wxCopyRectToRECT(rc, rect);
 883
 884     int imgWidth = wxMax(GetMarginWidth(), data->CheckSize.cx);
 885
 886     if ( IsOwnerDrawn() )
 887     {
 888         // font and colors to use
 889         wxFont font;
 890         GetFontToUse(font);
 891
 892         wxColour colText, colBack;
 893         GetColourToUse(stat, colText, colBack);
 894
 895         // calculate metrics of item parts
 896         RECT rcSelection = rect;
 897         data->ItemMargin.ApplyTo(rcSelection);
 898
 899         RECT rcSeparator = rcSelection;
 900         data->SeparatorMargin.ApplyTo(rcSeparator);
 901
 902         RECT rcGutter = rcSelection;
 903         rcGutter.right = data->ItemMargin.cxLeftWidth
 904                        + data->CheckBgMargin.cxLeftWidth
 905                        + data->CheckMargin.cxLeftWidth
 906                        + imgWidth
 907                        + data->CheckMargin.cxRightWidth
 908                        + data->CheckBgMargin.cxRightWidth;
 909
 910         RECT rcText = rcSelection;
 911         rcText.left = rcGutter.right + data->TextBorder;
 912
 913         // we draw the text label vertically centered, but this results in it
 914         // being 1px too low compared to native menus for some reason, fix it
 915         if ( data->MenuLayout() != MenuDrawData::FullTheme )
 916             rcText.top--;
 917
 918 #if wxUSE_UXTHEME
 919         // If a custom background colour is explicitly specified, we should use
 920         // it instead of the default theme background.
 921         wxUxThemeEngine* const theme = GetBackgroundColour().IsOk()
 922                                         ? NULL
 923                                         : MenuDrawData::GetUxThemeEngine();
 924         if ( theme )
 925         {
 926             POPUPITEMSTATES state;
 927             if ( stat & wxODDisabled )
 928             {
 929                 state = (stat & wxODSelected) ? MPI_DISABLEDHOT
 930                                               : MPI_DISABLED;
 931             }
 932             else if ( stat & wxODSelected )
 933             {
 934                 state = MPI_HOT;
 935             }
 936             else
 937             {
 938                 state = MPI_NORMAL;
 939             }
 940
 941             wxUxThemeHandle hTheme(GetMenu()->GetWindow(), L"MENU");
 942
 943             if ( theme->IsThemeBackgroundPartiallyTransparent(hTheme,
 944                     MENU_POPUPITEM, state) )
 945             {
 946                 theme->DrawThemeBackground(hTheme, hdc,
 947                                            MENU_POPUPBACKGROUND,
 948                                            0, &rect, NULL);
 949             }
 950
 951             theme->DrawThemeBackground(hTheme, hdc, MENU_POPUPGUTTER,
 952                                        0, &rcGutter, NULL);
 953
 954             if ( IsSeparator() )
 955             {
 956                 rcSeparator.left = rcGutter.right;
 957                 theme->DrawThemeBackground(hTheme, hdc, MENU_POPUPSEPARATOR,
 958                                            0, &rcSeparator, NULL);
 959                 return true;
 960             }
 961
 962             theme->DrawThemeBackground(hTheme, hdc, MENU_POPUPITEM,
 963                                        state, &rcSelection, NULL);
 964
 965         }
 966         else
 967 #endif // wxUSE_UXTHEME
 968         {
 969             if ( IsSeparator() )
 970             {
 971                 DrawEdge(hdc, &rcSeparator, EDGE_ETCHED, BF_TOP);
 972                 return true;
 973             }
 974
 975             AutoHBRUSH hbr(colBack.GetPixel());
 976             SelectInHDC selBrush(hdc, hbr);
 977             ::FillRect(hdc, &rcSelection, hbr);
 978         }
 979
 980
 981         // draw text label
 982         // using native API because it recognizes '&'
 983
 984         HDCTextColChanger changeTextCol(hdc, colText.GetPixel());
 985         HDCBgColChanger changeBgCol(hdc, colBack.GetPixel());
 986         HDCBgModeChanger changeBgMode(hdc, TRANSPARENT);
 987
 988         SelectInHDC selFont(hdc, GetHfontOf(font));
 989
 990
 991         // item text name without mnemonic for calculating size
 992         wxString text = GetName();
 993
 994         SIZE textSize;
 995         ::GetTextExtentPoint32(hdc, text.c_str(), text.length(), &textSize);
 996
 997         // item text name with mnemonic
 998         text = GetItemLabel().BeforeFirst('\t');
 999
1000         int flags = DST_PREFIXTEXT;
1001         // themes menu is using specified color for disabled labels
1002         if ( data->MenuLayout() == MenuDrawData::Classic &&
1003              (stat & wxODDisabled) && !(stat & wxODSelected) )
1004             flags |= DSS_DISABLED;
1005
1006         if ( (stat & wxODHidePrefix) && !data->AlwaysShowCues )
1007             flags |= DSS_HIDEPREFIX;
1008
1009         int x = rcText.left;
1010         int y = rcText.top + (rcText.bottom - rcText.top - textSize.cy) / 2;
1011
1012         ::DrawState(hdc, NULL, NULL, (LPARAM)text.wx_str(),
1013                     text.length(), x, y, 0, 0, flags);
1014
1015         // ::SetTextAlign(hdc, TA_RIGHT) doesn't work with DSS_DISABLED or DSS_MONO
1016         // as the last parameter in DrawState() (at least with Windows98). So we have
1017         // to take care of right alignment ourselves.
1018         wxString accel = GetItemLabel().AfterFirst(wxT('\t'));
1019         if ( !accel.empty() )
1020         {
1021             SIZE accelSize;
1022             ::GetTextExtentPoint32(hdc, accel.c_str(), accel.length(), &accelSize);
1023
1024             int flags = DST_TEXT;
1025             // themes menu is using specified color for disabled labels
1026             if ( data->MenuLayout() == MenuDrawData::Classic &&
1027                  (stat & wxODDisabled) && !(stat & wxODSelected) )
1028                 flags |= DSS_DISABLED;
1029
1030             int x = rcText.right - data->ArrowMargin.GetTotalX()
1031                                  - data->ArrowSize.cx
1032                                  - data->ArrowBorder;
1033
1034             // right align accel on FullTheme menu, left otherwise
1035             if ( data->MenuLayout() == MenuDrawData::FullTheme)
1036                 x -= accelSize.cx;
1037             else
1038                 x -= m_parentMenu->GetMaxAccelWidth();
1039
1040             int y = rcText.top + (rcText.bottom - rcText.top - accelSize.cy) / 2;
1041
1042             ::DrawState(hdc, NULL, NULL, (LPARAM)accel.wx_str(),
1043                         accel.length(), x, y, 0, 0, flags);
1044         }
1045     }
1046
1047
1048     // draw the bitmap
1049
1050     RECT rcImg;
1051     SetRect(&rcImg,
1052             rect.left   + data->ItemMargin.cxLeftWidth
1053                         + data->CheckBgMargin.cxLeftWidth
1054                         + data->CheckMargin.cxLeftWidth,
1055             rect.top    + data->ItemMargin.cyTopHeight
1056                         + data->CheckBgMargin.cyTopHeight
1057                         + data->CheckMargin.cyTopHeight,
1058             rect.left   + data->ItemMargin.cxLeftWidth
1059                         + data->CheckBgMargin.cxLeftWidth
1060                         + data->CheckMargin.cxLeftWidth
1061                         + imgWidth,
1062             rect.bottom - data->ItemMargin.cyBottomHeight
1063                         - data->CheckBgMargin.cyBottomHeight
1064                         - data->CheckMargin.cyBottomHeight);
1065
1066     if ( IsCheckable() && !m_bmpChecked.Ok() )
1067     {
1068         if ( stat & wxODChecked )
1069         {
1070             DrawStdCheckMark((WXHDC)hdc, &rcImg, stat);
1071         }
1072     }
1073     else
1074     {
1075         wxBitmap bmp;
1076
1077         if ( stat & wxODDisabled )
1078         {
1079             bmp = GetDisabledBitmap();
1080         }
1081
1082         if ( !bmp.Ok() )
1083         {
1084             // for not checkable bitmaps we should always use unchecked one
1085             // because their checked bitmap is not set
1086             bmp = GetBitmap(!IsCheckable() || (stat & wxODChecked));
1087
1088 #if wxUSE_IMAGE
1089             if ( bmp.Ok() && stat & wxODDisabled )
1090             {
1091                 // we need to grey out the bitmap as we don't have any specific
1092                 // disabled bitmap
1093                 wxImage imgGrey = bmp.ConvertToImage().ConvertToGreyscale();
1094                 if ( imgGrey.Ok() )
1095                     bmp = wxBitmap(imgGrey);
1096             }
1097 #endif // wxUSE_IMAGE
1098         }
1099
1100         if ( bmp.Ok() )
1101         {
1102             wxMemoryDC dcMem(&dc);
1103             dcMem.SelectObjectAsSource(bmp);
1104
1105             // center bitmap
1106             int nBmpWidth  = bmp.GetWidth(),
1107                 nBmpHeight = bmp.GetHeight();
1108
1109             // there should be enough space!
1110             wxASSERT( nBmpWidth <= imgWidth && nBmpHeight <= (rcImg.bottom - rcImg.top) );
1111
1112             int x = rcImg.left + (imgWidth - nBmpWidth) / 2;
1113             int y = rcImg.top  + (rcImg.bottom - rcImg.top - nBmpHeight) / 2;
1114             dc.Blit(x, y, nBmpWidth, nBmpHeight, &dcMem, 0, 0, wxCOPY, true);
1115         }
1116     }
1117
1118     return true;
1119
1120 }
1121
1122 namespace
1123 {
1124
1125 // helper function for draw coloured check mark
1126 void DrawColorCheckMark(HDC hdc, int x, int y, int cx, int cy, HDC hdcCheckMask, int idxColor)
1127 {
1128     const COLORREF colBlack = RGB(0, 0, 0);
1129     const COLORREF colWhite = RGB(255, 255, 255);
1130
1131     HDCTextColChanger changeTextCol(hdc, colBlack);
1132     HDCBgColChanger changeBgCol(hdc, colWhite);
1133     HDCBgModeChanger changeBgMode(hdc, TRANSPARENT);
1134
1135     // memory DC for color bitmap
1136     MemoryHDC hdcMem(hdc);
1137     CompatibleBitmap hbmpMem(hdc, cx, cy);
1138     SelectInHDC selMem(hdcMem, hbmpMem);
1139
1140     RECT rect = { 0, 0, cx, cy };
1141     ::FillRect(hdcMem, &rect, ::GetSysColorBrush(idxColor));
1142
1143     const COLORREF colCheck = ::GetSysColor(idxColor);
1144     if ( colCheck == colWhite )
1145     {
1146         ::BitBlt(hdc, x, y, cx, cy, hdcCheckMask, 0, 0, MERGEPAINT);
1147         ::BitBlt(hdc, x, y, cx, cy, hdcMem, 0, 0, SRCAND);
1148     }
1149     else
1150     {
1151         if ( colCheck != colBlack )
1152         {
1153             const DWORD ROP_DSna = 0x00220326;  // dest = (NOT src) AND dest
1154             ::BitBlt(hdcMem, 0, 0, cx, cy, hdcCheckMask, 0, 0, ROP_DSna);
1155         }
1156
1157         ::BitBlt(hdc, x, y, cx, cy, hdcCheckMask, 0, 0, SRCAND);
1158         ::BitBlt(hdc, x, y, cx, cy, hdcMem, 0, 0, SRCPAINT);
1159     }
1160 }
1161
1162 } // anonymous namespace
1163
1164 void wxMenuItem::DrawStdCheckMark(WXHDC hdc_, const RECT* rc, wxODStatus stat)
1165 {
1166     HDC hdc = (HDC)hdc_;
1167
1168 #if wxUSE_UXTHEME
1169     wxUxThemeEngine* theme = MenuDrawData::GetUxThemeEngine();
1170     if ( theme )
1171     {
1172         wxUxThemeHandle hTheme(GetMenu()->GetWindow(), L"MENU");
1173
1174         const MenuDrawData* data = MenuDrawData::Get();
1175
1176         // rect for background must be without check margins
1177         RECT rcBg = *rc;
1178         data->CheckMargin.UnapplyFrom(rcBg);
1179
1180         POPUPCHECKBACKGROUNDSTATES stateCheckBg = (stat & wxODDisabled)
1181                                                     ? MCB_DISABLED
1182                                                     : MCB_NORMAL;
1183
1184         theme->DrawThemeBackground(hTheme, hdc, MENU_POPUPCHECKBACKGROUND,
1185                                    stateCheckBg, &rcBg, NULL);
1186
1187         POPUPCHECKSTATES stateCheck;
1188         if ( GetKind() == wxITEM_CHECK )
1189         {
1190             stateCheck = (stat & wxODDisabled) ? MC_CHECKMARKDISABLED
1191                                                : MC_CHECKMARKNORMAL;
1192         }
1193         else
1194         {
1195             stateCheck = (stat & wxODDisabled) ? MC_BULLETDISABLED
1196                                                : MC_BULLETNORMAL;
1197         }
1198
1199         theme->DrawThemeBackground(hTheme, hdc, MENU_POPUPCHECK,
1200                                    stateCheck, rc, NULL);
1201     }
1202     else
1203 #endif // wxUSE_UXTHEME
1204     {
1205         int cx = rc->right - rc->left;
1206         int cy = rc->bottom - rc->top;
1207
1208         // first create mask of check mark
1209         MemoryHDC hdcMask(hdc);
1210         MonoBitmap hbmpMask(cx, cy);
1211         SelectInHDC selMask(hdcMask,hbmpMask);
1212
1213         // then draw a check mark into it
1214         UINT stateCheck = (GetKind() == wxITEM_CHECK) ? DFCS_MENUCHECK
1215                                                       : DFCS_MENUBULLET;
1216         RECT rect = { 0, 0, cx, cy };
1217         ::DrawFrameControl(hdcMask, &rect, DFC_MENU, stateCheck);
1218
1219         // first draw shadow if disabled
1220         if ( (stat & wxODDisabled) && !(stat & wxODSelected) )
1221         {
1222             DrawColorCheckMark(hdc, rc->left + 1, rc->top + 1,
1223                                cx, cy, hdcMask, COLOR_3DHILIGHT);
1224         }
1225
1226         // then draw a check mark
1227         int color = COLOR_MENUTEXT;
1228         if ( stat & wxODDisabled )
1229             color = COLOR_BTNSHADOW;
1230         else if ( stat & wxODSelected )
1231             color = COLOR_HIGHLIGHTTEXT;
1232
1233         DrawColorCheckMark(hdc, rc->left, rc->top, cx, cy, hdcMask, color);
1234     }
1235 }
1236
1237 void wxMenuItem::GetFontToUse(wxFont& font) const
1238 {
1239     font = GetFont();
1240     if ( !font.IsOk() )
1241         font = MenuDrawData::Get()->Font;
1242 }
1243
1244 void wxMenuItem::GetColourToUse(wxODStatus stat, wxColour& colText, wxColour& colBack) const
1245 {
1246 #if wxUSE_UXTHEME
1247     wxUxThemeEngine* theme = MenuDrawData::GetUxThemeEngine();
1248     if ( theme )
1249     {
1250         wxUxThemeHandle hTheme(GetMenu()->GetWindow(), L"MENU");
1251
1252         if ( stat & wxODDisabled)
1253         {
1254             wxRGBToColour(colText, theme->GetThemeSysColor(hTheme, COLOR_GRAYTEXT));
1255         }
1256         else
1257         {
1258             colText = GetTextColour();
1259             if ( !colText.IsOk() )
1260                 wxRGBToColour(colText, theme->GetThemeSysColor(hTheme, COLOR_MENUTEXT));
1261         }
1262
1263         if ( stat & wxODSelected )
1264         {
1265             wxRGBToColour(colBack, theme->GetThemeSysColor(hTheme, COLOR_HIGHLIGHT));
1266         }
1267         else
1268         {
1269             colBack = GetBackgroundColour();
1270             if ( !colBack.IsOk() )
1271                 wxRGBToColour(colBack, theme->GetThemeSysColor(hTheme, COLOR_MENU));
1272         }
1273     }
1274     else
1275 #endif // wxUSE_UXTHEME
1276     {
1277         wxOwnerDrawn::GetColourToUse(stat, colText, colBack);
1278     }
1279 }
1280 #endif // wxUSE_OWNER_DRAWN
1281
1282 // ----------------------------------------------------------------------------
1283 // wxMenuItemBase
1284 // ----------------------------------------------------------------------------
1285
1286 wxMenuItem *wxMenuItemBase::New(wxMenu *parentMenu,
1287                                 int id,
1288                                 const wxString& name,
1289                                 const wxString& help,
1290                                 wxItemKind kind,
1291                                 wxMenu *subMenu)
1292 {
1293     return new wxMenuItem(parentMenu, id, name, help, kind, subMenu);
1294 }
1295
1296 #endif // wxUSE_MENUS