C++ wxMenuEvent::GetMenu方法代码示例

void CCamFrame::OnInitMenuPopup( wxMenuEvent& event )
{
	// Before anything else let's set Document::Current and DocView::Current properly...
	// Menus will either work on no document or the selected document. So the most useful
	// thing to do is to set Current to Selected.
	Document::GetSelected()->SetCurrent();
	DocView::GetSelected()->SetCurrent();

	wxSetCursor( *wxSTANDARD_CURSOR );

PORTNOTE( "other", "Removed usage of bSysMent from OnInitMenuPopup" )
#if !defined(EXCLUDE_FROM_XARALX)
	if (bSysMenu)
	{
		CMDIFrameWnd::OnInitMenuPopup(pMenu, n, bSysMenu);
		// bug fix 2996 
		if(FullScreenMode)
		{
			pMenu->EnableMenuItem(SC_MOVE,MF_GRAYED);
			pMenu->EnableMenuItem(SC_SIZE,MF_GRAYED);
			pMenu->EnableMenuItem(SC_MAXIMIZE,MF_GRAYED);
		}
	}
	else
#endif
	if( !UpdateMenu( event.GetMenu() ) )
		event.Skip();
}

void Frame::OnMenuOpen( wxMenuEvent& evt )
{
    wxMenu* menu = evt.GetMenu();
    wxMenuItemList list = menu->GetMenuItems();
    wxMenuItemList::iterator i;
    for ( i = list.begin(); i != list.end(); ++i )
    {
        if ( (*i)->GetId() == toggleRunwayID )
        {
            (*i)->Check( grav->usingRunway() );
        }
        else if ( (*i)->GetId() == toggleVCCID )
        {
            bool showable = grav->isVenueClientControllerShowable();
            (*i)->Enable( showable );
            if ( showable )
            {
                (*i)->Check( grav->isVenueClientControllerShown() );
            }
        }
        else if ( (*i)->GetId() == toggleSideFrameID )
        {
            SideFrame* sf = findChildSideFrame();
            if ( sf != NULL )
            {
                (*i)->Check( sf->IsShown() );
            }
        }
        else if ( (*i)->GetId() == toggleAutomaticID )
        {
            (*i)->Check( grav->usingAutoFocusRotate() );
        }
    }
}

void wxFrameBase::OnMenuOpen(wxMenuEvent& event)
{
    if ( !ShouldUpdateMenuFromIdle() )
    {
        // as we didn't update the menus from idle time, do it now
        DoMenuUpdates(event.GetMenu());
    }
}

void wxFrameBase::OnMenuOpen(wxMenuEvent& event)
{
#if wxUSE_IDLEMENUUPDATES
    wxUnusedVar(event);
#else // !wxUSE_IDLEMENUUPDATES
    // as we didn't update the menus from idle time, do it now
    DoMenuUpdates(event.GetMenu());
#endif // wxUSE_IDLEMENUUPDATES/!wxUSE_IDLEMENUUPDATES
}

void CommandManager::HandleMenuClose(wxMenuEvent &evt)
{
#if defined(__WXMAC__)
   mOpenMenu = evt.GetMenu();
#endif

   // This can happen when if the Windows system menu is used   
   if (mOpenMenu == NULL)
      return;

   // GetMenu() under Windows will always return NULL.  And on other
   // platforms we must ensure we are a top-level menu.
   wxMenu *m = evt.GetMenu();
   if (m && m->GetParent())
      return;

   // Turn off the accelerators
   ToggleAccels(mOpenMenu, false);

   // Forget about it
   mOpenMenu = NULL;

   return;
}

void VaultPanel::OnOptionsMenuOpen( wxMenuEvent& event )
{
    event.Skip();
    if ( event.GetMenu() == m_OptionsMenu )
    {
        for ( wxMenuItemList::iterator itr = event.GetMenu()->GetMenuItems().begin(), end = event.GetMenu()->GetMenuItems().end(); itr != end; ++itr )
        {
            (*itr)->Check( false );
        }

        HELIUM_ASSERT( m_CurrentViewMode != VaultViewMode::None );

        int id = -1;
        switch ( m_CurrentViewMode )
        {
        default:
        case VaultViewMode::List:
            id = VaultMenu::ViewResultList;
            break;
        case VaultViewMode::Details:
            id = VaultMenu::ViewResultDetails;
            break;
        case VaultViewMode::ThumbnailsSmall:
            id = VaultMenu::ViewThumbnailsSmall;
            break;
        case VaultViewMode::ThumbnailsMedium:
            id = VaultMenu::ViewThumbnailsMedium;
            break;
        case VaultViewMode::ThumbnailsLarge:
            id = VaultMenu::ViewThumbnailsLarge;
            break;
        }

        event.GetMenu()->Check( id, true );
    }
}

