void CViewTransfers::GetDocStatus(size_t item, wxString& strBuffer) const { CMainDocument* pDoc = wxGetApp().GetDocument(); FILE_TRANSFER* transfer = 0; if (pDoc) { transfer = pDoc->file_transfer(item); } CC_STATUS status; int retval = pDoc->GetCoreClientStatus(status); if ((transfer) && (!retval)) { wxDateTime dtNextRequest((time_t)transfer->next_request_time); wxDateTime dtNow(wxDateTime::Now()); if (dtNextRequest > dtNow) { wxTimeSpan tsNextRequest(dtNextRequest - dtNow); strBuffer = _("Retry in ") + tsNextRequest.Format(); } else if (ERR_GIVEUP_DOWNLOAD == transfer->status) { strBuffer = _("Download failed"); } else if (ERR_GIVEUP_UPLOAD == transfer->status) { strBuffer = _("Upload failed"); } else { if (status.network_suspend_reason) { strBuffer = _("Suspended"); } else { if (transfer->xfer_active) { strBuffer = transfer->generated_locally? _("Uploading") : _("Downloading"); } else { strBuffer = transfer->generated_locally? _("Upload pending") : _("Download pending"); } } } } }
bool ClientStateIndicator::Suspended() { CMainDocument* pDoc = wxGetApp().GetDocument(); CC_STATUS status; bool result = false; pDoc->GetCoreClientStatus(status); if ( pDoc->IsConnected() && status.task_suspend_reason > 0 && status.task_suspend_reason != SUSPEND_REASON_DISK_SIZE && status.task_suspend_reason != SUSPEND_REASON_CPU_THROTTLE ) { result = true; } return result; }
void CSimpleTaskPanel::DisplayIdleState() { CMainDocument* pDoc = wxGetApp().GetDocument(); wxASSERT(pDoc); if ( pDoc->IsReconnecting() ) { error_time = 0; UpdateStaticText(&m_StatusValueText, _("Retrieving current status.")); } else if ( pDoc->IsConnected() && pDoc->state.projects.size() == 0) { error_time = 0; UpdateStaticText(&m_StatusValueText, m_sNoProjectsString); } else if ( DownloadingResults() ) { error_time = 0; UpdateStaticText(&m_StatusValueText, _("Downloading work from the server.")); } else if ( Suspended() ) { CC_STATUS status; pDoc->GetCoreClientStatus(status); if ( status.task_suspend_reason & SUSPEND_REASON_BATTERIES ) { UpdateStaticText(&m_StatusValueText, _("Processing Suspended: Running On Batteries.")); } else if ( status.task_suspend_reason & SUSPEND_REASON_USER_ACTIVE ) { UpdateStaticText(&m_StatusValueText, _("Processing Suspended: User Active.")); } else if ( status.task_suspend_reason & SUSPEND_REASON_USER_REQ ) { UpdateStaticText(&m_StatusValueText, _("Processing Suspended: User paused processing.")); } else if ( status.task_suspend_reason & SUSPEND_REASON_TIME_OF_DAY ) { UpdateStaticText(&m_StatusValueText, _("Processing Suspended: Time of Day.")); } else if ( status.task_suspend_reason & SUSPEND_REASON_BENCHMARKS ) { UpdateStaticText(&m_StatusValueText, _("Processing Suspended: Benchmarks Running.")); } else { UpdateStaticText(&m_StatusValueText, _("Processing Suspended.")); } } else if ( ProjectUpdateScheduled() ) { error_time = 0; UpdateStaticText(&m_StatusValueText, _("Waiting to contact project servers.")); } else { if ( error_time == 0 ) { error_time = time(NULL) + 10; UpdateStaticText(&m_StatusValueText, _("Retrieving current status")); } else if ( error_time < time(NULL) ) { // TODO: should we display "ERROR" like old Simple GUI? if ( pDoc->IsConnected() ) { UpdateStaticText(&m_StatusValueText, _("No work available to process")); } else { UpdateStaticText(&m_StatusValueText, _("Unable to connect to the core client")); } } else { UpdateStaticText(&m_StatusValueText, _("Retrieving current status")); } } }
void CViewTransfers::GetDocStatus(wxInt32 item, wxString& strBuffer) const { FILE_TRANSFER* transfer = NULL; CMainDocument* pDoc = wxGetApp().GetDocument(); int retval; strBuffer = wxString("", wxConvUTF8); transfer = pDoc->file_transfer(item); if (!transfer) return; CC_STATUS status; wxASSERT(pDoc); wxASSERT(wxDynamicCast(pDoc, CMainDocument)); retval = pDoc->GetCoreClientStatus(status); if (retval) return; wxDateTime dtNextRequest((time_t)transfer->next_request_time); wxDateTime dtNow(wxDateTime::Now()); strBuffer = transfer->is_upload?_("Upload"):_("Download"); strBuffer += wxString(": ", wxConvUTF8); if (dtNextRequest > dtNow) { wxTimeSpan tsNextRequest(dtNextRequest - dtNow); strBuffer += _("retry in ") + tsNextRequest.Format(); } else if (transfer->status == ERR_GIVEUP_DOWNLOAD || transfer->status == ERR_GIVEUP_UPLOAD) { strBuffer = _("failed"); } else { if (status.network_suspend_reason) { strBuffer += _("suspended"); strBuffer += wxString(" - ", wxConvUTF8); strBuffer += suspend_reason_wxstring(status.network_suspend_reason); } else { if (transfer->xfer_active) { strBuffer += _("active"); } else { strBuffer += _("pending"); } } } if (transfer->project_backoff) { wxString x; FormatTime(transfer->project_backoff, x); strBuffer += _(" (project backoff: ") + x + _(")"); } }
void ClientStateIndicator::DisplayState() { CMainDocument* pDoc = wxGetApp().GetDocument(); if ( pDoc->IsReconnecting() ) { error_time = 0; SetActionState(_("Retrieving current status.")); } else if ( pDoc->IsConnected() && pDoc->state.projects.size() == 0) { error_time = 0; SetPausedState(_("You don't have any projects. Please Add a Project.")); } else if ( DownloadingResults() ) { error_time = 0; SetActionState(_("Downloading work from the server.")); } else if ( Suspended() ) { CC_STATUS status; pDoc->GetCoreClientStatus(status); if ( status.task_suspend_reason & SUSPEND_REASON_BATTERIES ) { SetActionState(_("Processing Suspended: Running On Batteries.")); } else if ( status.task_suspend_reason & SUSPEND_REASON_USER_ACTIVE ) { SetActionState(_("Processing Suspended: User Active.")); } else if ( status.task_suspend_reason & SUSPEND_REASON_USER_REQ ) { SetActionState(_("Processing Suspended: User paused processing.")); } else if ( status.task_suspend_reason & SUSPEND_REASON_TIME_OF_DAY ) { SetActionState(_("Processing Suspended: Time of Day.")); } else if ( status.task_suspend_reason & SUSPEND_REASON_BENCHMARKS ) { SetActionState(_("Processing Suspended: Benchmarks Running.")); } else { SetActionState(_("Processing Suspended.")); } } else if ( ProjectUpdateScheduled() ) { error_time = 0; SetActionState(_("Waiting to contact project servers.")); } else { if ( error_time == 0 ) { error_time = time(NULL) + 10; SetActionState(_("Retrieving current status")); } else if ( error_time < time(NULL) ) { if ( pDoc->IsConnected() ) { SetNoActionState(_("No work available to process")); } else { SetNoActionState(_("Unable to connect to the core client")); } } else { SetActionState(_("Retrieving current status")); } } }
void CViewTransfers::OnTransfersRetryNow( wxCommandEvent& WXUNUSED(event) ) { wxLogTrace(wxT("Function Start/End"), wxT("CViewTransfers::OnTransfersRetryNow - Function Begin")); CMainDocument* pDoc = wxGetApp().GetDocument(); CAdvancedFrame* pFrame = wxDynamicCast(GetParent()->GetParent()->GetParent(), CAdvancedFrame); int row; wxASSERT(pDoc); wxASSERT(wxDynamicCast(pDoc, CMainDocument)); wxASSERT(pFrame); wxASSERT(wxDynamicCast(pFrame, CAdvancedFrame)); wxASSERT(m_pListPane); CC_STATUS status; pDoc->GetCoreClientStatus(status); if (status.network_suspend_reason) { wxString msg = _("Network activity is suspended - "); msg += suspend_reason_wxstring(status.network_suspend_reason); msg += _(".\nYou can enable it using the Activity menu."); wxGetApp().SafeMessageBox( msg, _("BOINC"), wxOK | wxICON_INFORMATION, this ); return; } pFrame->UpdateStatusText(_("Retrying transfer now...")); row = -1; while (1) { // Step through all selected items row = m_pListPane->GetNextItem(row, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED); if (row < 0) break; pDoc->TransferRetryNow(m_iSortedIndexes[row]); } pFrame->UpdateStatusText(wxT("")); UpdateSelection(); pFrame->ResetReminderTimers(); pFrame->FireRefreshView(); wxLogTrace(wxT("Function Start/End"), wxT("CViewTransfers::OnTransfersRetryNow - Function End")); }
bool CSimpleTaskPanel::isRunning(RESULT* result) { bool outcome = false; // It must be scheduled to be running if ( result->scheduler_state == CPU_SCHED_SCHEDULED ) { // If either the project or task have been suspended, then it cannot be running if ( !result->suspended_via_gui && !result->project_suspended_via_gui ) { CC_STATUS status; CMainDocument* pDoc = wxGetApp().GetDocument(); wxASSERT(pDoc); pDoc->GetCoreClientStatus(status); // Make sure that the core client isn't global suspended for some reason if ( status.task_suspend_reason == 0 || status.task_suspend_reason == SUSPEND_REASON_CPU_THROTTLE ) { outcome = true; } } } return outcome; }
void CProjectsComponent::OnResume(wxCommandEvent& /*event*/) { wxLogTrace(wxT("Function Start/End"), wxT("CProjectsComponent::OnResume - Function Begin")); CMainDocument* pDoc = wxGetApp().GetDocument(); CC_STATUS ccs; wxASSERT(pDoc); wxASSERT(wxDynamicCast(pDoc, CMainDocument)); pDoc->GetCoreClientStatus(ccs); if ((RUN_MODE_NEVER == ccs.task_mode) && (0 >= ccs.task_mode_delay)) { pDoc->SetActivityRunMode(RUN_MODE_AUTO, 0); } else { pDoc->SetActivityRunMode(RUN_MODE_RESTORE, 0); } btnResume->Show(false); btnPause->Show(true); wxLogTrace(wxT("Function Start/End"), wxT("CProjectsComponent::OnResume - Function End")); }
void CSimpleGUIPanel::OnSuspendResume(wxCommandEvent& /*event*/) { CMainDocument* pDoc = wxGetApp().GetDocument(); CC_STATUS ccs; wxASSERT(pDoc); wxASSERT(wxDynamicCast(pDoc, CMainDocument)); if (m_bIsSuspended) { pDoc->GetCoreClientStatus(ccs); if ((RUN_MODE_NEVER == ccs.task_mode) && (0 >= ccs.task_mode_delay)) { pDoc->SetActivityRunMode(RUN_MODE_AUTO, 0); } else { pDoc->SetActivityRunMode(RUN_MODE_RESTORE, 0); } } else { pDoc->SetActivityRunMode(RUN_MODE_NEVER, 3600); } m_SuspendResumeButton->SetLabel(m_bIsSuspended ? m_sResumeString : m_sSuspendString); m_SuspendResumeButton->SetToolTip(m_bIsSuspended ? m_sResumeButtonToolTip : m_sSuspendButtonToolTip); }
wxInt32 CViewTransfersGrid::FormatStatus(wxInt32 item, wxString& strBuffer) const { CMainDocument* doc = wxGetApp().GetDocument(); FILE_TRANSFER* transfer = wxGetApp().GetDocument()->file_transfer(item); CC_STATUS status; wxASSERT(doc); wxASSERT(wxDynamicCast(doc, CMainDocument)); doc->GetCoreClientStatus(status); wxDateTime dtNextRequest((time_t)transfer->next_request_time); wxDateTime dtNow(wxDateTime::Now()); if (transfer) { if (dtNextRequest > dtNow) { wxTimeSpan tsNextRequest(dtNextRequest - dtNow); strBuffer = _("Retry in ") + tsNextRequest.Format(); } else if (ERR_GIVEUP_DOWNLOAD == transfer->status) { strBuffer = _("Download failed"); } else if (ERR_GIVEUP_UPLOAD == transfer->status) { strBuffer = _("Upload failed"); } else { if (status.network_suspend_reason) { strBuffer = _("Suspended"); } else { if (transfer->xfer_active) { strBuffer = transfer->generated_locally? _("Uploading") : _("Downloading"); } else { strBuffer = transfer->generated_locally? _("Upload pending") : _("Download pending"); } } } } strBuffer = wxT(" ") + strBuffer; return 0; }
void CSimpleTaskPopupButton::OnTasksCommandButton(wxMouseEvent& /*event*/) { CMainDocument* pDoc = wxGetApp().GetDocument(); bool enableShowGraphics = true; bool enableAbort = true; CC_STATUS status; wxString strMachineName; wxASSERT(pDoc); TaskSelectionData* selData = ((CSimpleTaskPanel*)GetParent())->GetTaskSelectionData(); if (selData == NULL) return; RESULT* result = lookup_result(selData->project_url, selData->result_name); if (!result) return; if (result->suspended_via_gui) { m_TaskSuspendedViaGUI = true; m_SuspendResumeMenuItem->SetItemLabel(_("Resume")); m_SuspendResumeMenuItem->SetHelp(_("Resume work for this task.")); } else { m_TaskSuspendedViaGUI = false; m_SuspendResumeMenuItem->SetItemLabel(_("Suspend")); m_SuspendResumeMenuItem->SetHelp(_("Suspend work for this task.")); } pDoc->GetCoreClientStatus(status); if (status.task_suspend_reason & ~(SUSPEND_REASON_CPU_THROTTLE)) { enableShowGraphics = false; } pDoc->GetConnectedComputerName(strMachineName); if (!pDoc->IsComputerNameLocal(strMachineName)) { enableShowGraphics = false; } // Disable Show Graphics button if selected task can't display graphics if (!strlen(result->web_graphics_url) && !strlen(result->graphics_exec_path)) { enableShowGraphics = false; } if (result->suspended_via_gui || result->project_suspended_via_gui || (result->scheduler_state != CPU_SCHED_SCHEDULED) ) { enableShowGraphics = false; } m_ShowGraphicsMenuItem->Enable(enableShowGraphics); // Disable Abort button if any selected task already aborted if ( result->active_task_state == PROCESS_ABORT_PENDING || result->active_task_state == PROCESS_ABORTED || result->state == RESULT_ABORTED ) { enableAbort = false; } m_AbortMenuItem->Enable(enableAbort); #ifdef __WXMAC__ // Disable tooltips on Mac while menus are popped up because they cover menus wxToolTip::Enable(false); #endif PopupMenu(m_TaskCommandPopUpMenu); #if TESTBIGICONPOPUP /*** CAF *** FOR TESTING ONLY ***/ static int i; wxString s; if (i > 9) i = 0; if ( i < 5) { s = (wxT("This is a very very very and extremely long label.")); } else { s = (wxT("short.")); } switch (i++) { case 0: case 5: UpdateStaticText(&m_TaskProjectName, s); break; case 1: case 6: UpdateStaticText(&m_TaskApplicationName, s); break; case 2: case 7: UpdateStaticText(&m_ElapsedTimeValue, s); break; case 3: case 8: UpdateStaticText(&m_TimeRemainingValue, s); break; case 4: case 9: UpdateStaticText(&m_StatusValueText, s); break; } m_ProgressBar->SetValue( i * 10 ); int sel = i % 3; // m_TaskSelectionCtrl->SetStringSelection(tempArray[sel]); m_TaskSelectionCtrl->SetSelection(sel); #endif }
void CSimpleProjectPanel::UpdateInterface() { int n, count = -1; bool b_needMenuRebuild = false; wxString str = wxEmptyString; wxString projName = wxEmptyString; CMainDocument* pDoc = wxGetApp().GetDocument(); wxASSERT(pDoc); // Should we display the synchronize button instead of the // attach to project button? if ( pDoc->IsConnected() ) { CC_STATUS status; int is_acct_mgr_detected = 0; pDoc->GetCoreClientStatus(status); if (pDoc->m_iAcct_mgr_info_rpc_result == 0) { // We use an integer rather than a bool to force action the first time is_acct_mgr_detected = pDoc->ami.acct_mgr_url.size() ? 1 : 0; if ((m_UsingAccountManager != is_acct_mgr_detected) || (!m_TaskAddProjectButton->IsEnabled())) { m_UsingAccountManager = is_acct_mgr_detected; if (is_acct_mgr_detected) { m_TaskAddProjectButton->SetLabel(m_sSynchronizeString); m_TaskAddProjectButton->Enable(); m_TaskAddProjectButton->SetToolTip(m_sSynchronizeToolTip); } else { m_TaskAddProjectButton->SetLabel(m_sAddProjectString); if (!status.disallow_attach) { m_TaskAddProjectButton->Enable(); m_TaskAddProjectButton->SetToolTip(m_sAddProjectToolTip); } } this->Layout(); } } else { m_TaskAddProjectButton->Disable(); } UpdateProjectList(); count = m_ProjectSelectionCtrl->GetCount(); } if (count > 0) { n = m_ProjectSelectionCtrl->GetSelection(); if ((n < 0) || (n > count -1)) { m_ProjectSelectionCtrl->SetSelection(0); n = 0; } // Check to see if we need to rebuild the menu char* ctrl_url = ((ProjectSelectionData*)m_ProjectSelectionCtrl->GetClientData(n))->project_url; if (strcmp(m_CurrentSelectedProjectURL, ctrl_url)) { b_needMenuRebuild = true; strncpy(m_CurrentSelectedProjectURL, ctrl_url, sizeof(m_CurrentSelectedProjectURL)); } PROJECT* project = pDoc->state.lookup_project(ctrl_url); if ( project != NULL && project->last_rpc_time > m_Project_last_rpc_time ) { b_needMenuRebuild = true; m_Project_last_rpc_time = project->last_rpc_time; } if (b_needMenuRebuild) { m_ProjectWebSitesButton->RebuildMenu(); } m_ProjectWebSitesButton->Enable(); m_ProjectCommandsButton->Enable(); if (m_fDisplayedCredit != project->user_total_credit) { str.Printf(wxT("%s: %s"), m_sTotalWorkDoneString.c_str(), format_number(project->user_total_credit, 0) ); UpdateStaticText(&m_TotalCreditValue, str); m_TotalCreditValue->SetName(str); // For accessibility on Windows } projName = m_ProjectSelectionCtrl->GetStringSelection(); str.Printf(_("Pop up a menu of web sites for project %s"), projName.c_str()); m_ProjectWebSitesButton->SetToolTip(str); str.Printf(_("Pop up a menu of commands to apply to project %s"), projName.c_str()); m_ProjectCommandsButton->SetToolTip(str); } else { m_ProjectWebSitesButton->Disable(); m_ProjectCommandsButton->Disable(); m_CurrentSelectedProjectURL[0] = '\0'; m_fDisplayedCredit = -1.0; UpdateStaticText(&m_TotalCreditValue, wxEmptyString); m_TotalCreditValue->SetName(wxEmptyString); // For accessibility on Windows m_ProjectWebSitesButton->SetToolTip(wxEmptyString); m_ProjectCommandsButton->SetToolTip(wxEmptyString); } }
void CViewWork::UpdateSelection() { int i, n, row; CTaskItemGroup* pGroup = NULL; RESULT* result = NULL; PROJECT* project = NULL; CC_STATUS status; CMainDocument* pDoc = wxGetApp().GetDocument(); std::string first_project_url; wxString strMachineName; bool wasSuspended=false; bool all_same_project=false; bool enableShowGraphics = false; bool enableShowVMConsole = false; bool enableSuspendResume = false; bool enableAbort = false; bool enableProperties = false; wxASSERT(NULL != pDoc); wxASSERT(wxDynamicCast(pDoc, CMainDocument)); wxASSERT(NULL != m_pTaskPane); CBOINCBaseView::PreUpdateSelection(); pGroup = m_TaskGroups[0]; n = m_pListPane->GetSelectedItemCount(); if (n > 0) { enableShowGraphics = true; enableShowVMConsole = true; enableSuspendResume = true; enableAbort = true; pDoc->GetCoreClientStatus(status); if (status.task_suspend_reason & ~(SUSPEND_REASON_CPU_THROTTLE)) { enableShowGraphics = false; enableShowVMConsole = false; } pDoc->GetConnectedComputerName(strMachineName); if (!pDoc->IsComputerNameLocal(strMachineName)) { enableShowGraphics = false; enableShowVMConsole = false; } } if (pDoc->m_ActiveTasksOnly) { m_pTaskPane->UpdateTask( pGroup->m_Tasks[BTN_ACTIVE_ONLY], _("Show all tasks"), _("Show all tasks.") ); } else { m_pTaskPane->UpdateTask( pGroup->m_Tasks[BTN_ACTIVE_ONLY], _("Show active tasks"), _("Show only active tasks.") ); } row = -1; for (i=0; i<n; i++) { // Step through all selected items row = m_pListPane->GetNextItem(row, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED); if (row < 0) break; // Should never happen result = pDoc->result(m_iSortedIndexes[row]); if (!result) continue; if (i == 0) { wasSuspended = result->suspended_via_gui; if (result->suspended_via_gui) { m_pTaskPane->UpdateTask( pGroup->m_Tasks[BTN_SUSPEND], _("Resume"), _("Resume work for this task.") ); } else { m_pTaskPane->UpdateTask( pGroup->m_Tasks[BTN_SUSPEND], _("Suspend"), _("Suspend work for this task.") ); } } else { if (wasSuspended != result->suspended_via_gui) { // Disable Suspend / Resume button if the multiple selection // has a mix of suspended and not suspended tasks enableSuspendResume = false; } } // Disable Show VM console if the selected task hasn't registered a remote // desktop connection // if (!strlen(result->remote_desktop_addr)) { enableShowVMConsole = false; } // Disable Show Graphics button if the selected task can't display graphics // if (!strlen(result->web_graphics_url) && !strlen(result->graphics_exec_path)) { enableShowGraphics = false; } if (result->suspended_via_gui || result->project_suspended_via_gui || (result->scheduler_state != CPU_SCHED_SCHEDULED) ) { enableShowGraphics = false; } // Disable Abort button if any selected task already aborted if ( result->active_task_state == PROCESS_ABORT_PENDING || result->active_task_state == PROCESS_ABORTED || result->state == RESULT_ABORTED ) { enableAbort = false; } if (i == 0) { first_project_url = result->project_url; all_same_project = true; } else { if (first_project_url != result->project_url) { all_same_project = false; } } if (n == 1) { enableProperties = true; } } // To minimize flicker, set each button only once to the final desired state pGroup->m_Tasks[BTN_GRAPHICS]->m_pButton->Enable(enableShowGraphics); if (enableShowVMConsole) { pGroup->m_Tasks[BTN_VMCONSOLE]->m_pButton->Enable(); pGroup->m_Tasks[BTN_VMCONSOLE]->m_pButton->Show(); } else { pGroup->m_Tasks[BTN_VMCONSOLE]->m_pButton->Disable(); pGroup->m_Tasks[BTN_VMCONSOLE]->m_pButton->Hide(); } pGroup->m_Tasks[BTN_SUSPEND]->m_pButton->Enable(enableSuspendResume); pGroup->m_Tasks[BTN_ABORT]->m_pButton->Enable(enableAbort); pGroup->m_Tasks[BTN_PROPERTIES]->m_pButton->Enable(enableProperties); if (all_same_project) { project = pDoc->state.lookup_project(result->project_url); UpdateWebsiteSelection(GRP_WEBSITES, project); if(m_TaskGroups.size()>1) { m_pTaskPane->EnableTaskGroupTasks(m_TaskGroups[1]); } } else { UpdateWebsiteSelection(GRP_WEBSITES, NULL); if(m_TaskGroups.size()>1) { m_pTaskPane->DisableTaskGroupTasks(m_TaskGroups[1]); } } CBOINCBaseView::PostUpdateSelection(); }
void CProjectPropertiesPage::OnStateChange( CProjectPropertiesPageEvent& WXUNUSED(event) ) { CMainDocument* pDoc = wxGetApp().GetDocument(); CWizardAttach* pWAP = ((CWizardAttach*)GetParent()); PROJECT_CONFIG* pc = &pWAP->project_config; CC_STATUS status; wxDateTime dtStartExecutionTime; wxDateTime dtCurrentExecutionTime; wxTimeSpan tsExecutionTime; wxString strBuffer = wxEmptyString; bool bPostNewEvent = true; int iReturnValue = 0; wxASSERT(pDoc); wxASSERT(wxDynamicCast(pDoc, CMainDocument)); switch(GetCurrentState()) { case PROJPROP_INIT: pWAP->DisableNextButton(); pWAP->DisableBackButton(); StartProgress(m_pProgressIndicator); SetNextState(PROJPROP_RETRPROJECTPROPERTIES_BEGIN); break; case PROJPROP_RETRPROJECTPROPERTIES_BEGIN: SetNextState(PROJPROP_RETRPROJECTPROPERTIES_EXECUTE); break; case PROJPROP_RETRPROJECTPROPERTIES_EXECUTE: // Attempt to retrieve the project's account creation policies // Wait until we are done processing the request. dtStartExecutionTime = wxDateTime::Now(); dtCurrentExecutionTime = wxDateTime::Now(); tsExecutionTime = dtCurrentExecutionTime - dtStartExecutionTime; iReturnValue = 0; pc->clear(); pc->error_num = ERR_RETRY; while ( !iReturnValue && ((ERR_IN_PROGRESS == pc->error_num) || (ERR_RETRY == pc->error_num)) && tsExecutionTime.GetSeconds() <= 60 && !CHECK_CLOSINGINPROGRESS() ) { if (ERR_RETRY == pc->error_num) { pDoc->rpc.get_project_config( (const char*)pWAP->m_ProjectInfoPage->GetProjectURL().mb_str() ); } dtCurrentExecutionTime = wxDateTime::Now(); tsExecutionTime = dtCurrentExecutionTime - dtStartExecutionTime; iReturnValue = pDoc->rpc.get_project_config_poll(*pc); IncrementProgress(m_pProgressIndicator); ::wxMilliSleep(500); wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_USER_INPUT); } if ( !iReturnValue && (!pc->error_num || pc->error_num == ERR_ACCT_CREATION_DISABLED) ) { // We either successfully retrieved the project's // account creation policies or we were able to talk // to the web server and found out they do not support // account creation through the wizard. // In either case, claim success and set the correct flags // to show the correct 'next' page. // SetProjectPropertiesSucceeded(true); SetProjectAccountCreationDisabled(pc->account_creation_disabled); SetProjectClientAccountCreationDisabled(pc->client_account_creation_disabled); SetTermsOfUseRequired(!pc->terms_of_use.empty()); } else { SetProjectPropertiesSucceeded(false); SetProjectPropertiesURLFailure(pc->error_num == ERR_HTTP_PERMANENT); bool comm_failure = !iReturnValue && ( (ERR_GETHOSTBYNAME == pc->error_num) || (ERR_CONNECT == pc->error_num) || (ERR_XML_PARSE == pc->error_num) || (ERR_PROJECT_DOWN == pc->error_num) ); SetProjectPropertiesCommunicationFailure(comm_failure); bool server_reported_error = !iReturnValue && ( (ERR_HTTP_PERMANENT != pc->error_num) && (ERR_GETHOSTBYNAME != pc->error_num) && (ERR_CONNECT != pc->error_num) && (ERR_XML_PARSE != pc->error_num) && (ERR_PROJECT_DOWN != pc->error_num) ); SetServerReportedError(server_reported_error); if (server_reported_error) { strBuffer = pWAP->m_CompletionErrorPage->m_pServerMessagesCtrl->GetLabel(); if (pc->error_msg.size()) { strBuffer += wxString(pc->error_msg.c_str(), wxConvUTF8) + wxString(wxT("\n")); } pWAP->m_CompletionErrorPage->m_pServerMessagesCtrl->SetLabel(strBuffer); } } SetNextState(PROJPROP_DETERMINENETWORKSTATUS_BEGIN); break; case PROJPROP_DETERMINENETWORKSTATUS_BEGIN: SetNextState(PROJPROP_DETERMINENETWORKSTATUS_EXECUTE); break; case PROJPROP_DETERMINENETWORKSTATUS_EXECUTE: // Attempt to determine if we are even connected to a network // Wait until we are done processing the request. dtStartExecutionTime = wxDateTime::Now(); dtCurrentExecutionTime = wxDateTime::Now(); tsExecutionTime = dtCurrentExecutionTime - dtStartExecutionTime; iReturnValue = 0; status.network_status = NETWORK_STATUS_LOOKUP_PENDING; while ((!iReturnValue && (NETWORK_STATUS_LOOKUP_PENDING == status.network_status)) && tsExecutionTime.GetSeconds() <= 60 && !CHECK_CLOSINGINPROGRESS() ) { dtCurrentExecutionTime = wxDateTime::Now(); tsExecutionTime = dtCurrentExecutionTime - dtStartExecutionTime; iReturnValue = pDoc->GetCoreClientStatus(status); IncrementProgress(m_pProgressIndicator); ::wxMilliSleep(500); wxEventLoopBase::GetActive()->YieldFor(wxEVT_CATEGORY_USER_INPUT); } SetNetworkConnectionNotDetected(NETWORK_STATUS_WANT_CONNECTION == status.network_status); SetNextState(PROJPROP_DETERMINEACCOUNTINFOSTATUS_BEGIN); break; case PROJPROP_DETERMINEACCOUNTINFOSTATUS_BEGIN: SetNextState(PROJPROP_DETERMINEACCOUNTINFOSTATUS_EXECUTE); break; case PROJPROP_DETERMINEACCOUNTINFOSTATUS_EXECUTE: // Determine if the account settings are already pre-populated. // If so, advance to the Project Processing page. SetCredentialsAlreadyAvailable(pWAP->m_bCredentialsCached || pWAP->m_bCredentialsDetected); SetNextState(PROJPROP_CLEANUP); break; case PROJPROP_CLEANUP: FinishProgress(m_pProgressIndicator); SetNextState(PROJPROP_END); break; default: // Allow a glimps of what the result was before advancing to the next page. wxSleep(1); pWAP->EnableNextButton(); pWAP->EnableBackButton(); pWAP->SimulateNextButton(); bPostNewEvent = false; break; } Update(); if (bPostNewEvent && !CHECK_CLOSINGINPROGRESS()) { CProjectPropertiesPageEvent TransitionEvent(wxEVT_PROJECTPROPERTIES_STATECHANGE, this); AddPendingEvent(TransitionEvent); } }
void CProjectsComponent::UpdateInterface() { CMainDocument* pDoc = wxGetApp().GetDocument(); // Check to see if error messages have been received if ( receivedErrorMessage ) { Freeze(); if ( alertMessageDisplayed ) { btnAlertMessages->Show(false); btnMessages->Show(true); alertMessageDisplayed = false; } else { btnAlertMessages->Show(true); btnMessages->Show(false); alertMessageDisplayed = true; } Thaw(); } else { if ( alertMessageDisplayed ) { Freeze(); btnAlertMessages->Show(false); btnMessages->Show(true); alertMessageDisplayed = false; Thaw(); } } // Should we display the synchronize button instead of the // attach to project button? CC_STATUS status; bool is_acct_mgr_detected = false; pDoc->GetCoreClientStatus(status); is_acct_mgr_detected = pDoc->ami.acct_mgr_url.size() ? true : false; if (is_acct_mgr_detected) { btnAddProj->Show(false); btnSynchronize->Show(true); } else { if (!status.disallow_attach) { btnAddProj->Show(true); } btnSynchronize->Show(false); } // Show resume or pause as appropriate if (RUN_MODE_NEVER == status.task_mode) { btnPause->Show(false); btnResume->Show(true); } else { btnPause->Show(true); btnResume->Show(false); } // Should we disable the attach to project button? if (status.disallow_attach || is_acct_mgr_detected) { btnAddProj->Show(false); } else { btnAddProj->Show(true); } // Should we only be able to see the simple gui? if (status.simple_gui_only) { btnAdvancedView->Show(false); } else { btnAdvancedView->Show(true); } // Check number of projects UpdateProjectArray(); // Update stat icons for(int m = 0; m < (int)m_statProjects.size(); m++){ StatImageLoader *i_statIcon = m_statProjects.at(m); i_statIcon->UpdateInterface(); } }
void CBOINCDialUpManager::OnPoll() { CMainDocument* pDoc = wxGetApp().GetDocument(); CBOINCBaseFrame* pFrame = wxGetApp().GetFrame(); static bool bAlreadyRunningLoop = false; bool bIsOnline = false; bool bWantConnection = false; bool bWantDisconnect = false; wxString strDialogMessage = wxEmptyString; CC_STATUS cc_status; // We are ready to rock and roll. if (!bAlreadyRunningLoop && pDoc) { wxASSERT(wxDynamicCast(pDoc, CMainDocument)); wxASSERT(wxDynamicCast(pFrame, CBOINCBaseFrame)); bAlreadyRunningLoop = true; // cache the various states // The dialup manager tells us if we are still dialing or if we have // successfully connected. IsNetworkAlive/IsOnline both report the // success or failure of the dialup device to establish a connection // to the outside world. pDoc->GetCoreClientStatus(cc_status); bIsOnline = (cc_status.network_status == NETWORK_STATUS_ONLINE); bWantConnection = (cc_status.network_status == NETWORK_STATUS_WANT_CONNECTION); bWantDisconnect = (cc_status.network_status == NETWORK_STATUS_WANT_DISCONNECT); // The timers are used to keep from spamming the user with the same // messages over each iteration of the poll loop. we only need to // reset them during a connect event in case we randomly loose // a connection. if (m_bResetTimers) { wxLogTrace(wxT("Function Status"), wxT("CBOINCDialUpManager::poll - Resetting dial-up notification timers")); m_bResetTimers = false; m_bSetConnectionTimer = false; ResetReminderTimers(); } // Log out the trace information for debugging purposes. /* wxLogTrace(wxT("Function Status"), wxT("CBOINCDialUpManager::poll - Dialup Flags")); wxLogTrace(wxT("Function Status"), wxT("CBOINCDialUpManager::poll - -- bIsOnline = '%d', bIsDialing = '%d', m_bWasDialing = '%d', iNetworkStatus = '%d', bWantConnection = '%d'"), bIsOnline, bIsDialing, m_bWasDialing, iNetworkStatus, bWantConnection ); wxLogTrace(wxT("Function Status"), wxT("CBOINCDialUpManager::poll - -- m_bResetTimers = '%d', m_bNotifyConnectionAvailable = '%d', m_bConnectedSuccessfully = '%d'"), m_bResetTimers, m_bNotifyConnectionAvailable, m_bConnectedSuccessfully ); wxLogTrace(wxT("Function Status"), wxT("CBOINCDialUpManager::poll - -- confirm_before_connecting = '%d', hangup_if_dialed = '%d'"), pDoc->state.global_prefs.confirm_before_connecting, pDoc->state.global_prefs.hangup_if_dialed ); */ #ifndef __WXMSW__ // notification logic for non MS-Windows systems if (!bIsOnline && bWantConnection) { // Make sure window is visable and active, don't want the message box // to pop up on top of anything else wxLogTrace(wxT("Function Status"), wxT("CBOINCDialUpManager::poll - Notify need Internet Connection")); if (pFrame->IsShown() && wxGetApp().IsActive()) { NotifyUserNeedConnection(false); } /* // this section commented out until taskbar/systray notification alerts are implemented else { // window is not visible, show alert if (pTaskbar && pTaskbar->IsBalloonsSupported()) { NotifyUserNeedConnection(true); } } */ } #else // dialer stuff for MS-Windows systems bool bIsDialing = m_pDialupManager->IsDialing(); if (!bIsOnline && !bIsDialing && !m_bWasDialing && bWantConnection) { wxLogTrace(wxT("Function Status"), wxT("CBOINCDialUpManager::poll - !bIsOnline && !bIsDialing && !m_bWasDialing && bWantConnection")); if (!pFrame->IsShown()) { // BOINC Manager is hidden and displaying a dialog might interupt what they // are doing. NotifyUserNeedConnection(true); } else { // BOINC Manager is visable and can process user input. m_bSetConnectionTimer = true; Connect(); } } else if (!bIsDialing && !m_bWasDialing) { // We are not doing anything now, were we up to something before? if (bIsOnline && m_bConnectedSuccessfully && m_bNotifyConnectionAvailable) { // Ah ha, we are online and we initiated the connection, so we need to // notify the CC that the network is available. wxLogTrace(wxT("Function Status"), wxT("CBOINCDialUpManager::poll - bIsOnline && m_bConnectedSuccessfully && m_bNotifyConnectionAvailable")); NetworkAvailable(); } else if (bWantDisconnect && m_bConnectedSuccessfully) { // We are online, and the CC says it is safe to disconnect. Since we // initiated the connection we need to disconnect now. wxLogTrace(wxT("Function Status"), wxT("CBOINCDialUpManager::poll - bWantDisconnect && m_bConnectedSuccessfully")); Disconnect(); } } else if (!bIsDialing && m_bWasDialing) { // We initiated a connection attempt and now we are either online or failed to // connect because of a modem error or a users credentials were wrong. wxLogTrace(wxT("Function Status"), wxT("CBOINCDialUpManager::poll - !bIsDialing && m_bWasDialing")); if (m_bSetConnectionTimer) { m_bSetConnectionTimer = false; m_dtDialupConnectionTimeout = wxDateTime::Now(); m_iConnectAttemptRetVal = ERR_NO_NETWORK_CONNECTION; } wxTimeSpan tsTimeout = wxDateTime::Now() - m_dtDialupConnectionTimeout; if (30 > tsTimeout.GetSeconds()) { if(m_iConnectAttemptRetVal != BOINC_SUCCESS) { return; } } m_bWasDialing = false; m_bResetTimers = true; if (!m_iConnectAttemptRetVal) { ConnectionSucceeded(); } else { ConnectionFailed(); } } else if (bIsDialing && !m_bWasDialing) { // Setup the state machine so that it knows when we have finished the connection // attempt. wxLogTrace(wxT("Function Status"), wxT("CBOINCDialUpManager::poll - bIsDialing && !m_bWasDialing")); m_bWasDialing = true; } #endif bAlreadyRunningLoop = false; } }
// called from CSimpleFrame::OnRefreshView() void CSimpleGUIPanel::OnFrameRender() { CMainDocument* pDoc = wxGetApp().GetDocument(); wxASSERT(pDoc); int workCount = pDoc->GetSimpleGUIWorkCount(); CC_STATUS status; bool isSuspended; // OnFrameRender() may be called while SimpleGUI initialization is // in progress due to completion of a periodic get_messages RPC, // causing unintended recursion in CMainDocument::RequestRPC(). // Check for that situation here. if (pDoc->WaitingForRPC()) return; // Workaround for Linux refresh problem if (m_irefreshCount < REFRESH_WAIT) { ++m_irefreshCount; m_taskPanel->UpdatePanel(true); return; } if (workCount != m_oldWorkCount) { if (workCount < 0) { m_projPanel->Hide(); } else if (m_oldWorkCount == 0) { m_projPanel->Show(); } this->Layout(); ReskinInterface(); } if (IsShown()) { if ( pDoc->IsConnected() ) { // Show Resume or Suspend as appropriate pDoc->GetCoreClientStatus(status); isSuspended = (RUN_MODE_NEVER == status.task_mode); if ((isSuspended != m_bIsSuspended) || (!m_SuspendResumeButton->IsEnabled())) { m_bIsSuspended = isSuspended; m_SuspendResumeButton->SetLabel(m_bIsSuspended ? m_sResumeString : m_sSuspendString); m_SuspendResumeButton->SetToolTip(m_bIsSuspended ? m_sResumeButtonToolTip : m_sSuspendButtonToolTip); } m_SuspendResumeButton->Enable(); } else { m_SuspendResumeButton->SetToolTip(wxEmptyString); m_SuspendResumeButton->Disable(); } UpdateProjectView(); if (m_bNewNoticeAlert) { wxRect r = m_NoticesButton->GetRect(); r.Inflate(4, 4); RefreshRect(r, m_bNoticesButtonIsRed); m_bNoticesButtonIsRed = !m_bNoticesButtonIsRed; } // State changes can cause the BSG to crash if a dialogue is open. // Defer state change until after the dialogue is closed if ( dlgOpen ) { return; } m_oldWorkCount = workCount; m_taskPanel->UpdatePanel(false); } }
void CViewWork::GetDocStatus(wxInt32 item, wxString& strBuffer) const { CMainDocument* doc = wxGetApp().GetDocument(); RESULT* result = wxGetApp().GetDocument()->result(item); CC_STATUS status; int retval; wxASSERT(doc); wxASSERT(wxDynamicCast(doc, CMainDocument)); strBuffer.Clear(); retval = doc->GetCoreClientStatus(status); if (retval || !result) { return; } if (result->coproc_missing) { strBuffer += _("GPU missing, "); } int throttled = status.task_suspend_reason & SUSPEND_REASON_CPU_THROTTLE; switch(result->state) { case RESULT_NEW: strBuffer += _("New"); break; case RESULT_FILES_DOWNLOADING: if (result->ready_to_report) { strBuffer += _("Download failed"); } else { strBuffer += _("Downloading"); if (status.network_suspend_reason) { strBuffer += _(" (suspended)"); } } break; case RESULT_FILES_DOWNLOADED: if (result->project_suspended_via_gui) { strBuffer += _("Project suspended by user"); } else if (result->suspended_via_gui) { strBuffer += _("Task suspended by user"); } else if (status.task_suspend_reason && !throttled) { strBuffer += _("Suspended"); if (status.task_suspend_reason & SUSPEND_REASON_BATTERIES) { strBuffer += _(" - on batteries"); } if (status.task_suspend_reason & SUSPEND_REASON_USER_ACTIVE) { strBuffer += _(" - user active"); } if (status.task_suspend_reason & SUSPEND_REASON_USER_REQ) { strBuffer += _(" - computation suspended"); } if (status.task_suspend_reason & SUSPEND_REASON_TIME_OF_DAY) { strBuffer += _(" - time of day"); } if (status.task_suspend_reason & SUSPEND_REASON_BENCHMARKS) { strBuffer += _(" - CPU benchmarks"); } if (status.task_suspend_reason & SUSPEND_REASON_DISK_SIZE) { strBuffer += _(" - need disk space"); } if (status.task_suspend_reason & SUSPEND_REASON_EXCLUSIVE_APP_RUNNING) { strBuffer += _(" - an exclusive app is running"); } if (result->resources.size()) { strBuffer += wxString(wxT(" (")) + wxString(result->resources.c_str(), wxConvUTF8) + wxString(wxT(")")); } } else if (result->active_task) { if (result->too_large) { strBuffer += _("Waiting for memory"); } else if (result->needs_shmem) { strBuffer += _("Waiting for shared memory"); } else if (result->scheduler_state == CPU_SCHED_SCHEDULED) { if (result->edf_scheduled) { strBuffer += _("Running, high priority"); } else { strBuffer += _("Running"); } #if 0 // doesn't work - project pointer not there if (result->project->non_cpu_intensive) { strBuffer += _(" (non-CPU-intensive)"); } #endif } else if (result->scheduler_state == CPU_SCHED_PREEMPTED) { strBuffer += _("Waiting to run"); } else if (result->scheduler_state == CPU_SCHED_UNINITIALIZED) { strBuffer += _("Ready to start"); } if (result->resources.size()) { strBuffer += wxString(wxT(" (")) + wxString(result->resources.c_str(), wxConvUTF8) + wxString(wxT(")")); } } else { strBuffer += _("Ready to start"); } if (result->gpu_mem_wait) { strBuffer += _(" (waiting for GPU memory)"); } break; case RESULT_COMPUTE_ERROR: strBuffer += _("Computation error"); break; case RESULT_FILES_UPLOADING: if (result->ready_to_report) { strBuffer += _("Upload failed"); } else { strBuffer += _("Uploading"); if (status.network_suspend_reason) { strBuffer += _(" (suspended)"); } } break; case RESULT_ABORTED: switch(result->exit_status) { case ERR_ABORTED_VIA_GUI: strBuffer += _("Aborted by user"); break; case ERR_ABORTED_BY_PROJECT: strBuffer += _("Aborted by project"); break; case ERR_UNSTARTED_LATE: strBuffer += _("Aborted: not started by deadline"); break; default: strBuffer += _("Aborted"); } break; default: if (result->got_server_ack) { strBuffer += _("Acknowledged"); } else if (result->ready_to_report) { strBuffer += _("Ready to report"); } else { strBuffer.Format(_("Error: invalid state '%d'"), result->state); } break; } }
void CSimpleFrame::OnConnect(CFrameEvent& WXUNUSED(event)) { wxLogTrace(wxT("Function Start/End"), wxT("CSimpleFrame::OnConnect - Function Begin")); CMainDocument* pDoc = wxGetApp().GetDocument(); CWizardAttach* pWizard = NULL; wxString strComputer = wxEmptyString; wxString strName = wxEmptyString; wxString strURL = wxEmptyString; wxString strTeamName = wxEmptyString; std::string strProjectName; std::string strProjectURL; std::string strProjectAuthenticator; std::string strProjectInstitution; std::string strProjectDescription; std::string strProjectKnown; bool bCachedCredentials = false; ACCT_MGR_INFO ami; PROJECT_INIT_STATUS pis; CC_STATUS status; int wasShown = 0; int wasVisible = 0; wxASSERT(pDoc); wxASSERT(wxDynamicCast(pDoc, CMainDocument)); pDoc->ForceCacheUpdate(); pDoc->GetCoreClientStatus(status, true); // If we are connected to the localhost, run a really quick screensaver // test to trigger a firewall popup. pDoc->GetConnectedComputerName(strComputer); if (pDoc->IsComputerNameLocal(strComputer)) { wxGetApp().StartBOINCScreensaverTest(); wxGetApp().StartBOINCDefaultScreensaverTest(); } pDoc->rpc.get_project_init_status(pis); pDoc->rpc.acct_mgr_info(ami); if (detect_simple_account_credentials( strProjectName, strProjectURL, strProjectAuthenticator, strProjectInstitution, strProjectDescription, strProjectKnown ) ){ if (!pDoc->project((char*)strProjectURL.c_str())) { wasShown = IsShown(); Show(); wasVisible = wxGetApp().IsApplicationVisible(); if (!wasVisible) { wxGetApp().ShowApplication(true); } pWizard = new CWizardAttach(this); pWizard->RunSimpleProjectAttach( wxURI::Unescape(strProjectName), wxURI::Unescape(strProjectURL), wxURI::Unescape(strProjectAuthenticator), wxURI::Unescape(strProjectInstitution), wxURI::Unescape(strProjectDescription), wxURI::Unescape(strProjectKnown) ); } } else if (ami.acct_mgr_url.size() && ami.have_credentials) { // Fall through // // There isn't a need to bring up the attach wizard, the account manager will // take care of ataching to projects when it completes the RPCs // } else if (ami.acct_mgr_url.size() && !ami.have_credentials) { wasShown = IsShown(); Show(); wasVisible = wxGetApp().IsApplicationVisible(); if (!wasVisible) { wxGetApp().ShowApplication(true); } pWizard = new CWizardAttach(this); if (pWizard->SyncToAccountManager()) { // _GRIDREPUBLIC, _PROGRESSTHRUPROCESSORS and _CHARITYENGINE // are defined for those branded builds on Windows only #if defined(_GRIDREPUBLIC) || defined(_PROGRESSTHRUPROCESSORS) || defined(_CHARITYENGINE) || defined(__WXMAC__) #ifdef __WXMAC__ // For GridRepublic, Charity Engine or ProgressThruProcessors, // the Mac installer put a branding file in our data directory long iBrandID = 0; // 0 is unbranded (default) BOINC FILE *f = boinc_fopen("/Library/Application Support/BOINC Data/Branding", "r"); if (f) { fscanf(f, "BrandId=%ld\n", &iBrandID); fclose(f); } if ((iBrandID > 0) && (iBrandID < 4)) #endif { // If successful, hide the main window if we showed it if (!wasVisible) { wxGetApp().ShowApplication(false); } #ifndef __WXMAC__ // See comment in CBOINCGUIApp::OnFinishInit() if (!wasShown) { Hide(); } #endif } #endif } } else if ((pis.url.size() || (0 >= pDoc->GetSimpleProjectCount())) && !status.disallow_attach) { Show(); wxGetApp().ShowApplication(true); strURL = wxString(pis.url.c_str(), wxConvUTF8); bCachedCredentials = pis.url.length() && pis.has_account_key; pWizard = new CWizardAttach(this); pWizard->Run(strURL, bCachedCredentials); } if (pWizard) { pWizard->Destroy(); m_pBackgroundPanel->UpdateProjectView(); } wxLogTrace(wxT("Function Start/End"), wxT("CSimpleFrame::OnConnect - Function End")); }