自学教程：C++ timeKillEvent函数代码示例

PHPAPI int setitimer(int which, const struct itimerval *value, struct itimerval *ovalue){	int timeout = value->it_value.tv_sec * 1000 + value->it_value.tv_usec;	int repeat = TIME_ONESHOT;	/*make sure the message queue is initialized */	PeekMessage(phpmsg, NULL, WM_USER, WM_USER, PM_NOREMOVE);	if (timeout > 0) {		struct timer_msg *msg = malloc(sizeof(struct timer_msg));		msg->threadid = GetCurrentThreadId();		if (!ovalue) {			repeat = TIME_PERIODIC;		}		switch (which) {			case ITIMER_REAL:				msg->signal = SIGALRM;				realtimer = timeSetEvent(timeout, 100, (LPTIMECALLBACK) setitimer_timeout, (UINT) msg, repeat);				break;			case ITIMER_VIRT:				msg->signal = SIGVTALRM;				virttimer = timeSetEvent(timeout, 100, (LPTIMECALLBACK) setitimer_timeout, (UINT) msg, repeat);				break;			case ITIMER_PROF:				msg->signal = SIGPROF;				proftimer = timeSetEvent(timeout, 100, (LPTIMECALLBACK) setitimer_timeout, (UINT) msg, repeat);				break;			default:				errno = EINVAL;				return -1;				break;		}	} else {		switch (which) {			case ITIMER_REAL:				timeKillEvent(realtimer);				break;			case ITIMER_VIRT:				timeKillEvent(virttimer);				break;			case ITIMER_PROF:				timeKillEvent(proftimer);				break;			default:				errno = EINVAL;				return -1;				break;		}	}	return 0;}

static void mm_rearm_timer(struct qemu_alarm_timer *t, int64_t delta){    int64_t nearest_delta_ms = delta / 1000000;    if (nearest_delta_ms < 1) {        nearest_delta_ms = 1;    }    /* UINT_MAX can be 32 bit */    if (nearest_delta_ms > UINT_MAX) {        nearest_delta_ms = UINT_MAX;    }    timeKillEvent(mm_timer);    mm_timer = timeSetEvent((unsigned int) nearest_delta_ms,                            mm_period,                            mm_alarm_handler,                            (DWORD_PTR)t,                            TIME_ONESHOT | TIME_CALLBACK_FUNCTION);    if (!mm_timer) {        fprintf(stderr, "Failed to re-arm win32 alarm timer %ld/n",                GetLastError());        timeEndPeriod(mm_period);        exit(1);    }}

/** * Timer callback used to check about end of media (except JTS type) */static void CALLBACK audio_timer_callback(UINT uID, UINT uMsg,                                           DWORD dwUser,                                           DWORD dw1,                                           DWORD dw2) {    audio_handle* pHandle = (audio_handle*)dwUser;    if (pHandle->hWnd) {        if (-1 == pHandle->duration) {            pHandle->duration = MCIWndGetLength(pHandle->hWnd);            JAVA_DEBUG_PRINT1("[jc_media] audio_timer_callback %d/n",                 pHandle->duration);        }        pHandle->offset = MCIWndGetPosition(pHandle->hWnd);        pHandle->curTime = pHandle->offset;                /* Is end of media reached? */        if (pHandle->offset >= pHandle->duration) {            /* Post EOM event to Java and kill player timer */            pHandle->timerId = 0;            pHandle->offset = 0;            timeKillEvent(uID);            JAVA_DEBUG_PRINT1("[jc_media] javanotify_on_media_notification %d/n",                 pHandle->playerId);            javanotify_on_media_notification(JAVACALL_EVENT_MEDIA_END_OF_MEDIA,                 pHandle->playerId, (void*)pHandle->duration);        }    }}

static voidmpx_shutdown_itimer( void ){	if ( timeKillEvent( mpxTimerID ) != TIMERR_NOERROR ) {		MPXDBG( "setitimer(MPX_ITIMER) in mpx_shutdown_itimer" );	}}

