C++ FireEvent函数代码示例

//Setting values
void wxFixWidthImportCtrl::SetValues(const wxArrayInt& values)
{
    size_t nval = values.GetCount();
    size_t i, j, tot;
    int val;

    m_values.Clear();

    if ( nval < 1 )
    {   Refresh();
        FireEvent();
        return;
    }

    //Add the first value
    m_values.Add( values.Item(0) );

    //Add/insert the rest, avoiding duplicates
    for ( i=1; i<nval; i++)
    {   j=0;
        val = values.Item(i);
        tot = m_values.GetCount();
        while ( j < tot && val > m_values.Item(j) )
            j++;
        if ( j >= tot && val > m_values.Item(tot-1) )
            m_values.Add(val);
        if ( j < tot && val < m_values.Item(j) )
            m_values.Insert(val, j);
    }

    Refresh();
    FireEvent();
}

void SListBoxEx::NotifySelChange( int nOldSel,int nNewSel)
{
    EventLBSelChanging evt1(this);
    
    evt1.nOldSel=nOldSel;
    evt1.nNewSel=nNewSel;
    FireEvent(evt1);
    
    if(evt1.bCancel) return ;

    m_iSelItem=nNewSel;
    if(nOldSel!=-1)
    {
        m_arrItems[nOldSel]->ModifyItemState(0,WndState_Check);
        RedrawItem(nOldSel);
    }
    if(m_iSelItem!=-1)
    {
        m_arrItems[m_iSelItem]->ModifyItemState(WndState_Check,0);
        RedrawItem(m_iSelItem);
    }
    
    EventLBSelChanged evt2(this);
    evt2.nOldSel=nOldSel;
    evt2.nNewSel=nNewSel;
    FireEvent(evt2);
}

LRESULT CPdnWnd::OnSysCommand(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	if((wParam == SC_CLOSE || wParam == SC_DEFAULT) && m_sCloseHandler.length())
	{
		FireEvent(m_sCloseHandler, 0, 0);
		return 0;
	}
	else if((wParam == SC_SCREENSAVE || (wParam == SC_MONITORPOWER &&
		lParam == 2) ) && m_sScreenSaveHandler.length())
	{
		FireEvent(m_sScreenSaveHandler, 0, 0);
	}
	else if(wParam == SC_MINIMIZE && m_sMinHandler.length())
	{
		FireEvent(m_sMinHandler, 0, 0);
	}
	else if(wParam == SC_RESTORE && m_sRestoreHandler.length())
	{
		FireEvent(m_sRestoreHandler, 0, 0);
	}
	else if(wParam == SC_MAXIMIZE)
	{
	}
	return ::DefWindowProc(m_hWnd, uMsg, wParam, lParam);
}

LRESULT CPdnWnd::OnWTSSessionChange(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
	if(wParam == 0x1 /* WTS_CONSOLE_CONNECT */) {
	}
	else if(wParam == 0x2 /* WTS_CONSOLE_DISCONNECT */) {
	}
	else if(wParam == 0x3 /* WTS_REMOTE_CONNECT */) {
	}
	else if(wParam == 0x4 /* WTS_REMOTE_DISCONNECT */) {
	}
	else if(wParam == 0x5 /* WTS_SESSION_LOGON */) {
	}
	else if(wParam == 0x6 /* WTS_SESSION_LOGOFF */) {
	}
	else if(wParam == 0x7 /* WTS_SESSION_LOCK */ &&
		m_sWorkstationLockHandler.length()) {
		FireEvent(m_sWorkstationLockHandler, 0, 0);
	}
	else if(wParam == 0x8 /* WTS_SESSION_UNLOCK */ &&
		m_sWorkstationUnlockHandler.length()) {
		FireEvent(m_sWorkstationUnlockHandler, 0, 0);
	}
	else if(wParam == 0x9 /* WTS_SESSION_REMOTE_CONTROL */) {
	}

	return 0;
}

void KAIVM::Active()
{
    if (m_nPendingEvent != aevInvalid)
    {
        int nEvent = m_nPendingEvent;
        m_nPendingEvent = aevInvalid;

        FireEvent(nEvent, m_dwPendingEventSrc, m_nPendingEventParam);
    }

    if (m_nPrimaryTimerFrame != 0 && g_pSO3World->m_nGameLoop >= m_nPrimaryTimerFrame)
    {
        m_nPrimaryTimerFrame = 0;
        FireEvent(aevOnPrimaryTimer, m_pOwner->m_dwID, g_pSO3World->m_nGameLoop);
    }

    if (m_nSecondaryTimerFrame != 0 && g_pSO3World->m_nGameLoop >= m_nSecondaryTimerFrame)
    {
        m_nSecondaryTimerFrame = 0;
        FireEvent(aevOnSecondaryTimer, m_pOwner->m_dwID, g_pSO3World->m_nGameLoop);
    }

    if (m_nTertiaryTimerFrame != 0 && g_pSO3World->m_nGameLoop >= m_nTertiaryTimerFrame)
    {
        m_nTertiaryTimerFrame = 0;
        FireEvent(aevOnTertiaryTimer, m_pOwner->m_dwID, g_pSO3World->m_nGameLoop);
    }
}