void MyFrame::OnShowMenu(wxMenuEvent &event)
{
        wxMenu *menu = event.GetMenu();
        if (menu != m_port_menu) return;
        //printf("OnShow Port Menu, %s\n", (const char *)menu->GetTitle());
	while (menu->GetMenuItemCount() > 0) {
		menu->Delete(menu->GetMenuItems()[0]);
	}
        menu->AppendRadioItem(9000, " (none)");
	bool isopen = port_is_open();
	if (!isopen) menu->Check(9000, true);
        wxArrayString list = serial_port_list();
        int num = list.GetCount();
        for (int i=0; i < num; i++) {
                menu->AppendRadioItem(9001 + i, list[i]);
                if (isopen && port_name.IsSameAs(list[i])) {
                        menu->Check(9001 + i, true);
                }
        }
	menu->UpdateUI();
}

void CommandManager::HandleMenuOpen(wxMenuEvent &evt)
{
   // Ensure we have a menu and that it's a top-level menu.
   wxMenu *m = evt.GetMenu();
   if (!m || m->GetParent())
      return;

   // Windows does not send a CLOSE event if you move from one 
   // top-level menu to another, so simulate it.
   if (mOpenMenu) {
      wxMenuEvent dummy;
      HandleMenuClose(dummy);
   }

   // Remember this menu
   mOpenMenu = m;

   // Turn on the accelerators
   ToggleAccels(m, true);

   return;
}

void FB_Frame::OnMenuOpen ( wxMenuEvent& event )
{
    if ( event.GetMenu() == m_EditMenu )
    {
        FB_STC * stc = 0;
        if( m_Code_areaTab != 0 )
            stc = reinterpret_cast<FB_STC *>( m_Code_areaTab->GetCurrentPage() );

        #define _ENABLE( id, func ) m_EditMenu->Enable( id, ( stc != 0 ) ? stc -> func : false )
            _ENABLE( wxID_UNDO,                 CanUndo() );
            _ENABLE( wxID_REDO,                 CanRedo() );
            _ENABLE( wxID_COPY,                 HasSelection() );
            _ENABLE( wxID_CUT,                  HasSelection() );
            _ENABLE( wxID_PASTE,                CanPaste() );
            _ENABLE( wxID_SELECTALL,            GetLength() );
            _ENABLE( fbideID_SelectLine,        GetLength() );
            _ENABLE( fbideID_CommentBlock,      CanComment() );
            _ENABLE( fbideID_UncommentBlock,    CanComment() );
        #undef _ENABLE
        m_EditMenu->Enable(wxID_JUSTIFY_RIGHT,    ( stc ) ? true : false );
        m_EditMenu->Enable(wxID_JUSTIFY_LEFT,     ( stc ) ? true : false );
    }
}

void log_window::OnMenuOpen(wxMenuEvent &event) {
	if (event.GetMenu() == debug_menu) {
		DestroyMenuContents(debug_menu);

		debug_menu->Append(LOGWIN_ID_DUMP_PENDING, wxT("Dump &Pendings"));
		debug_menu->Append(LOGWIN_ID_DUMP_CONN, wxT("Dump &Socket Data"));
		debug_menu->Append(LOGWIN_ID_DUMP_STATS, wxT("Dump S&tats"));
		debug_menu->Append(LOGWIN_ID_FLUSH_STATE, wxT("&Flush State"));
		debug_menu->Append(LOGWIN_ID_PURGE_TIMELINES, wxT("Purge old tweets from &timelines"));

		unsigned int flushable_log_outputs = 0;
		for (auto &it : logfunclist) {
			if (it->IsFlushable()) {
				flushable_log_outputs++;
			}
		}
		if (flushable_log_outputs) {
			debug_menu->Append(LOGWIN_ID_FLUSH_LOGFILES, wxString::Format(wxT("Flush %u Log Outputs"), flushable_log_outputs));
		}

		if (sm.PendingRetryCount()) {
			debug_menu->Append(LOGWIN_ID_RETRY_FIRST_CONN_NOW,
					wxString::Format(wxT("Retry first of %u pending connection attempts"), sm.PendingRetryCount()));
		}

		unsigned int accs_restartable_stream_conn = 0;
		for (auto &it : alist) {
			if (it->CanRestartStreamingConn()) {
				accs_restartable_stream_conn++;
			}
		}
		if (accs_restartable_stream_conn) {
			debug_menu->Append(LOGWIN_ID_RETRY_STREAMS_NOW,
					wxString::Format(wxT("Retry %u failed streaming connection"), accs_restartable_stream_conn));
		}
	}
}

void CSimpleFrame::OnMenuOpening( wxMenuEvent &event) {
    wxLogTrace(wxT("Function Start/End"), wxT("CAdvancedFrame::OnMenuOpening - Function Begin"));

    CMainDocument*     pDoc = wxGetApp().GetDocument();
    wxMenu* menuFile = NULL;
    wxMenu* menuHelp = NULL;
    
    wxASSERT(pDoc);
    
    bool isConnected = pDoc->IsConnected();
    wxMenu* menu = event.GetMenu();
    
    menu->FindItem(ID_CLOSEWINDOW, &menuFile);
    menu->FindItem(ID_HELPBOINC, &menuHelp);
    size_t numItems = menu->GetMenuItemCount();
    for (size_t pos = 0; pos < numItems; ++pos) {
        wxMenuItem * item = menu->FindItemByPosition(pos);
        if ((menu == menuFile) || (menu == menuHelp)) {
            // Always enable all items in File menu or Help menu:
            // ID_CLOSEWINDOW, wxID_EXIT, ID_HELPBOINC, ID_HELPBOINCMANAGER,
            // ID_HELPBOINCWEBSITE, wxID_ABOUT
            item->Enable(true);
        } else {
            // Disable other menu items if not connected to client
            item->Enable(isConnected);
        }
    }
    
    // wxID_EXIT and wxID_PREFERENCES are not in File menu on some platforms
    wxMenuItem* exitItem = menu->FindChildItem(wxID_EXIT, NULL);
    if (exitItem) {
        exitItem->Enable(true);
    }
    
    wxLogTrace(wxT("Function Start/End"), wxT("CAdvancedFrame::OnMenuOpening - Function End"));
}

