static void ex_update() { log_msg("EXCMD", "check_update"); if ((ex.state & EX_HIST)) return menu_update(ex.menu, &ex.cmd); int cur = ex.curofs - 1; int pos = compl_cur_pos(); char ch = ex_cmd_curch(); bool root = compl_isroot(); Token *tok = ex_cmd_curtok(); char *str = token_val(tok, VAR_STRING); bool quote = ((str && (*str == '\'' || *str == '\"')) || (tok && tok->quoted)); if (ch == '|' && !quote && (pos < cur || !root)) { menu_restart(ex.menu); ex.state = 0; } else if (ch == '!' && !quote && root && pos == cur) { ex.state &= EX_EXEC; return compl_set_exec(ex.curofs); } menu_update(ex.menu, &ex.cmd); }
void File_Browser::bookmark_del_callback(const List<int> & in) { const List<String> & bookmark = File_Browser_Prefs::global()->bookmark(); List<String> tmp; for (size_t i = 0; i < bookmark.size(); ++i) { size_t j = 0; for (; j < in.size(); ++j) if (in[j] == static_cast<int>(i)) { break; } if (j < in.size()) { continue; } tmp += bookmark[i]; } File_Browser_Prefs::global()->bookmark(tmp); menu_update(); }
eOSState pagebase::ProcessKey(eKeys key) { bool hadSubMenu = HasSubMenu(); if (!hadSubMenu && key == kBack && !menu_closing()) return osContinue; int current = Current(); eOSState state = cOsdMenu::ProcessKey(key); if (hadSubMenu && HasSubMenu()) return state; if (state == osUnknown) state = dispatch_key(key); else if (state == osContinue && (current != Current() || key == kOk || key == kBack)) set_help_keys(); if ( current >= Count() ) return state; menu_item_base& item = dynamic_cast< menu_item_base& >( *Get( current ) ); if ( !item.is_editing() ) { menu_update(); } return state; }
void main_timer_update(main_timer_t *timer) { #ifdef __DEBUG assert(timer!=NULL); assert(main_timer_valid(timer)==1); #endif menu_update(&timer->menu); unsigned char pause_status=menu_get_pause_value(&timer->menu); if(pause_status==SET){ //to pause hardware timer TMR1ON=NOT_SET; if(time_is_zero(&timer->time)==1&&timer->flags.dont_reset==NOT_SET) main_timer_initialize(timer); else{ time_change_piece(&timer->time, *menu_get_deltaT(&timer->menu), *menu_get_time_to_change(&timer->menu)); timer->flags.segments_flag=SET; } } else TMR1ON=SET;/*to unpause hardware timer*/ if(TMR1IF==SET){ TMR1IF=NOT_SET; if(time_decrease(&timer->time)==SET){ timer->flags.music_flag=SET; timer->flags.segments_flag=SET; } } main_timer_fill_output_buffer(timer); }
void File_Browser::dirty() { //DJV_DEBUG("File_Browser::dirty"); Dialog::dirty(); // Update tooltips. const List<Shortcut> & shortcut = File_Browser_Prefs::global()->shortcut(); _value_widget->tooltip(tooltip_value); _up_widget->tooltip(String_Format(tooltip_up). arg(Shortcut::label(shortcut[File_Browser_Prefs::UP].value))); _prev_widget->tooltip(String_Format(tooltip_prev). arg(Shortcut::label(shortcut[File_Browser_Prefs::PREV].value))); _reload_widget->tooltip(String_Format(tooltip_reload). arg(Shortcut::label(shortcut[File_Browser_Prefs::RELOAD].value))); // General updates. if (visible() && shown()) { directory_update(); } menu_update(); }
enum state wiimote_send_event(enum state state, struct game* game, SDLKey key, key_event_t key_event) { switch (state) { case GAME: assert(game); return(game_update(state, game, key, key_event)); break; default: break; } return(menu_update(state, key, key_event)); }
// // Go back in the menu hierachy after the left key has been pressed // in an applet (or double clicked) // static void menu_back_after_applet() { void (*callback)(int) = g_menu[g_index][g_item].activate; //printf("Item %d %x\r\n", g_item, callback); if (callback) callback(0); // deactivate g_item = -1; menu_update(); g_menu_applet = NULL; menu_run_callback(1); }
void File_Browser::sort(SORT in) { if (in == _sort) { return; } _sort = in; _prefs->sort(_sort); directory_update(); menu_update(); }
int main() { // Peripheral initialisation I2C_init(); LCD_init(); LCD_write("Loading..."); DEBUG_init(); // Function initialisation WAVE_init(); synth_init(); CAN_init(); menu_display(); while (1) { menu_update(); } // Keypad for synth debugging /*int down = 0; int key = -1; while(1) { key = KEYPAD_get_key(); if ((key != -1) && !down) { int note = 69+key; synth_note_on(note_to_freq(note),1.0); LCD_write_int("%d",note_to_freq(note)); down = 1; } if ((key == -1) && down) { synth_note_off(1.0); LCD_clear(); down = 0; } }*/ // Loop to allow interupts while(1); return(1); }
void File_Browser::sort_directory(bool in) { if (in == _sort_directory) { return; } _sort_directory = in; _prefs->sort_directory(_sort_directory); directory_update(); menu_update(); }
void File_Browser::hidden(bool in) { if (in == _hidden) { return; } _hidden = in; _prefs->hidden(_hidden); directory_update(); menu_update(); }
void File_Browser::sort_reverse(bool in) { if (in == _sort_reverse) { return; } _sort_reverse = in; _prefs->sort_reverse(_sort_reverse); directory_update(); menu_update(); }
void File_Browser::image(IMAGE in) { if (in == _image) { return; } _image = in; _prefs->image(_image); directory_update(); menu_update(); }
void File_Browser::seq(Seq::COMPRESS in) { if (in == _seq) { return; } _seq = in; _prefs->seq(_seq); directory_update(); widget_update(); menu_update(); }
void File_Browser::type(int in) { if (in == _type) { return; } _type = in; _prefs->type(_type); directory_update(); type_update(); menu_update(); }
/**********MAIN ROUTINE*************/ int main(int argc, char** argv) { //char i = '0'; config_init(); lcdInit(); lcdWriteStrC("Counting test: "); while (1) { /* lcdSetPos(0,1); lcdWriteChar(i++); if(i > '9') i = '0'; for(int j = 0; j < 10; j++) __delay_ms(50); */ menu = read_button(); // wait for any changes in buttons menu_update(menu); } return (EXIT_SUCCESS); }
void File_Browser::ok_callback(bool) { //DJV_DEBUG("File_Browser::ok_callback"); //DJV_DEBUG_PRINT("value = " << _value); //DJV_DEBUG_PRINT("value type = " << _value.type()); //DJV_DEBUG_PRINT("value seq = " << _value.seq()); File_Browser_Prefs::global()->recent_add(_value.path()); if (! _pin) { hide(); } menu_update(); signal.emit(_value); }
/** * menu_select - selects the next idle state to enter * @drv: cpuidle driver containing state data * @dev: the CPU */ static int menu_select(struct cpuidle_driver *drv, struct cpuidle_device *dev) { struct menu_device *data = &__get_cpu_var(menu_devices); int latency_req = pm_qos_request(PM_QOS_CPU_DMA_LATENCY); int i; int multiplier; struct timespec t; if (data->needs_update) { menu_update(drv, dev); data->needs_update = 0; } data->last_state_idx = 0; data->exit_us = 0; /* Special case when user has set very strict latency requirement */ if (unlikely(latency_req == 0)) return 0; /* determine the expected residency time, round up */ t = ktime_to_timespec(tick_nohz_get_sleep_length()); data->expected_us = t.tv_sec * USEC_PER_SEC + t.tv_nsec / NSEC_PER_USEC; data->bucket = which_bucket(data->expected_us); multiplier = performance_multiplier(); /* * if the correction factor is 0 (eg first time init or cpu hotplug * etc), we actually want to start out with a unity factor. */ if (data->correction_factor[data->bucket] == 0) data->correction_factor[data->bucket] = RESOLUTION * DECAY; /* Make sure to round up for half microseconds */ #ifdef CONFIG_SKIP_IDLE_CORRELATION if (dev->skip_idle_correlation) data->predicted_us = data->expected_us; else #endif data->predicted_us = div_round64(data->expected_us * data->correction_factor[data->bucket], RESOLUTION * DECAY); /* This patch is not checked */ #ifndef CONFIG_CPU_THERMAL_IPA get_typical_interval(data); #else /* * HACK - Ignore repeating patterns when we're * forecasting a very large idle period. */ if(data->predicted_us < MAX_INTERESTING) get_typical_interval(data); #endif /* * We want to default to C1 (hlt), not to busy polling * unless the timer is happening really really soon. */ if (data->expected_us > 5 && !drv->states[CPUIDLE_DRIVER_STATE_START].disabled && dev->states_usage[CPUIDLE_DRIVER_STATE_START].disable == 0) data->last_state_idx = CPUIDLE_DRIVER_STATE_START; /* * Find the idle state with the lowest power while satisfying * our constraints. */ for (i = CPUIDLE_DRIVER_STATE_START; i < drv->state_count; i++) { struct cpuidle_state *s = &drv->states[i]; struct cpuidle_state_usage *su = &dev->states_usage[i]; if (s->disabled || su->disable) continue; if (s->target_residency > data->predicted_us) continue; if (s->exit_latency > latency_req) continue; if (s->exit_latency * multiplier > data->predicted_us) continue; data->last_state_idx = i; data->exit_us = s->exit_latency; } return data->last_state_idx; }
/** * menu_select - selects the next idle state to enter * @drv: cpuidle driver containing state data * @dev: the CPU */ static int menu_select(struct cpuidle_driver *drv, struct cpuidle_device *dev) { struct menu_device *data = &__get_cpu_var(menu_devices); int latency_req = pm_qos_request(PM_QOS_CPU_DMA_LATENCY); int power_usage = INT_MAX; int i; int multiplier; struct timespec t; int repeat = 0, low_predicted = 0; int cpu = smp_processor_id(); struct hrtimer *hrtmr = &per_cpu(menu_hrtimer, cpu); if (data->needs_update) { menu_update(drv, dev); data->needs_update = 0; } data->last_state_idx = 0; data->exit_us = 0; /* Special case when user has set very strict latency requirement */ if (unlikely(latency_req == 0)) return 0; /* determine the expected residency time, round up */ t = ktime_to_timespec(tick_nohz_get_sleep_length()); data->expected_us = t.tv_sec * USEC_PER_SEC + t.tv_nsec / NSEC_PER_USEC; data->bucket = which_bucket(data->expected_us); multiplier = performance_multiplier(); /* * if the correction factor is 0 (eg first time init or cpu hotplug * etc), we actually want to start out with a unity factor. */ if (data->correction_factor[data->bucket] == 0) data->correction_factor[data->bucket] = RESOLUTION * DECAY; /* Make sure to round up for half microseconds */ data->predicted_us = div_round64(data->expected_us * data->correction_factor[data->bucket], RESOLUTION * DECAY); repeat = get_typical_interval(data); /* * We want to default to C1 (hlt), not to busy polling * unless the timer is happening really really soon. */ if (data->expected_us > 5 && dev->states_usage[CPUIDLE_DRIVER_STATE_START].disable == 0) data->last_state_idx = CPUIDLE_DRIVER_STATE_START; /* * Find the idle state with the lowest power while satisfying * our constraints. */ for (i = CPUIDLE_DRIVER_STATE_START; i < drv->state_count; i++) { struct cpuidle_state *s = &drv->states[i]; struct cpuidle_state_usage *su = &dev->states_usage[i]; if (su->disable) continue; if (s->target_residency > data->predicted_us) { low_predicted = 1; continue; } if (s->exit_latency > latency_req) continue; if (s->exit_latency * multiplier > data->predicted_us) continue; if (s->power_usage < power_usage) { power_usage = s->power_usage; data->last_state_idx = i; data->exit_us = s->exit_latency; } } /* not deepest C-state chosen for low predicted residency */ if (low_predicted) { unsigned int timer_us = 0; unsigned int perfect_us = 0; /* * Set a timer to detect whether this sleep is much * longer than repeat mode predicted. If the timer * triggers, the code will evaluate whether to put * the CPU into a deeper C-state. * The timer is cancelled on CPU wakeup. */ timer_us = 2 * (data->predicted_us + MAX_DEVIATION); perfect_us = perfect_cstate_ms * 1000; if (repeat && (4 * timer_us < data->expected_us)) { hrtimer_start(hrtmr, ns_to_ktime(1000 * timer_us), HRTIMER_MODE_REL_PINNED); /* In repeat case, menu hrtimer is started */ per_cpu(hrtimer_status, cpu) = MENU_HRTIMER_REPEAT; } else if (perfect_us < data->expected_us) { /* * The next timer is long. This could be because * we did not make a useful prediction. * In that case, it makes sense to re-enter * into a deeper C-state after some time. */ hrtimer_start(hrtmr, ns_to_ktime(1000 * timer_us), HRTIMER_MODE_REL_PINNED); /* In general case, menu hrtimer is started */ per_cpu(hrtimer_status, cpu) = MENU_HRTIMER_GENERAL; } } return data->last_state_idx; }
/** * menu_select - selects the next idle state to enter * @dev: the CPU */ static int menu_select(struct cpuidle_device *dev) { struct menu_device *data = &__get_cpu_var(menu_devices); int latency_req = pm_qos_request(PM_QOS_CPU_DMA_LATENCY); int int_vote_req = pm_qos_request(PM_QOS_CPU_INT_LATENCY); unsigned int power_usage = -1; int i; int multiplier; struct timespec t; unsigned int timer_id = 0; unsigned int schedule_time = 0xffffffff; if (data->needs_update) { menu_update(dev); data->needs_update = 0; } data->last_state_idx = 0; data->exit_us = 0; if (unlikely(int_vote_req != PM_QOS_CPUIDLE_INT_DEFAULT_VALUE)) { PRINT_PWC_DBG(PWC_SWITCH_CPUIDLE,"menu_select,int_vote_req=0x%x\n",int_vote_req); return 0; } if(num_online_cpus() > 1) return 0; pwrctrl_sleep_mgr_get_next_schedule_time(0, &timer_id, &schedule_time); if(schedule_time > (0xFFFFFFFF / 1000)) { schedule_time = 0xFFFFFFFF; } else { schedule_time *= USEC_PER_MSEC; } /* Special case when user has set very strict latency requirement */ if (unlikely(latency_req == 0)) return 0; /* determine the expected residency time, round up */ t = ktime_to_timespec(tick_nohz_get_sleep_length()); data->expected_us = t.tv_sec * USEC_PER_SEC + t.tv_nsec / NSEC_PER_USEC; PRINT_PWC_DBG(PWC_SWITCH_CPUIDLE,"menu_select,data->expected_us=%d,schedule_time=%d\n",data->expected_us,schedule_time); if(schedule_time < data->expected_us) { /*PRINT_PWC_DBG(PWC_SWITCH_CPUIDLE,"menu_select,system time:%d private time:%d\n",data->expected_us, schedule_time);*/ data->expected_us = schedule_time; } data->bucket = which_bucket(data->expected_us); multiplier = performance_multiplier(); /* * if the correction factor is 0 (eg first time init or cpu hotplug * etc), we actually want to start out with a unity factor. */ if (data->correction_factor[data->bucket] == 0) data->correction_factor[data->bucket] = RESOLUTION * DECAY; /* Make sure to round up for half microseconds */ data->predicted_us = div_round64(data->expected_us * data->correction_factor[data->bucket], RESOLUTION * DECAY); detect_repeating_patterns(data); /* * We want to default to C1 (hlt), not to busy polling * unless the timer is happening really really soon. */ if (data->expected_us > 5) data->last_state_idx = CPUIDLE_DRIVER_STATE_START; /* * Find the idle state with the lowest power while satisfying * our constraints. */ PRINT_PWC_DBG(PWC_SWITCH_CPUIDLE,"menu_select,multiplier=%d, latency_req=%d, predicted_us=%llu\n", multiplier,latency_req, data->predicted_us); for (i = CPUIDLE_DRIVER_STATE_START; i < dev->state_count; i++) { struct cpuidle_state *s = &dev->states[i]; if (s->flags & CPUIDLE_FLAG_IGNORE) continue; if (s->target_residency > data->predicted_us) continue; if (s->exit_latency > latency_req) continue; if (s->exit_latency * multiplier > data->predicted_us) continue; if (s->power_usage < power_usage) { power_usage = s->power_usage; data->last_state_idx = i; data->exit_us = s->exit_latency; } } return data->last_state_idx; }
/** * menu_select - selects the next idle state to enter * @dev: the CPU */ static int menu_select(struct cpuidle_device *dev) { struct menu_device *data = &__get_cpu_var(menu_devices); int latency_req = pm_qos_request(PM_QOS_CPU_DMA_LATENCY); unsigned int power_usage = -1; int i; int multiplier; struct timespec t; if (data->needs_update) { menu_update(dev); data->needs_update = 0; } data->last_state_idx = 0; data->exit_us = 0; /* Special case when user has set very strict latency requirement */ if (unlikely(latency_req == 0)) return 0; /* determine the expected residency time, round up */ t = ktime_to_timespec(tick_nohz_get_sleep_length()); data->expected_us = t.tv_sec * USEC_PER_SEC + t.tv_nsec / NSEC_PER_USEC; data->bucket = which_bucket(data->expected_us); multiplier = performance_multiplier(); /* * if the correction factor is 0 (eg first time init or cpu hotplug * etc), we actually want to start out with a unity factor. */ if (data->correction_factor[data->bucket] == 0) data->correction_factor[data->bucket] = RESOLUTION * DECAY; /* Make sure to round up for half microseconds */ data->predicted_us = div_round64(data->expected_us * data->correction_factor[data->bucket], RESOLUTION * DECAY); detect_repeating_patterns(data); /* * We want to default to C1 (hlt), not to busy polling * unless the timer is happening really really soon. */ if (data->expected_us > 5) data->last_state_idx = CPUIDLE_DRIVER_STATE_START; /* * Find the idle state with the lowest power while satisfying * our constraints. */ for (i = CPUIDLE_DRIVER_STATE_START; i < dev->state_count; i++) { struct cpuidle_state *s = &dev->states[i]; if (s->flags & CPUIDLE_FLAG_IGNORE) continue; if (s->target_residency > data->predicted_us) continue; if (s->exit_latency > latency_req) continue; if (s->exit_latency * multiplier > data->predicted_us) continue; if (s->power_usage < power_usage) { power_usage = s->power_usage; data->last_state_idx = i; data->exit_us = s->exit_latency; } } return data->last_state_idx; }
void ISR(_TIMER_1_VECTOR,IPL1AUTO) clock_refresh(void) { uint32_t static average; uint16_t tmp; draw_markers(); /* hours ---------------------------------- */ tmp = (5 * (date.hours % 12)) + date.minutes / 11; libpixel_set(pixels, (tmp + 59) % 60, color.hr.r, color.hr.g, color.hr.b); libpixel_set(pixels, tmp % 60, color.hr.r, color.hr.g, color.hr.b); libpixel_set(pixels, (tmp + 1) % 60, color.hr.r, color.hr.g, color.hr.b); /* minutes --------------------------------- */ libpixel_set(pixels, date.minutes, color.mn.r - color.mn.r * (date.seconds) / 59, color.mn.g - color.mn.g * (date.seconds) / 59, color.mn.b - color.mn.b * (date.seconds) / 59); libpixel_set(pixels, (date.minutes + 1) % 60, color.mn.r * (date.seconds) / 59, color.mn.g * (date.seconds) / 59, color.mn.b * (date.seconds / 59)); /* seconds --------------------------------- */ libpixel_set(pixels, date.seconds, color.sc.r, color.sc.g, color.sc.b); sample_brightness(&average); libpixel_brightness(pixels, 255 * (average - 130) / 1023); libpixel_show(pixels); if (!(date.millis)) menu_update(menu, lcd); date.millis = (date.millis + 100) % 1000 ; if (!date.millis) { date.seconds = (date.seconds + 1) % 60; if (!date.seconds) { date.minutes = (date.minutes + 1) % 60; if (!date.minutes) { date.hours = (date.hours + 1) % 24; if (!date.hours) { date.day = date.day % 31 + 1; if (!date.day) { date.month = date.month % 12 + 1; if (!date.month) { date.year = (date.year + 1); } } if (date.day > long_month(date.month, date.year)) date.day = 1; date.day_of_week = tondering_day_of_week(); } } } } IFS0bits.T1IF = 0; }
void PuyoCommander::updateAll(PuyoDrawable *starter, SDL_Surface *extra_surf) { Uint32 now = 0; // mise a jour menu_update (mainMenu, display); menu_update(gameOver2PMenu, display); menu_update(gameOver1PMenu, display); menu_update(nextLevelMenu, display); menu_update(finishedMenu, display); menu_update(looserMenu, display); menu_update (optionMenu, display); menu_update (controlsMenu, display); menu_update (rulesMenu, display); menu_update (highScoresMenu, display); menu_update (aboutMenu, display); menu_update (mustRestartMenu, display); menu_update (singleGameMenu, display); menu_update (twoPlayerGameMenu, display); menu_update (menu_pause,display); scrolling_text_update(scrollingText, display); doom_melt_update(melt); // affichage eventuel (pourrait ne pas avoir lieu de tps en tps si machine // trop lente) cycle++; now = SDL_GetTicks (); if ((now < (start_time + (cycle + TIME_TOLERANCE) * cycle_duration)) || (cycle - lastRenderedCycle > maxFrameDrop)) { lastRenderedCycle = cycle; if (starter) { starter->draw(); } else { SDL_BlitSurface (menuBGImage->surf, NULL, display, NULL); } if (corona) { short frequency[2][512]; for (int i=0; i<512; ++i) { // Generate random sound. frequency[0][i] = rand(); frequency[1][i] = rand(); } corona32_update(corona, SDL_GetTicks(), frequency); corona32_displayRGBA(corona, corona_screen); SDL_Surface *tmpsurf = SDL_CreateRGBSurfaceFrom (corona_screen, 320, CORONA_HEIGHT, 32, 320*4, 0x00ff0000, 0x0000ff00, 0x000000ff, 0xff000000); SDL_Rect rect; rect.x = 0; rect.y = 240 - tmpsurf->h; rect.w = tmpsurf->w; rect.h = tmpsurf->h; SDL_BlitSurface(tmpsurf, NULL, display, &rect); SDL_FreeSurface (tmpsurf); } if (extra_surf) { SDL_Rect rect; rect.x = 0; rect.y = 240 - extra_surf->h; rect.w = extra_surf->w; rect.h = extra_surf->h; SDL_BlitSurface(extra_surf, NULL, display, &rect); } if (!starter) scrolling_text_draw(scrollingText, display, 220); menu_draw (mainMenu, display); menu_draw(gameOver2PMenu, display); menu_draw(gameOver1PMenu, display); menu_draw(nextLevelMenu, display); menu_draw(finishedMenu, display); menu_draw(looserMenu, display); menu_draw (optionMenu, display); menu_draw (controlsMenu, display); menu_draw (rulesMenu, display); menu_draw (highScoresMenu, display); menu_draw (aboutMenu, display); menu_draw (mustRestartMenu, display); menu_draw (singleGameMenu, display); menu_draw (twoPlayerGameMenu, display); menu_draw(menu_pause,display); doom_melt_display(melt, display); SDL_Flip (display); } // delay si machine trop rapide now = SDL_GetTicks (); if (now < (start_time + cycle * cycle_duration)) { int ttw = ((start_time + cycle * cycle_duration) - now); ttw /= 2; SDL_Delay (ttw); } }
void menu_touch(int xx, int yy) { if (g_menu_applet) { if (g_menu_applet(xx, yy)) menu_back_after_applet(); return; } menu_touch_y = yy; menu_touch_x = xx; //menu_update(); int old = g_item; g_item = menu_get_selected(); lcd_lock(); if (old != -1) menu_paint_cell(old); if (g_item != -1) menu_paint_cell(g_item); lcd_release(); if (xx == -1 || yy == -1 || g_item == -1) { if (old != -1) { if (g_menu[g_index][old].press_handler) { g_menu[g_index][old].press_handler(0); } void (*callback)(int) = g_menu[g_index][old].activate; g_crumbs[g_index] = old; if (g_menu[g_index][old].next && g_index < MAX_DEPTH) { g_index++; g_menu[g_index] = g_menu[g_index-1][old].next; menu_update(); } else if (g_menu[g_index][old].touch_handler) { g_menu_applet = g_menu[g_index][old].touch_handler; g_item = old; menu_clear(); } else if (strcmp(g_menu[g_index][old].text, "Back") == 0) { menu_run_callback(0); if (g_index > 0) g_index--; menu_update(); menu_run_callback(1); } // run the callback which should start the applet or update the display if (callback) { callback(1); } } return; } menu_touch_y = 0; menu_touch_x = 0; if (g_menu[g_index][g_item].press_handler) { g_menu[g_index][g_item].press_handler(1); } }
/* ==================================================================== Run menu until request sent ==================================================================== */ int manager_run() { SDL_Event event; int result = ACTION_NONE; int ms; /* draw highscores */ chart_show( chart_set_query_id( chart_id ), cx, cy, cw, ch ); /* loop */ stk_timer_reset(); while ( result == ACTION_NONE && !stk_quit_request ) { menu_hide( cur_menu ); hint_hide(); /* fullscreen if no item selected */ if ( SDL_PollEvent( &event ) ) { if ( cur_menu->cur_item == 0 || (cur_menu->cur_item->type != ITEM_EDIT && cur_menu->cur_item->type != ITEM_KEY ) ) if ( event.type == SDL_KEYDOWN ) if ( event.key.keysym.sym == SDLK_f ) { config.fullscreen = !config.fullscreen; stk_display_apply_fullscreen( config.fullscreen ); stk_surface_blit( mbkgnd, 0,0,-1,-1, stk_display, 0,0 ); stk_display_update( STK_UPDATE_ALL ); } /* check if clicked on highscore */ if ( event.type == SDL_MOUSEBUTTONDOWN ) if ( event.button.x >= cx && event.button.y >= cy ) if ( event.button.x < cx + cw && event.button.y < cy + ch ) { #ifdef AUDIO_ENABLED stk_sound_play( wav_menu_click ); #endif /* set chart id */ if ( event.button.button == STK_BUTTON_LEFT ) { chart_id++; if ( chart_id == charts->count ) chart_id = 0; } else { chart_id--; if ( chart_id == -1 ) chart_id = charts->count - 1; } /* redraw */ stk_surface_blit( mbkgnd, 0,0,-1,-1, stk_display, 0,0 ); chart_show( chart_set_query_id( chart_id ), cx, cy, cw, ch ); } result = menu_handle_event( cur_menu, &event ); } else #ifdef ANDROID stk_surface_blit( mbkgnd, 0,0,-1,-1, stk_display, 0,0 ); #endif menu_handle_event( cur_menu, 0 ); /* update motion */ ms = stk_timer_get_time(); menu_update( cur_menu, ms ); hint_update( ms ); menu_show( cur_menu ); chart_show( chart_set_query_id( chart_id ), cx, cy, cw, ch ); hint_show(); stk_display_update( STK_UPDATE_RECTS ); SDL_Delay( 5 ); } return result; }
void menu_set_root(struct menu *root_menu) { g_menu[0] = root_menu; menu_update(); }
enum state game_update(enum state state, struct game* game, int key, key_event_t key_event) { struct player* players[game->nb_player]; for(int i=0; i<game->nb_player; i++) { players[i] = game->players[i]; } struct map* map = level_get_curr_map(game_get_curr_level(game)); if(game->nb_player == 1 && player_get_key(players[0]) == -1) return(W); if(game->nb_player == 1 && player_get_key(players[0]) == -2) return(GO); if(key_event == DOWN) { switch (key) { case SDLK_p: if(game->game_state == CHOOSE_MAP) break; /* no break */ case SDLK_ESCAPE: // Pause if(game->game_state == PLAYING) { if(game->nb_player == 1) new_menu(PAUSE_SINGLE); else new_menu(PAUSE_MULTI); game->game_state = PAUSED; } else if(game->game_state == PAUSED){ menu_free(NULL); game->game_state = PLAYING; } else if(game->game_state == CHOOSE_MAP) { return ENDGAME; } return GAME; break; case SDLK_RETURN: case SDLK_KP_ENTER: switch(game->game_state) { case PAUSED: switch(menu_update(state, key, key_event)) { case KEEP: menu_free(NULL); game->game_state = PLAYING; break; case MAINMENU: return ENDGAME; break; case QUIT: return(QUIT); break; case SAVEGAME_MAINMENU: file_savegame(game); return ENDGAME; break; case SAVEGAME_QUIT: file_savegame(game); return(QUIT); break; case CHANGEMAP: multi_change_state(game, CHOOSE_MAP); break; default: break; } break; case CHOOSE_MAP: multi_change_state(game, PLAYING); break; case SCORE: if(game_get_score_max(game, 0) < game->score_obj) multi_change_state(game, PLAYING); else multi_change_state(game, CHOOSE_MAP); break; default: break; } break; case SDLK_UP: if(game->game_state == PLAYING){ player_set_way(players[0], NORTH); player_inc_moving(players[0]); } else if (game->game_state == PAUSED) return(menu_update(state, key, key_event)); else if(game->game_state == CHOOSE_MAP) { if(game->pos > 0) { game->pos--; level_set_cur_map(game_get_curr_level(game), game->pos); } } break; case SDLK_DOWN: if(game->game_state == PLAYING){ player_set_way(players[0], SOUTH); player_inc_moving(players[0]); } else if (game->game_state == PAUSED) { return(menu_update(state, key, key_event)); } else if(game->game_state == CHOOSE_MAP) { if(game->pos < sprite_get_nb_map_multi() - 1) { game->pos++; level_set_cur_map(game_get_curr_level(game), game->pos); } } break; case SDLK_RIGHT: if(game->game_state == PLAYING){ player_set_way(players[0], EAST); player_inc_moving(players[0]); } break; case SDLK_LEFT: if(game->game_state == PLAYING){ player_set_way(players[0], WEST); player_inc_moving(players[0]); } break; case SDLK_SPACE: if(game->game_state == PLAYING) bomb_plant(game, map, players[0]); // the bomb is planted if it is possible break; case SDLK_z: if(game->nb_player >= 2) { if(game->game_state == PLAYING){ player_set_way(players[1], NORTH); player_inc_moving(players[1]); } else if (game->game_state == PAUSED) { return(menu_update(state, key, key_event)); } } break; case SDLK_s: if(game->nb_player >= 2) { if(game->game_state == PLAYING){ player_set_way(players[1], SOUTH); player_inc_moving(players[1]); } else if (game->game_state == PAUSED) { return(menu_update(state, key, key_event)); } } break; case SDLK_d: if(game->nb_player >= 2) { if(game->game_state == PLAYING){ player_set_way(players[1], EAST); player_inc_moving(players[1]); } } break; case SDLK_q: if(game->nb_player >= 2) { if(game->game_state == PLAYING){ player_set_way(players[1], WEST); player_inc_moving(players[1]); } } break; case SDLK_a: if(game->nb_player >= 2) { if(game->game_state == PLAYING) bomb_plant(game, map, players[1]); // the bomb is planted if it is possible } break; case SDLK_t: if(game->nb_player >= 3) { if(game->game_state == PLAYING){ player_set_way(players[2], NORTH); player_inc_moving(players[2]); } else if (game->game_state == PAUSED) { return(menu_update(state, key, key_event)); } } break; case SDLK_g: if(game->nb_player >= 3) { if(game->game_state == PLAYING){ player_set_way(players[2], SOUTH); player_inc_moving(players[2]); } else if (game->game_state == PAUSED) { return(menu_update(state, key, key_event)); } } break; case SDLK_h: if(game->nb_player >= 3) { if(game->game_state == PLAYING){ player_set_way(players[2], EAST); player_inc_moving(players[2]); } } break; case SDLK_f: if(game->nb_player >= 3) { if(game->game_state == PLAYING){ player_set_way(players[2], WEST); player_inc_moving(players[2]); } } break; case SDLK_r: if(game->nb_player >= 3) { if(game->game_state == PLAYING) bomb_plant(game, map, players[2]); // the bomb is planted if it is possible } break; case SDLK_i: if(game->nb_player >= 4) { if(game->game_state == PLAYING){ player_set_way(players[3], NORTH); player_inc_moving(players[3]); } else if (game->game_state == PAUSED) { return(menu_update(state, key, key_event)); } } break; case SDLK_k: if(game->nb_player >= 4) { if(game->game_state == PLAYING){ player_set_way(players[3], SOUTH); player_inc_moving(players[3]); } else if (game->game_state == PAUSED) { return(menu_update(state, key, key_event)); } } break; case SDLK_l: if(game->nb_player >= 4) { if(game->game_state == PLAYING){ player_set_way(players[3], EAST); player_inc_moving(players[3]); } } break; case SDLK_j: if(game->nb_player >= 4) { if(game->game_state == PLAYING){ player_set_way(players[3], WEST); player_inc_moving(players[3]); } } break; case SDLK_u: if(game->nb_player >= 4) { if(game->game_state == PLAYING) bomb_plant(game, map, players[3]); // the bomb is planted if it is possible } break; default: break; } } else if(key_event == UP) { switch (key) { case SDLK_UP: player_dec_moving(players[0]); player_unset_way(players[0], NORTH); break; case SDLK_DOWN: player_dec_moving(players[0]); player_unset_way(players[0], SOUTH); break; case SDLK_RIGHT: player_dec_moving(players[0]); player_unset_way(players[0], EAST); break; case SDLK_LEFT: player_dec_moving(players[0]); player_unset_way(players[0], WEST); break; case SDLK_z: if(game->nb_player >= 2) { player_dec_moving(players[1]); player_unset_way(players[1], NORTH); } break; case SDLK_s: if(game->nb_player >= 2) { player_dec_moving(players[1]); player_unset_way(players[1], SOUTH); } break; case SDLK_d: if(game->nb_player >= 2) { player_dec_moving(players[1]); player_unset_way(players[1], EAST); } break; case SDLK_q: if(game->nb_player >= 2) { player_dec_moving(players[1]); player_unset_way(players[1], WEST); } break; case SDLK_t: if(game->nb_player >= 3) { player_dec_moving(players[2]); player_unset_way(players[2], NORTH); } break; case SDLK_g: if(game->nb_player >= 3) { player_dec_moving(players[2]); player_unset_way(players[2], SOUTH); } break; case SDLK_h: if(game->nb_player >= 3) { player_dec_moving(players[2]); player_unset_way(players[2], EAST); } break; case SDLK_f: if(game->nb_player >= 3) { player_dec_moving(players[2]); player_unset_way(players[2], WEST); } break; case SDLK_i: if(game->nb_player >= 4) { player_dec_moving(players[3]); player_unset_way(players[3], NORTH); } break; case SDLK_k: if(game->nb_player >= 4) { player_dec_moving(players[3]); player_unset_way(players[3], SOUTH); } break; case SDLK_l: if(game->nb_player >= 4) { player_dec_moving(players[3]); player_unset_way(players[3], EAST); } break; case SDLK_j: if(game->nb_player >= 4) { player_dec_moving(players[3]); player_unset_way(players[3], WEST); } break; case SDLK_F1: player_reset_way_mov(game->players[0]); break; case SDLK_F2: player_reset_way_mov(game->players[1]); break; case SDLK_F3: player_reset_way_mov(game->players[2]); break; case SDLK_F4: player_reset_way_mov(game->players[3]); break; } } return GAME; }
static void update(struct game_state *gs) { main_menu_background_update(); menu_update(main_menu); }
/** * menu_select - selects the next idle state to enter * @drv: cpuidle driver containing state data * @dev: the CPU */ static int menu_select(struct cpuidle_driver *drv, struct cpuidle_device *dev) { struct menu_device *data = &__get_cpu_var(menu_devices); int latency_req = pm_qos_request(PM_QOS_CPU_DMA_LATENCY); int i; int multiplier; struct timespec t; if (data->needs_update) { menu_update(drv, dev); data->needs_update = 0; } data->last_state_idx = CPUIDLE_DRIVER_STATE_START - 1; data->exit_us = 0; /* Special case when user has set very strict latency requirement */ if (unlikely(latency_req == 0)) return 0; /* determine the expected residency time, round up */ t = ktime_to_timespec(tick_nohz_get_sleep_length()); data->expected_us = t.tv_sec * USEC_PER_SEC + t.tv_nsec / NSEC_PER_USEC; data->bucket = which_bucket(data->expected_us); multiplier = performance_multiplier(); /* * if the correction factor is 0 (eg first time init or cpu hotplug * etc), we actually want to start out with a unity factor. */ if (data->correction_factor[data->bucket] == 0) data->correction_factor[data->bucket] = RESOLUTION * DECAY; /* * Force the result of multiplication to be 64 bits even if both * operands are 32 bits. * Make sure to round up for half microseconds. */ data->predicted_us = div_round64((uint64_t)data->expected_us * data->correction_factor[data->bucket], RESOLUTION * DECAY); get_typical_interval(data); /* * We want to default to C1 (hlt), not to busy polling * unless the timer is happening really really soon. */ if (data->expected_us > 5 && !drv->states[CPUIDLE_DRIVER_STATE_START].disabled && dev->states_usage[CPUIDLE_DRIVER_STATE_START].disable == 0) data->last_state_idx = CPUIDLE_DRIVER_STATE_START; /* * Find the idle state with the lowest power while satisfying * our constraints. */ for (i = CPUIDLE_DRIVER_STATE_START; i < drv->state_count; i++) { struct cpuidle_state *s = &drv->states[i]; struct cpuidle_state_usage *su = &dev->states_usage[i]; if (s->disabled || su->disable) continue; if (s->target_residency > data->predicted_us) continue; if (s->exit_latency > latency_req) continue; if (s->exit_latency * multiplier > data->predicted_us) continue; data->last_state_idx = i; data->exit_us = s->exit_latency; } return data->last_state_idx; }
// entry point void _main(void) { // some variables for the main loop unsigned int lasttick = 0; void *keyqueue = kbd_queue(); unsigned short key; // initiate all the stuff init(); // start at the menu switchgs(GS_MENU); // main loop while (gs != GS_NONE) { // run at 20 fps if (FiftyMsecTick != lasttick) { // Check for keypresses if (!OSdequeue(&key, keyqueue)) { if (key == KEY_ON) off(); else if (key == KEY_QUIT) switchgs(GS_NONE); else { switch (gs) { case GS_MENU: if (key == KEY_ENTER) switchgs(GS_GAME); else if (key == KEY_ESC) switchgs(GS_NONE); break; case GS_GAME: if (key == KEY_ENTER) game_flap(); else if (key == KEY_ESC) switchgs(GS_MENU); break; case GS_GAMEOVER: if (key == KEY_ENTER) switchgs(GS_GAME); else if (key == KEY_ESC) switchgs(GS_MENU); break; default: break; } } } // draw to the buffers GrayClearScreen2B(lightbuffer, darkbuffer); switch (gs) { case GS_MENU: menu_update(); menu_draw(); break; case GS_GAME: game_update(); game_draw(); break; case GS_GAMEOVER: gameover_update(); game_draw(); gameover_draw(); break; default: break; } // flip the buffers FastCopyScreen(darkbuffer, darkplane); FastCopyScreen(lightbuffer, lightplane); lasttick = FiftyMsecTick; framecounter++; } } // important! deinit(); }