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

void CONTEXT_MENU::onMenuEvent( wxMenuEvent& aEvent )
{
    OPT_TOOL_EVENT evt;

    wxEventType type = aEvent.GetEventType();

    // When the currently chosen item in the menu is changed, an update event is issued.
    // For example, the selection tool can use this to dynamically highlight the current item
    // from selection clarification popup.
    if( type == wxEVT_MENU_HIGHLIGHT )
        evt = TOOL_EVENT( TC_COMMAND, TA_CONTEXT_MENU_UPDATE, aEvent.GetId() );

    // One of menu entries was selected..
    else if( type == wxEVT_COMMAND_MENU_SELECTED )
    {
        // Store the selected position
        m_selected = aEvent.GetId();

        // Check if there is a TOOL_ACTION for the given ID
        if( m_toolActions.count( aEvent.GetId() ) == 1 )
        {
            evt = m_toolActions[aEvent.GetId()]->MakeEvent();
        }
        else
        {
            runEventHandlers( aEvent, evt );

            // Under Linux, every submenu can have a separate event handler, under
            // Windows all submenus are handled by the main menu.
#ifdef __WINDOWS__
            if( !evt )
            {
                // Try to find the submenu which holds the selected item
                wxMenu* menu = NULL;
                FindItem( m_selected, &menu );

                if( menu && menu != this )
                {
                    menu->ProcessEvent( aEvent );
                    return;
                }
            }
#endif

            // Handling non-action menu entries (e.g. items in clarification list)
            if( !evt )
                evt = TOOL_EVENT( TC_COMMAND, TA_CONTEXT_MENU_CHOICE, aEvent.GetId() );
        }
    }

    assert( m_tool );   // without tool & tool manager we cannot handle events

    // forward the action/update event to the TOOL_MANAGER
    if( evt && m_tool )
        m_tool->GetManager()->ProcessEvent( *evt );
}

    OPT_TOOL_EVENT eventHandler( const wxMenuEvent& aEvent ) override
    {
        BOARD_DESIGN_SETTINGS &bds = m_frame.GetBoard()->GetDesignSettings();
        int id = aEvent.GetId();

        // On Windows, this handler can be called with an event ID not existing in any
        // menuitem, so only set flags when we have an ID match.

        if( id == ID_POPUP_PCB_SELECT_CUSTOM_DIFFPAIR )
        {
            bds.UseCustomDiffPairDimensions( true );
            TOOL_MANAGER* toolManager = m_frame.GetToolManager();
            toolManager->RunAction( PCB_ACTIONS::routerActivateDpDimensionsDialog, true );
        }
        else if( id == ID_POPUP_PCB_SELECT_USE_NETCLASS_DIFFPAIR )
        {
            bds.UseCustomDiffPairDimensions( false );
            bds.SetDiffPairIndex( 0 );
        }
        else if( id >= ID_POPUP_PCB_SELECT_DIFFPAIR1 && id <= ID_POPUP_PCB_SELECT_DIFFPAIR16 )
        {
            bds.UseCustomDiffPairDimensions( false );
            // remember that the menu doesn't contain index 0 (which is the netclass values)
            bds.SetDiffPairIndex( id - ID_POPUP_PCB_SELECT_DIFFPAIR1 + 1 );
        }

        return OPT_TOOL_EVENT( PCB_ACTIONS::trackViaSizeChanged.MakeEvent() );
    }

OPT_TOOL_EVENT GRID_MENU::eventHandler( const wxMenuEvent& aEvent )
{
    OPT_TOOL_EVENT event( ACTIONS::gridPreset.MakeEvent() );
    intptr_t idx = aEvent.GetId() - ID_POPUP_GRID_SELECT - 1;
    event->SetParameter( idx );

    return event;
}