void *InstallThread::Action()
{
    LocalDictionary *dict = dynamic_cast<LocalDictionary*>((Dictionary*)m_data);
    if (dict) {
        FireEvent(wxT(""), myID_START);
        m_exword->InstallDictionary(dict);
        FireEvent(wxT(""), myID_FINISH);
    }
    return NULL;
}

BOOL STabCtrl::SetCurSel( int nIndex )
{
    if( nIndex < 0 || nIndex> (int)GetItemCount()-1 || (m_nCurrentPage == nIndex)) return FALSE;
    int nOldPage = m_nCurrentPage;
    
    EventTabSelChanging evt(this);
    evt.uOldSel=nOldPage;
    evt.uNewSel=nIndex;

    FireEvent(evt);

    if (evt.bCancel)
        return FALSE;

    STabPage *pTab=GetItem(nIndex);

    CRect rcItem;

    GetItemRect(m_nCurrentPage, rcItem);
    InvalidateRect(rcItem);
    GetItemRect(nIndex, rcItem);
    InvalidateRect(rcItem);
    
    if(m_tabSlider)
    {
        m_tabSlider->Stop();
    }
    if(m_nAnimateSteps && IsVisible(TRUE) && nOldPage!=-1 && nIndex !=-1)
    {
        m_tabSlider = new STabSlider(this,nOldPage,nIndex,m_nAnimateSteps);
    }else
    {
        if(nOldPage!=-1)
        {
            GetItem(nOldPage)->SetVisible(FALSE,TRUE);
        }
        if(nIndex!=-1)
        {
            GetItem(nIndex)->SetVisible(TRUE,TRUE);
        }
    }
    m_nCurrentPage = nIndex;
        
    EventTabSelChanged evt2(this);
    evt2.uNewSel=nIndex;
    evt2.uOldSel=nOldPage;

    FireEvent(evt2);
    return TRUE;
}

HRESULT CSampleMSPStream::ProcessGraphEvent(
    IN  long lEventCode,
    IN  long lParam1,
    IN  long lParam2
    )
{
    LOG((MSP_EVENT, "CSampleMSPStream::ProcessGraphEvent - enter"));

    HRESULT        hr = S_OK;

    switch (lEventCode)
    {
    case EC_COMPLETE:
        
        hr = FireEvent(CALL_STREAM_INACTIVE, (HRESULT) lParam1, CALL_CAUSE_UNKNOWN);
        break;
    
    case EC_USERABORT:
        
        hr = FireEvent(CALL_STREAM_INACTIVE, S_OK, CALL_CAUSE_UNKNOWN);
        break;

    case EC_ERRORABORT:
    case EC_STREAM_ERROR_STOPPED:
    case EC_STREAM_ERROR_STILLPLAYING:
    case EC_ERROR_STILLPLAYING:

        hr = FireEvent(CALL_STREAM_FAIL, (HRESULT) lParam1, CALL_CAUSE_UNKNOWN);
        break;

    default:
        
        LOG((MSP_EVENT, "CSampleMSPStream::ProcessGraphEvent - "
            "ignoring event code %d", lEventCode));
        break;
    }

    if ( FAILED(hr) )
    {
        LOG((MSP_ERROR, "CSampleMSPStream::ProcessGraphEvent - "
            "FireEvent failed - exit 0x%08x", hr));

        return hr;
    }

    LOG((MSP_EVENT, "CSampleMSPStream::ProcessGraphEvent - exit S_OK"));

    return S_OK;
}

LRESULT SItemPanel::DoFrameEvent(UINT uMsg,WPARAM wParam,LPARAM lParam)
{
    AddRef();

    if(!IsDisabled())
    {
        switch(uMsg)
        {
        case WM_MOUSEHOVER: 
            {
                ModifyState(WndState_Hover,0,TRUE);
                EventItemPanelHover evt(this);
                FireEvent(evt);
                break;
            }
        case WM_MOUSELEAVE: 
            {
                ModifyState(0,WndState_Hover,TRUE);
                EventItemPanelLeave evt(this);
                FireEvent(evt);
                break;
            }
        case WM_LBUTTONDOWN:
            {
                EventItemPanelClick evt(this);
                FireEvent(evt);
                break;
            }
        case WM_RBUTTONDOWN:
            {
                EventItemPanelRclick evt(this);
                FireEvent(evt);
                break;
            }
        case WM_LBUTTONDBLCLK:
            {
                EventItemPanelDbclick evt(this);
                FireEvent(evt);
                break;
            }
        }
    }

    SetMsgHandled(FALSE);
    LRESULT lRet=__super::DoFrameEvent(uMsg,wParam,lParam);
    Release();
    return lRet;
}