void EDA_DRAW_FRAME::OnMenuOpen( wxMenuEvent& event )
{
    // On wxWidgets 3.0.x Windows, EVT_MENU_OPEN ( and other EVT_MENU_xx) events are not
    // captured by the ACTON_MENU menus.  While it is fixed in wxWidgets 3.1.x, we still
    // need a solution for the earlier verions.
    //
    // This could be made conditional, but for now I'm going to use the same strategy
    // everywhere so it gets wider testing.
    // Note that if the conditional compilation is reactivated, the Connect() lines in
    // ACTION_MENU::setupEvents() will need to be re-enabled.
//#if defined( __WINDOWS__ ) && wxCHECK_VERSION( 3, 0, 0 ) && !wxCHECK_VERSION( 3, 1, 0 )

    // As if things weren't bad enough, wxWidgets doesn't pass the menu pointer when the
    // event is a wxEVT_MENU_HIGHLIGHT, so we store the menu from the EVT_MENU_OPEN call.
    static ACTION_MENU* currentMenu;

    if( event.GetEventType() == wxEVT_MENU_OPEN )
    {
        currentMenu = dynamic_cast<ACTION_MENU*>( event.GetMenu() );

        if( currentMenu )
            currentMenu->OnMenuEvent( event );
    }
    else if( event.GetEventType() == wxEVT_MENU_HIGHLIGHT )
    {
        if( currentMenu )
            currentMenu->OnMenuEvent( event );
    }
    else    // if( event.GetEventType() == wxEVT_MENU_CLOSE )
    {
        currentMenu = nullptr;
    }
//#endif

    event.Skip();
}

void SavvyEditor::AppFrame::OnMenuOpen(wxMenuEvent& a_Event)
{
	wxMenu* currMenu = a_Event.GetMenu();

	// Fixes a bug when clicking on the icon
	if (currMenu == NULL)
		return;

	wxMenuItem* currItem = NULL;
	if (currMenu->GetTitle() == "&Edit")
	{
		// Redo enable/disable
		if (m_LastSelectedTextCtrl->CanRedo())
		{
			currItem = currMenu->FindItem(wxID_REDO);
			EnableMenuItem(currItem, true);
		}
		else
		{
			currItem = currMenu->FindItem(wxID_REDO);
			EnableMenuItem(currItem, false);
		}

		// Undo enable/disable
		if (m_LastSelectedTextCtrl->CanUndo())
		{
			currItem = currMenu->FindItem(wxID_UNDO);
			EnableMenuItem(currItem, true);
		}
		else
		{
			currItem = currMenu->FindItem(wxID_UNDO);
			EnableMenuItem(currItem, false);
		}

		// Delete enable/disable
		if (!m_LastSelectedTextCtrl->IsEmpty())
		{
			currItem = currMenu->FindItem(wxID_DELETE);
			EnableMenuItem(currItem, true);
		}
		else
		{
			currItem = currMenu->FindItem(wxID_DELETE);
			EnableMenuItem(currItem, false);
		}

		// Copy
		if (m_LastSelectedTextCtrl->CanCopy())
		{
			currItem = currMenu->FindItem(wxID_COPY);
			EnableMenuItem(currItem, true);
		}
		else
		{
			currItem = currMenu->FindItem(wxID_COPY);
			EnableMenuItem(currItem, false);
		}

		// Cut
		if (m_LastSelectedTextCtrl->CanCut())
		{
			currItem = currMenu->FindItem(wxID_CUT);
			EnableMenuItem(currItem, true);
		}
		else
		{
			currItem = currMenu->FindItem(wxID_CUT);
			EnableMenuItem(currItem, false);
		}

		// Paste
		if (m_LastSelectedTextCtrl->CanPaste())
		{
			currItem = currMenu->FindItem(wxID_PASTE);
			EnableMenuItem(currItem, true);
		}
		else
		{
			currItem = currMenu->FindItem(wxID_PASTE);
			EnableMenuItem(currItem, false);
		}
	}
	else if (currMenu->GetTitle() == "&File")
	{
		if (m_LastSelectedTextCtrl->IsModified())
		{
			currItem = currMenu->FindItem(wxID_SAVE);
			EnableMenuItem(currItem, true);
		}
		else
		{
			currItem = currMenu->FindItem(wxID_SAVE);
			EnableMenuItem(currItem, false);
		}
	}
}