void MyFrame::onToolRClick(wxMenuEvent& evt){
	wxPoint point = m_toolBar1->ScreenToClient(wxGetMousePosition());
	wxMenu menu;
	menu.Append(ID_EDIT_TOOL, wxT("Edit Tool"));
	menu.Append(ID_REMOVE_TOOL, wxT("Remove Tool"));
	idCTool = evt.GetId();
	PopupMenu(&menu, point.x, point.y);
}

OPT_TOOL_EVENT ZOOM_MENU::eventHandler( const wxMenuEvent& aEvent )
{
    OPT_TOOL_EVENT event( ACTIONS::zoomPreset.MakeEvent() );
    intptr_t idx = aEvent.GetId() - ID_POPUP_ZOOM_LEVEL_START;
    event->SetParameter( idx );

    return event;
}

void wxStfChildFrame::OnMenuHighlight(wxMenuEvent& event) {
    if (this->GetMenuBar()) {
        wxMenuItem *item = this->GetMenuBar()->FindItem(event.GetId());
        if(item) {
            wxLogStatus(item->GetHelp());
        }
    }
    event.Skip();

}

void MyFrame::onDynTask(wxMenuEvent& evt){
	wxMenuItem *cTask = aiDynTasks[evt.GetId() - mID_USEDTASKS];
	unsigned long TID;
	if (!startTask(cTask->GetHelp(), TID)) return;
	wxMenuItem *victim = 0;
	m_menu11->Remove(cTask);
	m_menu11->Prepend(cTask); 

	return;
}

    OPT_TOOL_EVENT EventHandler( const wxMenuEvent& aEvent )
    {
#if ID_POPUP_PCB_SELECT_VIASIZE1 < ID_POPUP_PCB_SELECT_WIDTH1
#error You have changed event ids order, it breaks code. Check the source code for more details.
// Recognising type of event (track width/via size) is based on comparison if the event id is
// within a specific range. If ranges of event ids changes, then the following is not valid anymore.
#endif
        BOARD_DESIGN_SETTINGS &bds = m_board->GetDesignSettings();

        int id = aEvent.GetId();

        // Initial settings, to be modified below
        bds.m_UseConnectedTrackWidth = false;
        bds.UseCustomTrackViaSize( false );

        if( id == ID_POPUP_PCB_SELECT_CUSTOM_WIDTH )
        {
            bds.UseCustomTrackViaSize( true );
        }

        else if( id == ID_POPUP_PCB_SELECT_AUTO_WIDTH )
        {
            bds.m_UseConnectedTrackWidth = true;
        }

        else if( id == ID_POPUP_PCB_SELECT_USE_NETCLASS_VALUES )
        {
            bds.SetViaSizeIndex( 0 );
            bds.SetTrackWidthIndex( 0 );
        }

        else if( id >= ID_POPUP_PCB_SELECT_VIASIZE1 )     // via size has changed
        {
            assert( id < ID_POPUP_PCB_SELECT_WIDTH_END_RANGE );

            bds.SetViaSizeIndex( id - ID_POPUP_PCB_SELECT_VIASIZE1 );
        }

        else    // track width has changed
        {
            assert( id >= ID_POPUP_PCB_SELECT_WIDTH1 );
            assert( id < ID_POPUP_PCB_SELECT_VIASIZE );

            bds.SetTrackWidthIndex( id - ID_POPUP_PCB_SELECT_WIDTH1 );
        }

        return OPT_TOOL_EVENT( COMMON_ACTIONS::trackViaSizeChanged.MakeEvent() );
    }

void SIM_PLOT_FRAME::SIGNAL_CONTEXT_MENU::onMenuEvent( wxMenuEvent& aEvent )
{
    SIM_PLOT_PANEL* plot = m_plotFrame->CurrentPlot();

    switch( aEvent.GetId() )
    {
        case HIDE_SIGNAL:
            m_plotFrame->removePlot( m_signal );
            break;

        case SHOW_CURSOR:
            plot->EnableCursor( m_signal, true );
            break;

        case HIDE_CURSOR:
            plot->EnableCursor( m_signal, false );
            break;
    }
}

