// Keeps the progress bar updated, even when the process is otherwise busy. static void *progress_thread(void *cookie) { for (;;) { usleep(1000000 / PROGRESSBAR_INDETERMINATE_FPS); pthread_mutex_lock(&gUpdateMutex); // update the progress bar animation, if active // skip this if we have a text overlay (too expensive to update) if (gProgressBarType == PROGRESSBAR_TYPE_INDETERMINATE) { update_progress_locked(); } // move the progress bar forward on timed intervals, if configured int duration = gProgressScopeDuration; if (gProgressBarType == PROGRESSBAR_TYPE_NORMAL && duration > 0) { int elapsed = time(NULL) - gProgressScopeTime; float progress = 1.0 * elapsed / duration; if (progress > 1.0) progress = 1.0; if (progress > gProgress) { gProgress = progress; update_progress_locked(); } } pthread_mutex_unlock(&gUpdateMutex); } return NULL; }
void ui_show_indeterminate_progress() { pthread_mutex_lock(&gUpdateMutex); if (gProgressBarType != PROGRESSBAR_TYPE_INDETERMINATE) { gProgressBarType = PROGRESSBAR_TYPE_INDETERMINATE; update_progress_locked(); } pthread_mutex_unlock(&gUpdateMutex); }
void ScreenRecoveryUI::progress_loop() { double interval = 1.0 / animation_fps; for (;;) { double start = now(); pthread_mutex_lock(&updateMutex); int redraw = 0; // update the installation animation, if active // skip this if we have a text overlay (too expensive to update) if ((currentIcon == INSTALLING_UPDATE || currentIcon == ERASING) && installing_frames > 0 && !show_text) { installingFrame = (installingFrame + 1) % installing_frames; redraw = 1; } // update the progress bar animation, if active // skip this if we have a text overlay (too expensive to update) if (progressBarType == INDETERMINATE && !show_text) { redraw = 1; } // move the progress bar forward on timed intervals, if configured int duration = progressScopeDuration; if (progressBarType == DETERMINATE && duration > 0) { double elapsed = now() - progressScopeTime; float p = 1.0 * elapsed / duration; if (p > 1.0) p = 1.0; if (p > progress) { progress = p; redraw = 1; } } if (redraw) update_progress_locked(); #ifdef VENDOR_EDIT //[email protected], 2012/06/11, Add for scroll the line when the string is too long if (show_text && show_menu && (gFocusScrollState == FOCUSSTATE_TYPE_SCROLL)){ cur_point = cur_point - SCROLL_STEP; if (cur_point + focus_line_length < 5){ cur_point = 20; } //if the focus line need to scroll, we should refresh the screen update_screen_locked(); } #endif /* VENDOR_EDIT */ pthread_mutex_unlock(&updateMutex); double end = now(); // minimum of 20ms delay between frames double delay = interval - (end-start); if (delay < 0.02) delay = 0.02; usleep((long)(delay * 1000000)); } }
void ScreenRecoveryUI::ShowProgress(float portion, float seconds) { pthread_mutex_lock(&updateMutex); progressBarType = DETERMINATE; progressScopeStart += progressScopeSize; progressScopeSize = portion; progressScopeTime = now(); progressScopeDuration = seconds; progress = 0; update_progress_locked(); pthread_mutex_unlock(&updateMutex); }
void ScreenRecoveryUI::SetProgressType(ProgressType type) { pthread_mutex_lock(&updateMutex); if (progressBarType != type) { progressBarType = type; } progressScopeStart = 0; progressScopeSize = 0; progress = 0; update_progress_locked(); pthread_mutex_unlock(&updateMutex); }
void ui_show_progress(float portion, int seconds) { pthread_mutex_lock(&gUpdateMutex); gProgressBarType = PROGRESSBAR_TYPE_NORMAL; gProgressScopeStart += gProgressScopeSize; gProgressScopeSize = portion; gProgressScopeTime = now(); gProgressScopeDuration = seconds; gProgress = 0; update_progress_locked(); pthread_mutex_unlock(&gUpdateMutex); }
void ScreenRecoveryUI::SetProgressType(ProgressType type) { pthread_mutex_lock(&updateMutex); if (progressBarType != type) { progressBarType = type; update_progress_locked(); } progressScopeStart = 0; progress = 0; #if 1 //wschen 2012-07-31 progressScopeSize = 0; #endif pthread_mutex_unlock(&updateMutex); }
void ScreenRecoveryUI::ShowProgress(float portion, float seconds) { DataManager::SetValue("ui_progress_portion", (float)(portion * 100.0)); DataManager::SetValue("ui_progress_frames", seconds * 30); pthread_mutex_lock(&updateMutex); progressBarType = DETERMINATE; progressScopeStart += progressScopeSize; progressScopeSize = portion; progressScopeTime = now(); progressScopeDuration = seconds; progress = 0; update_progress_locked(); pthread_mutex_unlock(&updateMutex); }
void ScreenRecoveryUI::SetProgress(float fraction) { pthread_mutex_lock(&updateMutex); if (fraction < 0.0) fraction = 0.0; if (fraction > 1.0) fraction = 1.0; if (progressBarType == DETERMINATE && fraction > progress) { // Skip updates that aren't visibly different. int width = gr_get_width(progressBarEmpty); float scale = width * progressScopeSize; if ((int) (progress * scale) != (int) (fraction * scale)) { progress = fraction; update_progress_locked(); } } pthread_mutex_unlock(&updateMutex); }
// Keeps the progress bar updated, even when the process is otherwise busy. static void *progress_thread(void *cookie) { double interval = 1.0 / ui_parameters.update_fps; for (;;) { double start = now(); pthread_mutex_lock(&gUpdateMutex); int redraw = 0; // update the installation animation, if active // skip this if we have a text overlay (too expensive to update) if (gCurrentIcon == BACKGROUND_ICON_INSTALLING && ui_parameters.installing_frames > 0 && !show_text) { gInstallingFrame = (gInstallingFrame + 1) % ui_parameters.installing_frames; redraw = 1; } // update the progress bar animation, if active // skip this if we have a text overlay (too expensive to update) if (gProgressBarType == PROGRESSBAR_TYPE_INDETERMINATE && !show_text) { redraw = 1; } // move the progress bar forward on timed intervals, if configured int duration = gProgressScopeDuration; if (gProgressBarType == PROGRESSBAR_TYPE_NORMAL && duration > 0) { double elapsed = now() - gProgressScopeTime; float progress = 1.0 * elapsed / duration; if (progress > 1.0) progress = 1.0; if (progress > gProgress) { gProgress = progress; redraw = 1; } } if (redraw) update_progress_locked(); pthread_mutex_unlock(&gUpdateMutex); double end = now(); // minimum of 20ms delay between frames double delay = interval - (end-start); if (delay < 0.02) delay = 0.02; usleep((long)(delay * 1000000)); } return NULL; }
void ui_set_progress(float fraction) { pthread_mutex_lock(&gUpdateMutex); if (fraction < 0.0) fraction = 0.0; if (fraction > 1.0) fraction = 1.0; if (gProgressBarType == PROGRESSBAR_TYPE_NORMAL && fraction > gProgress) { // Skip updates that aren't visibly different. int width = gr_get_width(gProgressBarIndeterminate[0]); float scale = width * gProgressScopeSize; if ((int) (gProgress * scale) != (int) (fraction * scale)) { gProgress = fraction; update_progress_locked(); } } pthread_mutex_unlock(&gUpdateMutex); }
void ScreenRecoveryUI::ProgressThreadLoop() { double interval = 1.0 / animation_fps; while (true) { double start = now(); pthread_mutex_lock(&updateMutex); bool redraw = false; // update the installation animation, if active // skip this if we have a text overlay (too expensive to update) if ((currentIcon == INSTALLING_UPDATE || currentIcon == ERASING) && !show_text) { if (!intro_done) { if (current_frame == intro_frames - 1) { intro_done = true; current_frame = 0; } else { ++current_frame; } } else { current_frame = (current_frame + 1) % loop_frames; } redraw = true; } // move the progress bar forward on timed intervals, if configured int duration = progressScopeDuration; if (progressBarType == DETERMINATE && duration > 0) { double elapsed = now() - progressScopeTime; float p = 1.0 * elapsed / duration; if (p > 1.0) p = 1.0; if (p > progress) { progress = p; redraw = true; } } if (redraw) update_progress_locked(); pthread_mutex_unlock(&updateMutex); double end = now(); // minimum of 20ms delay between frames double delay = interval - (end-start); if (delay < 0.02) delay = 0.02; usleep((long)(delay * 1000000)); } }
void ScreenRecoveryUI::SetProgress(float fraction) { DataManager::SetValue("ui_progress", (float) (fraction * 100.0)); return; pthread_mutex_lock(&updateMutex); if (fraction < 0.0) fraction = 0.0; if (fraction > 1.0) fraction = 1.0; if (progressBarType == DETERMINATE && fraction > progress) { // Skip updates that aren't visibly different. int width = gr_get_width(progressBarIndeterminate[0]); float scale = width * progressScopeSize; if ((int) (progress * scale) != (int) (fraction * scale)) { progress = fraction; update_progress_locked(); } } pthread_mutex_unlock(&updateMutex); }
void ScreenRecoveryUI::progress_loop() { double interval = 1.0 / animation_fps; for (;;) { double start = now(); pthread_mutex_lock(&updateMutex); int redraw = 0; // update the installation animation, if active // skip this if we have a text overlay (too expensive to update) if ((currentIcon == INSTALLING_UPDATE || currentIcon == ERASING) && installing_frames > 0 && !show_text) { installingFrame = (installingFrame + 1) % installing_frames; redraw = 1; } // update the progress bar animation, if active // skip this if we have a text overlay (too expensive to update) if (progressBarType == INDETERMINATE && !show_text) { redraw = 1; } // move the progress bar forward on timed intervals, if configured int duration = progressScopeDuration; if (progressBarType == DETERMINATE && duration > 0) { double elapsed = now() - progressScopeTime; float p = 1.0 * elapsed / duration; if (p > 1.0) p = 1.0; if (p > progress) { progress = p; redraw = 1; } } if (redraw) update_progress_locked(); pthread_mutex_unlock(&updateMutex); double end = now(); // minimum of 20ms delay between frames double delay = interval - (end-start); if (delay < 0.02) delay = 0.02; usleep((long)(delay * 1000000)); } }
// Keeps the progress bar updated, even when the process is otherwise busy. static void *progress_thread(void *cookie) { double interval = 1.0 / ui_parameters.update_fps; for (;;) { double start = now(); pthread_mutex_lock(&gUpdateMutex); int redraw = 0; // update the progress bar animation, if active // update the spinning cube animation, even if no progress bar if (gProgressBarType == PROGRESSBAR_TYPE_INDETERMINATE || gCurrentIcon == BACKGROUND_ICON_INSTALLING) { redraw = 1; } // move the progress bar forward on timed intervals, if configured int duration = gProgressScopeDuration; if (gProgressBarType == PROGRESSBAR_TYPE_NORMAL) { if (duration > 0) { double elapsed = now() - gProgressScopeTime; float progress = 1.0 * elapsed / duration; if (progress > 1.0) progress = 1.0; if (progress > gProgress) { gProgress = progress; redraw = 1; } } } if (redraw) update_progress_locked(); pthread_mutex_unlock(&gUpdateMutex); double end = now(); // minimum of 20ms delay between frames double delay = interval - (end-start); if (delay < 0.02) delay = 0.02; usleep((long)(delay * 1000000)); } return NULL; }