void CUpdateWizard::OnTimer(wxTimerEvent& event)
{
if (event.GetId() == m_statusTimer.GetId())
{
bool changed;
CTransferStatus status;
if (!m_pEngine)
m_statusTimer.Stop();
else if (!m_pEngine->GetTransferStatus(status, changed))
SetTransferStatus(0);
else if (changed)
SetTransferStatus(&status);
else
m_statusTimer.Stop();
}
else if (event.GetId() == m_autoCheckTimer.GetId())
{
if (m_autoUpdateCheckRunning)
return;
if (CanAutoCheckForUpdateNow())
{
m_autoUpdateCheckRunning = true;
const wxDateTime& now = wxDateTime::Now();
COptions::Get()->SetOption(OPTION_UPDATECHECK_LASTDATE, now.Format(_T("%Y-%m-%d %H:%M:%S")));
StartUpdateCheck();
}
}
else if (event.GetId() == m_busy_timer.GetId())
DisplayUpdateAvailability(true);
}
void CLed::OnTimer(wxTimerEvent& event)
{
if (event.GetId() != TIMER_ID)
{
event.Skip();
return;
}
if (!m_timer.IsRunning())
return;
if (!m_pState->m_pEngine)
{
m_timer.Stop();
return;
}
if (!m_pState->m_pEngine->IsActive(m_index == 0))
{
Unset();
m_timer.Stop();
}
return;
}
void CCManager::OnTimer(wxTimerEvent& event)
{
if (event.GetId() == idCallTipTimer) // m_CallTipTimer
{
CodeBlocksEvent evt(cbEVT_SHOW_CALL_TIP);
evt.SetInt(FROM_TIMER);
Manager::Get()->ProcessEvent(evt);
}
else if (event.GetId() == idAutoLaunchTimer) // m_AutoLaunchTimer
{
cbEditor* ed = Manager::Get()->GetEditorManager()->GetBuiltinActiveEditor();
if (ed && ed->GetControl()->GetCurrentPos() == m_AutocompPosition)
{
CodeBlocksEvent evt(cbEVT_COMPLETE_CODE);
evt.SetInt(FROM_TIMER);
Manager::Get()->ProcessEvent(evt);
}
m_AutocompPosition = wxSCI_INVALID_POSITION;
}
else if (event.GetId() == idAutocompSelectTimer) // m_AutocompSelectTimer
{
cbEditor* ed = Manager::Get()->GetEditorManager()->GetBuiltinActiveEditor();
if (ed)
{
cbStyledTextCtrl* stc = ed->GetControl();
if (stc->AutoCompActive())
{
m_LastAutocompIndex = stc->AutoCompGetCurrent();
DoShowDocumentation(ed);
}
}
}
else // ?!
event.Skip();
}
void CQueueViewBase::OnTimer(wxTimerEvent& event)
{
if (event.GetId() != m_filecount_delay_timer.GetId())
{
event.Skip();
return;
}
if (m_fileCountChanged || m_folderScanCountChanged)
DisplayNumberQueuedFiles();
}
//
// Watch for shift key changes
//
void ToolManager::OnTimer( wxTimerEvent & event )
{
// Go ahead and set the event to propagate
event.Skip();
// Can't do anything if we're not dragging. This also prevents
// us from intercepting events that don't belong to us from the
// parent since we're Connect()ed to a couple.
if( !mDragWindow )
{
return;
}
bool state = wxGetKeyState( WXK_SHIFT );
if( mLastState != state )
{
mLastState = state;
#if defined(__WXMAC__)
// Disable window animation
wxSystemOptions::SetOption( wxMAC_WINDOW_PLAIN_TRANSITION, 1 );
#endif
mIndicator->Show( !state );
#if defined(__WXMAC__)
// Disable window animation
wxSystemOptions::SetOption( wxMAC_WINDOW_PLAIN_TRANSITION, mTransition );
#endif
}
return;
}
// Various timers
void dlgMain::OnTimer(wxTimerEvent& event)
{
// Don't wipe the server list if a refresh is already running
if(GetThread() && GetThread()->IsRunning())
return;
// Don't update the list if the client is still running
if(ClientIsRunning())
return;
// What timer generated this event and what actions to perform
switch(event.GetId())
{
case TIMER_ID_NEWLIST:
{
DoGetList(true);
}
break;
case TIMER_ID_REFRESH:
{
DoRefreshList(true);
}
break;
}
}
void CSafeCombinationChange::OnPollingTimer(wxTimerEvent &evt)
{
if (evt.GetId() == CYubiMixin::POLLING_TIMER_ID) {
m_yubiMixin1.HandlePollingTimer();
m_yubiMixin2.HandlePollingTimer();
}
}
void OpenResourceDlg::OnTimer(wxTimerEvent& event)
{
event.Skip();
wxString currentFilter = m_textCtrlFilter->GetValue();
if(currentFilter != m_lastFilter) {
m_lastFilter = currentFilter;
m_dvListCtrl->DeleteAllItems();
if(m_lastFilter.IsEmpty()) {
m_timer->Start(500, true);
return;
}
ResourceVector_t filesVec;
ResourceVector_t allVec;
// Refresh the list
filesVec = DoGetFiles(m_lastFilter);
DoGetResources(m_lastFilter);
allVec.insert(allVec.end(), filesVec.begin(), filesVec.end());
allVec.insert(allVec.end(), m_resources.begin(), m_resources.end());
DoPopulateListCtrl(allVec);
}
m_timer->Start(500, true);
}
void PwsafeApp::OnIdleTimer(wxTimerEvent &evt)
{
if (evt.GetId() == IDLE_TIMER_ID && PWSprefs::GetInstance()->GetPref(PWSprefs::LockDBOnIdleTimeout)) {
if (m_frame != NULL && !m_frame->GetCurrentSafe().IsEmpty()) {
m_frame->HideUI(true); //true => lock
}
}
}
void CmdRecorder::OnTimer(wxTimerEvent& event) {
if( event.GetId() == ME_CmdTimer ) {
if( ScriptOp.isPlaying(wxGetApp().getScript(), NULL) )
m_Timer->Start( 1000, wxTIMER_ONE_SHOT );
else
m_labStatus->SetLabel( wxT("") );
}
}
void wxToolBar::OnTimer ( wxTimerEvent& rEvent )
{
if (rEvent.GetId() == m_vToolTimer.GetId())
{
wxPoint vPos( m_vXMouse, m_vYMouse );
m_pToolTip->DisplayToolTipWindow(vPos);
m_vToolTimer.Stop();
m_vToolExpTimer.Start(4000L, TRUE);
}
else if (rEvent.GetId() == m_vToolExpTimer.GetId())
{
m_pToolTip->HideToolTipWindow();
GetParent()->Refresh();
m_vToolExpTimer.Stop();
}
} // end of wxToolBar::OnTimer
void TimedDialogEnder::OnTimer (wxTimerEvent& event)
{
wxLogTrace (_T("TimedDialogEnder"), _T("OnTimer"));
if (event.GetId () == m_timerId) {
// Hm, apparently the main thread is calling this event handling
// function (this is standard?), even though the message box is
// blocking the application??? Thus, ::wxMutexGuiEnter() and
// ::wxMutexGuiLeave() functions must not be used in favour of:
#if defined(__WXMSW__) || defined(__WXMAC__) || defined(__WXPM__)
::wxMutexGuiLeaveOrEnter ();
#endif
// Try using portable (standard wxWidgets) code - does not work even
// when using wxMessageDialog and it's SetName() method which seems to
// be the compared window identifier instead of the window caption?
/*
wxWindow* parent = NULL;
wxWindow* dlgWdw = wxWindow::FindWindowByName (m_windowCaption, parent);
if (dlgWdw) {
wxDialog *dlg = wxDynamicCast (dlgWdw, wxDialog);
if (dlg) {
dlg->EndModal (m_returnCode);
::wxLogTrace (_T("TimedDialogEnder"), _T("Window killed"));
this->DestroyTimer ();
}
}*/
// So we currently have to use M$ specific code :-(((
#ifndef WIN32
wxFAIL_MSG (_T("Only supported under M$ Windows"));
#else
HWND wdw = FindWindow (NULL, m_windowCaption);
if (wdw) {
// Killing the message box using brute force is detected
// because of an irregular return code of the message box:
//if (DestroyWindow (wdw)) {
// Interestingly the message box can be killed "softly" or as
// not irregular detected:
if (EndDialog (wdw, m_returnCode)) {
wxLogTrace (_T("TimedDialogEnder"), _T("Window killed"));
this->DestroyTimer ();
m_success = true;
}
}
#endif
#if defined(__WXMSW__) || defined(__WXMAC__) || defined(__WXPM__)
::wxMutexGuiLeaveOrEnter ();
#endif
}
}
void SDRDevicesDialog::OnDeviceTimer( wxTimerEvent& event ) {
if (refresh) {
if (wxGetApp().areDevicesEnumerating() || !wxGetApp().areDevicesReady()) {
std::string msg = wxGetApp().getNotification();
devStatusBar->SetStatusText(msg);
devTree->DeleteAllItems();
devTree->AddRoot(msg);
event.Skip();
return;
}
devTree->DeleteAllItems();
wxTreeItemId devRoot = devTree->AddRoot("Devices");
wxTreeItemId localBranch = devTree->AppendItem(devRoot, "Local");
wxTreeItemId dsBranch = devTree->AppendItem(devRoot, "Local Net");
wxTreeItemId remoteBranch = devTree->AppendItem(devRoot, "Remote");
devs[""] = SDREnumerator::enumerate_devices("",true);
if (devs[""] != NULL) {
for (devs_i = devs[""]->begin(); devs_i != devs[""]->end(); devs_i++) {
if ((*devs_i)->isRemote()) {
devItems[devTree->AppendItem(dsBranch, (*devs_i)->getName())] = (*devs_i);
} else {
devItems[devTree->AppendItem(localBranch, (*devs_i)->getName())] = (*devs_i);
}
}
}
std::vector<std::string> remotes = SDREnumerator::getRemotes();
std::vector<std::string>::iterator remotes_i;
std::vector<SDRDeviceInfo *>::iterator remoteDevs_i;
if (remotes.size()) {
for (remotes_i = remotes.begin(); remotes_i != remotes.end(); remotes_i++) {
devs[*remotes_i] = SDREnumerator::enumerate_devices(*remotes_i, true);
wxTreeItemId remoteNode = devTree->AppendItem(remoteBranch, *remotes_i);
if (devs[*remotes_i] != NULL) {
for (remoteDevs_i = devs[*remotes_i]->begin(); remoteDevs_i != devs[*remotes_i]->end(); remoteDevs_i++) {
devItems[devTree->AppendItem(remoteNode, (*remoteDevs_i)->getName())] = (*remoteDevs_i);
}
}
}
}
m_addRemoteButton->Enable();
m_useSelectedButton->Enable();
devTree->Enable();
devTree->ExpandAll();
devStatusBar->SetStatusText("Ready.");
refresh = false;
}
}
//-----------------------------------------------------------------------------
void LogOutputHandlerDlg::OnTimer( wxTimerEvent& e )
//-----------------------------------------------------------------------------
{
switch( e.GetId() )
{
case teUpdate:
UpdateMissingConfigsList();
break;
}
}
void ScoreBot::OnTimerPulseM(wxTimerEvent &evt)
{
if (m_alert)
{
evt.SetId(m_alert_id);
m_alert->ProcessEvent(evt);
}
OnTimerPulse(evt);
}
//----------------------------------------------------------------------------
void RenderView::OnTimer(wxTimerEvent& event)
{
int ival = event.GetInterval();
double dIval = ival / 1000.0;
if (mTimerID == event.GetId())
{
std::map<std::string, PX2::EditRenderViewPtr>::iterator it
= mEditRenderViews.begin();
for (; it != mEditRenderViews.end(); it++)
{
EditRenderView *renderView = it->second;
if (renderView)
{
renderView->Tick(dIval);
}
}
}
}
void CLed::OnTimer(wxTimerEvent& event)
{
if (!m_timer.IsRunning())
return;
if (event.GetId() != m_timer.GetId())
{
event.Skip();
return;
}
if (!m_pEngine || !m_pEngine->IsActive((enum CFileZillaEngine::_direction)m_index))
{
Unset();
m_timer.Stop();
}
return;
}
//----------------------------------------------------------------------------
void MainFrame::OnTimer (wxTimerEvent& event)
{
if (mInited)
{
int ival = event.GetInterval();
double dIval = ival/1000.0;
EditSystem::GetSingleton().Update(dIval);
}
}
void ClangPlugin::OnTimer(wxTimerEvent& event)
{
cbEditor* ed = Manager::Get()->GetEditorManager()->GetBuiltinActiveEditor();
if ( (!ed) || (m_TranslUnitId == wxNOT_FOUND) )
return;
const int evId = event.GetId();
if ( evId == idReparseTimer )
{
RequestReparse( m_TranslUnitId, ed->GetFilename() );
}
}
void WXAppBar::OnTimer(wxTimerEvent& event)
{
#if defined(__WXGTK__)
long x, y;
m_pMouseControl->GetPointerLocation (x, y);
wxRect barRect = GetRect();
if (m_autohide && m_currentDockingMode != NON_DOCKED && m_isAutohideWindowShown && !barRect.Contains(x,y))
{
// Get X11 display
Display* dd= (Display *) wxGetDisplay(); assert (dd);
// Get desktop working area dimensions
int xDesktop, yDesktop, widthDesktop, heightDesktop, screenWidth, screenHeight;
GetDesktopDimensions (dd, xDesktop, yDesktop, widthDesktop, heightDesktop, screenWidth, screenHeight);
// Get original dimensions of the bar
wxSize proposedSize= GetBestSize();
// Compute bar position and size depending on docking mode
m_Width= proposedSize.GetWidth();
m_Height= proposedSize.GetHeight();
switch (m_currentDockingMode) {
case TOP_DOCKED:
m_X= (screenWidth - proposedSize.GetWidth())/2;
m_Y= 0 - proposedSize.GetHeight() + AUTOHIDE_FLANGE;
break;
case BOTTOM_DOCKED:
m_X= (screenWidth - proposedSize.GetWidth())/2;
m_Y= screenHeight - AUTOHIDE_FLANGE;
break;
case LEFT_DOCKED:
m_X= 0 - proposedSize.GetWidth() + AUTOHIDE_FLANGE;
m_Y= (screenHeight - proposedSize.GetHeight())/2;
break;
case RIGHT_DOCKED:
m_X= screenWidth - AUTOHIDE_FLANGE;
m_Y= (screenHeight - proposedSize.GetHeight())/2;
break;
case NON_DOCKED:
default:
assert (false);
}
// Set desired location and dimensions
SetSize(m_X, m_Y, m_Width, m_Height);
m_isAutohideWindowShown= false;
}
#endif
event.Skip(false);
}
void wxVideoTerminal::OnTimer(wxTimerEvent &evt)
{
m_counter_blink = (m_counter_blink+1)% 10;
if (m_counter_blink == 0)
{
m_cursor_blink = !m_cursor_blink;
Refresh(false);
}
//wxLogDebug("%d", m_counter_test++);
evt.Skip();
}
void nwxShiftSizer::OnTimer(wxTimerEvent &e)
{
if(m_pCurrent != NULL)
{
m_nTotalInterval += e.GetInterval();
if(m_nTotalInterval >= m_nWaitInterval)
{
_DoShift();
m_nTotalInterval = 0;
}
}
}
void OpenResourceDlg::OnTimer(wxTimerEvent& event)
{
event.Skip();
wxString currentFilter = m_textCtrlFilter->GetValue();
if(currentFilter != m_lastFilter) {
m_lastFilter = currentFilter;
m_dvListCtrl->DeleteAllItems();
if(m_lastFilter.IsEmpty()) {
m_timer->Start(50, true);
return;
}
ResourceVector_t filesVec;
ResourceVector_t allVec;
// Refresh the list
filesVec = DoGetFiles(m_lastFilter);
DoGetResources(m_lastFilter);
allVec.insert(allVec.end(), filesVec.begin(), filesVec.end());
allVec.insert(allVec.end(), m_resources.begin(), m_resources.end());
// and sort the results
wxString lcFilter = m_lastFilter.Lower();
ResourceVector_t v1, v2, v3, v4, v5;
std::for_each(allVec.begin(), allVec.end(), [&](const ResourceItem& a) {
if(a.displayName == m_lastFilter) {
v1.push_back(a); // Exact match
} else if(a.displayName.Lower() == lcFilter) {
v2.push_back(a); // case insenstive exact match
} else if(a.displayName.StartsWith(m_lastFilter)) {
v3.push_back(a); // starts with
} else if(a.displayName.Lower().StartsWith(lcFilter)) {
v4.push_back(a); // case insenstive starts with
} else {
// other
v5.push_back(a);
}
});
allVec.clear();
allVec.insert(allVec.end(), v1.begin(), v1.end());
allVec.insert(allVec.end(), v2.begin(), v2.end());
allVec.insert(allVec.end(), v3.begin(), v3.end());
allVec.insert(allVec.end(), v4.begin(), v4.end());
allVec.insert(allVec.end(), v5.begin(), v5.end());
DoPopulateListCtrl(allVec);
}
m_timer->Start(50, true);
}
void ClangCodeCompletion::OnTimer(wxTimerEvent& event)
{
if (!IsAttached())
{
return;
}
const int evId = event.GetId();
cbEditor* ed = Manager::Get()->GetEditorManager()->GetBuiltinActiveEditor();
if (!ed)
{
return;
}
if (evId == idReparseTimer) // m_ReparseTimer
{
//wxCommandEvent evt(cbEVT_COMMAND_REPARSE, idReparse);
//AddPendingEvent(evt);
m_pClangPlugin->RequestReparse( GetCurrentTranslationUnitId(), ed->GetFilename() );
}
else if (evId == idHighlightTimer)
{
//if (m_TranslUnitId == wxNOT_FOUND)
//{
// return;
//}
HighlightOccurrences(ed);
}
else if (evId == idDiagnosticTimer)
{
//wxCommandEvent evt(cbEVT_COMMAND_DIAGNOSEED, idDiagnoseEd);
//AddPendingEvent(evt);
}
else
{
event.Skip();
}
}
void ControlToolBar::OnTimer(wxTimerEvent & event)
{
event.Skip();
// bug 307 fix:
// Shift key-up events get swallowed if a command with a Shift in its keyboard
// shortcut opens a dialog, and ControlToolBar::OnKeyUp() doesn't get called.
if (!wxGetKeyState(WXK_SHIFT))
{
wxKeyEvent dummyEvent;
dummyEvent.m_keyCode = WXK_SHIFT;
this->OnKeyUp(dummyEvent);
mShiftKeyTimer.Stop();
}
}
void TimerManager::OnPeriodicTimer(wxTimerEvent &event)
{
// Get the resolution out of the event, which is the key to everything.
size_t resolution = event.GetInterval();
PeriodicMap::iterator itMap = mPeriodicMap.find(resolution);
// Sanity check.
if(mPeriodicMap.end() == itMap)
{
wxASSERT(false);
mPeriodicMap.erase(itMap);
mTimerMap[resolution]->Stop();
mTimerMap.erase(mTimerMap.find(resolution));
}
else
{
PeriodicFunctionList &periodics = itMap->second;
// Fire the events.
PeriodicFunctionList::iterator it = periodics.begin(), itThis,
itEnd = periodics.end();
while(it != itEnd)
{
itThis = it++;
if ((*itThis).first)
{
it = periodics.erase(itThis);
}
else
{
(*itThis).second();
}
}
// Remove the entry if there's nothing left.
if(true == periodics.empty())
{
mPeriodicMap.erase(itMap);
mTimerMap[resolution]->Stop();
mTimerMap.erase(mTimerMap.find(resolution));
}
}
}
void WConfirmCalibration::OnTimer(wxTimerEvent& event)
{
if (m_okCountdown == 0)
{
m_timer.Stop();
EndModal(BUTTON_OK);
}
else if (m_cancelCountdown == 0)
{
m_timer.Stop();
EndModal(BUTTON_CANCEL);
}
else if (m_repeatCountdown == 0)
{
m_timer.Stop();
EndModal(BUTTON_REPEAT);
}
else
{
switch (m_activeButton)
{
case OK:
m_okCountdown--;
m_buttonOk->SetLabel(_("Ok") + wxString::Format(wxT(" %i"), m_okCountdown));
m_buttonCancel->SetLabel(_("Cancel"));
m_buttonRepeat->SetLabel(_("Repeat"));
break;
case CANCEL:
m_cancelCountdown--;
m_buttonOk->SetLabel(_("Ok"));
m_buttonCancel->SetLabel(_("Cancel") + wxString::Format(wxT(" %i"), m_cancelCountdown));
m_buttonRepeat->SetLabel(_("Repeat"));
break;
case REPEAT:
m_repeatCountdown--;
m_buttonOk->SetLabel(_("Ok"));
m_buttonCancel->SetLabel(_("Cancel"));
m_buttonRepeat->SetLabel(_("Repeat") + wxString::Format(wxT(" %i"), m_repeatCountdown));
break;
}
m_timer.Stop();
m_timer.Start(1000);
}
event.Skip(false);
}
void AButton::Listener::OnTimer(wxTimerEvent & event)
{
event.Skip();
// bug 307 fix:
// Shift key-up events get swallowed if a command with a Shift in its keyboard
// shortcut opens a dialog, and OnKeyUp() doesn't get called.
// With CTRL now causing the button to change appearance, presumably similar
// can happen with that key.
if (!wxGetKeyState(WXK_SHIFT) ||
!wxGetKeyState(WXK_CONTROL))
{
wxKeyEvent dummy;
this->OnKeyUp(dummy);
mShiftKeyTimer.Stop();
}
}
void WebTools::OnTimer(wxTimerEvent& event)
{
event.Skip();
time_t curtime = time(NULL);
if((curtime - m_lastColourUpdate) < 5) return;
IEditor* editor = m_mgr->GetActiveEditor();
// Sanity
CHECK_PTR_RET(editor);
CHECK_PTR_RET(editor->IsModified());
if(!IsJavaScriptFile(editor->GetFileName())) return;
// This file is a modified JS file
m_lastColourUpdate = time(NULL);
m_jsColourThread->QueueBuffer(editor->GetFileName().GetFullPath(), editor->GetTextRange(0, editor->GetLength()));
}
void App::Update(wxTimerEvent& event)
{
switch(mPage) // refresh draw panel
{
case PAGE_OSZI:
{
mOsziPage->RefreshPanel();
break;
}
case PAGE_FFT:
{
mFFTPage->RefreshPanel();
break;
}
}
event.Skip();
}
