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

bool Camera_OpticstarPL130Class::Capture(int duration, usImage& img, int options, const wxRect& subframe){    bool still_going = true;    int mode = 3 * (int) Color;    if (img.Init(FullSize))    {        DisconnectWithAlert(CAPT_FAIL_MEMORY);        return true;    }    if (OSPL130_Capture(mode,duration)) {        pFrame->Alert(_("Cannot start exposure"));        return true;    }    if (duration > 100) {        wxMilliSleep(duration - 100); // wait until near end of exposure, nicely        wxGetApp().Yield();//      if (Abort) {//          MeadeCam->AbortImage();//          return true;//      }    }    while (still_going) {  // wait for image to finish and d/l        wxMilliSleep(20);        OSPL130_IsExposing(&still_going);        wxGetApp().Yield();    }    // Download    OSPL130_GetRawImage(0,0,FullSize.GetWidth(),FullSize.GetHeight(), (void *) img.ImageData);    unsigned short *dataptr;    dataptr = img.ImageData;    // byte swap    if (options & CAPTURE_SUBTRACT_DARK) SubtractDark(img);    if (Color && (options & CAPTURE_RECON))        QuickLRecon(img);    return false;}

wxThread::ExitCode MyJoinableThread::Entry(){    unsigned long res = 1;    for ( size_t n = 1; n < m_n; n++ )    {        res *= n;        // it's a loooong calculation :-)        wxMilliSleep(100);    }    return (ExitCode)res;}

bool wxLuaDebugTarget::IsConnected(bool wait_for_connect) const{    if (m_fConnected || !wait_for_connect) return m_fConnected;    for (int idx = 0; idx < WXLUASOCKET_CONNECT_TIMEOUT; ++idx)    {        if (m_fConnected)            break;        wxMilliSleep(100);    }    return m_fConnected;}

/// Gets a new list of devices by terminating and restarting portaudio/// Assumes that DeviceManager is only used on the main thread.void DeviceManager::Rescan(){   // get rid of the previous scan info   this->mInputDeviceSourceMaps.clear();   this->mOutputDeviceSourceMaps.clear();   // if we are doing a second scan then restart portaudio to get new devices   if (m_inited) {      // check to see if there is a stream open - can happen if monitoring,      // but otherwise Rescan() should not be available to the user.      if (gAudioIO) {         if (gAudioIO->IsMonitoring())          {            gAudioIO->StopStream();            while (gAudioIO->IsBusy())               wxMilliSleep(100);         }      }            // restart portaudio - this updates the device list      Pa_Terminate();      Pa_Initialize();   }   int nDevices = Pa_GetDeviceCount();   //The heirarchy for devices is Host/device/source.   //Some newer systems aggregate this.   //So we need to call port mixer for every device to get the sources   for (int i = 0; i < nDevices; i++) {      const PaDeviceInfo *info = Pa_GetDeviceInfo(i);      if (info->maxOutputChannels > 0) {         AddSources(i, info->defaultSampleRate, &mOutputDeviceSourceMaps, 0);      }      if (info->maxInputChannels > 0) {         AddSources(i, info->defaultSampleRate, &mInputDeviceSourceMaps, 1);      }   }   // If this was not an initial scan update each device toolbar.   // Hosts may have disappeared or appeared so a complete repopulate is needed.   if (m_inited) {      DeviceToolBar *dt;      for (size_t i = 0; i < gAudacityProjects.GetCount(); i++) {         dt = gAudacityProjects[i]->GetDeviceToolBar();         dt->RefillCombos();      }   }	m_inited = true;}

/** /brief Worker method of the Squidd.io server communication thread * * /return void* * */   void *SquiddioThread::Entry(){    wxMilliSleep(500); //Give everything some time to settle down before we try to do our work    m_pHandler->SetThreadRunning(true);    while (!TestDestroy())    {        if( !m_bIsWorking )        {            m_bIsWorking = true;            if( m_getdata )            {                m_getdata = false;                m_pHandler->RefreshLayer();                SquiddioEvent evt;                m_pHandler->AddPendingEvent(evt);            }            else if ( m_bCheckOnline )            {                m_pHandler->CheckIsOnline();                m_bCheckOnline = false;            }            else if ( m_bPositionReport )            {                //TODO: Separate from logwindow first.                m_bPositionReport = false;            }            m_bIsWorking = false;        }        wxMilliSleep(250);    }    // signal the event handler that this thread is going to be destroyed    // NOTE: here we assume that using the m_pHandler pointer is safe,    // (in this case this is assured by the MyFrame destructor)    //    wxQueueEvent(m_pHandler, new wxThreadEvent(wxEVT_COMMAND_DBTHREAD_COMPLETED));    //return (wxThread::ExitCode)0; // success    return 0;}

void wxLuaDebugTarget::Stop(){    NotifyExit();    if (m_fConnected)    {        m_clientSocket.Shutdown(SD_BOTH);        wxMilliSleep(100);        m_clientSocket.Close();    }    if (m_pThread)        m_pThread->Wait();}

// This function performs the main work of the service. // When this function returns the service has stopped.void wxGISNTService::Run(){	wxCmdLineParser parser;	if(!m_Server.Start(wxT("wxGISServer"), CONFIG_DIR, parser)) 	{        m_Server.Stop();		return;	}    while (m_bIsRunning)        wxMilliSleep(300);	m_Server.Stop();}

	virtual void OnIdle(wxIdleEvent& event)	{		if(OpQuit())		{			GetParent()->Close(true);			return;		}		Handler()->OnLoop();		OnLoopSound();		Refresh(false);		if(!Handler()->FullSpeed())			wxMilliSleep(3);		event.RequestMore();	}

void Parser::TerminateAllThreads(){    while (!m_PoolTask.empty())    {        PTVector& v = m_PoolTask.front();        for (PTVector::iterator it = v.begin(); it != v.end(); ++it)            delete *it;        m_PoolTask.pop();    }    m_Pool.AbortAllTasks();    while (!m_Pool.Done())        wxMilliSleep(1);}

void ManagedThread::abort_all(){    // 1) Send signal to threads telling to terminate ASAP    if(count_running() > 0)    {        ManagedThread::s_abort_all = true;        while(count_running() > 0)        {            wxMilliSleep(5);        }        wxMilliSleep(50);        // (there's a tiny delay between the thread disminishing the count        // and the thread actually stopping)        // 50 ms should be more than enough    }    // 2) Delete thread objects    ManagedThread *thread;    for(unsigned int i = 0; i < count_threads();++i)    {        thread = GetThread(i);        if(thread)        {            if(thread->IsAlive())                { thread->Delete(); }            delete thread;        }    }    // 3) Clear thread list    wxCriticalSectionLocker lock(ManagedThread::s_list_mutex);    s_threadslist.Clear();    // 4) Reset the abort flag now that no threads are running    ManagedThread::s_abort_all = false;}

///Runs the wait for start dialog.  Returns false if the user clicks stop while we are recording///so that the highbool TimerRecordDialog::RunWaitDialog(){   int updateResult = eProgressSuccess;   if (m_DateTime_Start > wxDateTime::UNow())       updateResult = this->WaitForStart();    if (updateResult != eProgressSuccess)    {      // Don't proceed, but don't treat it as canceled recording. User just canceled waiting.       return true;   }   else    {      // Record for specified time.      AudacityProject* pProject = GetActiveProject();      pProject->OnRecord();      bool bIsRecording = true;      wxString strMsg =         _("Recording start") + (wxString)wxT(":/t/t")         + GetDisplayDate(m_DateTime_Start) + wxT("/n") + _("Recording end")         + wxT(":/t/t") + GetDisplayDate(m_DateTime_End) + wxT("/n")         + _("Duration") + wxT(":/t/t") + m_TimeSpan_Duration.Format();       TimerProgressDialog          progress(m_TimeSpan_Duration.GetMilliseconds().GetValue(),                   _("Audacity Timer Record Progress"),                   strMsg,                   pdlgHideCancelButton);       // Make sure that start and end time are updated, so we always get the full       // duration, even if there's some delay getting here.      wxTimerEvent dummyTimerEvent;      this->OnTimer(dummyTimerEvent);      // Loop for progress display during recording.      while (bIsRecording && (updateResult == eProgressSuccess))       {         wxMilliSleep(kTimerInterval);         updateResult = progress.Update();         bIsRecording = (wxDateTime::UNow() <= m_DateTime_End); // Call UNow() again for extra accuracy...      }      pProject->OnStop();   }   // Let the caller handle cancellation or failure from recording progress.    if (updateResult == eProgressCancelled || updateResult == eProgressFailed)      return false;   return true;}

ProgressResult TimerRecordDialog::WaitForStart(){   // MY: The Waiting For Start dialog now shows what actions will occur after recording has completed   wxString sPostAction = m_pTimerAfterCompleteChoiceCtrl->GetString(m_pTimerAfterCompleteChoiceCtrl->GetSelection());   // Two column layout.   TimerProgressDialog::MessageTable columns(2);   auto &column1 = columns[0];   auto &column2 = columns[1];   column1.push_back(_("Waiting to start recording at:"));   column2.push_back(GetDisplayDate(m_DateTime_Start));   column1.push_back(_("Recording duration:"));   column2.push_back(m_TimeSpan_Duration.Format());   column1.push_back(_("Scheduled to stop at:"));   column2.push_back(GetDisplayDate(m_DateTime_End));   column1.push_back( {} );   column2.push_back( {} );   column1.push_back(_("Automatic Save enabled:"));   column2.push_back((m_bAutoSaveEnabled ? _("Yes") : _("No")));   column1.push_back(_("Automatic Export enabled:"));   column2.push_back((m_bAutoExportEnabled ? _("Yes") : _("No")));   column1.push_back(_("Action after Timer Recording:"));   column2.push_back(sPostAction);   wxDateTime startWait_DateTime = wxDateTime::UNow();   wxTimeSpan waitDuration = m_DateTime_Start - startWait_DateTime;   TimerProgressDialog progress(waitDuration.GetMilliseconds().GetValue(),      _("Audacity Timer Record - Waiting for Start"),      columns,      pdlgHideStopButton | pdlgConfirmStopCancel | pdlgHideElapsedTime,      _("Recording will commence in:"));   auto updateResult = ProgressResult::Success;   bool bIsRecording = false;   while (updateResult == ProgressResult::Success && !bIsRecording)   {      updateResult = progress.UpdateProgress();      wxMilliSleep(10);      bIsRecording = (m_DateTime_Start <= wxDateTime::UNow());   }   return updateResult;}

wxThread::ExitCode Timer::Entry(){    // here we do our long task, periodically calling TestDestroy():    while (_running && !GetThread()->TestDestroy())    {        wxMilliSleep(_ms);        if (_running)        {            wxQueueEvent(_parent->GetEventHandler(), new wxCommandEvent(UpdateEvent)); //new wxTimerEvent());        }    }    // TestDestroy() returned true (which means the main thread asked us    // to terminate as soon as possible) or we ended the long task...    return (wxThread::ExitCode)0;}

void MiscThreadTestCase::TestThreadDelete(){    // FIXME:    // As above, using Sleep() is only for testing here - we must use some    // synchronisation object instead to ensure that the thread is still    // running when we delete it - deleting a detached thread which already    // terminated will lead to a crash!    MyDetachedThread *thread0 = new MyDetachedThread(30, 'W');    CPPUNIT_ASSERT_EQUAL( wxTHREAD_MISC_ERROR, thread0->Delete() );            // delete a thread which didn't start to run yet.    MyDetachedThread *thread1 = new MyDetachedThread(30, 'Y');    CPPUNIT_ASSERT_EQUAL( wxTHREAD_NO_ERROR, thread1->Run() );    wxMilliSleep(300);    CPPUNIT_ASSERT_EQUAL( wxTHREAD_NO_ERROR, thread1->Delete() );              // delete a running thread    MyDetachedThread *thread2 = new MyDetachedThread(30, 'Z');    CPPUNIT_ASSERT_EQUAL( wxTHREAD_NO_ERROR, thread2->Run() );    wxMilliSleep(300);    CPPUNIT_ASSERT_EQUAL( wxTHREAD_NO_ERROR, thread2->Pause() );    CPPUNIT_ASSERT_EQUAL( wxTHREAD_NO_ERROR, thread2->Delete() );              // delete a sleeping thread    MyJoinableThread thread3(20);    CPPUNIT_ASSERT_EQUAL( wxTHREAD_NO_ERROR, thread3.Run() );    CPPUNIT_ASSERT_EQUAL( wxTHREAD_NO_ERROR, thread3.Delete() );               // delete a joinable running thread    MyJoinableThread thread4(2);    CPPUNIT_ASSERT_EQUAL( wxTHREAD_NO_ERROR, thread4.Run() );    wxMilliSleep(300);    CPPUNIT_ASSERT_EQUAL( wxTHREAD_NO_ERROR, thread4.Delete() );               // delete a joinable thread which already terminated}

bool GlobalConfig::stopAudioThread(){    if( m_AudioThread && m_AudioThread->IsRunning() )    {        m_AudioThread->terminate();        while( m_AudioThread->IsRunning() )        {            wxMilliSleep( 100 );        }    }    m_LoggingWindow->Close();    m_LoggingWindow->Destroy();    return( false );}

void wxPlFrame::OnCheckTimer( wxTimerEvent &event ){    //repeatedly call ReadTransmission until there is nothing    //left to read    PLINT nFalses = 0;    while ( nFalses < 100 )    {        if ( ReadTransmission() )            nFalses = 0;        else        {            ++nFalses;            wxMilliSleep( 1 );        }    }}

void wxGISMapView::PanStart(wxPoint MouseLocation){	if(m_timer.IsRunning())	{		wxTimerEvent ev;		OnTimer( ev );#ifdef WAITTIME		wxMilliSleep(WAITTIME);#endif		m_pTrackCancel->Cancel();		if(m_pThread)			m_pThread->Delete();	}	m_StartMouseLocation = MouseLocation;	m_MapToolState |= enumGISMapPanning;	CaptureMouse();//events ???}

void ToasterBox::Notify(){	//if the list is empty, skip this	if (winList->IsEmpty())		return;	wxLogDebug(_T("%s"), _T("clean&shrink"));	//clean the window list	CleanList();	//figure out how many blanks we have	ToasterBoxWindowListNode node = winList->GetFirst();	if (!node)		return;	//( (our base position)-(position of this node) ) / (default height of the windows)+1	//long blanks = ((popupPosition.y -	//  node->GetData()->GetPosition().y) / popupSize.GetHeight()) +1;	//move windows to fill in blank space	for (int i = node->GetData()->GetPosition().y; i < popupPosition.y; i += 4) {		if (i > popupPosition.y)			i = popupPosition.y;		//loop through all the windows		for (unsigned int j = 0; j < winList->GetCount(); j++) {			long ourNewHeight = i - (j * popupSize.GetHeight() - 8);			ToasterBoxWindowListNode tmpNode = winList->Item(j);			ToasterBoxWindow* tmpTb = tmpNode->GetData();			//reset where the object THINKS its supposed to be			tmpTb->SetPopupPosition(popupPosition.x, ourNewHeight);			//actually move it			tmpTb->SetSize(popupPosition.x, ourNewHeight,				       tmpTb->GetSize().GetWidth(),				       tmpTb->GetSize().GetHeight());			//tmpNode = 0;			tmpTb = 0;		}		wxMilliSleep(sleepTime);		//DrawText();		//Update();	}	StartAll();	//node = 0;}

void DeviceToolBar::OnChoice(wxCommandEvent &event){   wxObject *eventObject = event.GetEventObject();   //if we've changed hosts, we've handled the device switching already.   if (eventObject == mHost) {      ChangeHost();   } else if (eventObject == mInputChannels) {      int channelsSelectionIndex = mInputChannels->GetSelection();      if (channelsSelectionIndex >= 0)         gPrefs->Write(wxT("/AudioIO/RecordChannels"),channelsSelectionIndex + 1);   } else if (eventObject == mInput) {      ChangeDevice(true);   }   else if (eventObject == mOutput) {      ChangeDevice(false);   }   if (gAudioIO) {      // We cannot have gotten here if gAudioIO->IsAudioTokenActive(),      // per the setting of AudioIONotBusyFlag and AudioIOBusyFlag in      // AudacityProject::GetUpdateFlags().      // However, we can have an invalid audio token (so IsAudioTokenActive()      // is false), but be monitoring.      // If monitoring, have to stop the stream, so HandleDeviceChange() can work.      // We could disable the Preferences command while monitoring, i.e.,      // set AudioIONotBusyFlag/AudioIOBusyFlag according to monitoring, as well.      // Instead allow it because unlike recording, for example, monitoring      // is not clearly something that should prohibit changing device.      // TODO: We *could* be smarter in this method and call HandleDeviceChange()      // only when the device choices actually changed. True of lots of prefs!      // As is, we always stop monitoring before handling the device change.      if (gAudioIO->IsMonitoring())      {         gAudioIO->StopStream();         while (gAudioIO->IsBusy())            wxMilliSleep(100);      }      gAudioIO->HandleDeviceChange();   }   // Update all projects' DeviceToolBar.   for (size_t i = 0; i < gAudacityProjects.GetCount(); i++) {      gAudacityProjects[i]->GetDeviceToolBar()->UpdatePrefs();   }}

USBDM_ErrorCode HCS12Unsecure::programSecurityLocation() {   uint8_t unsecureFlashValue[] = {0xFF, 0xFE};   const uint8_t allOnes   = 0xFF;   const uint8_t allZeroes = 0x00;   int timeout;   uint8_t statValue;   uint8_t Hex_02 = 0x02;   uint8_t Hex_30 = 0x30;   // Unsecure Chip - re-programming flash NVSEC   print( "HCS12Unsecure::programSecurityLocation() - unsecuring target/n");   USBDM_WriteMemory(1, 1, HCS12DeviceData::getCOPCTL(), &COPCTL_value);   USBDM_WriteMemory(1, 1, HCS12DeviceData::getFTSTMODAddress(), &allZeroes);   USBDM_WriteMemory(1, 1, HCS12DeviceData::getFSTATAddress(),   &Hex_02);   USBDM_WriteMemory(1, 1, HCS12DeviceData::getFCLKDIVAddress(), &fcdivValue);   USBDM_WriteMemory(1, 1, HCS12DeviceData::getFCLKDIVAddress(), &fcdivValue);   USBDM_WriteMemory(1, 1, HCS12DeviceData::getFPROTAddress(),   &allOnes);   USBDM_WriteMemory(1, 1, HCS12DeviceData::getFSTATAddress(),   &Hex_30);   USBDM_WriteMemory(1, 1, HCS12DeviceData::getFTSTMODAddress(), &allZeroes);   USBDM_WriteMemory(1, 1, HCS12DeviceData::getFSTATAddress(),   &Hex_02);   USBDM_WriteMemory(2, 2, HCS12DeviceData::getNVSECAddress()-1, unsecureFlashValue);   USBDM_WriteMemory(1, 1, HCS12DeviceData::getFCMDAddress(),    &mWordProg);   USBDM_WriteMemory(1, 1, HCS12DeviceData::getFSTATAddress(),   &startFlashCommand);   // Program non-volatile Flash security location//   USBDM_WriteMemory(1, 1, HCS12DeviceData::getFPROTAddress(),   &allOnes);//   USBDM_WriteMemory(1, 1, HCS12DeviceData::getFSTATAddress(),   &HCS12_clearFlashErrors);//   USBDM_WriteMemory(2, 2, HCS12DeviceData::getNVSECAddress()-1, unsecureFlashValue);//   USBDM_WriteMemory(1, 1, HCS12DeviceData::getFCMDAddress(),    &mWordProg);//   USBDM_WriteMemory(1, 1, HCS12DeviceData::getFSTATAddress(),   &startFlashCommand);   // Wait for flash command to complete   timeout = 10;   do {      // Programming should take ???      wxMilliSleep(100);      if (USBDM_ReadMemory(1,1,HCS12DeviceData::getFSTATAddress(),&statValue) != BDM_RC_OK)         return BDM_RC_FAIL;      if (timeout-- == 0)         return BDM_RC_FAIL;   } while ((statValue & 0xC0) != 0xC0);   return BDM_RC_OK;}

wxThread::ExitCode TaskBase::Entry(){    // here we do our long task, periodically calling TestDestroy():    // TODO(JK#1#2017-09-29): do not use _running to stop the task but another variable. Use _running = false here to check afterwards if running    while (_running && !GetThread()->TestDestroy())    {        update();        // give other tasks some time        wxMilliSleep(1);    }    // call onStop whenever the thread exits its main loop (i.e is stopped by user or system)    onStop();    // reset recording state    _recording = false;    // TestDestroy() returned true (which means the main thread asked us    // to terminate as soon as possible) or we ended the long task...    return (wxThread::ExitCode)0;}

void StopWatchTestCase::RestartBug(){    wxStopWatch sw;    sw.Pause();    // Calling Start() should resume the stopwatch if it was paused.    static const int offset = 5000;    sw.Start(offset);    wxMilliSleep(sleepTime);    long t = sw.Time();    WX_ASSERT_MESSAGE    (        ("Actual time value is %ld", t),        t > offset + sleepTime - tolerance &&            t < offset + sleepTime + tolerance    );}

Resources::~Resources(){	/** check that connection checker has exited cleanly **/	connectionChecker->Delete();	while ( true ) {		/** make sure we process events here, since the thread will signal with an event when done **/		wxTheApp->ProcessPendingEvents();		if ( connectionChecker == NULL ) {			break;		}		wxMilliSleep( 1 );	}	delete settings;	delete connectionDatabase;	delete commandDatabase;	delete versionChecker;}

 bool Entry() {     bool err = pPointingSource->SlewToCoordinatesAsync(ra, dec);     if (err)     {         SetErrorMsg(_("Slew failed!"));         return true;     }     while (pPointingSource->Slewing())     {         wxMilliSleep(500);         if (IsCanceled())         {             pPointingSource->AbortSlew();             SetErrorMsg(_("Slew was canceled"));             break;         }     }     return false; }

wxThread::ExitCode MyProgressThread::Entry(){	wxFrame* frame = new wxFrame(NULL, wxID_ANY, _("Rivendell Transfering File - Please Wait"));	frame->CenterOnParent();	frame->Show(true);	wxGauge * myGauge = new wxGauge(frame, wxID_ANY, 300, wxDefaultPosition, wxDefaultSize, wxGAUGE_EMULATE_INDETERMINATE_MODE);	myGauge->CenterOnParent();		myGauge->Pulse();		// do something here that takes a long time		// it's a good idea to periodically check TestDestroy()	while (!TestDestroy()) {		wxMilliSleep(10);		myGauge->Pulse();	}	delete myGauge;	delete frame;	return static_cast<ExitCode>(NULL);}

void* gravApp::threadTest( void* args ){    gravUtil::logVerbose( "grav::starting network/decoding thread.../n" );    gravApp* g = (gravApp*)args;    // wait a bit before starting this thread, since doing it too early might    // affect the WX tree before it's fully initialized somehow, rarely    // resulting in broken text or a crash    wxMilliSleep( 100 );    while ( g->isThreadRunning() )    {        g->iterateSessions();        if ( threadDebug )        {            if ( threadCounter == 0 )                gravUtil::logVerbose( "grav::thread still running/n" );            threadCounter = (threadCounter+1)%1000;        }    }    gravUtil::logVerbose( "grav::thread ending.../n" );    return 0;}

bool wxGUIEventLoop::Dispatch(){    if ( !wxTheApp )        return false;    wxMacAutoreleasePool autoreleasepool;    EventRef theEvent;    OSStatus status = ReceiveNextEvent(0, NULL, m_sleepTime, true, &theEvent) ;    switch (status)    {        case eventLoopTimedOutErr :            if ( wxTheApp->ProcessIdle() )                m_sleepTime = kEventDurationNoWait ;            else            {                m_sleepTime = kEventDurationSecond;#if wxUSE_THREADS                wxMutexGuiLeave();                wxMilliSleep(20);                wxMutexGuiEnter();#endif            }            break;        case eventLoopQuitErr :            // according to QA1061 this may also occur            // when a WakeUp Process is executed            break;        default:            DispatchAndReleaseEvent(theEvent);            m_sleepTime = kEventDurationNoWait ;            break;    }    return true;}

int TimerRecordDialog::WaitForStart(){   // MY: The Waiting For Start dialog now shows what actions will occur after recording has completed   wxString sPostAction = m_pTimerAfterCompleteChoiceCtrl->GetString(m_pTimerAfterCompleteChoiceCtrl->GetSelection());   /* i18n-hint: Time specifications like "Sunday 28th October 2007 15:16:17 GMT"   * but hopefully translated by wxwidgets will be inserted into this */   wxString strMsg;   strMsg.Printf(_("Waiting to start recording at:/t%s/n") +      _("Recording duration:/t/t%s/n") +      _("Scheduled to stop at:/t/t%s/n/n") +      _("Automatic Save Enabled:/t/t%s/n") +      _("Automatic Export Enabled:/t/t%s/n") +      _("Post Timer Recording Action:/t%s"),      GetDisplayDate(m_DateTime_Start).c_str(),      m_TimeSpan_Duration.Format(),      GetDisplayDate(m_DateTime_End).c_str(),      (m_bAutoSaveEnabled ? _("Yes") : _("No")),      (m_bAutoExportEnabled ? _("Yes") : _("No")),      sPostAction);   wxDateTime startWait_DateTime = wxDateTime::UNow();   wxTimeSpan waitDuration = m_DateTime_Start - startWait_DateTime;   TimerProgressDialog progress(waitDuration.GetMilliseconds().GetValue(),      _("Audacity Timer Record - Waiting for Start"),      strMsg,      pdlgHideStopButton | pdlgConfirmStopCancel | pdlgHideElapsedTime,      _("Recording will commence in:"));   int updateResult = eProgressSuccess;   bool bIsRecording = false;   while (updateResult == eProgressSuccess && !bIsRecording)   {      updateResult = progress.Update();      wxMilliSleep(10);      bIsRecording = (m_DateTime_Start <= wxDateTime::UNow());   }   return updateResult;}

void gravApp::idleHandler( wxIdleEvent& evt ){    // start secondary thread if not running    if ( usingThreads && !threadRunning )    {        grav->setThreads( usingThreads );        threadRunning = true;        VPMthread = thread_start( threadTest, this );    }    if ( !usingThreads )        sessionManager->iterateSessions();    if ( timerIntervalUS > 0 )    {        // this is the method for rendering on idle, with a limiter based on the        // timer interval        unsigned long time = (unsigned long)timer->getTiming();        if ( time > (unsigned long)timerIntervalUS )        {            //gravUtil::logVerbose( "%lu/n", time );            canvas->draw();            timer->resetTiming();        }        else        {            wxMilliSleep( 1 );        }    }    // otherwise (if fps value isn't set) just constantly draw - if vsync is on,    // will be limited to vsync    else if ( timerIntervalUS == 0 )    {        canvas->draw();    }    evt.RequestMore();}