VOID
ReleasePollTimer()
{
BOOL bRes;
DWORD dwErr;
EnterCriticalSection(&g_CritSectPollRelease);
#if VERBOSE >= 2
dprintf("[sync] ReleasePollTimer called\n");
#endif
if (!(g_hPollTimer==INVALID_HANDLE_VALUE))
{
ResetEvent(g_hPollCompleteEvent);
bRes = DeleteTimerQueueTimer(NULL, g_hPollTimer, g_hPollCompleteEvent);
if (bRes==NULL)
{
// msdn: If the error code is ERROR_IO_PENDING, it is not necessary to
// call this function again. For any other error, you should retry the call.
dwErr = GetLastError();
if (dwErr != ERROR_IO_PENDING)
bRes = DeleteTimerQueueTimer(NULL, g_hPollTimer, g_hPollCompleteEvent);
}
g_hPollTimer = INVALID_HANDLE_VALUE;
}
LeaveCriticalSection(&g_CritSectPollRelease);
}
virtual DWORD OnStop()
{
if (hTimer != NULL)
{
DeleteTimerQueueTimer(NULL, hTimer, NULL);
hTimer = NULL;
}
if (m_hOneInstance != NULL)
{
CloseHandle(m_hOneInstance);
m_hOneInstance = NULL;
}
ReportStatusToSCM(SERVICE_STOP_PENDING);
if (m_pPlugMgr != NULL)
{
m_pPlugMgr->Stop();
}
if (m_pLogger)
{
m_pLogger->WriteLog(i8desk::LM_INFO, TEXT("I8VDisk Service already stoped."));
m_pLogger->SetAddDateBefore(false);
m_pLogger->WriteLog(i8desk::LM_INFO, TEXT("==============================================================\r\n\r\n"));
}
ReportStatusToSCM(SERVICE_STOPPED);
return ERROR_SUCCESS;
}
int _tmain(int argc, _TCHAR* argv[])
{
HRESULT hr = S_OK;
HANDLE _hScanTimer;
if (!CreateTimerQueueTimer(
&_hScanTimer,
nullptr, // Use default timer queue
&s_ScanTimerCallback,
NULL, // Context
WLAN_SCAN_TIMER_DELAY, // DueTime
WLAN_SCAN_TIMER_DELAY, // Period
WT_EXECUTEDEFAULT // Flags
))
{
hr = HRESULT_FROM_WIN32(GetLastError());
printf("CreateTimerQueueTimer failed with result %!HRESULT!\r\n", hr);
}
printf("Press any key to exit...\r\n");
getchar();
HANDLE hAPCThread = CreateThread(NULL,
0,
DeleteTimer,
_hScanTimer,
0,
NULL);
if (!DeleteTimerQueueTimer(nullptr, _hScanTimer, INVALID_HANDLE_VALUE))
{
printf("DeleteTimerQueueTimer failed with result %!HRESULT!", HRESULT_FROM_WIN32(GetLastError()));
}
WaitForSingleObject(hAPCThread, INFINITE);
return 0;
}
void CNetManager::ServerClose()
{
m_pIocpHandler->CloseAllThreads(THREAD_DIE_WAITTIME); // IOCP Worker Thread Close
ServerLog()->Log("IOCP Worker Thread All Died.");
m_pProcessThread->End(THREAD_DIE_WAITTIME); // ProcesssThread Close
ServerLog()->Log("Process Thread Died.");
// 모든 사용자 종료
CUserList * pUserList = SMemManager()->GetUserList();
CUser * pUser = pUserList->GetFirstUser();
while(pUser != NULL)
{
m_pPacketProcess->CloseClient(pUser, false);
pUser = pUserList->GetNext(pUser);
}
m_pAcceptThread->End(THREAD_DIE_WAITTIME);
ServerLog()->Log("Accept Process Thread Die.");
// 타이머 해제 윈도우 2000 전용함수 Platform SDK 업데이트 해야됨
if(!DeleteTimerQueueTimer(NULL, m_hTimerQTimer, NULL))
{
ServerLog()->Log("Delete Timer Error.");
}
m_hTimerQTimer = NULL;
CleanMemory();
InitializeVariable();
delete SCMemoryManager::GetMemManager(); // 메모리 관리 클래스 소멸
delete SCProfile::GetProfile(); // Profile 클래스 소멸
ServerLog()->Log("Server Close.\n");
}
void deTimer_disable (deTimer* timer)
{
if (timer->timer)
{
const int maxTries = 100;
HANDLE waitEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
int tryNdx = 0;
DE_ASSERT(waitEvent);
for (tryNdx = 0; tryNdx < maxTries; tryNdx++)
{
BOOL success = DeleteTimerQueueTimer(NULL, timer->timer, waitEvent);
if (success)
{
/* Wait for all callbacks to complete. */
DWORD res = WaitForSingleObject(waitEvent, INFINITE);
DE_ASSERT(res == WAIT_OBJECT_0);
DE_UNREF(res);
break;
}
else
{
DWORD err = GetLastError();
if (err == ERROR_IO_PENDING)
break; /* \todo [2013-03-21 pyry] Does this mean that callback is still in progress? */
deYield();
}
}
DE_ASSERT(tryNdx < maxTries);
CloseHandle(waitEvent);
timer->timer = 0;
}
}
/**
* @see pomp_timer_destroy.
*/
static int pomp_timer_win32_destroy(struct pomp_timer *timer)
{
struct pomp_fd *pfd = NULL;
POMP_RETURN_ERR_IF_FAILED(timer != NULL, -EINVAL);
/* Free resources */
if (timer->htimer != NULL) {
/* Wait for cancellation */
DeleteTimerQueueTimer(NULL, timer->htimer,
INVALID_HANDLE_VALUE);
}
if (timer->hevt != NULL) {
pfd = pomp_loop_win32_find_pfd_by_hevt(
timer->loop, timer->hevt);
if (pfd == NULL) {
POMP_LOGW("hevt %p not found in loop %p",
timer->hevt, timer->loop);
} else {
pomp_loop_remove_pfd(timer->loop, pfd);
free(pfd);
}
CloseHandle(timer->hevt);
}
free(timer);
return 0;
}
MyQProgressDialog::~MyQProgressDialog()
{
if (m_hUpdateTimer)
{
DeleteTimerQueueTimer(m_hTimerQueue, m_hUpdateTimer, NULL);
m_hUpdateTimer = NULL;
}
if (m_hTimerQueue)
{
DeleteTimerQueueEx(m_hTimerQueue, NULL);
m_hTimerQueue = NULL;
}
if (m_hWinHook)
{
UnhookWindowsHookEx(m_hWinHook);
m_hWinHook = NULL;
}
if (m_hMouseHook)
{
UnhookWindowsHookEx(m_hMouseHook);
m_hMouseHook = NULL;
}
}
~imp() {
#if defined(_WINDOWS) || defined(_CYGWIN)
DeleteTimerQueueTimer(NULL,
m_timer,
INVALID_HANDLE_VALUE);
#elif defined(__APPLE__) && defined(__MACH__)
// Mac OS X
// If the waiting-thread is not up and waiting yet,
// we can make sure that it finishes quickly by
// setting the end-time to zero.
m_end_time.tv_sec = 0;
m_end_time.tv_nsec = 0;
// Otherwise it's already up and waiting, and
// we can send a signal on m_condition_var:
pthread_mutex_lock(&m_mutex);
pthread_cond_signal(&m_condition_var);
pthread_mutex_unlock(&m_mutex);
if (pthread_join(m_thread_id, NULL) != 0)
throw default_exception("failed to join thread");
if (pthread_mutex_destroy(&m_mutex) != 0)
throw default_exception("failed to destroy pthread mutex");
if (pthread_cond_destroy(&m_condition_var) != 0)
throw default_exception("failed to destroy pthread condition variable");
if (pthread_attr_destroy(&m_attributes) != 0)
throw default_exception("failed to destroy pthread attributes object");
#elif defined(_LINUX_) || defined(_FREEBSD_)
// Linux & FreeBSD
timer_delete(m_timerid);
#else
// Other Platforms
#endif
}
void
stopTicker(void)
{
if (timer_queue != NULL && timer != NULL) {
DeleteTimerQueueTimer(timer_queue, timer, NULL);
timer = NULL;
}
}
static void
reset_quit_timer() {
if (timer_handle)
DeleteTimerQueueTimer(NULL, timer_handle, NULL);
CreateTimerQueueTimer(&timer_handle, NULL, &WaitOrTimerCallback,
NULL, TIMEOUT*1000, 0, 0);
}
void stop()
{
if (isRunning()) {
DeleteTimerQueueTimer(mTimerQueue, mTimerHandle, NULL);
mTimerHandle = NULL;
mTimerQueue = NULL;
}
}
static void win32_stop_timer(struct qemu_alarm_timer *t)
{
HANDLE hTimer = t->timer;
if (hTimer) {
DeleteTimerQueueTimer(NULL, hTimer, NULL);
}
}
bool CScriptDebugging::SetLogfile ( const char* szFilename, unsigned int uiLevel )
{
assert ( szFilename );
// Close the previously loaded file
if ( m_pLogFile )
{
fprintf ( m_pLogFile, "INFO: Logging to this file ended\n" );
// if we have a flush timer
if ( m_flushTimerHandle != NULL )
{
// delete our flush timer
DeleteTimerQueueTimer ( NULL, m_flushTimerHandle, INVALID_HANDLE_VALUE ); // INVALID_HANDLE_VALUE = wait for running callbacks to finish
}
fclose ( m_pLogFile );
m_pLogFile = NULL;
}
// Apply log size limit
uint uiMaxSizeKB = 0;
g_pCore->GetCVars ()->Get ( "max_clientscript_log_kb", uiMaxSizeKB );
CycleFile( szFilename, uiMaxSizeKB );
// Try to load the new file
FILE* pFile = fopen ( szFilename, "a+" );
if ( pFile )
{
// [2014-07-09 14:39:31] WARNING: Bad argument @ 'setElementPosition' [Expected element at argument 1, got nil] [string "return addEventHandler("onClientRender", ro..."]
// length = 158
// set our buffer size
// assumed message length of 158
// if we pulse at 150FPS (unrealistic but whatever)
// that's 1 update every 6.66666666ms
// pulse rate is 50 so 50 / 6.6666666 = 7.5 (close enough)
// if we are doing 5 error messages a pulse that's 5 * 7.5
// 5 * 7.5 = 37.5
// we need room for at least 37.5 messages in this buffer
// round 37.5 to 38 because we can't have half a message
// 8 * 256 bytes = 6004B
// round 6004 up to the nearest divisible by 1024 = 6144
// we have our buffer size.
setvbuf ( pFile , NULL , _IOFBF , 6144 );
// Set the new pointer and level and return true
m_uiLogFileLevel = uiLevel;
m_pLogFile = pFile;
// Create a timer
::CreateTimerQueueTimer( &m_flushTimerHandle, NULL, TimerProc, NULL, 50, 50, WT_EXECUTEINTIMERTHREAD );
return true;
}
return false;
}
int TestSynchTimerQueue(int argc, char* argv[])
{
int index;
HANDLE hTimerQueue;
HANDLE hTimers[TIMER_COUNT];
APC_DATA apcData[TIMER_COUNT];
g_Event = CreateEvent(NULL, TRUE, FALSE, NULL);
hTimerQueue = CreateTimerQueue();
if (!hTimerQueue)
{
printf("CreateTimerQueue failed (%d)\n", (int) GetLastError());
return -1;
}
for (index = 0; index < TIMER_COUNT; index++)
{
apcData[index].TimerId = index;
apcData[index].StartTime = GetTickCount();
apcData[index].DueTime = (index * 100) + 500;
apcData[index].Period = 1000;
apcData[index].FireCount = 0;
if (!CreateTimerQueueTimer(&hTimers[index], hTimerQueue, (WAITORTIMERCALLBACK) TimerRoutine,
&apcData[index], apcData[index].DueTime, apcData[index].Period, 0))
{
printf("CreateTimerQueueTimer failed (%d)\n", (int) GetLastError());
return -1;
}
}
if (WaitForSingleObject(g_Event, INFINITE) != WAIT_OBJECT_0)
{
printf("WaitForSingleObject failed (%d)\n", (int) GetLastError());
return -1;
}
for (index = 0; index < TIMER_COUNT; index++)
{
if (!DeleteTimerQueueTimer(hTimerQueue, hTimers[index], NULL))
{
printf("DeleteTimerQueueTimer failed (%d)\n", (int) GetLastError());
return -1;
}
}
if (!DeleteTimerQueue(hTimerQueue))
{
printf("DeleteTimerQueue failed (%d)\n", (int) GetLastError());
return -1;
}
CloseHandle(g_Event);
return 0;
}
void setSharedTimerFireInterval(double interval)
{
ASSERT(sharedTimerFiredFunction);
unsigned intervalInMS;
interval *= 1000;
if (interval > USER_TIMER_MAXIMUM)
intervalInMS = USER_TIMER_MAXIMUM;
else
intervalInMS = static_cast<unsigned>(interval);
initializeOffScreenTimerWindow();
bool timerSet = false;
#if !OS(WINCE)
if (Settings::shouldUseHighResolutionTimers()) {
if (interval < highResolutionThresholdMsec) {
if (!highResTimerActive) {
highResTimerActive = true;
timeBeginPeriod(timerResolution);
}
SetTimer(timerWindowHandle, endHighResTimerID, stopHighResTimerInMsec, 0);
}
DWORD queueStatus = LOWORD(GetQueueStatus(QS_PAINT | QS_MOUSEBUTTON | QS_KEY | QS_RAWINPUT));
// Win32 has a tri-level queue with application messages > user input > WM_PAINT/WM_TIMER.
// If the queue doesn't contains input events, we use a higher priorty timer event posting mechanism.
if (!(queueStatus & (QS_MOUSEBUTTON | QS_KEY | QS_RAWINPUT))) {
if (intervalInMS < USER_TIMER_MINIMUM && !processingCustomTimerMessage && !(queueStatus & QS_PAINT)) {
// Call PostMessage immediately if the timer is already expired, unless a paint is pending.
// (we prioritize paints over timers)
if (InterlockedIncrement(&pendingTimers) == 1)
PostMessage(timerWindowHandle, timerFiredMessage, 0, 0);
timerSet = true;
} else {
// Otherwise, delay the PostMessage via a CreateTimerQueueTimer
if (!timerQueue)
timerQueue = CreateTimerQueue();
if (timer)
DeleteTimerQueueTimer(timerQueue, timer, 0);
timerSet = CreateTimerQueueTimer(&timer, timerQueue, queueTimerProc, 0, intervalInMS, 0, WT_EXECUTEINTIMERTHREAD | WT_EXECUTEONLYONCE);
}
}
}
#endif // !OS(WINCE)
if (timerSet) {
if (timerID) {
KillTimer(timerWindowHandle, timerID);
timerID = 0;
}
} else {
timerID = SetTimer(timerWindowHandle, sharedTimerID, intervalInMS, 0);
timer = 0;
}
}
void GamePhase::CheckCollision()
{
for (size_t i = 0; i < GamePhase::playerPath.size() - 1; i++)
{
if (GamePhase::enemy.first == GamePhase::playerPath[i].first && GamePhase::enemy.second == GamePhase::playerPath[i].second)
{
// enemy fail
// klavesy
Reader::RemovePair('w', GamePhase::up);
Reader::RemovePair('a', GamePhase::left);
Reader::RemovePair('s', GamePhase::down);
Reader::RemovePair('d', GamePhase::right);
// timer
DeleteTimerQueueTimer(NULL, GamePhase::waitHandle, NULL);
GamePhase::returnFunctionCorrect();
return;
}
}
for (size_t i = 0; i < GamePhase::enemyPath.size() - 1; i++)
{
if (GamePhase::player.first == GamePhase::enemyPath[i].first && GamePhase::player.second == GamePhase::enemyPath[i].second)
{
// player fail
// klavesy
Reader::RemovePair('w', GamePhase::up);
Reader::RemovePair('a', GamePhase::left);
Reader::RemovePair('s', GamePhase::down);
Reader::RemovePair('d', GamePhase::right);
// timer
DeleteTimerQueueTimer(NULL, GamePhase::waitHandle, NULL);
GamePhase::returnFunctionBad();
return;
}
}
}
/*
ÏìÓ¦°ü´¦Àíº¯Êý£¬½«ÏìÓ¦ÄÚÈÝÖ±½ÓÉÏËÍ ÔÚµ÷ÓÃÍê³Éºó»ØÊÕSOCKET
Èë²Î: thisÖ¸Õë
·µ»ØÖµ ³É¹¦ VOS_OK ʧ°Ü VOS_ERROR
*/
UINT32 IpappDispatchResponse(PKT_HEAD_S* pThis)
{
//Èë²Î¼ì²é
CHECK_PARAM(pThis);
UINT32 uiRet = VOS_OK;
map<UINT32, IPAPP_LOCAL_BUF_S>::iterator iter = g_PktMap.find(pThis->uiPktID);
if ( iter != g_PktMap.end())// -->TEST_CODE;
{
//ÏÈÍ£Ö¹¶¨Ê±Æ÷
DeleteTimerQueueTimer(iter->second.hTimerQueue, iter->second.hNewTimer, NULL);
DeleteTimerQueue(iter->second.hTimerQueue);
if(iter->second.callback_pfn != NULL)
{
pfn pfnKey = iter->second.callback_pfn;
IPAPP_RESPONSE_PACKET_S* pPkt = (IPAPP_RESPONSE_PACKET_S* )(pThis + 1);
/*
if(FUNCTION_NOT_FOUND == pPkt->uiErrCode) //·þÎñÆ÷¶ËδÕÒµ½º¯Êý
{
no_function();
return VOS_OK;
}
*/
size_t szPktLength = sizeof(IPAPP_RESPONSE_PACKET_S) + pPkt->stRetArgs.szLen;
if(pPkt->stRetArgs.szLen != 0)
{
pPkt->stRetArgs.Buf = (char *)pPkt + sizeof(IPAPP_RESPONSE_PACKET_S);
}
else
{
pPkt->stRetArgs.Buf = NULL;
}
//µ÷ÓöÔÓ¦»Øµ÷º¯Êý
//uiRet = UPLOADMSG(pMsg);
CHAR *pArgList = (char *)pPkt->stRetArgs.Buf;
pfnKey(pPkt->uiErrCode, pArgList, pPkt->stRetArgs.szLen, pPkt->context, (HANDLE)pThis->uiPktID);
}
IpappClearMap(pThis->uiPktID);
//µ÷ÓÃÍê³É »ØÊÕÌ×½Ó×Ö
if(SockCloseSocket((SOCKET)pThis->uiPktID))
{
printf("RESTORE SOCKET ERROR\n");
}
//printf("SOCKET IS ALREADY CLOSED\n");
}
return VOS_OK;
}
void DisposeHttpListener(PHTTP_LISTENER listener)
{
ULONG state = InterlockedCompareExchange(&listener->State,
HTTP_LISTENER_STATE_DISPOSING,
HTTP_LISTENER_STATE_STARTED);
if(state = HTTP_LISTENER_STATE_STOPPED)
{
return;
}
// Thread responsible for disposing the listener.
if(state = HTTP_LISTENER_STATE_STARTED)
{
if(listener && listener->hRequestQueue)
{
for(int i=1; i<=listener->urlsCount; i++)
{
HttpRemoveUrlFromUrlGroup(
listener->UrlGroupId, // Req Queue
listener->urls[i], // Fully qualified URL
NULL);
}
//Close the request queue.
CloseHandle(listener->hRequestQueue);
}
//
// Call HttpTerminate.
//
HttpTerminate(HTTP_INITIALIZE_SERVER, NULL);
return;
}
else if (state == HTTP_LISTENER_STATE_DISPOSING)
{
// Only one thread can dispose the listener
if(InterlockedCompareExchange(&listener->State,
HTTP_LISTENER_STATE_STOPPED,
HTTP_LISTENER_STATE_DISPOSING) == HTTP_LISTENER_STATE_DISPOSING)
{
//
// Cleanup threadpool
//
HttpListenerCleanupThreadPool(listener);
//Delete timers and release the IOContexts
DeleteTimerQueueTimer(listener->TimerQueue, listener->FlushTimer,NULL);
DeleteTimerQueue(listener->TimerQueue);
HttpListenerFlushLookasideThreadProc(listener,NULL);
// Free the listener
FREE_MEM(listener);
printf("Http listener terminated...\n");
}
}
}
/*************************************************************************
**
** Function : canClose_driver
**
** Description : Close the message and control channel
** Parameters : CAN_HANDLE inst - handle for CAN controller
** Returnvalue :
**
*************************************************************************/
int __stdcall canClose_driver(CAN_HANDLE inst)
{
printf("CAN close \n");
canControlReset(hCanCtl);
canChannelClose(hCanChn);
canControlClose(hCanCtl);
vciDeviceClose(hDevice);
DeleteTimerQueueTimer(NULL,hTimerHandle,NULL);
return 1;
}
void WiFiInfo::Impl::GetApnsAndNotifyClient()
{
vector<WiFiInfo::AccessPoint> apns;
PWLAN_INTERFACE_INFO_LIST pIfList = NULL;
DWORD dwResult = WlanEnumInterfaces(m_hClient, NULL, &pIfList);
if (dwResult == ERROR_SUCCESS)
{
for (int ifIndex = 0; ifIndex < static_cast<int>(pIfList->dwNumberOfItems); ++ifIndex)
{
PWLAN_INTERFACE_INFO pIfInfo = (PWLAN_INTERFACE_INFO)&pIfList->InterfaceInfo[ifIndex];
PWLAN_BSS_LIST pWlanBssList = NULL;
if (pWlanGetNetworkBssList)
{ // on WinXP we don't have this function :(
dwResult = pWlanGetNetworkBssList(m_hClient,
&pIfInfo->InterfaceGuid,
0,
dot11_BSS_type_any,
FALSE,
NULL,
&pWlanBssList);
if (dwResult == ERROR_SUCCESS)
{
for (int wlanIndex = 0; wlanIndex < static_cast<int>(pWlanBssList->dwNumberOfItems); ++wlanIndex)
{
PWLAN_BSS_ENTRY pBssEntry = &pWlanBssList->wlanBssEntries[wlanIndex];
WiFiInfo::AccessPoint apn;
apn.m_ssid.assign(&pBssEntry->dot11Ssid.ucSSID[0],
&pBssEntry->dot11Ssid.ucSSID[pBssEntry->dot11Ssid.uSSIDLength]);
char buff[20] = {};
sprintf(buff, "%02X-%02X-%02X-%02X-%02X-%02X",
pBssEntry->dot11Bssid[0], pBssEntry->dot11Bssid[1],
pBssEntry->dot11Bssid[2], pBssEntry->dot11Bssid[3],
pBssEntry->dot11Bssid[4], pBssEntry->dot11Bssid[5]);
apn.m_bssid = buff;
sprintf(buff, "%ld", pBssEntry->lRssi);
apn.m_signalStrength = buff;
apns.push_back(apn);
}
WlanFreeMemory(pWlanBssList);
}
}
}
WlanFreeMemory(pIfList);
}
m_callback(apns);
// on WinXP, clean up timer if it was used
if (m_timer)
{
DeleteTimerQueueTimer(NULL, m_timer, NULL);
m_timer = NULL;
}
}
void stopSharedTimer()
{
if (timerQueue && timer) {
DeleteTimerQueueTimer(timerQueue, timer, 0);
timer = 0;
}
if (timerID) {
KillTimer(timerWindowHandle, timerID);
timerID = 0;
}
}
EXEC_RETURN timer_Close(TIMER_ID* timer_id){
#if defined(WIN32) || defined(_WIN64)
BOOL res = DeleteTimerQueueTimer(NULL,timer_id->id,NULL);
if(res == FALSE && GetLastError() == ERROR_IO_PENDING)
res = TRUE;
return res ? EXEC_SUCCESS:EXEC_ERROR;
#elif __linux__
return timer_delete(timer_id->id) == 0 ? EXEC_SUCCESS:EXEC_ERROR;
#elif __APPLE__
return close(timer_id->kq) == 0 ? EXEC_SUCCESS:EXEC_ERROR;
#endif
}
VOID TIMER_Stop(ULONG ulHandle)
{
if ((ulHandle >= TIMER_CB_NUM)
||(g_pstTimerCB[ulHandle].ucIsUsed == FALSE))
{
return;
}
DeleteTimerQueueTimer(NULL, g_pstTimerCB[ulHandle].hTimer, NULL);
TIMER_ReleaseCB(ulHandle);
return;
}
void vlc_timer_destroy (vlc_timer_t timer)
{
#ifndef UNDER_CE
if (timer->handle != INVALID_HANDLE_VALUE)
DeleteTimerQueueTimer (NULL, timer->handle, INVALID_HANDLE_VALUE);
#else
if (timer->id)
timeKillEvent (timer->id);
/* FIXME: timers that have not yet completed will trigger use-after-free */
#endif
free (timer);
}
void Timer::stop()
{
if(timerHandle != NULL)
{
if(mTimer.lock() != WAIT_OBJECT_0)
throw RobotException("Timer::stop could not get lock!");
DeleteTimerQueueTimer(NULL, timerHandle, INVALID_HANDLE_VALUE);
timerHandle = NULL;
mTimer.unlock();
}
}
Component* Destroy()
{
if (mhTimer != nullptr)
{
DeleteTimerQueueTimer(nullptr, mhTimer, nullptr);
mhTimer = nullptr;
}
if (mpComponent->destroy() != OPROS_SUCCESS)
return nullptr;
else
return mpComponent;
}
void
setupTimer(Renderer* renderer)
{
runningRenderer = renderer;
if (renderer) {
CreateTimerQueueTimer(&timerQueueTimer, NULL, statusTimer,
NULL, 250, 250, WT_EXECUTEINTIMERTHREAD);
} else {
if (timerQueueTimer) {
DeleteTimerQueueTimer(NULL, timerQueueTimer, INVALID_HANDLE_VALUE);
}
}
}
void dspConfigCb::clear_handle_list() const
{
for( t_size i = 0 , imax = dspConfigCb::h_list.get_count(); i < imax; ++i )
{
CONST BOOL ret = DeleteTimerQueueTimer( NULL , *dspConfigCb::h_list[i] , NULL );
if( ret == 0 )
{
console::printf( CONSOLE_HEADER "%s(): DeleteTimerQueueTimer() failed" , __FUNCTION__ );
}
delete dspConfigCb::h_list[i];
}
dspConfigCb::h_list.remove_all();
return;
}
void ArtWindow::OnDestroy()
{
delete renderer;
//KillTimer(TIMER_REPAINT);
if (RepaintTimer)
DeleteTimerQueueTimer(TimerQueue, RepaintTimer, INVALID_HANDLE_VALUE);
if (TimerQueue)
DeleteTimerQueue(TimerQueue);
// Does this do anything?
RepaintTimer = NULL;
TimerQueue = NULL;
}
void stopSharedTimer()
{
#if !OS(WINCE)
if (timerQueue && timer) {
DeleteTimerQueueTimer(timerQueue, timer, 0);
timer = 0;
}
#endif
if (timerID) {
KillTimer(timerWindowHandle, timerID);
timerID = 0;
}
}
