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 high bool 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 ); } } }
ProgressResult TimerRecordDialog::PreActionDelay(int iActionIndex, TimerRecordCompletedActions eCompletedActions) { wxString sAction = m_pTimerAfterCompleteChoiceCtrl->GetString(iActionIndex); wxString sCountdownLabel; sCountdownLabel.Printf("%s in:", sAction); // Two column layout. TimerProgressDialog::MessageTable columns(2); auto &column1 = columns[0]; auto &column2 = columns[1]; column1.push_back(_("Timer Recording completed.")); column2.push_back( {} ); column1.push_back( {} ); column2.push_back( {} ); column1.push_back(_("Recording Saved:")); column2.push_back(((eCompletedActions & TR_ACTION_SAVED) ? _("Yes") : _("No"))); column1.push_back(_("Recording Exported:")); column2.push_back(((eCompletedActions & TR_ACTION_EXPORTED) ? _("Yes") : _("No"))); column1.push_back(_("Action after Timer Recording:")); column2.push_back(sAction); wxDateTime dtNow = wxDateTime::UNow(); wxTimeSpan tsWait = wxTimeSpan(0, 1, 0, 0); wxDateTime dtActionTime = dtNow.Add(tsWait); TimerProgressDialog dlgAction(tsWait.GetMilliseconds().GetValue(), _("Audacity Timer Record - Waiting"), columns, pdlgHideStopButton | pdlgHideElapsedTime, sCountdownLabel); auto iUpdateResult = ProgressResult::Success; bool bIsTime = false; while (iUpdateResult == ProgressResult::Success && !bIsTime) { iUpdateResult = dlgAction.UpdateProgress(); wxMilliSleep(10); bIsTime = (dtActionTime <= wxDateTime::UNow()); } return iUpdateResult; }
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(); }