//Setting the selected line (0 to nulines-1)
void wxFixWidthImportCtrl::SelectLine(size_t nline)
{
    size_t nulines = m_Lines.GetCount();
    if ( nline >= 0 && nline != m_markedL && nulines > 0)
    {   if ( nline >= nulines )
            m_markedL = nulines - 1;
        else
            m_markedL = nline;

        //Adjust vertical scrollbar's thumb position
        int pos=0; //number of hidden lines upwards
        int range = m_scrbarV->GetRange();
        int tsize = m_scrbarV->GetThumbSize();
        if (m_markedL == nulines - 1) //last line
            pos = range - tsize;
        else if (m_markedL > 0) //middle line, cuasi-center m_markedL
            pos = m_markedL - (tsize - 1)/2; //page is tsize-1

        pos = wxMin(pos, range - tsize);
        pos = wxMax(pos, 0);

        m_scrbarV->SetThumbPosition(pos);
        m_curposL = (size_t)pos;

        Refresh();
        FireEvent();
    }
}

    bool SSearchDropdownList::OnEditNotify(EventArgs *e)
    {
        EventRENotify *pEvtNotify = sobj_cast<EventRENotify>(e);
        if(pEvtNotify->iNotify == EN_CHANGE)
        {
            if(!m_pDropDownWnd)
            {
                m_pDropDownWnd = new SDropdownList(this);
                m_pDropDownWnd -> Create(m_xmlDropdown.child(KNode_PopupStyle));
                SASSERT(m_pDropDownWnd);
            }

            EventFillSearchDropdownList evt(this);
            evt.strKey = sobj_cast<SEdit>(e->sender)->GetWindowText();
            evt.pDropdownWnd = m_pDropDownWnd;
            FireEvent(evt);
            
            if(evt.bPopup)
            {
                AdjustDropdownList();
            }else
            {
                CloseUp(IDCANCEL);
            }
        }
        return true;
    }

	// Notify the Firefox that the progress has changed.
	void CPlugin::OnIEProgressChanged(int progress)
	{
		CString strEventType = _T("IEProgressChanged");
		CString strDetail;
		strDetail.Format(_T("%d"), progress);
		FireEvent(strEventType, strDetail);
	}

//Fill array with file passed
bool wxFixWidthImportCtrl::LoadFile(const wxString& filename, const wxMBConv& conv)
{
    wxTextFile file;
    if (!file.Open(filename, conv) )
        return false;

    m_Lines.Clear();
    wxString str;
    m_maxLen = 0;
    size_t i = 0;
    size_t nto = file.GetLineCount();
    if (nto > 0)
    {   m_Lines.Alloc(nto);
        for ( i=0; i < nto; i++ )
        {   str = file.GetLine(i);

            if (m_tabSize > -1) //replace tabs with needed spaces
                str = TabsToSpaces(str);

            if (str.Len() > m_maxLen)
                m_maxLen = str.Len();

            m_Lines.Add(str);
        }
    }

    m_Lines.Shrink();

    m_curposX = m_curposL = m_markedL = m_LAct = 0;
    AdjustScrollbars();
    Refresh();
    FireEvent();
    return true;
}

bool DesktopNode::updateChildren()
{
    if ((status_filter_ & NODE_NOT_ON_CLOUD) && !checkCloudCacheOrUpdate())
    {
        // pending scaning until cloud info is retrieved
        pending_scan_ = true;
        return true;
    }    

    switch (current_display_mode_)
    {
        case BY_FOLDER:
            updateChildrenByFolder();
            break;
        case BY_SORT:
            updateChildrenBySort();
            break;
        case EXPAND_ALL:
            updateChildrenByExpandingAll();
            break;
        default:
            return false;
    }
    setDirty(false);

    NodeChildenReadyArgs children_ready_args;
    children_ready_args.current_node_path = absolutePath();
    children_ready_args.succeeded = true;
    children_ready_args.children = filterChildren(children_);
    FireEvent(EventChildrenIsReady, children_ready_args);
    return true;
}

    void SFlyWnd::OnAnimatorState( int percent )
    {
        if(percent == SAnimator::PER_END)
        {
            m_bAniMove = TRUE;
            Move(m_rcAniEnd);
            m_bAniMove = FALSE;
            m_bFloat = FALSE;

            GetContainer()->UnregisterTimelineHandler(this);
        }else
        {
            CRect rcWnd;
            rcWnd.left   = m_rcAniBegin.left   + (m_rcAniEnd.left  - m_rcAniBegin.left  ) * percent / 100; 
            rcWnd.top    = m_rcAniBegin.top    + (m_rcAniEnd.top   - m_rcAniBegin.top   ) * percent / 100;
            rcWnd.right  = m_rcAniBegin.right  + (m_rcAniEnd.right - m_rcAniBegin.right ) * percent / 100;
            rcWnd.bottom = m_rcAniBegin.bottom + (m_rcAniEnd.bottom- m_rcAniBegin.bottom) * percent / 100;

            m_bAniMove = TRUE;
            Move(rcWnd);
            m_bFloat = FALSE;
            m_bAniMove = FALSE;
        }
        FlyStateEvent evt(this,percent,m_bEndPos);
        FireEvent(evt);
    }