void CSpyUserPanel::OnSpySelectFileCtrlMenu(wxMenuEvent& event)
{
    switch (event.GetId())
    {
    case eSUPUIID_DownloadMenu:
        {
            TString strStorePath;
            if (CUtilityManager::GetInstance()->AcquireDirectory(this->GetHWND(), strStorePath, _T("选择保存的位置")))
            {
                typedef bool (*TDownloadFileFunc)(SOCKET sock, const std::vector<TString>& files, const TString& strStorePath, CFileFilter* pFilter);
                static TDownloadFileFunc pDownloadFunc = TDownloadFileFunc(GetProcAddress(m_hSpyDllHandle, "Spy_DownloadFiles"));
                BEATS_ASSERT(pDownloadFunc != NULL, _T("Get function address %s failed!"), _T("Spy_DownloadFiles"));
                if (pDownloadFunc != NULL)
                {
                    std::vector<TString> files;
                    uint32_t uSelectedCount = m_pRemoteFileCtrl->GetSelectedItemCount();
                    if (uSelectedCount == 0)
                    {
                        const TString& curPath = m_pRemoteFileCtrl->GetCurrentDirectoryPath();
                        if (curPath.length() > 0)
                        {
                            files.push_back(curPath);
                        }
                    }
                    else
                    {
                        uint32_t uCounter = 0;
                        long item = m_pRemoteFileCtrl->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
                        while ( item != -1 && uCounter++ < uSelectedCount )
                        {
                            TString curPath = m_pRemoteFileCtrl->GetCurrentDirectoryPath();
                            files.push_back(curPath.append(m_pRemoteFileCtrl->GetItemText(item)));
                            item = m_pRemoteFileCtrl->GetNextItem(item, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
                        }
                    }
                    BEATS_ASSERT(files.size() > 0, _T("Can't start download with nothing!"));
                    if (files.size() > 0 && strStorePath.length() > 0)
                    {
                        pDownloadFunc(m_pSocketInfo->m_socket, files, strStorePath, NULL);
                    }
                }
            }
        }
        break;
    case eSUPUIID_UploadMenu:
        {
            std::vector<TString> strPath;
            bool bGetUploadFiles = CUtilityManager::GetInstance()->AcquireMuiltyFilePath(true, this->GetHWND(), strPath, _T("选择上传的文件"), NULL, NULL);
            if (bGetUploadFiles)
            {
                typedef bool (*TUploadFileFunc)(SOCKET sock, const std::vector<TString>& files, const TString& strStorePath, CFileFilter* pFilter);
                static TUploadFileFunc pUploadFunc = TUploadFileFunc(GetProcAddress(m_hSpyDllHandle, "Spy_UploadFiles"));
                BEATS_ASSERT(pUploadFunc != NULL, _T("Get function address %s failed!"), _T("Spy_DownloadFiles"));
                if (pUploadFunc != NULL)
                {
                    TString curPath = m_pRemoteFileCtrl->GetCurrentDirectoryPath();
                    BEATS_ASSERT(curPath.length() > 0 && strPath.size() > 0, _T("Upload failed! upload files size: %d store path: %s"), strPath.size(), curPath.c_str());
                    if (curPath.length() > 0 && strPath.size() > 0)
                    {
                        pUploadFunc(m_pSocketInfo->m_socket, strPath, curPath, NULL);
                    }
                    else
                    {
                        MessageBox(this->GetHWND(), _T("Current path is not valid!"), NULL, MB_OK);
                    }
                }
            }
        }
        break;
    default:
        BEATS_ASSERT(false, _T("Never Reach Here!"));
        break;
    }
}

void MyFrame::onToolClick (wxMenuEvent& evt){
	unsigned long TID;
	startTask( m_toolBar1->GetToolShortHelp(evt.GetId()), TID);
}