int destroy_timer_event ( int timer_id ){	int		count,		found;	found = FALSE;	for ( count = 0; ( ( count < number_of_timers ) && ( !found ) ); count++ )	{		if ( ( timer_list[count].used ) && ( timer_list[count].id ) )		{			found = TRUE;		}	}	if ( found )	{#ifdef _WIN32		timeKillEvent ( timer_list[count].id );#endif		timer_list[count].used = FALSE;		return ( TRUE );	}	else	{		return ( FALSE );	}}

ELTE_VOID CTimer::SetTimer(ELTE_UINT32 tick){	LOG_TRACE();	if(m_uTimerID)	{		timeKillEvent(m_uTimerID);		m_uTimerID = 0;	}	if(0 == tick)	{		//默认200ms发送数据		tick = 200;	}	TIMECAPS   timecaps; 	ELTE_UINT32 TimerAccuracy = Accuracy; 	//从系统获得关于定时器服务能力的信息， 	//分辨率不能超出系统许可值（1到16毫秒） 	if   (timeGetDevCaps(&timecaps,sizeof(TIMECAPS))==TIMERR_NOERROR) 		TimerAccuracy = min(max(timecaps.wPeriodMin,Accuracy),timecaps.wPeriodMax); 	timeBeginPeriod(TimerAccuracy); 	m_uDelayTime = tick;	m_uTimerID = timeSetEvent(m_uDelayTime, TimerAccuracy, TimeProc, (DWORD_PTR)this, TIME_PERIODIC);	LOG_RUN_DEBUG("TimerId is %d.", m_uTimerID);	timeEndPeriod(TimerAccuracy); }

VOID timing_timeSetEvent(UINT delayInSeconds){	// Some vars	UINT uResolution;	TIMECAPS tc;	MMRESULT idEvent;	// We can obtain this minimum value by calling	timeGetDevCaps(&tc, sizeof(TIMECAPS));	uResolution = min(max(tc.wPeriodMin, 0), tc.wPeriodMax);	// Create the timer	idEvent = timeSetEvent(		delayInSeconds,		uResolution,		TimerFunction,		0,		TIME_ONESHOT);	while (!bProcessed){		// wait until uor function finish	}	// destroy the timer	timeKillEvent(idEvent);	// reset the timer	timeEndPeriod(uResolution);}

void COptionsAbout::OnDestroy() {	CDialog::OnDestroy();	timeKillEvent( mmTimer );	//KillTimer( TIMER_ABOUT );}

void CALLBACK DSOUND_timer(UINT timerID, UINT msg, DWORD_PTR dwUser,                           DWORD_PTR dw1, DWORD_PTR dw2){	DirectSoundDevice * device = (DirectSoundDevice*)dwUser;	DWORD start_time =  GetTickCount();	DWORD end_time;	TRACE("(%d,%d,0x%lx,0x%lx,0x%lx)/n",timerID,msg,dwUser,dw1,dw2);	TRACE("entering at %d/n", start_time);	if (DSOUND_renderer[device->drvdesc.dnDevNode] != device) {		ERR("dsound died without killing us?/n");		timeKillEvent(timerID);		timeEndPeriod(DS_TIME_RES);		return;	}	RtlAcquireResourceShared(&(device->buffer_list_lock), TRUE);	if (device->ref)		DSOUND_PerformMix(device);	RtlReleaseResource(&(device->buffer_list_lock));	end_time = GetTickCount();	TRACE("completed processing at %d, duration = %d/n", end_time, end_time - start_time);}

static ULONG DirectSoundCaptureDevice_Release(    DirectSoundCaptureDevice * device){    ULONG ref = InterlockedDecrement(&(device->ref));    TRACE("(%p) ref was %d/n", device, ref + 1);    if (!ref) {        TRACE("deleting object/n");        timeKillEvent(device->timerID);        timeEndPeriod(DS_TIME_RES);        EnterCriticalSection(&DSOUND_capturers_lock);        list_remove(&device->entry);        LeaveCriticalSection(&DSOUND_capturers_lock);        if (device->capture_buffer)            IDirectSoundCaptureBufferImpl_Release(&device->capture_buffer->IDirectSoundCaptureBuffer8_iface);        if(device->mmdevice)            IMMDevice_Release(device->mmdevice);        HeapFree(GetProcessHeap(), 0, device->pwfx);        device->lock.DebugInfo->Spare[0] = 0;        DeleteCriticalSection( &(device->lock) );        HeapFree(GetProcessHeap(), 0, device);	TRACE("(%p) released/n", device);    }    return ref;}

HRESULT CLHTMLActiveDocument::StopPlay(){#if 0	if (m_dsBuffer8)	{		m_dsBuffer8->Stop();		//m_dsBuffer8.Release();	}	if (m_hEvent)	{		CloseHandle(m_hEvent);		m_hEvent = NULL;	}#endif	if (m_nTimerID)	{		timeKillEvent(m_nTimerID);		m_nTimerID = 0;	}	if (m_hThread)	{		::PostThreadMessage(m_threadID, WM_QUIT, 0, 0);		::WaitForSingleObject(m_hThread, INFINITE);		m_hThread = NULL;		m_threadID = 0;	}	return S_OK;}

/* ------------------------------------------------------------------------------------ */int StreamingAudio::Delete(){	if(ogg)	{		if(Ogg == NULL)			return RGF_FAILURE;		Ogg->Stop();		delete Ogg;		Ogg = NULL;		return RGF_SUCCESS;	}	timeKillEvent(m_nTimerID);							// Kill timer	if(mp3)	{		if(Mpeg3 == NULL)			return RGF_FAILURE;		Mpeg3->StopMp3();		delete Mpeg3;		Mpeg3 = NULL;		return RGF_SUCCESS;	}	// Check for stream availability	if(m_pStream == NULL)		return RGF_FAILURE;								// No stream	Stop();												// Stop playback	return RGF_SUCCESS;}

int timer::stop(){    if (control.stop)        timeKillEvent(control.stop);    control.stop = 0;    return 0;};

void tranquilizar() {#ifdef __WIN32__    timeKillEvent(wintimer);#else    alarm(0);#endif}

static void win32_rearm_timer(struct qemu_alarm_timer *t){    struct qemu_alarm_win32 *data = t->priv;    assert(alarm_has_dynticks(t));    if (!active_timers[QEMU_CLOCK_REALTIME] &&        !active_timers[QEMU_CLOCK_VIRTUAL] &&        !active_timers[QEMU_CLOCK_HOST])        return;    timeKillEvent(data->timerId);    data->timerId = timeSetEvent(1,                        data->period,                        host_alarm_handler,                        (DWORD)t,                        TIME_ONESHOT | TIME_CALLBACK_FUNCTION);    if (!data->timerId) {        fprintf(stderr, "Failed to re-arm win32 alarm timer %ld/n",                GetLastError());        timeEndPeriod(data->period);        exit(1);    }}

void PASCAL TimeProc(UINT wTimerID, UINT msg, DWORD dwUser, DWORD dw1, DWORD dw2){	sprintf(str, "%s", "res//");		if (c > 5472)	{		timeKillEvent(wTimerID);	}	if (c / 10 == 0)		sprintf(buff, "B000%d.BMP", c);	else if (c / 100 == 0)		sprintf(buff, "B00%d.BMP", c);	else if (c / 1000 == 0)		sprintf(buff, "B0%d.BMP", c);	else	{		sprintf(buff, "B%d.BMP", c);	}	str1 = str;	str1 += buff;	temp = c%25;	if (temp == 0)		count++;	if (count == 10)count = 0;	DrawImg(str1,count);	c++;}

// Destructorvoid Timer::destructor(void){	if (m_nIDTimer) {		timeKillEvent (m_nIDTimer);		m_nIDTimer = NULL;	}}

static void win32_stop_timer(struct qemu_alarm_timer *t){    struct qemu_alarm_win32 *data = t->priv;    timeKillEvent(data->timerId);    timeEndPeriod(data->period);}

bool CDirectSoundPlayer::Stop(){    HRESULT hr;	if(m_InitOK && m_AudioEnabled)	{		if(m_TimerID!=NULL) timeKillEvent(m_TimerID);		hr=m_BufferSecondary->Stop();		if(hr!=DS_OK)		{			CString message ("CDirectSoundPlayer::Stop - Error: /n");			message += DXAppErrorToString (hr);			gError->Warning(message);		}		hr=m_BufferSecondary->SetCurrentPosition(0);		if(hr!=DS_OK)		{			CString message ("CDirectSoundPlayer::Stop - Error: /n");			message += DXAppErrorToString (hr);			gError->Warning(message);		}//		dbg.Close();	}	m_AudioEnabled=FALSE;	return m_AudioEnabled;}

void SDL_SYS_TimerQuit(void){	if ( timerID ) {		timeKillEvent(timerID);	}	timeEndPeriod(TIMER_RESOLUTION);}

static void mm_rearm_timer(struct qemu_alarm_timer *t){    int nearest_delta_ms;    assert(alarm_has_dynticks(t));    if (!active_timers[QEMU_CLOCK_REALTIME] &&        !active_timers[QEMU_CLOCK_VIRTUAL] &&        !active_timers[QEMU_CLOCK_HOST]) {        return;    }    timeKillEvent(mm_timer);    nearest_delta_ms = (qemu_next_alarm_deadline() + 999999) / 1000000;    if (nearest_delta_ms < 1) {        nearest_delta_ms = 1;    }    mm_timer = timeSetEvent(nearest_delta_ms,                            mm_period,                            mm_alarm_handler,                            (DWORD_PTR)t,                            TIME_ONESHOT | TIME_CALLBACK_FUNCTION);    if (!mm_timer) {        fprintf(stderr, "Failed to re-arm win32 alarm timer %ld/n",                GetLastError());        timeEndPeriod(mm_period);        exit(1);    }}

	void Timer::Stop()	{		if (mTimerID) {			timeKillEvent(mTimerID);			mTimerID = 0;		}	}

void SysTimer::cancel(){	EnterCriticalSection(&Win32::win32Section);	if (data->timerId != NULL)		timeKillEvent(data->timerId);	data->timerId = NULL;	LeaveCriticalSection(&Win32::win32Section);}

	void CDuiTimerBase::InnerKillTimer()	{		timeKillEvent(m_uTimerID);		timeEndPeriod(m_uTimerAccuracy);		m_uTimerID = NULL;		m_uTimerAccuracy = NULL;		m_iCurTimer		= m_iInterval;	}

void KillMMTimer(UINT nID){	if(nID!=0)	{		timeKillEvent(nID);		timeEndPeriod(g_iAccuracy);	}	g_iMMTimerID=0;}

DttSP_EXP voidStopKeyer (){	EnterCriticalSection(update_ok);	if (timerid)		timeKillEvent ((UINT) timerid);	LeaveCriticalSection(update_ok);	timerid = 0;}

void VirtualOHT::DestoryTimer(void){	if (m_nTimerID > 0)	{		timeKillEvent(m_nTimerID);		timeEndPeriod(1);		m_nTimerID = 0;	}}

void _StopTimer(MMRESULT timerid){TIMECAPS caps;	if (timerid != 0) 	{	timeKillEvent(timerid);		timerid = 0;		timeGetDevCaps(&caps, sizeof(caps));		timeEndPeriod(caps.wPeriodMin);	}}