void mode_settings(){
uint8_t current_item = 0;
uint8_t pressed = 0;
uint8_t old_roll_pitch_link = eepromP_read_byte(eeLinkRollPitch);
ScreenData->title = &mode_settings_tittle;
ScreenData->footer_callback = &print_std_footer;
ScreenData->ok_callback = &_mds_ok_callback;
ScreenData->render_callback = &_mds_render;
ScreenData->total_options = 4;
ScreenData->initial_option = 0;
if (flagGimbalMode){
ScreenData->footer_callback = print_back_chg_footer;
}
render_screen(ScreenData);
flagRollPitchLink = eepromP_read_byte(eeLinkRollPitch);
if (flagRollPitchLink != old_roll_pitch_link){
/* Copy Elevator gains from Aileron gains */
eepromP_copy_block(eeParameterTableAileron, eeParameterTableElevator, 8);
}
}
int main(int argc, char **argv)
{
if(argc == 1) {
fprintf(stderr, "Usage: %s FILE\n", argv[0]);
exit(1);
}
errno = 0;
size_t size;
int32_t *mem = read_file(argv[1], &size);
if(!mem) {
if(errno)
perror(argv[0]);
else
fprintf(stderr, "%s: The file was invalid.\n", argv[0]);
exit(1);
}
init_vm(mem, size);
while(1) {
run_vm();
render_screen();
process_events();
delay();
}
}
void black_screen_now(void)
{
if(prSDLScreen != NULL) {
SDL_FillRect(prSDLScreen, NULL, 0);
render_screen(true);
show_screen(0);
}
}
void simulation_run(simulation_t *simulation){
// two arrays for double-buffering
particle_t particle_buf_a[MAX_PARTICLES];
particle_t particle_buf_b[MAX_PARTICLES];
unsigned int fill_pointer = simulation_fill(particle_buf_a, particle_buf_b); // we start by filling particle_buf_a
printf("Fill pointer: %d\n", fill_pointer);
double dt = simulation->dt;
unsigned long step = 0;
step_return retval; // return value from each step
particle_t *src_buf = particle_buf_a;
particle_t *dst_buf = particle_buf_b;
printf("particle mass: %f\n", src_buf[0].mass);
while(1){
// we want to exit the simulation after a while
if(step > 500000){
return;
}
// Input handling goes here
// solve the step
solve(dt, src_buf, dst_buf, fill_pointer);
// visualize. Might not happen every step.
render_screen(simulation->main_surface, dst_buf, fill_pointer);
//swiWaitForVBlank();
// buffer swap!
particle_t *tmp;
tmp = src_buf;
src_buf = dst_buf;
dst_buf = tmp;
step++;
}
}
void gb_run()
{
#ifdef PROFILE
prof_enter(PF_GB_RUN);
#endif
//if (rom_get_loaded()){
if (g_regs.LCDC&0x80){ // LCDC 起動時
g_regs.LY=(g_regs.LY+1)%154;
g_regs.STAT&=0xF8;
if (g_regs.LYC==g_regs.LY){
g_regs.STAT|=4;
if (g_regs.STAT&0x40)
cpu_irq(INT_LCDC);
}
if (g_regs.LY==0){
renderer_refresh();
if (now_frame>=skip){
//pgFillvram(0);
render_screen(vframe);
now_frame=0;
}
else
now_frame++;
lcd_clear_win_count();
// skip=skip_buf;
}
if (g_regs.LY>=144){ // VBlank 期間中
g_regs.STAT|=1;
if (g_regs.LY==144){
cpu_exec(72);
cpu_irq(INT_VBLANK);
if (g_regs.STAT&0x10)
cpu_irq(INT_LCDC);
cpu_exec(456-80);
}
else if (g_regs.LY==153){
cpu_exec(80);
g_regs.LY=0;
cpu_exec(456-80); // 前のラインのかなり早目から0になるようだ。
g_regs.LY=153;
}
else
cpu_exec(456);
}
else{ // VBlank 期間外
g_regs.STAT|=2;
if (g_regs.STAT&0x20)
cpu_irq(INT_LCDC);
cpu_exec(80); // state=2
g_regs.STAT|=3;
cpu_exec(169); // state=3
if (dma_executing){ // HBlank DMA
if (b_dma_first){
dma_dest_bank=vram_bank;
if (dma_src<0x4000)
dma_src_bank=get_rom();
else if (dma_src<0x8000)
dma_src_bank=mbc_get_rom();
else if (dma_src>=0xA000&&dma_src<0xC000)
dma_src_bank=mbc_get_sram()-0xA000;
else if (dma_src>=0xC000&&dma_src<0xD000)
dma_src_bank=ram-0xC000;
else if (dma_src>=0xD000&&dma_src<0xE000)
dma_src_bank=ram_bank-0xD000;
else dma_src_bank=NULL;
b_dma_first=false;
}
memcpy(dma_dest_bank+(dma_dest&0x1ff0),dma_src_bank+dma_src,16);
// fprintf(cpu_file,"%03d : dma exec %04X -> %04X rest %d\n",g_regs.LY,cpu_dma_src,cpu_dma_dest,cpu_dma_rest);
dma_src+=16;
dma_src&=0xfff0;
dma_dest+=16;
dma_dest&=0xfff0;
dma_rest--;
if (!dma_rest)
dma_executing=false;
// cpu_total_clock+=207*(cpu_speed?2:1);
// cpu_sys_clock+=207*(cpu_speed?2:1);
// cpu_div_clock+=207*(cpu_speed?2:1);
// g_regs.STAT|=3;
if (now_frame>=skip && !sgb_mask)
lcd_render(vframe,g_regs.LY);
g_regs.STAT&=0xfc;
cpu_exec(207); // state=3
}
else{
/* if (lcd_get_sprite_count()){
if (lcd_get_sprite_count()>=10){
cpu_exec(129);
if ((g_regs.STAT&0x08))
cpu_irq(INT_LCDC);
g_regs.STAT&=0xfc;
if (now_frame>=skip)
lcd_render(vframe,g_regs.LY);
cpu_exec(78); // state=0
}
else{
cpu_exec(129*lcd_get_sprite_count()/10);
if ((g_regs.STAT&0x08))
cpu_irq(INT_LCDC);
g_regs.STAT&=0xfc;
if (now_frame>=skip)
lcd_render(vframe,g_regs.LY);
cpu_exec(207-(129*lcd_get_sprite_count()/10)); // state=0
}
}
else{
*/ g_regs.STAT&=0xfc;
if (now_frame>=skip && !sgb_mask)
lcd_render(vframe,g_regs.LY);
if ((g_regs.STAT&0x08))
cpu_irq(INT_LCDC);
cpu_exec(207); // state=0
// }
}
}
}
else{ // LCDC 停止時
g_regs.LY=0;
// g_regs.LY=(g_regs.LY+1)%154;
re_render++;
if (re_render>=154){
gb_fill_vframe(0xff);
renderer_refresh();
if (now_frame>=skip){
//pgFillvram(0);
render_screen(vframe);
now_frame=0;
}
else
now_frame++;
lcd_clear_win_count();
re_render=0;
}
g_regs.STAT&=0xF8;
cpu_exec(456);
}
//}
#ifdef PROFILE
prof_out();
#endif
}
// ------------------------------------
// Main function
// ------------------------------------
int main(int argc, char *argv[])
{
SDL_Init(SDL_INIT_EVERYTHING);
SDL_Surface* screen;
const int ScreenWidth = 640;
const int ScreenHeight = 480;
screen = SDL_SetVideoMode(ScreenWidth, ScreenHeight, 32, SDL_SWSURFACE);
bool running = true;
const int FPS = 30;
BoxColor boxcolor;
boxcolor = RED;
Uint32 start;
SDL_Rect rect;
rect.w = RECTANGLE_WIDTH;
rect.h = RECTANGLE_WIDTH;
rect.x = ScreenWidth/SCREENDIVIDER - rect.w/SCREENDIVIDER;
rect.y = ScreenHeight/SCREENDIVIDER - rect.h/SCREENDIVIDER;
Uint32 ScreenColor = SDL_MapRGB(screen->format, 0xcf, 0xcf, 0xcf);
Uint32 RectColor;
int time1 = 0;
Uint32 * pstart = &start;
int * ptime1 = &time1;
while (running)
{
start = SDL_GetTicks();
SDL_Event event;
while (SDL_PollEvent(&event))
{
switch (event.type) {
case SDL_QUIT: running = false;
break;
}
}
boxcolor = color_timer(start, time1, boxcolor);
switch (boxcolor) {
case RED: RectColor = SDL_MapRGB(screen->format, 255, 0, 0);
break;
case BLUE: RectColor = SDL_MapRGB(screen->format, 0, 255, 0);
break;
case GREEN: RectColor = SDL_MapRGB(screen->format, 0, 0, 255);
break;
}
//render_screen(SDL_Surface screen);
render_screen(screen, rect, ScreenColor, RectColor); //whenever you make a call function, you dont have to provide its type
//render_screen need 4 parametes, and you provided just 1
if (1000/FPS > SDL_GetTicks()-start)
SDL_Delay (1000/FPS-(SDL_GetTicks()-start));
}
SDL_Quit();
return 0;
}
static void
do_mainloop(void)
{
Screen *s;
struct timeval t;
struct timeval last_t;
int sleeptime;
long int process_lag = 0;
long int render_lag = 0;
long int t_diff;
debug(RPT_DEBUG, "%s()", __FUNCTION__);
gettimeofday(&t, NULL); /* Get initial time */
while (1) {
/* Get current time */
last_t = t;
gettimeofday(&t, NULL);
t_diff = t.tv_sec - last_t.tv_sec;
if ( ((t_diff + 1) > (LONG_MAX / 1e6)) || (t_diff < 0) ) {
/* We're going to overflow the calculation - probably been to sleep, fudge the values */
t_diff = 0;
process_lag = 1;
render_lag = (1e6/RENDER_FREQ);
} else {
t_diff *= 1e6;
t_diff += t.tv_usec - last_t.tv_usec;
}
process_lag += t_diff;
if (process_lag > 0) {
/* Time for a processing stroke */
sock_poll_clients(); /* poll clients for input*/
parse_all_client_messages(); /* analyze input from network clients*/
handle_input(); /* handle key input from devices*/
/* We've done the job... */
process_lag = 0 - (1e6/PROCESS_FREQ);
/* Note : this does not make a fixed frequency */
}
render_lag += t_diff;
if (render_lag > 0) {
/* Time for a rendering stroke */
timer ++;
screenlist_process();
s = screenlist_current();
/* TODO: Move this call to every client connection
* and every screen add...
*/
if (s == server_screen) {
update_server_screen();
}
render_screen(s, timer);
/* We've done the job... */
if (render_lag > (1e6/RENDER_FREQ) * MAX_RENDER_LAG_FRAMES) {
/* Cause rendering slowdown because too much lag */
render_lag = (1e6/RENDER_FREQ) * MAX_RENDER_LAG_FRAMES;
}
render_lag -= (1e6/RENDER_FREQ);
/* Note: this DOES make a fixed frequency (except with slowdown) */
}
/* Sleep just as long as needed */
sleeptime = min(0-process_lag, 0-render_lag);
if (sleeptime > 0) {
usleep(sleeptime);
}
/* Check if a SIGHUP has been caught */
if (got_reload_signal) {
got_reload_signal = 0;
do_reload();
}
}
/* Quit! */
exit_program(0);
}
static void handle_game_key(const SDL_Event &event)
{
SDL_Keycode key = event.key.keysym.sym;
SDL_Scancode sc = event.key.keysym.scancode;
bool changed_screen_mode = false;
bool changed_prefs = false;
if (!game_is_networked && (event.key.keysym.mod & KMOD_CTRL) && CheatsActive) {
int type_of_cheat = process_keyword_key(key);
if (type_of_cheat != NONE)
handle_keyword(type_of_cheat);
}
if (Console::instance()->input_active()) {
switch(key) {
case SDLK_RETURN:
case SDLK_KP_ENTER:
Console::instance()->enter();
break;
case SDLK_ESCAPE:
Console::instance()->abort();
break;
case SDLK_BACKSPACE:
Console::instance()->backspace();
break;
case SDLK_DELETE:
Console::instance()->del();
break;
case SDLK_UP:
Console::instance()->up_arrow();
break;
case SDLK_DOWN:
Console::instance()->down_arrow();
break;
case SDLK_LEFT:
Console::instance()->left_arrow();
break;
case SDLK_RIGHT:
Console::instance()->right_arrow();
break;
case SDLK_HOME:
Console::instance()->line_home();
break;
case SDLK_END:
Console::instance()->line_end();
break;
case SDLK_a:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->line_home();
break;
case SDLK_b:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->left_arrow();
break;
case SDLK_d:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->del();
break;
case SDLK_e:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->line_end();
break;
case SDLK_f:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->right_arrow();
break;
case SDLK_h:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->backspace();
break;
case SDLK_k:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->forward_clear();
break;
case SDLK_n:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->down_arrow();
break;
case SDLK_p:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->up_arrow();
break;
case SDLK_t:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->transpose();
break;
case SDLK_u:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->clear();
break;
case SDLK_w:
if (event.key.keysym.mod & KMOD_CTRL)
Console::instance()->delete_word();
break;
}
}
else
{
if (sc == SDL_SCANCODE_ESCAPE) // (ZZZ) Quit gesture (now safer)
{
if(!player_controlling_game())
do_menu_item_command(mGame, iQuitGame, false);
else {
if(get_ticks_since_local_player_in_terminal() > 1 * TICKS_PER_SECOND) {
if(!game_is_networked) {
do_menu_item_command(mGame, iQuitGame, false);
}
else {
#if defined(__APPLE__) && defined(__MACH__)
screen_printf("If you wish to quit, press Command-Q");
#else
screen_printf("If you wish to quit, press Alt+Q.");
#endif
}
}
}
}
else if (input_preferences->shell_key_bindings[_key_volume_up].count(sc))
{
changed_prefs = SoundManager::instance()->AdjustVolumeUp(Sound_AdjustVolume());
}
else if (input_preferences->shell_key_bindings[_key_volume_down].count(sc))
{
changed_prefs = SoundManager::instance()->AdjustVolumeDown(Sound_AdjustVolume());
}
else if (input_preferences->shell_key_bindings[_key_switch_view].count(sc))
{
walk_player_list();
render_screen(NONE);
}
else if (input_preferences->shell_key_bindings[_key_zoom_in].count(sc))
{
if (zoom_overhead_map_in())
PlayInterfaceButtonSound(Sound_ButtonSuccess());
else
PlayInterfaceButtonSound(Sound_ButtonFailure());
}
else if (input_preferences->shell_key_bindings[_key_zoom_out].count(sc))
{
if (zoom_overhead_map_out())
PlayInterfaceButtonSound(Sound_ButtonSuccess());
else
PlayInterfaceButtonSound(Sound_ButtonFailure());
}
else if (input_preferences->shell_key_bindings[_key_inventory_left].count(sc))
{
if (player_controlling_game()) {
PlayInterfaceButtonSound(Sound_ButtonSuccess());
scroll_inventory(-1);
} else
decrement_replay_speed();
}
else if (input_preferences->shell_key_bindings[_key_inventory_right].count(sc))
{
if (player_controlling_game()) {
PlayInterfaceButtonSound(Sound_ButtonSuccess());
scroll_inventory(1);
} else
increment_replay_speed();
}
else if (input_preferences->shell_key_bindings[_key_toggle_fps].count(sc))
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
extern bool displaying_fps;
displaying_fps = !displaying_fps;
}
else if (input_preferences->shell_key_bindings[_key_activate_console].count(sc))
{
if (game_is_networked) {
#if !defined(DISABLE_NETWORKING)
Console::instance()->activate_input(InGameChatCallbacks::SendChatMessage, InGameChatCallbacks::prompt());
#endif
PlayInterfaceButtonSound(Sound_ButtonSuccess());
}
else if (Console::instance()->use_lua_console())
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
Console::instance()->activate_input(ExecuteLuaString, ">");
}
else
{
PlayInterfaceButtonSound(Sound_ButtonFailure());
}
}
else if (input_preferences->shell_key_bindings[_key_show_scores].count(sc))
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
{
extern bool ShowScores;
ShowScores = !ShowScores;
}
}
else if (sc == SDL_SCANCODE_F1) // Decrease screen size
{
if (!graphics_preferences->screen_mode.hud)
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
graphics_preferences->screen_mode.hud = true;
changed_screen_mode = changed_prefs = true;
}
else
{
int mode = alephone::Screen::instance()->FindMode(get_screen_mode()->width, get_screen_mode()->height);
if (mode < alephone::Screen::instance()->GetModes().size() - 1)
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
graphics_preferences->screen_mode.width = alephone::Screen::instance()->ModeWidth(mode + 1);
graphics_preferences->screen_mode.height = alephone::Screen::instance()->ModeHeight(mode + 1);
graphics_preferences->screen_mode.auto_resolution = false;
graphics_preferences->screen_mode.hud = false;
changed_screen_mode = changed_prefs = true;
} else
PlayInterfaceButtonSound(Sound_ButtonFailure());
}
}
else if (sc == SDL_SCANCODE_F2) // Increase screen size
{
if (graphics_preferences->screen_mode.hud)
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
graphics_preferences->screen_mode.hud = false;
changed_screen_mode = changed_prefs = true;
}
else
{
int mode = alephone::Screen::instance()->FindMode(get_screen_mode()->width, get_screen_mode()->height);
int automode = get_screen_mode()->fullscreen ? 0 : 1;
if (mode > automode)
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
graphics_preferences->screen_mode.width = alephone::Screen::instance()->ModeWidth(mode - 1);
graphics_preferences->screen_mode.height = alephone::Screen::instance()->ModeHeight(mode - 1);
if ((mode - 1) == automode)
graphics_preferences->screen_mode.auto_resolution = true;
graphics_preferences->screen_mode.hud = true;
changed_screen_mode = changed_prefs = true;
} else
PlayInterfaceButtonSound(Sound_ButtonFailure());
}
}
else if (sc == SDL_SCANCODE_F3) // Resolution toggle
{
if (!OGL_IsActive()) {
PlayInterfaceButtonSound(Sound_ButtonSuccess());
graphics_preferences->screen_mode.high_resolution = !graphics_preferences->screen_mode.high_resolution;
changed_screen_mode = changed_prefs = true;
} else
PlayInterfaceButtonSound(Sound_ButtonFailure());
}
else if (sc == SDL_SCANCODE_F4) // Reset OpenGL textures
{
#ifdef HAVE_OPENGL
if (OGL_IsActive()) {
// Play the button sound in advance to get the full effect of the sound
PlayInterfaceButtonSound(Sound_OGL_Reset());
OGL_ResetTextures();
} else
#endif
PlayInterfaceButtonSound(Sound_ButtonInoperative());
}
else if (sc == SDL_SCANCODE_F5) // Make the chase cam switch sides
{
if (ChaseCam_IsActive())
PlayInterfaceButtonSound(Sound_ButtonSuccess());
else
PlayInterfaceButtonSound(Sound_ButtonInoperative());
ChaseCam_SwitchSides();
}
else if (sc == SDL_SCANCODE_F6) // Toggle the chase cam
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
ChaseCam_SetActive(!ChaseCam_IsActive());
}
else if (sc == SDL_SCANCODE_F7) // Toggle tunnel vision
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
SetTunnelVision(!GetTunnelVision());
}
else if (sc == SDL_SCANCODE_F8) // Toggle the crosshairs
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
player_preferences->crosshairs_active = !player_preferences->crosshairs_active;
Crosshairs_SetActive(player_preferences->crosshairs_active);
changed_prefs = true;
}
else if (sc == SDL_SCANCODE_F9) // Screen dump
{
dump_screen();
}
else if (sc == SDL_SCANCODE_F10) // Toggle the position display
{
PlayInterfaceButtonSound(Sound_ButtonSuccess());
{
extern bool ShowPosition;
ShowPosition = !ShowPosition;
}
}
else if (sc == SDL_SCANCODE_F11) // Decrease gamma level
{
if (graphics_preferences->screen_mode.gamma_level) {
PlayInterfaceButtonSound(Sound_ButtonSuccess());
graphics_preferences->screen_mode.gamma_level--;
change_gamma_level(graphics_preferences->screen_mode.gamma_level);
changed_prefs = true;
} else
PlayInterfaceButtonSound(Sound_ButtonFailure());
}
else if (sc == SDL_SCANCODE_F12) // Increase gamma level
{
if (graphics_preferences->screen_mode.gamma_level < NUMBER_OF_GAMMA_LEVELS - 1) {
PlayInterfaceButtonSound(Sound_ButtonSuccess());
graphics_preferences->screen_mode.gamma_level++;
change_gamma_level(graphics_preferences->screen_mode.gamma_level);
changed_prefs = true;
} else
PlayInterfaceButtonSound(Sound_ButtonFailure());
}
else
{
if (get_game_controller() == _demo)
set_game_state(_close_game);
}
}
if (changed_screen_mode) {
screen_mode_data temp_screen_mode = graphics_preferences->screen_mode;
temp_screen_mode.fullscreen = get_screen_mode()->fullscreen;
change_screen_mode(&temp_screen_mode, true);
render_screen(0);
}
if (changed_prefs)
write_preferences();
}
int main(int argc, char *argv[])
{
int fd;
int optc;
char *serial_port = NULL;
signal(SIGINT, sighandler);
signal(SIGQUIT, sighandler);
signal(SIGHUP, sighandler);
signal(SIGALRM, sigalrm);
setvbuf(stdin, NULL, _IONBF, 0);
setvbuf(stdout, NULL, _IONBF, 0);
setvbuf(stderr, NULL, _IONBF, 0);
while(EOF != (optc = getopt(argc, argv, "h"))) {
switch(optc) {
case 'h':
printf("%s", usage_str);
default:
break;
}
}
if(optind >= argc) {
fprintf(stderr, "Missing serial port\n");
exit(1);
} else {
serial_port = strdup(argv[optind]);
}
if(-1 == pipe(pfd)) {
perror("pipe");
exit(1);
}
if((fd = serial_open(serial_port)) < 0)
{
debug_printf("Couldn't open serial port\n");
exit(1);
}
if(isatty(0)) {
struct termios raw;
raw = orig_termios;
//cfmakeraw(&raw);
raw.c_cc[VMIN] = 0;
raw.c_cc[VTIME] = 0;
/* put terminal in raw mode after flushing */
if(tcsetattr(0, TCSAFLUSH, &raw) < 0) {
perror("tcsetattr raw mode");
exit(1);
}
atexit(reset_tty);
}
clear(fd);
timer_start();
while(!quit) {
fd_set fds;
FD_ZERO(&fds);
FD_SET(0, &fds);
FD_SET(pfd[0], &fds);
if(-1 == select(pfd[0] + 1, &fds, NULL, NULL, NULL)) {
if(errno == EINTR)
continue;
perror("select");
exit(1);
}
if(FD_ISSET(0, &fds)) {
char buffer[80];
memset(buffer, 0, sizeof(char)*80);
ssize_t n = read(0, &buffer, 80);
if(-1 == n) {
perror("read char");
exit(1);
} else if(!n) {
fprintf(stderr, "Serial port closed on me...\r\n");
exit(1);
}
render_screen(fd, buffer);
}
if(FD_ISSET(pfd[0], &fds)) {
char c;
timer_start();
xread(pfd[0], &c, 1);
}
scr_frontmap(fd);
}
timer_stop();
close(fd);
return 0;
}
void select_file(char result[13])
{
static int page = 0; // Remember selections while the program runs
static int index = 0;
int maxindex = 0;
bool rerender = true;
for(;;)
{
if (get_keys(BUTTON1) && index >= 0)
{
// File selected, get the name and return
if (get_name(result, page, index))
return;
else
rerender = true; // Couldn't find file, maybe fs has changed?
}
if (get_keys(BUTTON2))
{
// Refresh
//f_flush(&fatfs);
rerender = true;
}
if (get_keys(BUTTON4))
{
show_msgbox("About PAWN_APP",
"Pawn scripting language for DSO Quad\n"
"(C) 2012 Petteri Aimonen <*****@*****.**>\n"
"\n"
"Built " __DATE__ " at " __TIME__ "\n"
"Git id " COMMITID "\n"
"GCC version " __VERSION__
);
rerender = true;
}
if (peek_keys(SCROLL1_LEFT | SCROLL1_RIGHT | SCROLL2_LEFT | SCROLL2_RIGHT))
{
// Clear old cursor
show_cursor(index, 0);
// Update index
if (get_keys(SCROLL1_LEFT)) index -= 4;
if (get_keys(SCROLL1_RIGHT)) index += 4;
if (get_keys(SCROLL2_LEFT)) index -= 1;
if (get_keys(SCROLL2_RIGHT)) index += 1;
if (index < 0)
{
if (page > 0)
{
page--;
render_screen(page, &maxindex);
index += 12;
}
else
{
index = 0;
}
}
if (index >= maxindex)
{
if (maxindex > ICONS_ON_SCREEN)
{
page++;
index -= 12;
rerender = true;
}
else
{
index = maxindex - 1;
}
}
// Draw new cursor
show_cursor(index, RGB(128, 128, 255));
}
if (rerender)
{
render_screen(page, &maxindex);
show_cursor(index, RGB(128, 128, 255));
rerender = false;
if (index >= maxindex)
index = maxindex - 1;
}
}
}
