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();
}
