X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/fa7134b05abb0d8df4b800762aa9d040bfd689a4..f2049b683752950d1fe91aec07318e7f2122ff16:/src/msw/menuitem.cpp diff --git a/src/msw/menuitem.cpp b/src/msw/menuitem.cpp index d5ef1dc4e7..94d963d4ac 100644 --- a/src/msw/menuitem.cpp +++ b/src/msw/menuitem.cpp @@ -30,6 +30,8 @@ #include "wx/stockitem.h" #ifndef WX_PRECOMP + #include "wx/app.h" + #include "wx/dcmemory.h" #include "wx/font.h" #include "wx/bitmap.h" #include "wx/settings.h" @@ -45,12 +47,17 @@ #endif // wxUSE_ACCEL #include "wx/msw/private.h" +#include "wx/msw/dc.h" #ifdef __WXWINCE__ // Implemented in menu.cpp UINT GetMenuState(HMENU hMenu, UINT id, UINT flags) ; #endif +#if wxUSE_UXTHEME + #include "wx/msw/uxtheme.h" +#endif + // --------------------------------------------------------------------------- // macro // --------------------------------------------------------------------------- @@ -58,67 +65,404 @@ UINT GetMenuState(HMENU hMenu, UINT id, UINT flags) ; // hide the ugly cast #define GetHMenuOf(menu) ((HMENU)menu->GetHMenu()) -// conditional compilation -#if wxUSE_OWNER_DRAWN - #define OWNER_DRAWN_ONLY( code ) if ( IsOwnerDrawn() ) code -#else // !wxUSE_OWNER_DRAWN - #define OWNER_DRAWN_ONLY( code ) -#endif // wxUSE_OWNER_DRAWN/!wxUSE_OWNER_DRAWN +// ---------------------------------------------------------------------------- +// helper classes for temporarily changing HDC parameters +// ---------------------------------------------------------------------------- + +namespace +{ + +// This class just stores an HDC. +class HDCHandler +{ +protected: + HDCHandler(HDC hdc) : m_hdc(hdc) { } + + const HDC m_hdc; +}; + +class HDCTextColChanger : HDCHandler +{ +public: + HDCTextColChanger(HDC hdc, COLORREF col) + : HDCHandler(hdc), + m_colOld(::SetTextColor(hdc, col)) + { + } + + ~HDCTextColChanger() + { + ::SetTextColor(m_hdc, m_colOld); + } + +private: + COLORREF m_colOld; +}; + +class HDCBgColChanger : HDCHandler +{ +public: + HDCBgColChanger(HDC hdc, COLORREF col) + : HDCHandler(hdc), + m_colOld(::SetBkColor(hdc, col)) + { + } + + ~HDCBgColChanger() + { + ::SetBkColor(m_hdc, m_colOld); + } + +private: + COLORREF m_colOld; +}; + +class HDCBgModeChanger : HDCHandler +{ +public: + HDCBgModeChanger(HDC hdc, int mode) + : HDCHandler(hdc), + m_modeOld(::SetBkMode(hdc, mode)) + { + } + + ~HDCBgModeChanger() + { + ::SetBkMode(m_hdc, m_modeOld); + } + +private: + int m_modeOld; +}; + +} // anonymous namespace // ============================================================================ // implementation // ============================================================================ +#if wxUSE_OWNER_DRAWN + +#include "wx/fontutil.h" +#include "wx/msw/private/metrics.h" + +#ifndef SPI_GETKEYBOARDCUES +#define SPI_GETKEYBOARDCUES 0x100A +#endif + +#ifndef DSS_HIDEPREFIX +#define DSS_HIDEPREFIX 0x0200 +#endif + +#if wxUSE_UXTHEME + +enum MENUPARTS +{ + MENU_MENUITEM_TMSCHEMA = 1, + MENU_SEPARATOR_TMSCHEMA = 6, + MENU_POPUPBACKGROUND = 9, + MENU_POPUPBORDERS = 10, + MENU_POPUPCHECK = 11, + MENU_POPUPCHECKBACKGROUND = 12, + MENU_POPUPGUTTER = 13, + MENU_POPUPITEM = 14, + MENU_POPUPSEPARATOR = 15, + MENU_POPUPSUBMENU = 16, +}; + + +enum POPUPITEMSTATES +{ + MPI_NORMAL = 1, + MPI_HOT = 2, + MPI_DISABLED = 3, + MPI_DISABLEDHOT = 4, +}; + +enum POPUPCHECKBACKGROUNDSTATES +{ + MCB_DISABLED = 1, + MCB_NORMAL = 2, + MCB_BITMAP = 3, +}; + +enum POPUPCHECKSTATES +{ + MC_CHECKMARKNORMAL = 1, + MC_CHECKMARKDISABLED = 2, + MC_BULLETNORMAL = 3, + MC_BULLETDISABLED = 4, +}; + +const int TMT_MENUFONT = 803; +const int TMT_BORDERSIZE = 2403; +const int TMT_CONTENTMARGINS = 3602; +const int TMT_SIZINGMARGINS = 3601; + +#endif // wxUSE_UXTHEME + +#endif // wxUSE_OWNER_DRAWN + // ---------------------------------------------------------------------------- // dynamic classes implementation // ---------------------------------------------------------------------------- -#if wxUSE_EXTENDED_RTTI +// ---------------------------------------------------------------------------- +// wxMenuItem +// ---------------------------------------------------------------------------- + +#if wxUSE_OWNER_DRAWN + +namespace +{ -bool wxMenuItemStreamingCallback( const wxObject *object, wxWriter * , wxPersister * , wxxVariantArray & ) +// helper class to keep information about metrics and other stuff +// needed for measuring and drawing menu item +class MenuDrawData { - const wxMenuItem * mitem = dynamic_cast(object) ; - if ( mitem->GetMenu() && !mitem->GetMenu()->GetTitle().empty() ) +public: + // Wrapper around standard MARGINS structure providing some helper + // functions and automatically initializing the margin fields to 0. + struct Margins : MARGINS + { + Margins() + { + cxLeftWidth = + cxRightWidth = + cyTopHeight = + cyBottomHeight = 0; + } + + int GetTotalX() const { return cxLeftWidth + cxRightWidth; } + int GetTotalY() const { return cyTopHeight + cyBottomHeight; } + + void ApplyTo(RECT& rect) const + { + rect.top += cyTopHeight; + rect.left += cxLeftWidth; + rect.right -= cyTopHeight; + rect.bottom -= cyBottomHeight; + } + + void UnapplyFrom(RECT& rect) const + { + rect.top -= cyTopHeight; + rect.left -= cxLeftWidth; + rect.right += cyTopHeight; + rect.bottom += cyBottomHeight; + } + }; + + Margins ItemMargin; // popup item margins + + Margins CheckMargin; // popup check margins + Margins CheckBgMargin; // popup check background margins + + Margins ArrowMargin; // popup submenu arrow margins + + Margins SeparatorMargin; // popup separator margins + + SIZE CheckSize; // popup check size metric + SIZE ArrowSize; // popup submenu arrow size metric + SIZE SeparatorSize; // popup separator size metric + + int TextBorder; // popup border space between + // item text and gutter + + int AccelBorder; // popup border space between + // item text and accelerator + + int ArrowBorder; // popup border space between + // item accelerator and submenu arrow + + int Offset; // system added space at the end of the menu, + // add this offset for remove the extra space + + wxFont Font; // default menu font + + bool AlwaysShowCues; // must keyboard cues always be shown? + + bool Theme; // is data initialized for FullTheme? + + static const MenuDrawData* Get() + { + // notice that s_menuData can't be created as a global variable because + // it needs a window to initialize and no windows exist at the time of + // globals initialization yet + if ( !ms_instance ) + { + static MenuDrawData s_menuData; + ms_instance = &s_menuData; + } + + #if wxUSE_UXTHEME + bool theme = MenuLayout() == FullTheme; + if ( ms_instance->Theme != theme ) + ms_instance->Init(); + #endif // wxUSE_UXTHEME + return ms_instance; + } + + MenuDrawData() + { + Init(); + } + + + // get the theme engine or NULL if themes + // are not available or not supported on menu + static wxUxThemeEngine *GetUxThemeEngine() { - // we don't stream out the first two items for menus with a title, they will be reconstructed - if ( mitem->GetMenu()->FindItemByPosition(0) == mitem || mitem->GetMenu()->FindItemByPosition(1) == mitem ) - return false ; + #if wxUSE_UXTHEME + if ( MenuLayout() == FullTheme ) + return wxUxThemeEngine::GetIfActive(); + #endif // wxUSE_UXTHEME + return NULL; } - return true ; + + + enum MenuLayoutType + { + FullTheme, // full menu themes (Vista or new) + PseudoTheme, // pseudo menu themes (on XP) + Classic + }; + + static MenuLayoutType MenuLayout() + { + MenuLayoutType menu = Classic; + #if wxUSE_UXTHEME + if ( wxUxThemeEngine::GetIfActive() != NULL ) + { + static wxWinVersion ver = wxGetWinVersion(); + if ( ver >= wxWinVersion_Vista ) + menu = FullTheme; + else if ( ver == wxWinVersion_XP ) + menu = PseudoTheme; + } + #endif // wxUSE_UXTHEME + return menu; + } + +private: + void Init(); + + static MenuDrawData* ms_instance; +}; + +MenuDrawData* MenuDrawData::ms_instance = NULL; + +void MenuDrawData::Init() +{ +#if wxUSE_UXTHEME + wxUxThemeEngine* theme = GetUxThemeEngine(); + if ( theme ) + { + wxWindow* window = static_cast(wxApp::GetInstance())->GetTopWindow(); + wxUxThemeHandle hTheme(window, L"MENU"); + + theme->GetThemeMargins(hTheme, NULL, MENU_POPUPITEM, 0, + TMT_CONTENTMARGINS, NULL, + &ItemMargin); + + theme->GetThemeMargins(hTheme, NULL, MENU_POPUPCHECK, 0, + TMT_CONTENTMARGINS, NULL, + &CheckMargin); + theme->GetThemeMargins(hTheme, NULL, MENU_POPUPCHECKBACKGROUND, 0, + TMT_CONTENTMARGINS, NULL, + &CheckBgMargin); + + theme->GetThemeMargins(hTheme, NULL, MENU_POPUPSUBMENU, 0, + TMT_CONTENTMARGINS, NULL, + &ArrowMargin); + + theme->GetThemeMargins(hTheme, NULL, MENU_POPUPSEPARATOR, 0, + TMT_SIZINGMARGINS, NULL, + &SeparatorMargin); + + theme->GetThemePartSize(hTheme, NULL, MENU_POPUPCHECK, 0, + NULL, TS_TRUE, &CheckSize); + + theme->GetThemePartSize(hTheme, NULL, MENU_POPUPSUBMENU, 0, + NULL, TS_TRUE, &ArrowSize); + + theme->GetThemePartSize(hTheme, NULL, MENU_POPUPSEPARATOR, 0, + NULL, TS_TRUE, &SeparatorSize); + + theme->GetThemeInt(hTheme, MENU_POPUPBACKGROUND, 0, TMT_BORDERSIZE, &TextBorder); + + AccelBorder = 34; + ArrowBorder = 0; + + Offset = -14; + + wxUxThemeFont themeFont; + theme->GetThemeSysFont(hTheme, TMT_MENUFONT, themeFont.GetPtr()); + Font = wxFont(themeFont.GetLOGFONT()); + + Theme = true; + + // native menu doesn't uses the vertical margins + ItemMargin.cyTopHeight = + ItemMargin.cyBottomHeight = 0; + + // native menu uses small top margin for separator + if ( SeparatorMargin.cyTopHeight >= 2 ) + SeparatorMargin.cyTopHeight -= 2; + } + else +#endif // wxUSE_UXTHEME + { + const NONCLIENTMETRICS& metrics = wxMSWImpl::GetNonClientMetrics(); + + CheckMargin.cxLeftWidth = + CheckMargin.cxRightWidth = ::GetSystemMetrics(SM_CXEDGE); + CheckMargin.cyTopHeight = + CheckMargin.cyBottomHeight = ::GetSystemMetrics(SM_CYEDGE); + + CheckSize.cx = ::GetSystemMetrics(SM_CXMENUCHECK); + CheckSize.cy = ::GetSystemMetrics(SM_CYMENUCHECK); + + ArrowSize = CheckSize; + + // separator height with margins + int sepFullSize = metrics.iMenuHeight / 2; + + SeparatorMargin.cxLeftWidth = + SeparatorMargin.cxRightWidth = 1; + SeparatorMargin.cyTopHeight = + SeparatorMargin.cyBottomHeight = sepFullSize / 2 - 1; + + SeparatorSize.cx = 1; + SeparatorSize.cy = sepFullSize - SeparatorMargin.GetTotalY(); + + TextBorder = 0; + AccelBorder = 8; + ArrowBorder = 6; + + Offset = -12; + + Font = wxFont(wxNativeFontInfo(metrics.lfMenuFont)); + + Theme = false; + } + + int value; + if ( ::SystemParametersInfo(SPI_GETKEYBOARDCUES, 0, &value, 0) == 0 ) + { + // if it's not supported, we must be on an old Windows version + // which always shows them + value = 1; + } + + AlwaysShowCues = value == 1; + } -wxBEGIN_ENUM( wxItemKind ) - wxENUM_MEMBER( wxITEM_SEPARATOR ) - wxENUM_MEMBER( wxITEM_NORMAL ) - wxENUM_MEMBER( wxITEM_CHECK ) - wxENUM_MEMBER( wxITEM_RADIO ) -wxEND_ENUM( wxItemKind ) - -IMPLEMENT_DYNAMIC_CLASS_XTI_CALLBACK(wxMenuItem, wxObject,"wx/menuitem.h",wxMenuItemStreamingCallback) - -wxBEGIN_PROPERTIES_TABLE(wxMenuItem) - wxPROPERTY( Parent,wxMenu*, SetMenu, GetMenu, EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group") ) - wxPROPERTY( Id,int, SetId, GetId, EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group") ) - wxPROPERTY( Text, wxString , SetText, GetText, wxString(), 0 /*flags*/ , wxT("Helpstring") , wxT("group") ) - wxPROPERTY( Help, wxString , SetHelp, GetHelp, wxString(), 0 /*flags*/ , wxT("Helpstring") , wxT("group") ) - wxREADONLY_PROPERTY( Kind, wxItemKind , GetKind , EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group") ) - wxPROPERTY( SubMenu,wxMenu*, SetSubMenu, GetSubMenu, EMPTY_MACROVALUE , 0 /*flags*/ , wxT("Helpstring") , wxT("group") ) - wxPROPERTY( Enabled , bool , Enable , IsEnabled , wxxVariant((bool)true) , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) - wxPROPERTY( Checked , bool , Check , IsChecked , wxxVariant((bool)false) , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) - wxPROPERTY( Checkable , bool , SetCheckable , IsCheckable , wxxVariant((bool)false) , 0 /*flags*/ , wxT("Helpstring") , wxT("group")) -wxEND_PROPERTIES_TABLE() - -wxBEGIN_HANDLERS_TABLE(wxMenuItem) -wxEND_HANDLERS_TABLE() - -wxDIRECT_CONSTRUCTOR_6( wxMenuItem , wxMenu* , Parent , int , Id , wxString , Text , wxString , Help , wxItemKind , Kind , wxMenu* , SubMenu ) -#else -IMPLEMENT_DYNAMIC_CLASS(wxMenuItem, wxObject) -#endif +} // anonymous namespace + +#endif // wxUSE_OWNER_DRAWN -// ---------------------------------------------------------------------------- -// wxMenuItem -// ---------------------------------------------------------------------------- // ctor & dtor // ----------- @@ -130,13 +474,11 @@ wxMenuItem::wxMenuItem(wxMenu *pParentMenu, wxItemKind kind, wxMenu *pSubMenu) : wxMenuItemBase(pParentMenu, id, text, strHelp, kind, pSubMenu) -#if wxUSE_OWNER_DRAWN - , wxOwnerDrawn(text, kind == wxITEM_CHECK, true) -#endif // owner drawn { Init(); } +#if WXWIN_COMPATIBILITY_2_8 wxMenuItem::wxMenuItem(wxMenu *parentMenu, int id, const wxString& text, @@ -145,18 +487,13 @@ wxMenuItem::wxMenuItem(wxMenu *parentMenu, wxMenu *subMenu) : wxMenuItemBase(parentMenu, id, text, help, isCheckable ? wxITEM_CHECK : wxITEM_NORMAL, subMenu) -#if wxUSE_OWNER_DRAWN - , wxOwnerDrawn(text, isCheckable, true) -#endif // owner drawn { Init(); } +#endif void wxMenuItem::Init() { - m_radioGroup.start = -1; - m_isRadioGroupStart = false; - #if wxUSE_OWNER_DRAWN // when the color is not valid, wxOwnerDraw takes the default ones. @@ -167,14 +504,12 @@ void wxMenuItem::Init() SetBackgroundColour(wxNullColour); // setting default colors switched ownerdraw on: switch it off again - ResetOwnerDrawn(); + SetOwnerDrawn(false); // switch ownerdraw back on if using a non default margin if ( !IsSeparator() ) SetMarginWidth(GetMarginWidth()); - // tell the owner drawing code to show the accel string as well - SetAccelString(m_text.AfterFirst(_T('\t'))); #endif // wxUSE_OWNER_DRAWN } @@ -193,7 +528,7 @@ WXWPARAM wxMenuItem::GetMSWId() const // generating WM_COMMAND messages with negative high word of wParam), so // use the cast to ensure the id is in range return m_subMenu ? wxPtrToUInt(m_subMenu->GetHMenu()) - : wx_static_cast(unsigned short, GetId()); + : static_cast(GetId()); } // get item state @@ -201,44 +536,22 @@ WXWPARAM wxMenuItem::GetMSWId() const bool wxMenuItem::IsChecked() const { - // fix that RTTI is always getting the correct state (separators cannot be checked, but the call below - // returns true + // fix that RTTI is always getting the correct state (separators cannot be + // checked, but the Windows call below returns true if ( IsSeparator() ) - return false ; - - int flag = ::GetMenuState(GetHMenuOf(m_parentMenu), GetMSWId(), MF_BYCOMMAND); - - return (flag & MF_CHECKED) != 0; -} + return false; -/* static */ -wxString wxMenuItemBase::GetLabelText(const wxString& text) -{ - return wxStripMenuCodes(text); -} - -// radio group stuff -// ----------------- - -void wxMenuItem::SetAsRadioGroupStart() -{ - m_isRadioGroupStart = true; -} - -void wxMenuItem::SetRadioGroupStart(int start) -{ - wxASSERT_MSG( !m_isRadioGroupStart, - _T("should only be called for the next radio items") ); + // the item might not be attached to a menu yet + // + // TODO: shouldn't we just always call the base class version? It seems + // like it ought to always be in sync + if ( !m_parentMenu ) + return wxMenuItemBase::IsChecked(); - m_radioGroup.start = start; -} - -void wxMenuItem::SetRadioGroupEnd(int end) -{ - wxASSERT_MSG( m_isRadioGroupStart, - _T("should only be called for the first radio item") ); + HMENU hmenu = GetHMenuOf(m_parentMenu); + int flag = ::GetMenuState(hmenu, GetMSWId(), MF_BYCOMMAND); - m_radioGroup.end = end; + return (flag & MF_CHECKED) != 0; } // change item state @@ -249,13 +562,17 @@ void wxMenuItem::Enable(bool enable) if ( m_isEnabled == enable ) return; - long rc = EnableMenuItem(GetHMenuOf(m_parentMenu), - GetMSWId(), - MF_BYCOMMAND | - (enable ? MF_ENABLED : MF_GRAYED)); + if ( m_parentMenu ) + { + long rc = EnableMenuItem(GetHMenuOf(m_parentMenu), + GetMSWId(), + MF_BYCOMMAND | + (enable ? MF_ENABLED : MF_GRAYED)); - if ( rc == -1 ) { - wxLogLastError(wxT("EnableMenuItem")); + if ( rc == -1 ) + { + wxLogLastError(wxT("EnableMenuItem")); + } } wxMenuItemBase::Enable(enable); @@ -268,74 +585,71 @@ void wxMenuItem::Check(bool check) if ( m_isChecked == check ) return; - int flags = check ? MF_CHECKED : MF_UNCHECKED; - HMENU hmenu = GetHMenuOf(m_parentMenu); - - if ( GetKind() == wxITEM_RADIO ) + if ( m_parentMenu ) { - // it doesn't make sense to uncheck a radio item - what would this do? - if ( !check ) - return; - - // get the index of this item in the menu - const wxMenuItemList& items = m_parentMenu->GetMenuItems(); - int pos = items.IndexOf(this); - wxCHECK_RET( pos != wxNOT_FOUND, - _T("menuitem not found in the menu items list?") ); - - // get the radio group range - int start, - end; + int flags = check ? MF_CHECKED : MF_UNCHECKED; + HMENU hmenu = GetHMenuOf(m_parentMenu); - if ( m_isRadioGroupStart ) + if ( GetKind() == wxITEM_RADIO ) { - // we already have all information we need - start = pos; - end = m_radioGroup.end; - } - else // next radio group item - { - // get the radio group end from the start item - start = m_radioGroup.start; - end = items.Item(start)->GetData()->m_radioGroup.end; - } + // it doesn't make sense to uncheck a radio item -- what would this + // do? + if ( !check ) + return; + + // get the index of this item in the menu + const wxMenuItemList& items = m_parentMenu->GetMenuItems(); + int pos = items.IndexOf(this); + wxCHECK_RET( pos != wxNOT_FOUND, + wxT("menuitem not found in the menu items list?") ); + + // get the radio group range + int start, + end; + + if ( !m_parentMenu->MSWGetRadioGroupRange(pos, &start, &end) ) + { + wxFAIL_MSG( wxT("Menu radio item not part of radio group?") ); + return; + } #ifdef __WIN32__ - // calling CheckMenuRadioItem() with such parameters hangs my system - // (NT4 SP6) and I suspect this could happen to the others as well - so - // don't do it! - wxCHECK_RET( start != -1 && end != -1, - _T("invalid ::CheckMenuRadioItem() parameter(s)") ); - - if ( !::CheckMenuRadioItem(hmenu, - start, // the first radio group item - end, // the last one - pos, // the one to check - MF_BYPOSITION) ) - { - wxLogLastError(_T("CheckMenuRadioItem")); - } + // calling CheckMenuRadioItem() with such parameters hangs my system + // (NT4 SP6) and I suspect this could happen to the others as well, + // so don't do it! + wxCHECK_RET( start != -1 && end != -1, + wxT("invalid ::CheckMenuRadioItem() parameter(s)") ); + + if ( !::CheckMenuRadioItem(hmenu, + start, // the first radio group item + end, // the last one + pos, // the one to check + MF_BYPOSITION) ) + { + wxLogLastError(wxT("CheckMenuRadioItem")); + } #endif // __WIN32__ - // also uncheck all the other items in this radio group - wxMenuItemList::compatibility_iterator node = items.Item(start); - for ( int n = start; n <= end && node; n++ ) - { - if ( n != pos ) + // also uncheck all the other items in this radio group + wxMenuItemList::compatibility_iterator node = items.Item(start); + for ( int n = start; n <= end && node; n++ ) { - node->GetData()->m_isChecked = false; - } + if ( n != pos ) + { + node->GetData()->m_isChecked = false; + } - node = node->GetNext(); + node = node->GetNext(); + } } - } - else // check item - { - if ( ::CheckMenuItem(hmenu, - GetMSWId(), - MF_BYCOMMAND | flags) == (DWORD)-1 ) + else // check item { - wxFAIL_MSG( _T("CheckMenuItem() failed, item not in the menu?") ); + if ( ::CheckMenuItem(hmenu, + GetMSWId(), + MF_BYCOMMAND | flags) == (DWORD)-1 ) + { + wxFAIL_MSG(wxT("CheckMenuItem() failed, item not in the menu?")); + } } } @@ -353,86 +667,583 @@ void wxMenuItem::SetItemLabel(const wxString& txt) // wxMenuItemBase will do stock ID checks wxMenuItemBase::SetItemLabel(text); - // m_text could now be different from 'text' if we are a stock menu item, - // so use only m_text below - - OWNER_DRAWN_ONLY( wxOwnerDrawn::SetName(m_text) ); -#if wxUSE_OWNER_DRAWN - // tell the owner drawing code to to show the accel string as well - SetAccelString(m_text.AfterFirst(_T('\t'))); -#endif - - HMENU hMenu = GetHMenuOf(m_parentMenu); - wxCHECK_RET( hMenu, wxT("menuitem without menu") ); + // the item can be not attached to any menu yet and SetItemLabel() is still + // valid to call in this case and should do nothing else + if ( !m_parentMenu ) + return; #if wxUSE_ACCEL m_parentMenu->UpdateAccel(this); #endif // wxUSE_ACCEL - UINT id = GetMSWId(); - UINT flagsOld = ::GetMenuState(hMenu, id, MF_BYCOMMAND); - if ( flagsOld == 0xFFFFFFFF ) + const UINT id = GetMSWId(); + HMENU hMenu = GetHMenuOf(m_parentMenu); + if ( !hMenu || ::GetMenuState(hMenu, id, MF_BYCOMMAND) == (UINT)-1 ) + return; + +#if wxUSE_OWNER_DRAWN + if ( IsOwnerDrawn() ) { - // It's not an error, it means that the menu item doesn't exist - //wxLogLastError(wxT("GetMenuState")); + // we don't need to do anything for owner drawn items, they will redraw + // themselves using the new text the next time they're displayed + return; } +#endif // owner drawn + + // update the text of the native menu item + WinStruct info; + + // surprisingly, calling SetMenuItemInfo() with just MIIM_STRING doesn't + // work as it resets the menu bitmap, so we need to first get the old item + // state and then modify it + const bool isLaterThanWin95 = wxGetWinVersion() > wxWinVersion_95; + info.fMask = MIIM_STATE | + MIIM_ID | + MIIM_SUBMENU | + MIIM_CHECKMARKS | + MIIM_DATA; + if ( isLaterThanWin95 ) + info.fMask |= MIIM_BITMAP | MIIM_FTYPE; else + info.fMask |= MIIM_TYPE; + if ( !::GetMenuItemInfo(hMenu, id, FALSE, &info) ) + { + wxLogLastError(wxT("GetMenuItemInfo")); + return; + } + + if ( isLaterThanWin95 ) + info.fMask |= MIIM_STRING; + //else: MIIM_TYPE already specified + info.dwTypeData = (LPTSTR)m_text.wx_str(); + info.cch = m_text.length(); + if ( !::SetMenuItemInfo(hMenu, id, FALSE, &info) ) { - if ( IsSubMenu() ) + wxLogLastError(wxT("SetMenuItemInfo")); + } +} + +#if wxUSE_OWNER_DRAWN + +int wxMenuItem::MeasureAccelWidth() const +{ + wxString accel = GetItemLabel().AfterFirst(wxT('\t')); + + wxMemoryDC dc; + wxFont font; + GetFontToUse(font); + dc.SetFont(font); + + wxCoord w; + dc.GetTextExtent(accel, &w, NULL); + + return w; +} + +wxString wxMenuItem::GetName() const +{ + return GetItemLabelText(); +} + +bool wxMenuItem::OnMeasureItem(size_t *width, size_t *height) +{ + const MenuDrawData* data = MenuDrawData::Get(); + + if ( IsOwnerDrawn() ) + { + *width = data->ItemMargin.GetTotalX(); + *height = data->ItemMargin.GetTotalY(); + + if ( IsSeparator() ) { - // high byte contains the number of items in a submenu for submenus - flagsOld &= 0xFF; - flagsOld |= MF_POPUP; + *width += data->SeparatorSize.cx + + data->SeparatorMargin.GetTotalX(); + *height += data->SeparatorSize.cy + + data->SeparatorMargin.GetTotalY(); + return true; } - LPCTSTR data; + wxString str = GetName(); + + wxMemoryDC dc; + wxFont font; + GetFontToUse(font); + dc.SetFont(font); + + wxCoord w, h; + dc.GetTextExtent(str, &w, &h); + + *width = data->TextBorder + w + data->AccelBorder; + *height = h; + + w = m_parentMenu->GetMaxAccelWidth(); + if ( w > 0 ) + *width += w + data->ArrowBorder; + + *width += data->Offset; + *width += data->ArrowMargin.GetTotalX() + data->ArrowSize.cx; + } + else // don't draw the text, just the bitmap (if any) + { + *width = 0; + *height = 0; + } + + // bitmap + + if ( IsOwnerDrawn() ) + { + // width of menu icon with margins in ownerdrawn menu + // if any bitmap is not set, the width of space reserved for icon + // image is equal to the width of std check mark, + // if bitmap is set, then the width is set to the width of the widest + // bitmap in menu (GetMarginWidth()) unless std check mark is wider, + // then it's is set to std mark's width + int imgWidth = wxMax(GetMarginWidth(), data->CheckSize.cx) + + data->CheckMargin.GetTotalX(); + + *width += imgWidth + data->CheckBgMargin.GetTotalX(); + } + + if ( m_bmpChecked.IsOk() || m_bmpUnchecked.IsOk() ) + { + // get size of bitmap always return valid value (0 for invalid bitmap), + // so we don't needed check if bitmap is valid ;) + size_t heightBmp = wxMax(m_bmpChecked.GetHeight(), m_bmpUnchecked.GetHeight()); + size_t widthBmp = wxMax(m_bmpChecked.GetWidth(), m_bmpUnchecked.GetWidth()); -#if wxUSE_OWNER_DRAWN if ( IsOwnerDrawn() ) { - flagsOld |= MF_OWNERDRAW; - data = (LPCTSTR)this; + heightBmp += data->CheckMargin.GetTotalY(); } else -#endif //owner drawn { - flagsOld |= MF_STRING; - data = (wxChar*) m_text.wx_str(); + // we must allocate enough space for the bitmap + *width += widthBmp; } -#ifdef __WXWINCE__ - // FIXME: complete this, applying the old - // flags. - // However, the WinCE doc for SetMenuItemInfo - // says that you can't use it to set the menu - // item state; only data, id and type. - MENUITEMINFO info; - wxZeroMemory(info); - info.cbSize = sizeof(info); - info.fMask = MIIM_TYPE; - info.fType = MFT_STRING; - info.cch = m_text.length(); - info.dwTypeData = (LPTSTR) data ; - if ( !::SetMenuItemInfo(hMenu, id, FALSE, & info) ) + // Is BMP height larger than text height? + if ( *height < heightBmp ) + *height = heightBmp; + } + + // make sure that this item is at least as tall as the system menu height + const size_t menuHeight = data->CheckMargin.GetTotalY() + + data->CheckSize.cy; + if (*height < menuHeight) + *height = menuHeight; + + return true; +} + +bool wxMenuItem::OnDrawItem(wxDC& dc, const wxRect& rc, + wxODAction WXUNUSED(act), wxODStatus stat) +{ + const MenuDrawData* data = MenuDrawData::Get(); + + wxMSWDCImpl *impl = (wxMSWDCImpl*) dc.GetImpl(); + HDC hdc = GetHdcOf(*impl); + + RECT rect; + wxCopyRectToRECT(rc, rect); + + int imgWidth = wxMax(GetMarginWidth(), data->CheckSize.cx); + + if ( IsOwnerDrawn() ) + { + // font and colors to use + wxFont font; + GetFontToUse(font); + + wxColour colText, colBack; + GetColourToUse(stat, colText, colBack); + + // calculate metrics of item parts + RECT rcSelection = rect; + data->ItemMargin.ApplyTo(rcSelection); + + RECT rcSeparator = rcSelection; + data->SeparatorMargin.ApplyTo(rcSeparator); + + RECT rcGutter = rcSelection; + rcGutter.right = data->ItemMargin.cxLeftWidth + + data->CheckBgMargin.cxLeftWidth + + data->CheckMargin.cxLeftWidth + + imgWidth + + data->CheckMargin.cxRightWidth + + data->CheckBgMargin.cxRightWidth; + + RECT rcText = rcSelection; + rcText.left = rcGutter.right + data->TextBorder; + + // we draw the text label vertically centered, but this results in it + // being 1px too low compared to native menus for some reason, fix it + if ( data->MenuLayout() != MenuDrawData::FullTheme ) + rcText.top--; + +#if wxUSE_UXTHEME + // If a custom background colour is explicitly specified, we should use + // it instead of the default theme background. + wxUxThemeEngine* const theme = GetBackgroundColour().IsOk() + ? NULL + : MenuDrawData::GetUxThemeEngine(); + if ( theme ) { - wxLogLastError(wxT("SetMenuItemInfo")); + POPUPITEMSTATES state; + if ( stat & wxODDisabled ) + { + state = (stat & wxODSelected) ? MPI_DISABLEDHOT + : MPI_DISABLED; + } + else if ( stat & wxODSelected ) + { + state = MPI_HOT; + } + else + { + state = MPI_NORMAL; + } + + wxUxThemeHandle hTheme(GetMenu()->GetWindow(), L"MENU"); + + if ( theme->IsThemeBackgroundPartiallyTransparent(hTheme, + MENU_POPUPITEM, state) ) + { + theme->DrawThemeBackground(hTheme, hdc, + MENU_POPUPBACKGROUND, + 0, &rect, NULL); + } + + theme->DrawThemeBackground(hTheme, hdc, MENU_POPUPGUTTER, + 0, &rcGutter, NULL); + + if ( IsSeparator() ) + { + rcSeparator.left = rcGutter.right; + theme->DrawThemeBackground(hTheme, hdc, MENU_POPUPSEPARATOR, + 0, &rcSeparator, NULL); + return true; + } + + theme->DrawThemeBackground(hTheme, hdc, MENU_POPUPITEM, + state, &rcSelection, NULL); + } -#else - if ( ::ModifyMenu(hMenu, id, - MF_BYCOMMAND | flagsOld, - id, data) == (int)0xFFFFFFFF ) + else +#endif // wxUSE_UXTHEME { - wxLogLastError(wxT("ModifyMenu")); + if ( IsSeparator() ) + { + DrawEdge(hdc, &rcSeparator, EDGE_ETCHED, BF_TOP); + return true; + } + + AutoHBRUSH hbr(colBack.GetPixel()); + SelectInHDC selBrush(hdc, hbr); + ::FillRect(hdc, &rcSelection, hbr); } -#endif + + + // draw text label + // using native API because it recognizes '&' + + HDCTextColChanger changeTextCol(hdc, colText.GetPixel()); + HDCBgColChanger changeBgCol(hdc, colBack.GetPixel()); + HDCBgModeChanger changeBgMode(hdc, TRANSPARENT); + + SelectInHDC selFont(hdc, GetHfontOf(font)); + + + // item text name without mnemonic for calculating size + wxString text = GetName(); + + SIZE textSize; + ::GetTextExtentPoint32(hdc, text.c_str(), text.length(), &textSize); + + // item text name with mnemonic + text = GetItemLabel().BeforeFirst('\t'); + + int flags = DST_PREFIXTEXT; + // themes menu is using specified color for disabled labels + if ( data->MenuLayout() == MenuDrawData::Classic && + (stat & wxODDisabled) && !(stat & wxODSelected) ) + flags |= DSS_DISABLED; + + if ( (stat & wxODHidePrefix) && !data->AlwaysShowCues ) + flags |= DSS_HIDEPREFIX; + + int x = rcText.left; + int y = rcText.top + (rcText.bottom - rcText.top - textSize.cy) / 2; + + ::DrawState(hdc, NULL, NULL, (LPARAM)text.wx_str(), + text.length(), x, y, 0, 0, flags); + + // ::SetTextAlign(hdc, TA_RIGHT) doesn't work with DSS_DISABLED or DSS_MONO + // as the last parameter in DrawState() (at least with Windows98). So we have + // to take care of right alignment ourselves. + wxString accel = GetItemLabel().AfterFirst(wxT('\t')); + if ( !accel.empty() ) + { + SIZE accelSize; + ::GetTextExtentPoint32(hdc, accel.c_str(), accel.length(), &accelSize); + + int flags = DST_TEXT; + // themes menu is using specified color for disabled labels + if ( data->MenuLayout() == MenuDrawData::Classic && + (stat & wxODDisabled) && !(stat & wxODSelected) ) + flags |= DSS_DISABLED; + + int x = rcText.right - data->ArrowMargin.GetTotalX() + - data->ArrowSize.cx + - data->ArrowBorder; + + // right align accel on FullTheme menu, left otherwise + if ( data->MenuLayout() == MenuDrawData::FullTheme) + x -= accelSize.cx; + else + x -= m_parentMenu->GetMaxAccelWidth(); + + int y = rcText.top + (rcText.bottom - rcText.top - accelSize.cy) / 2; + + ::DrawState(hdc, NULL, NULL, (LPARAM)accel.wx_str(), + accel.length(), x, y, 0, 0, flags); + } + } + + + // draw the bitmap + + RECT rcImg; + SetRect(&rcImg, + rect.left + data->ItemMargin.cxLeftWidth + + data->CheckBgMargin.cxLeftWidth + + data->CheckMargin.cxLeftWidth, + rect.top + data->ItemMargin.cyTopHeight + + data->CheckBgMargin.cyTopHeight + + data->CheckMargin.cyTopHeight, + rect.left + data->ItemMargin.cxLeftWidth + + data->CheckBgMargin.cxLeftWidth + + data->CheckMargin.cxLeftWidth + + imgWidth, + rect.bottom - data->ItemMargin.cyBottomHeight + - data->CheckBgMargin.cyBottomHeight + - data->CheckMargin.cyBottomHeight); + + if ( IsCheckable() && !m_bmpChecked.IsOk() ) + { + if ( stat & wxODChecked ) + { + DrawStdCheckMark((WXHDC)hdc, &rcImg, stat); + } + } + else + { + wxBitmap bmp; + + if ( stat & wxODDisabled ) + { + bmp = GetDisabledBitmap(); + } + + if ( !bmp.IsOk() ) + { + // for not checkable bitmaps we should always use unchecked one + // because their checked bitmap is not set + bmp = GetBitmap(!IsCheckable() || (stat & wxODChecked)); + +#if wxUSE_IMAGE + if ( bmp.IsOk() && stat & wxODDisabled ) + { + // we need to grey out the bitmap as we don't have any specific + // disabled bitmap + wxImage imgGrey = bmp.ConvertToImage().ConvertToGreyscale(); + if ( imgGrey.IsOk() ) + bmp = wxBitmap(imgGrey); + } +#endif // wxUSE_IMAGE + } + + if ( bmp.IsOk() ) + { + wxMemoryDC dcMem(&dc); + dcMem.SelectObjectAsSource(bmp); + + // center bitmap + int nBmpWidth = bmp.GetWidth(), + nBmpHeight = bmp.GetHeight(); + + // there should be enough space! + wxASSERT( nBmpWidth <= imgWidth && nBmpHeight <= (rcImg.bottom - rcImg.top) ); + + int x = rcImg.left + (imgWidth - nBmpWidth) / 2; + int y = rcImg.top + (rcImg.bottom - rcImg.top - nBmpHeight) / 2; + dc.Blit(x, y, nBmpWidth, nBmpHeight, &dcMem, 0, 0, wxCOPY, true); + } + } + + return true; + +} + +namespace +{ + +// helper function for draw coloured check mark +void DrawColorCheckMark(HDC hdc, int x, int y, int cx, int cy, HDC hdcCheckMask, int idxColor) +{ + const COLORREF colBlack = RGB(0, 0, 0); + const COLORREF colWhite = RGB(255, 255, 255); + + HDCTextColChanger changeTextCol(hdc, colBlack); + HDCBgColChanger changeBgCol(hdc, colWhite); + HDCBgModeChanger changeBgMode(hdc, TRANSPARENT); + + // memory DC for color bitmap + MemoryHDC hdcMem(hdc); + CompatibleBitmap hbmpMem(hdc, cx, cy); + SelectInHDC selMem(hdcMem, hbmpMem); + + RECT rect = { 0, 0, cx, cy }; + ::FillRect(hdcMem, &rect, ::GetSysColorBrush(idxColor)); + + const COLORREF colCheck = ::GetSysColor(idxColor); + if ( colCheck == colWhite ) + { + ::BitBlt(hdc, x, y, cx, cy, hdcCheckMask, 0, 0, MERGEPAINT); + ::BitBlt(hdc, x, y, cx, cy, hdcMem, 0, 0, SRCAND); + } + else + { + if ( colCheck != colBlack ) + { + const DWORD ROP_DSna = 0x00220326; // dest = (NOT src) AND dest + ::BitBlt(hdcMem, 0, 0, cx, cy, hdcCheckMask, 0, 0, ROP_DSna); + } + + ::BitBlt(hdc, x, y, cx, cy, hdcCheckMask, 0, 0, SRCAND); + ::BitBlt(hdc, x, y, cx, cy, hdcMem, 0, 0, SRCPAINT); + } +} + +} // anonymous namespace + +void wxMenuItem::DrawStdCheckMark(WXHDC hdc_, const RECT* rc, wxODStatus stat) +{ + HDC hdc = (HDC)hdc_; + +#if wxUSE_UXTHEME + wxUxThemeEngine* theme = MenuDrawData::GetUxThemeEngine(); + if ( theme ) + { + wxUxThemeHandle hTheme(GetMenu()->GetWindow(), L"MENU"); + + const MenuDrawData* data = MenuDrawData::Get(); + + // rect for background must be without check margins + RECT rcBg = *rc; + data->CheckMargin.UnapplyFrom(rcBg); + + POPUPCHECKBACKGROUNDSTATES stateCheckBg = (stat & wxODDisabled) + ? MCB_DISABLED + : MCB_NORMAL; + + theme->DrawThemeBackground(hTheme, hdc, MENU_POPUPCHECKBACKGROUND, + stateCheckBg, &rcBg, NULL); + + POPUPCHECKSTATES stateCheck; + if ( GetKind() == wxITEM_CHECK ) + { + stateCheck = (stat & wxODDisabled) ? MC_CHECKMARKDISABLED + : MC_CHECKMARKNORMAL; + } + else + { + stateCheck = (stat & wxODDisabled) ? MC_BULLETDISABLED + : MC_BULLETNORMAL; + } + + theme->DrawThemeBackground(hTheme, hdc, MENU_POPUPCHECK, + stateCheck, rc, NULL); + } + else +#endif // wxUSE_UXTHEME + { + int cx = rc->right - rc->left; + int cy = rc->bottom - rc->top; + + // first create mask of check mark + MemoryHDC hdcMask(hdc); + MonoBitmap hbmpMask(cx, cy); + SelectInHDC selMask(hdcMask,hbmpMask); + + // then draw a check mark into it + UINT stateCheck = (GetKind() == wxITEM_CHECK) ? DFCS_MENUCHECK + : DFCS_MENUBULLET; + RECT rect = { 0, 0, cx, cy }; + ::DrawFrameControl(hdcMask, &rect, DFC_MENU, stateCheck); + + // first draw shadow if disabled + if ( (stat & wxODDisabled) && !(stat & wxODSelected) ) + { + DrawColorCheckMark(hdc, rc->left + 1, rc->top + 1, + cx, cy, hdcMask, COLOR_3DHILIGHT); + } + + // then draw a check mark + int color = COLOR_MENUTEXT; + if ( stat & wxODDisabled ) + color = COLOR_BTNSHADOW; + else if ( stat & wxODSelected ) + color = COLOR_HIGHLIGHTTEXT; + + DrawColorCheckMark(hdc, rc->left, rc->top, cx, cy, hdcMask, color); } } -void wxMenuItem::SetCheckable(bool checkable) +void wxMenuItem::GetFontToUse(wxFont& font) const +{ + font = GetFont(); + if ( !font.IsOk() ) + font = MenuDrawData::Get()->Font; +} + +void wxMenuItem::GetColourToUse(wxODStatus stat, wxColour& colText, wxColour& colBack) const { - wxMenuItemBase::SetCheckable(checkable); - OWNER_DRAWN_ONLY( wxOwnerDrawn::SetCheckable(checkable) ); +#if wxUSE_UXTHEME + wxUxThemeEngine* theme = MenuDrawData::GetUxThemeEngine(); + if ( theme ) + { + wxUxThemeHandle hTheme(GetMenu()->GetWindow(), L"MENU"); + + if ( stat & wxODDisabled) + { + wxRGBToColour(colText, theme->GetThemeSysColor(hTheme, COLOR_GRAYTEXT)); + } + else + { + colText = GetTextColour(); + if ( !colText.IsOk() ) + wxRGBToColour(colText, theme->GetThemeSysColor(hTheme, COLOR_MENUTEXT)); + } + + if ( stat & wxODSelected ) + { + wxRGBToColour(colBack, theme->GetThemeSysColor(hTheme, COLOR_HIGHLIGHT)); + } + else + { + colBack = GetBackgroundColour(); + if ( !colBack.IsOk() ) + wxRGBToColour(colBack, theme->GetThemeSysColor(hTheme, COLOR_MENU)); + } + } + else +#endif // wxUSE_UXTHEME + { + wxOwnerDrawn::GetColourToUse(stat, colText, colBack); + } } +#endif // wxUSE_OWNER_DRAWN // ---------------------------------------------------------------------------- // wxMenuItemBase