src/gui.c

   1 /*
   2  Copyright 2010, Volca
   3  Licenced under Academic Free License version 3.0
   4  Review OpenUsbLd README & LICENSE files for further details.
   5  */
   6
   7 #include "include/usbld.h"
   8 #include "include/gui.h"
   9 #include "include/renderman.h"
  10 #include "include/menusys.h"
  11 #include "include/fntsys.h"
  12 #include "include/ioman.h"
  13 #include "include/lang.h"
  14 #include "include/themes.h"
  15 #include "include/pad.h"
  16 #include "include/util.h"
  17 #include "include/config.h"
  18 #include "include/system.h"
  19 #include "include/ethsupport.h"
  20
  21 #include <stdlib.h>
  22 #include <libvux.h>
  23
  24 static int gScheduledOps;
  25 static int gCompletedOps;
  26 static int gTerminate;
  27 static int gInitComplete;
  28
  29 static gui_callback_t gFrameHook;
  30
  31 static s32 gSemaId;
  32 static s32 gGUILockSemaId;
  33 static ee_sema_t gQueueSema;
  34
  35 static int screenWidth;
  36 static float wideScreenScale;
  37 static int screenHeight;
  38
  39 // forward decl.
  40 static void guiShow();
  41
  42 #ifdef __DEBUG
  43
  44 #include <timer.h>
  45
  46 #define CLOCKS_PER_MILISEC 147456
  47
  48 // debug version displays an FPS meter
  49 static u32 curtime = 0;
  50 static u32 time_since_last = 0;
  51 static u32 time_render = 0;
  52
  53 #endif
  54
  55 struct gui_update_list_t {
  56         struct gui_update_t* item;
  57         struct gui_update_list_t* next;
  58 };
  59
  60 struct gui_update_list_t *gUpdateList;
  61 struct gui_update_list_t *gUpdateEnd;
  62
  63 typedef struct {
  64         void (*handleInput)(void);
  65         void (*renderScreen)(void);
  66         short inMenu;
  67 } gui_screen_handler_t;
  68
  69 static gui_screen_handler_t screenHandlers[] = {{ &menuHandleInputMain, &menuRenderMain, 0 },
  70                                                                                                 { &menuHandleInputMenu, &menuRenderMenu, 1 },
  71                                                                                                 { &menuHandleInputInfo, &menuRenderInfo, 1 } };
  72
  73 // default screen handler (menu screen)
  74 static gui_screen_handler_t *screenHandler = &screenHandlers[GUI_SCREEN_MENU];
  75
  76 // screen transition handling
  77 static gui_screen_handler_t *screenHandlerTarget = NULL;
  78 static int transIndex, transMax, transitionX, transitionY;
  79
  80 // Helper perlin noise data
  81 #define PLASMA_H 32
  82 #define PLASMA_W 32
  83 #define PLASMA_ROWS_PER_FRAME 6
  84 #define FADE_SIZE 256
  85
  86 static GSTEXTURE gBackgroundTex;
  87 static int pperm[512];
  88 static float fadetbl[FADE_SIZE + 1];
  89
  90 static VU_VECTOR pgrad3[12] = {{ 1, 1, 0, 1 }, { -1, 1, 0, 1 }, { 1, -1, 0, 1 }, { -1, -1, 0, 1 },
  91                                                                 { 1, 0, 1, 1 }, { -1, 0, 1, 1 }, { 1, 0, -1, 1 }, { -1, 0, -1, 1 },
  92                                                                 { 0, 1, 1, 1 }, { 0, -1, 1, 1 }, { 0, 1, -1, 1 }, { 0, -1, -1, 1 } };
  93
  94 void guiReloadScreenExtents() {
  95         rmGetScreenExtents(&screenWidth, &screenHeight);
  96 }
  97
  98 void guiInit(void) {
  99         guiFrameId = 0;
 100         guiInactiveFrames = 0;
 101
 102         gFrameHook = NULL;
 103         gTerminate = 0;
 104         gInitComplete = 0;
 105         gScheduledOps = 0;
 106         gCompletedOps = 0;
 107
 108         gUpdateList = NULL;
 109         gUpdateEnd = NULL;
 110
 111         gQueueSema.init_count = 1;
 112         gQueueSema.max_count = 1;
 113         gQueueSema.option = 0;
 114
 115         gSemaId = CreateSema(&gQueueSema);
 116         gGUILockSemaId = CreateSema(&gQueueSema);
 117
 118         guiReloadScreenExtents();
 119
 120         // background texture - for perlin
 121         gBackgroundTex.Width = PLASMA_W;
 122         gBackgroundTex.Height = PLASMA_H;
 123         gBackgroundTex.Mem = memalign(128, PLASMA_W * PLASMA_H * 4);
 124         gBackgroundTex.PSM = GS_PSM_CT32;
 125         gBackgroundTex.Filter = GS_FILTER_LINEAR;
 126         gBackgroundTex.Vram = 0;
 127         gBackgroundTex.VramClut = 0;
 128         gBackgroundTex.Clut = NULL;
 129
 130         wideScreenScale = 1.0f;
 131
 132         // Precalculate the values for the perlin noise plasma
 133         int i;
 134         for (i = 0; i < 256; ++i) {
 135                 pperm[i] = rand() % 256;
 136                 pperm[i + 256] = pperm[i];
 137         }
 138
 139         for (i = 0; i <= FADE_SIZE; ++i) {
 140                 float t = (float) (i) / FADE_SIZE;
 141
 142                 fadetbl[i] = t * t * t * (t * (t * 6.0 - 15.0) + 10.0);
 143         }
 144 }
 145
 146 void guiEnd() {
 147         if (gBackgroundTex.Mem)
 148                 free(gBackgroundTex.Mem);
 149
 150         DeleteSema(gSemaId);
 151         DeleteSema(gGUILockSemaId);
 152 }
 153
 154 void guiLock(void) {
 155         WaitSema(gGUILockSemaId);
 156 }
 157
 158 void guiUnlock(void) {
 159         SignalSema(gGUILockSemaId);
 160 }
 161
 162 void guiStartFrame(void) {
 163 #ifdef __DEBUG
 164         u32 newtime = cpu_ticks() / CLOCKS_PER_MILISEC;
 165         time_since_last = newtime - curtime;
 166         curtime = newtime;
 167 #endif
 168
 169         guiLock();
 170         rmStartFrame();
 171         guiFrameId++;
 172 }
 173
 174 void guiEndFrame(void) {
 175         guiUnlock();
 176         rmFlush();
 177
 178 #ifdef __DEBUG
 179         u32 newtime = cpu_ticks() / CLOCKS_PER_MILISEC;
 180         time_render = newtime - curtime;
 181 #endif
 182
 183         rmEndFrame();
 184 }
 185
 186 void guiShowAbout() {
 187         char OPLVersion[64];
 188         snprintf(OPLVersion, 64, _l(_STR_OUL_VER), USBLD_VERSION);
 189
 190 #ifdef VMC
 191         strcat(OPLVersion, " VMC");
 192 #endif
 193 #ifdef __RTL
 194         strcat(OPLVersion, " RTL");
 195 #endif
 196 #ifdef __CHILDPROOF
 197         strcat(OPLVersion, " CHILDPROOF");
 198 #endif
 199
 200         diaSetLabel(diaAbout, 1, OPLVersion);
 201
 202         diaExecuteDialog(diaAbout, -1, 1, NULL);
 203 }
 204
 205 void guiShowConfig() {
 206         // configure the enumerations
 207         const char* deviceNames[] = { _l(_STR_USB_GAMES), _l(_STR_NET_GAMES), _l(_STR_HDD_GAMES), NULL };
 208         const char* deviceModes[] = { _l(_STR_OFF), _l(_STR_MANUAL), _l(_STR_AUTO), NULL };
 209
 210         diaSetEnum(diaConfig, CFG_DEFDEVICE, deviceNames);
 211         diaSetEnum(diaConfig, CFG_USBMODE, deviceModes);
 212         diaSetEnum(diaConfig, CFG_HDDMODE, deviceModes);
 213         diaSetEnum(diaConfig, CFG_ETHMODE, deviceModes);
 214         diaSetEnum(diaConfig, CFG_APPMODE, deviceModes);
 215
 216         diaSetInt(diaConfig, CFG_DEBUG, gDisableDebug);
 217         diaSetString(diaConfig, CFG_EXITTO, gExitPath);
 218         diaSetInt(diaConfig, CFG_DANDROP, gEnableDandR);
 219         diaSetInt(diaConfig, CFG_HDDSPINDOWN, gHDDSpindown);
 220         diaSetInt(diaConfig, CFG_CHECKUSBFRAG, gCheckUSBFragmentation);
 221         diaSetInt(diaConfig, CFG_USBDELAY, gUSBDelay);
 222         diaSetString(diaConfig, CFG_USBPREFIX, gUSBPrefix);
 223         diaSetString(diaConfig, CFG_ETHPREFIX, gETHPrefix);
 224         diaSetInt(diaConfig, CFG_LASTPLAYED, gRememberLastPlayed);
 225         diaSetInt(diaConfig, CFG_DEFDEVICE, gDefaultDevice);
 226         diaSetInt(diaConfig, CFG_USBMODE, gUSBStartMode);
 227         diaSetInt(diaConfig, CFG_HDDMODE, gHDDStartMode);
 228         diaSetInt(diaConfig, CFG_ETHMODE, gETHStartMode);
 229         diaSetInt(diaConfig, CFG_APPMODE, gAPPStartMode);
 230
 231         int ret = diaExecuteDialog(diaConfig, -1, 1, NULL);
 232         if (ret) {
 233                 diaGetString(diaConfig, CFG_EXITTO, gExitPath);
 234                 diaGetInt(diaConfig, CFG_DEBUG, &gDisableDebug);
 235                 diaGetInt(diaConfig, CFG_DANDROP, &gEnableDandR);
 236                 diaGetInt(diaConfig, CFG_HDDSPINDOWN, &gHDDSpindown);
 237                 diaGetInt(diaConfig, CFG_CHECKUSBFRAG, &gCheckUSBFragmentation);
 238                 diaGetInt(diaConfig, CFG_USBDELAY, &gUSBDelay);
 239                 diaGetString(diaConfig, CFG_USBPREFIX, gUSBPrefix);
 240                 diaGetString(diaConfig, CFG_ETHPREFIX, gETHPrefix);
 241                 diaGetInt(diaConfig, CFG_LASTPLAYED, &gRememberLastPlayed);
 242                 diaGetInt(diaConfig, CFG_DEFDEVICE, &gDefaultDevice);
 243                 diaGetInt(diaConfig, CFG_USBMODE, &gUSBStartMode);
 244                 diaGetInt(diaConfig, CFG_HDDMODE, &gHDDStartMode);
 245                 diaGetInt(diaConfig, CFG_ETHMODE, &gETHStartMode);
 246                 diaGetInt(diaConfig, CFG_APPMODE, &gAPPStartMode);
 247
 248                 applyConfig(-1, -1);
 249         }
 250 }
 251
 252 static int curTheme = -1;
 253
 254 static int guiUIUpdater(int modified) {
 255         if (modified) {
 256                 int temp;
 257                 diaGetInt(diaUIConfig, UICFG_THEME, &temp);
 258                 if (temp != curTheme) {
 259                         curTheme = temp;
 260                         if (temp == 0) {
 261                                 diaUIConfig[32].type = UI_COLOUR; // Must be correctly set before doing the diaS/GetColor !!
 262                                 diaUIConfig[36].type = UI_COLOUR;
 263                                 diaUIConfig[40].type = UI_COLOUR;
 264                                 diaUIConfig[44].type = UI_COLOUR;
 265                                 diaSetColor(diaUIConfig, UICFG_BGCOL, gDefaultBgColor);
 266                                 diaSetColor(diaUIConfig, UICFG_UICOL, gDefaultUITextColor);
 267                                 diaSetColor(diaUIConfig, UICFG_TXTCOL, gDefaultTextColor);
 268                                 diaSetColor(diaUIConfig, UICFG_SELCOL, gDefaultSelTextColor);
 269                         } else if (temp == thmGetGuiValue()) {
 270                                 diaUIConfig[32].type = UI_COLOUR;
 271                                 diaUIConfig[36].type = UI_COLOUR;
 272                                 diaUIConfig[40].type = UI_COLOUR;
 273                                 diaUIConfig[44].type = UI_COLOUR;
 274                                 diaSetColor(diaUIConfig, UICFG_BGCOL, gTheme->bgColor);
 275                                 diaSetU64Color(diaUIConfig, UICFG_UICOL, gTheme->uiTextColor);
 276                                 diaSetU64Color(diaUIConfig, UICFG_TXTCOL, gTheme->textColor);
 277                                 diaSetU64Color(diaUIConfig, UICFG_SELCOL, gTheme->selTextColor);
 278                         } else {
 279                                 diaUIConfig[32].type = UI_SPACER;
 280                                 diaUIConfig[36].type = UI_SPACER;
 281                                 diaUIConfig[40].type = UI_SPACER;
 282                                 diaUIConfig[44].type = UI_SPACER;
 283                         }
 284
 285                         temp = !temp;
 286                         diaSetEnabled(diaUIConfig, UICFG_BGCOL, temp);
 287                         diaSetEnabled(diaUIConfig, UICFG_UICOL, temp);
 288                         diaSetEnabled(diaUIConfig, UICFG_TXTCOL, temp);
 289                         diaSetEnabled(diaUIConfig, UICFG_SELCOL, temp);
 290                 }
 291         }
 292
 293         return 0;
 294 }
 295
 296 void guiShowUIConfig() {
 297         curTheme = -1;
 298
 299         // configure the enumerations
 300         const char* scrollSpeeds[] = { _l(_STR_SLOW), _l(_STR_MEDIUM),  _l(_STR_FAST), NULL };
 301         const char* vmodeNames[] = { "AUTO", "PAL", "NTSC", NULL };
 302         diaSetEnum(diaUIConfig, UICFG_SCROLL, scrollSpeeds);
 303         diaSetEnum(diaUIConfig, UICFG_THEME, (const char **) thmGetGuiList());
 304         diaSetEnum(diaUIConfig, UICFG_LANG, (const char **) lngGetGuiList());
 305         diaSetEnum(diaUIConfig, UICFG_VMODE, vmodeNames);
 306
 307         diaSetInt(diaUIConfig, UICFG_SCROLL, gScrollSpeed);
 308         diaSetInt(diaUIConfig, UICFG_THEME, thmGetGuiValue());
 309         diaSetInt(diaUIConfig, UICFG_LANG, lngGetGuiValue());
 310         guiUIUpdater(1);
 311         diaSetInt(diaUIConfig, UICFG_AUTOSORT, gAutosort);
 312         diaSetInt(diaUIConfig, UICFG_AUTOREFRESH, gAutoRefresh);
 313         diaSetInt(diaUIConfig, UICFG_INFOPAGE, gUseInfoScreen);
 314         diaSetInt(diaUIConfig, UICFG_COVERART, gEnableArt);
 315         diaSetInt(diaUIConfig, UICFG_WIDESCREEN, gWideScreen);
 316         diaSetInt(diaUIConfig, UICFG_VMODE, gVMode);
 317         diaSetInt(diaUIConfig, UICFG_VSYNC, gVSync);
 318
 319         int ret = diaExecuteDialog(diaUIConfig, -1, 1, guiUIUpdater);
 320         if (ret) {
 321                 int themeID = -1, langID = -1;
 322                 diaGetInt(diaUIConfig, UICFG_SCROLL, &gScrollSpeed);
 323                 diaGetInt(diaUIConfig, UICFG_LANG, &langID);
 324                 diaGetInt(diaUIConfig, UICFG_THEME, &themeID);
 325                 if (themeID == 0) {
 326                         diaGetColor(diaUIConfig, UICFG_BGCOL, gDefaultBgColor);
 327                         diaGetColor(diaUIConfig, UICFG_UICOL, gDefaultUITextColor);
 328                         diaGetColor(diaUIConfig, UICFG_TXTCOL, gDefaultTextColor);
 329                         diaGetColor(diaUIConfig, UICFG_SELCOL, gDefaultSelTextColor);
 330                 }
 331                 diaGetInt(diaUIConfig, UICFG_AUTOSORT, &gAutosort);
 332                 diaGetInt(diaUIConfig, UICFG_AUTOREFRESH, &gAutoRefresh);
 333                 diaGetInt(diaUIConfig, UICFG_INFOPAGE, &gUseInfoScreen);
 334                 diaGetInt(diaUIConfig, UICFG_COVERART, &gEnableArt);
 335                 diaGetInt(diaUIConfig, UICFG_WIDESCREEN, &gWideScreen);
 336                 diaGetInt(diaUIConfig, UICFG_VMODE, &gVMode);
 337                 diaGetInt(diaUIConfig, UICFG_VSYNC, &gVSync);
 338
 339                 applyConfig(themeID, langID);
 340         }
 341 }
 342
 343 void guiShowIPConfig() {
 344         size_t i;
 345         // upload current values
 346         for (i = 0; i < 4; ++i) {
 347                 if (gNetworkStartup != ERROR_ETH_NOT_STARTED) {
 348                         diaSetEnabled(diaIPConfig, 2 + i, 0);
 349                         diaSetEnabled(diaIPConfig, 6 + i, 0);
 350                         diaSetEnabled(diaIPConfig, 10 + i, 0);
 351                 } else {
 352                         diaSetEnabled(diaIPConfig, 2 + i, 1);
 353                         diaSetEnabled(diaIPConfig, 6 + i, 1);
 354                         diaSetEnabled(diaIPConfig, 10 + i, 1);
 355                 }
 356                 diaSetInt(diaIPConfig, 2 + i, ps2_ip[i]);
 357                 diaSetInt(diaIPConfig, 6 + i, ps2_netmask[i]);
 358                 diaSetInt(diaIPConfig, 10 + i, ps2_gateway[i]);
 359                 diaSetInt(diaIPConfig, 14 + i, pc_ip[i]);
 360         }
 361
 362         diaSetInt(diaIPConfig, 18, gPCPort);
 363         diaSetString(diaIPConfig, 19, gPCShareName);
 364         diaSetString(diaIPConfig, 20, gPCUserName);
 365         diaSetString(diaIPConfig, 21, gPCPassword);
 366
 367         if (gNetworkStartup == 0) {
 368                 diaSetLabel(diaIPConfig, NETCFG_OK, _l(_STR_OK));
 369                 diaIPConfig[64].type = UI_SPACER;
 370         } else if (gNetworkStartup >= ERROR_ETH_SMB_LOGON) {
 371                 diaSetLabel(diaIPConfig, NETCFG_OK, _l(_STR_RECONNECT));
 372                 diaIPConfig[64].type = UI_TERMINATOR;
 373         } else {
 374                 diaSetLabel(diaIPConfig, NETCFG_OK, _l(_STR_OK));
 375                 diaIPConfig[64].type = UI_TERMINATOR;
 376         }
 377
 378
 379         int result = diaExecuteDialog(diaIPConfig, -1, 1, NULL);
 380         if (result) {
 381                 // Store values
 382                 for (i = 0; i < 4; ++i) {
 383                         diaGetInt(diaIPConfig, 2 + i, &ps2_ip[i]);
 384                         diaGetInt(diaIPConfig, 6 + i, &ps2_netmask[i]);
 385                         diaGetInt(diaIPConfig, 10 + i, &ps2_gateway[i]);
 386                         diaGetInt(diaIPConfig, 14 + i, &pc_ip[i]);
 387                 }
 388
 389                 diaGetInt(diaIPConfig, 18, &gPCPort);
 390                 diaGetString(diaIPConfig, 19, gPCShareName);
 391                 diaGetString(diaIPConfig, 20, gPCUserName);
 392                 diaGetString(diaIPConfig, 21, gPCPassword);
 393                 gIPConfigChanged = 1;
 394
 395                 if (result == NETCFG_RECONNECT)
 396                         gNetworkStartup = ERROR_ETH_SMB_LOGON;
 397
 398                 applyConfig(-1, -1);
 399         }
 400 }
 401
 402 int guiShowKeyboard(char* value, int maxLength) {
 403         char tmp[maxLength];
 404         strncpy(tmp, value, maxLength);
 405
 406         int result = diaShowKeyb(tmp, maxLength);
 407         if (result) {
 408                 strncpy(value, tmp, maxLength);
 409                 value[maxLength - 1] = '\0';
 410         }
 411
 412         return result;
 413 }
 414
 415 #ifdef VMC
 416 typedef struct { // size = 76
 417         int VMC_status; // 0=available, 1=busy
 418         int VMC_error;
 419         int VMC_progress;
 420         char VMC_msg[64];
 421 } statusVMCparam_t;
 422
 423 #define OPERATION_CREATE        0
 424 #define OPERATION_CREATING      1
 425 #define OPERATION_ABORTING      2
 426 #define OPERATION_ENDING        3
 427 #define OPERATION_END           4
 428
 429 static short vmc_refresh;
 430 static int vmc_operation;
 431 static statusVMCparam_t vmc_status;
 432
 433 int guiVmcNameHandler(char* text, int maxLen) {
 434         int result = diaShowKeyb(text, maxLen);
 435
 436         if (result)
 437         vmc_refresh = 1;
 438
 439         return result;
 440 }
 441
 442 static int guiRefreshVMCConfig(item_list_t *support, char* name) {
 443         int size = support->itemCheckVMC(name, 0);
 444
 445         if (size != -1) {
 446                 diaSetLabel(diaVMC, VMC_BUTTON_CREATE, _l(_STR_MODIFY));
 447                 diaSetLabel(diaVMC, VMC_STATUS, _l(_STR_VMC_FILE_EXISTS));
 448
 449                 if (size == 8)
 450                         diaSetInt(diaVMC, VMC_SIZE, 0);
 451                 else if (size == 16)
 452                         diaSetInt(diaVMC, VMC_SIZE, 1);
 453                 else if (size == 32)
 454                         diaSetInt(diaVMC, VMC_SIZE, 2);
 455                 else if (size == 64)
 456                         diaSetInt(diaVMC, VMC_SIZE, 3);
 457                 else {
 458                         diaSetInt(diaVMC, VMC_SIZE, 0);
 459                         diaSetLabel(diaVMC, VMC_STATUS, _l(_STR_VMC_FILE_ERROR));
 460                 }
 461
 462                 if (gEnableDandR) {
 463                         diaSetEnabled(diaVMC, VMC_SIZE, 1);
 464                         diaVMC[20].type = UI_SPLITTER;
 465                 }
 466                 else {
 467                         diaSetEnabled(diaVMC, VMC_SIZE, 0);
 468                         diaVMC[20].type = UI_TERMINATOR;
 469                 }
 470         }
 471         else {
 472                 diaSetLabel(diaVMC, VMC_BUTTON_CREATE, _l(_STR_CREATE));
 473                 diaSetLabel(diaVMC, VMC_STATUS, _l(_STR_VMC_FILE_NEW));
 474
 475                 diaSetInt(diaVMC, VMC_SIZE, 0);
 476                 diaSetEnabled(diaVMC, VMC_SIZE, 1);
 477                 diaVMC[20].type = UI_TERMINATOR;
 478         }
 479
 480         return size;
 481 }
 482
 483 static int guiVMCUpdater(int modified) {
 484         if (vmc_refresh) {
 485                 vmc_refresh = 0;
 486                 return VMC_REFRESH;
 487         }
 488
 489         if ((vmc_operation == OPERATION_CREATING) || (vmc_operation == OPERATION_ABORTING)) {
 490                 int result = fileXioDevctl("genvmc:", 0xC0DE0003, NULL, 0, (void*) &vmc_status, sizeof(vmc_status));
 491                 if (result == 0) {
 492                         diaSetLabel(diaVMC, VMC_STATUS, vmc_status.VMC_msg);
 493                         diaSetInt(diaVMC, VMC_PROGRESS, vmc_status.VMC_progress);
 494
 495                         if (vmc_status.VMC_error != 0)
 496                                 LOG("GUI VMCUpdater: %d\n", vmc_status.VMC_error);
 497
 498                         if (vmc_status.VMC_status == 0x00) {
 499                                 diaSetLabel(diaVMC, VMC_BUTTON_CREATE, _l(_STR_OK));
 500                                 vmc_operation = OPERATION_ENDING;
 501                                 return VMC_BUTTON_CREATE;
 502                         }
 503                 }
 504                 else
 505                         LOG("GUI Status result: %d\n", result);
 506         }
 507
 508         return 0;
 509 }
 510
 511 static int guiShowVMCConfig(int id, item_list_t *support, char *VMCName, int slot, int validate) {
 512         int result = validate ? VMC_BUTTON_CREATE : 0;
 513         char vmc[32];
 514
 515         if (strlen(VMCName))
 516                 strncpy(vmc, VMCName, 32);
 517         else {
 518                 if (validate)
 519                         return 1; // nothing to validate if no user input
 520
 521                 char* startup = support->itemGetStartup(id);
 522                 snprintf(vmc, 32, "%s_%d", startup, slot);
 523         }
 524
 525         vmc_refresh = 0;
 526         vmc_operation = OPERATION_CREATE;
 527         diaSetEnabled(diaVMC, VMC_NAME, 1);
 528         diaSetEnabled(diaVMC, VMC_SIZE, 1);
 529         diaSetInt(diaVMC, VMC_PROGRESS, 0);
 530
 531         const char* VMCSizes[] = {"8 Mb", "16 Mb", "32 Mb", "64 Mb", NULL};
 532         diaSetEnum(diaVMC, VMC_SIZE, VMCSizes);
 533         int size = guiRefreshVMCConfig(support, vmc);
 534         diaSetString(diaVMC, VMC_NAME, vmc);
 535
 536         do {
 537                 if (result == VMC_BUTTON_CREATE) {
 538                         if (vmc_operation == OPERATION_CREATE) { // User start creation of VMC
 539                                 int sizeUI;
 540                                 diaGetInt(diaVMC, VMC_SIZE, &sizeUI);
 541                                 if (sizeUI == 1)
 542                                 sizeUI = 16;
 543                                 else if (sizeUI == 2)
 544                                 sizeUI = 32;
 545                                 else if (sizeUI == 3)
 546                                 sizeUI = 64;
 547                                 else
 548                                 sizeUI = 8;
 549
 550                                 if (sizeUI != size) {
 551                                         support->itemCheckVMC(vmc, sizeUI);
 552
 553                                         diaSetEnabled(diaVMC, VMC_NAME, 0);
 554                                         diaSetEnabled(diaVMC, VMC_SIZE, 0);
 555                                         diaSetLabel(diaVMC, VMC_BUTTON_CREATE, _l(_STR_ABORT));
 556                                         vmc_operation = OPERATION_CREATING;
 557                                 }
 558                                 else
 559                                         break;
 560                         }
 561                         else if (vmc_operation == OPERATION_ENDING) {
 562                                 if (validate)
 563                                         break; // directly close VMC config dialog
 564
 565                                 vmc_operation = OPERATION_END;
 566                         }
 567                         else if (vmc_operation == OPERATION_END) { // User closed creation dialog of VMC
 568                                 break;
 569                         }
 570                         else if (vmc_operation == OPERATION_CREATING) { // User canceled creation of VMC
 571                                 fileXioDevctl("genvmc:", 0xC0DE0002, NULL, 0, NULL, 0);
 572                                 vmc_operation = OPERATION_ABORTING;
 573                         }
 574                 }
 575                 else if (result == VMC_BUTTON_DELETE) {
 576                         if (guiMsgBox(_l(_STR_DELETE_WARNING), 1, diaVMC)) {
 577                                 support->itemCheckVMC(vmc, -1);
 578                                 diaSetString(diaVMC, VMC_NAME, "");
 579                                 break;
 580                         }
 581                 }
 582                 else if (result == VMC_REFRESH) { // User changed the VMC name
 583                         diaGetString(diaVMC, VMC_NAME, vmc);
 584                         size = guiRefreshVMCConfig(support, vmc);
 585                 }
 586
 587                 result = diaExecuteDialog(diaVMC, result, 1, &guiVMCUpdater);
 588
 589                 if ((result == 0) && (vmc_operation == OPERATION_CREATE))
 590                         break;
 591         } while (1);
 592
 593         return result;
 594 }
 595 #endif
 596
 597 int guiAltStartupNameHandler(char* text, int maxLen) {
 598         int i;
 599
 600         int result = diaShowKeyb(text, maxLen);
 601         if (result) {
 602                 for (i = 0; text[i]; i++) {
 603                         if (text[i] > 96 && text[i] < 123)
 604                                 text[i] -= 32;
 605                 }
 606         }
 607
 608         return result;
 609 }
 610
 611 int guiShowCompatConfig(int id, item_list_t *support, config_set_t* configSet) {
 612         int dmaMode = 7; // defaulting to UDMA 4
 613         if (support->haveCompatibilityMode == COMPAT_FULL) {
 614                 configGetInt(configSet, CONFIG_ITEM_DMA, &dmaMode);
 615                 const char* dmaModes[] = { "MDMA 0", "MDMA 1", "MDMA 2", "UDMA 0",      "UDMA 1", "UDMA 2", "UDMA 3", "UDMA 4", "UDMA 5", "UDMA 6",     NULL };
 616                 diaSetEnum(diaCompatConfig, COMPAT_DMA, dmaModes);
 617                 diaSetInt(diaCompatConfig, COMPAT_DMA, dmaMode);
 618         } else {
 619                 const char* dmaModes[] = { NULL };
 620                 diaSetEnum(diaCompatConfig, COMPAT_DMA, dmaModes);
 621                 diaSetInt(diaCompatConfig, COMPAT_DMA, 0);
 622         }
 623
 624         diaSetLabel(diaCompatConfig, COMPAT_GAME, support->itemGetName(id));
 625
 626         int compatMode = 0;
 627         configGetInt(configSet, CONFIG_ITEM_COMPAT, &compatMode);
 628         int i, result = -1;
 629         for (i = 0; i < COMPAT_MODE_COUNT; ++i)
 630                 diaSetInt(diaCompatConfig, COMPAT_MODE_BASE + i, (compatMode & (1 << i)) > 0 ? 1 : 0);
 631
 632         // Find out the current game ID
 633         char hexid[32];
 634         configGetStrCopy(configSet, CONFIG_ITEM_DNAS, hexid);
 635         diaSetString(diaCompatConfig, COMPAT_GAMEID, hexid);
 636
 637         char altStartup[32];
 638         configGetStrCopy(configSet, CONFIG_ITEM_ALTSTARTUP, altStartup);
 639         diaSetString(diaCompatConfig, COMPAT_ALTSTARTUP, altStartup);
 640
 641 #ifdef VMC
 642         char vmc1[32];
 643         configGetVMC(configSet, vmc1, 0);
 644         diaSetLabel(diaCompatConfig, COMPAT_VMC1_DEFINE, vmc1);
 645
 646         char vmc2[32]; // required as diaSetLabel use pointer to value
 647         configGetVMC(configSet, vmc2, 1);
 648         diaSetLabel(diaCompatConfig, COMPAT_VMC2_DEFINE, vmc2);
 649 #endif
 650
 651         // show dialog
 652         do {
 653 #ifdef VMC
 654                 if (strlen(vmc1))
 655                         diaSetLabel(diaCompatConfig, COMPAT_VMC1_ACTION, _l(_STR_RESET));
 656                 else
 657                         diaSetLabel(diaCompatConfig, COMPAT_VMC1_ACTION, _l(_STR_USE_GENERIC));
 658                 if (strlen(vmc2))
 659                         diaSetLabel(diaCompatConfig, COMPAT_VMC2_ACTION, _l(_STR_RESET));
 660                 else
 661                         diaSetLabel(diaCompatConfig, COMPAT_VMC2_ACTION, _l(_STR_USE_GENERIC));
 662 #endif
 663
 664                 result = diaExecuteDialog(diaCompatConfig, result, 1, NULL);
 665
 666                 if (result == COMPAT_LOADFROMDISC) {
 667                         char hexDiscID[15];
 668                         if (sysGetDiscID(hexDiscID) >= 0)
 669                                 diaSetString(diaCompatConfig, COMPAT_GAMEID, hexDiscID);
 670                         else
 671                                 guiMsgBox(_l(_STR_ERROR_LOADING_ID), 0, NULL);
 672                 }
 673 #ifdef VMC
 674                 else if (result == COMPAT_VMC1_DEFINE) {
 675                         if(guiShowVMCConfig(id, support, vmc1, 0, 0))
 676                                 diaGetString(diaVMC, VMC_NAME, vmc1);
 677                 } else if (result == COMPAT_VMC2_DEFINE) {
 678                         if(guiShowVMCConfig(id, support, vmc2, 1, 0))
 679                                 diaGetString(diaVMC, VMC_NAME, vmc2);
 680                 } else if (result == COMPAT_VMC1_ACTION) {
 681                         if (strlen(vmc1))
 682                                 vmc1[0] = '\0';
 683                         else
 684                                 snprintf(vmc1, 32, "generic_%d", 0);
 685                 } else if (result == COMPAT_VMC2_ACTION) {
 686                         if (strlen(vmc2))
 687                                 vmc2[0] = '\0';
 688                         else
 689                                 snprintf(vmc2, 32, "generic_%d", 1);
 690                 }
 691 #endif
 692         } while (result >= COMPAT_NOEXIT);
 693
 694         if (result == COMPAT_REMOVE) {
 695                 configRemoveKey(configSet, CONFIG_ITEM_DMA);
 696                 configRemoveKey(configSet, CONFIG_ITEM_COMPAT);
 697                 configRemoveKey(configSet, CONFIG_ITEM_DNAS);
 698                 configRemoveKey(configSet, CONFIG_ITEM_ALTSTARTUP);
 699 #ifdef VMC
 700                 configRemoveVMC(configSet, 0);
 701                 configRemoveVMC(configSet, 1);
 702 #endif
 703                 menuSaveConfig();
 704         } else if (result > 0) { // test button pressed or save button
 705                 compatMode = 0;
 706                 for (i = 0; i < COMPAT_MODE_COUNT; ++i) {
 707                         int mdpart;
 708                         diaGetInt(diaCompatConfig, COMPAT_MODE_BASE + i, &mdpart);
 709                         compatMode |= (mdpart ? 1 : 0) << i;
 710                 }
 711
 712                 if (support->haveCompatibilityMode == COMPAT_FULL) {
 713                         diaGetInt(diaCompatConfig, COMPAT_DMA, &dmaMode);
 714                         if (dmaMode != 7)
 715                                 configSetInt(configSet, CONFIG_ITEM_DMA, dmaMode);
 716                         else
 717                                 configRemoveKey(configSet, CONFIG_ITEM_DMA);
 718                 }
 719
 720                 if (compatMode != 0)
 721                         configSetInt(configSet, CONFIG_ITEM_COMPAT, compatMode);
 722                 else
 723                         configRemoveKey(configSet, CONFIG_ITEM_COMPAT);
 724
 725                 diaGetString(diaCompatConfig, COMPAT_GAMEID, hexid);
 726                 if (hexid[0] != '\0')
 727                         configSetStr(configSet, CONFIG_ITEM_DNAS, hexid);
 728
 729                 diaGetString(diaCompatConfig, COMPAT_ALTSTARTUP, altStartup);
 730                 if (altStartup[0] != '\0')
 731                         configSetStr(configSet, CONFIG_ITEM_ALTSTARTUP, altStartup);
 732                 else
 733                         configRemoveKey(configSet, CONFIG_ITEM_ALTSTARTUP);
 734
 735 #ifdef VMC
 736                 configSetVMC(configSet, vmc1, 0);
 737                 configSetVMC(configSet, vmc2, 1);
 738                 guiShowVMCConfig(id, support, vmc1, 0, 1);
 739                 guiShowVMCConfig(id, support, vmc2, 1, 1);
 740 #endif
 741
 742                 if (result == COMPAT_SAVE)
 743                         menuSaveConfig();
 744         }
 745
 746         return result;
 747 }
 748
 749 int guiGetOpCompleted(int opid) {
 750         return gCompletedOps > opid;
 751 }
 752
 753 int guiDeferUpdate(struct gui_update_t *op) {
 754         WaitSema(gSemaId);
 755
 756         struct gui_update_list_t* up = (struct gui_update_list_t*) malloc(sizeof(struct gui_update_list_t));
 757         up->item = op;
 758         up->next = NULL;
 759
 760         if (!gUpdateList) {
 761                 gUpdateList = up;
 762                 gUpdateEnd = gUpdateList;
 763         } else {
 764                 gUpdateEnd->next = up;
 765                 gUpdateEnd = up;
 766         }
 767
 768         SignalSema(gSemaId);
 769
 770         return gScheduledOps++;
 771 }
 772
 773 static void guiHandleOp(struct gui_update_t* item) {
 774         submenu_list_t* result = NULL;
 775
 776         switch (item->type) {
 777                 case GUI_INIT_DONE:
 778                         gInitComplete = 1;
 779                         break;
 780
 781                 case GUI_OP_ADD_MENU:
 782                         menuAppendItem(item->menu.menu);
 783                         break;
 784
 785                 case GUI_OP_APPEND_MENU:
 786                         result = submenuAppendItem(item->menu.subMenu, item->submenu.icon_id,
 787                                         item->submenu.text, item->submenu.id, item->submenu.text_id);
 788
 789                         if (!item->menu.menu->submenu) { // first subitem in list
 790                                 item->menu.menu->submenu = result;
 791                                 item->menu.menu->current = result;
 792                                 item->menu.menu->pagestart = result;
 793                         } else if (item->submenu.selected) { // remember last game feat.
 794                                 item->menu.menu->current = result;
 795                                 item->menu.menu->pagestart = result;
 796                                 item->menu.menu->remindLast = 1;
 797                         }
 798
 799                         break;
 800
 801                 case GUI_OP_SELECT_MENU:
 802                         menuSetSelectedItem(item->menu.menu);
 803                         screenHandler = &screenHandlers[GUI_SCREEN_MAIN];
 804                         break;
 805
 806                 case GUI_OP_CLEAR_SUBMENU:
 807                         submenuDestroy(item->menu.subMenu);
 808                         item->menu.menu->submenu = NULL;
 809                         item->menu.menu->current = NULL;
 810                         item->menu.menu->pagestart = NULL;
 811                         break;
 812
 813                 case GUI_OP_SORT:
 814                         submenuSort(item->menu.subMenu);
 815                         item->menu.menu->submenu = *item->menu.subMenu;
 816
 817                         if (!item->menu.menu->remindLast)
 818                                 item->menu.menu->current = item->menu.menu->submenu;
 819
 820                         item->menu.menu->pagestart = item->menu.menu->current;
 821                         break;
 822
 823                 case GUI_OP_ADD_HINT:
 824                         // append the hint list in the menu item
 825                         menuAddHint(item->menu.menu, item->hint.text_id, item->hint.icon_id);
 826                         break;
 827
 828                 default:
 829                         LOG("GUI: ??? (%d)\n", item->type);
 830         }
 831 }
 832
 833 static void guiHandleDeferredOps(void) {
 834         // TODO: Fit into the given time interval, skip rest of operations of over limit
 835
 836         while (gUpdateList) {
 837                 WaitSema(gSemaId);
 838
 839                 guiHandleOp(gUpdateList->item);
 840
 841                 struct gui_update_list_t* td = gUpdateList;
 842                 gUpdateList = gUpdateList->next;
 843
 844                 free(td);
 845
 846                 gCompletedOps++;
 847
 848                 SignalSema(gSemaId);
 849         }
 850
 851         gUpdateEnd = NULL;
 852 }
 853
 854 static int bfadeout = 0x0;
 855 static void guiDrawBusy() {
 856         if (gTheme->loadingIcon) {
 857                 GSTEXTURE* texture = thmGetTexture(LOAD0_ICON + guiFrameId % gTheme->loadingIconCount);
 858                 if (texture && texture->Mem) {
 859                         u64 mycolor = GS_SETREG_RGBA(0x080, 0x080, 0x080, bfadeout);
 860                         rmDrawPixmap(texture, gTheme->loadingIcon->posX, gTheme->loadingIcon->posY, gTheme->loadingIcon->aligned, gTheme->loadingIcon->width, gTheme->loadingIcon->height, gTheme->loadingIcon->scaled, mycolor);
 861                 }
 862         }
 863 }
 864
 865 static int wfadeout = 0x0150;
 866 static void guiRenderGreeting() {
 867         int fade = wfadeout > 0xFF ? 0xFF : wfadeout;
 868         u64 mycolor = GS_SETREG_RGBA(0x10, 0x10, 0x10, fade >> 1);
 869         rmDrawRect(0, 0, screenWidth, screenHeight, mycolor);
 870
 871         GSTEXTURE* logo = thmGetTexture(LOGO_PICTURE);
 872         if (logo) {
 873                 mycolor = GS_SETREG_RGBA(0x080, 0x080, 0x080, fade >> 1);
 874                 rmDrawPixmap(logo, screenWidth >> 1, gTheme->usedHeight >> 1, ALIGN_CENTER, logo->Width, logo->Height, SCALING_RATIO, mycolor);
 875         }
 876
 877         return;
 878 }
 879
 880 static float mix(float a, float b, float t) {
 881         return (1.0 - t) * a + t * b;
 882 }
 883
 884 static float fade(float t) {
 885         return fadetbl[(int) (t * FADE_SIZE)];
 886 }
 887
 888 // The same as mix, but with 8 (2*4) values mixed at once
 889 static void VU0MixVec(VU_VECTOR *a, VU_VECTOR *b, float mix, VU_VECTOR* res) {
 890         asm (
 891                 "lqc2   vf1, 0(%0)\n" // load the first vector
 892                 "lqc2   vf2, 0(%1)\n" // load the second vector
 893                 "lw     $2, 0(%2)\n" // load value from ptr to reg
 894                 "qmtc2  $2, vf3\n" // load the mix value from reg to VU
 895                 "vaddw.x vf5, vf00, vf00\n" // vf5.x = 1
 896                 "vsub.x vf4x, vf5x, vf3x\n" // subtract 1 - vf3,x, store the result in vf4.x
 897                 "vmulax.xyzw ACC, vf1, vf3x\n" // multiply vf1 by vf3.x, store the result in ACC
 898                 "vmaddx.xyzw vf1, vf2, vf4x\n" // multiply vf2 by vf4.x add ACC, store the result in vf1
 899                 "sqc2   vf1, 0(%3)\n" // transfer the result in acc to the ee
 900                 : : "r" (a), "r" (b), "r" (&mix), "r" (res)
 901         );
 902 }
 903
 904 static float guiCalcPerlin(float x, float y, float z) {
 905         // Taken from: http://people.opera.com/patrickl/experiments/canvas/plasma/perlin-noise-classical.js
 906         // By Sean McCullough
 907
 908         // Find unit grid cell containing point
 909         int X = floor(x);
 910         int Y = floor(y);
 911         int Z = floor(z);
 912
 913         // Get relative xyz coordinates of point within that cell
 914         x = x - X;
 915         y = y - Y;
 916         z = z - Z;
 917
 918         // Wrap the integer cells at 255 (smaller integer period can be introduced here)
 919         X = X & 255;
 920         Y = Y & 255;
 921         Z = Z & 255;
 922
 923         // Calculate a set of eight hashed gradient indices
 924         int gi000 = pperm[X + pperm[Y + pperm[Z]]] % 12;
 925         int gi001 = pperm[X + pperm[Y + pperm[Z + 1]]] % 12;
 926         int gi010 = pperm[X + pperm[Y + 1 + pperm[Z]]] % 12;
 927         int gi011 = pperm[X + pperm[Y + 1 + pperm[Z + 1]]] % 12;
 928         int gi100 = pperm[X + 1 + pperm[Y + pperm[Z]]] % 12;
 929         int gi101 = pperm[X + 1 + pperm[Y + pperm[Z + 1]]] % 12;
 930         int gi110 = pperm[X + 1 + pperm[Y + 1 + pperm[Z]]] % 12;
 931         int gi111 = pperm[X + 1 + pperm[Y + 1 + pperm[Z + 1]]] % 12;
 932
 933         // The gradients of each corner are now:
 934         // g000 = grad3[gi000];
 935         // g001 = grad3[gi001];
 936         // g010 = grad3[gi010];
 937         // g011 = grad3[gi011];
 938         // g100 = grad3[gi100];
 939         // g101 = grad3[gi101];
 940         // g110 = grad3[gi110];
 941         // g111 = grad3[gi111];
 942         // Calculate noise contributions from each of the eight corners
 943         VU_VECTOR vec;
 944         vec.x = x;
 945         vec.y = y;
 946         vec.z = z;
 947         vec.w = 1;
 948
 949         VU_VECTOR a, b;
 950
 951         // float n000
 952         a.x = Vu0DotProduct(&pgrad3[gi000], &vec);
 953
 954         vec.y -= 1;
 955
 956         // float n010
 957         a.z = Vu0DotProduct(&pgrad3[gi010], &vec);
 958
 959         vec.x -= 1;
 960
 961         //float n110
 962         b.z = Vu0DotProduct(&pgrad3[gi110], &vec);
 963
 964         vec.y += 1;
 965
 966         // float n100
 967         b.x = Vu0DotProduct(&pgrad3[gi100], &vec);
 968
 969         vec.z -= 1;
 970
 971         // float n101
 972         b.y = Vu0DotProduct(&pgrad3[gi101], &vec);
 973
 974         vec.y -= 1;
 975
 976         // float n111
 977         b.w = Vu0DotProduct(&pgrad3[gi111], &vec);
 978
 979         vec.x += 1;
 980
 981         // float n011
 982         a.w = Vu0DotProduct(&pgrad3[gi011], &vec);
 983
 984         vec.y += 1;
 985
 986         // float n001
 987         a.y = Vu0DotProduct(&pgrad3[gi001], &vec);
 988
 989         // Compute the fade curve value for each of x, y, z
 990         float u = fade(x);
 991         float v = fade(y);
 992         float w = fade(z);
 993
 994         // TODO: Low priority... This could be done on VU0 (xyzw for the first 4 mixes)
 995         // The result in sw
 996         // Interpolate along x the contributions from each of the corners
 997         VU_VECTOR rv;
 998         VU0MixVec(&b, &a, u, &rv);
 999
1000         // TODO: The VU0MixVec could as well mix the results (as follows) - might improve performance...
1001         // Interpolate the four results along y
1002         float nxy0 = mix(rv.x, rv.z, v);
1003         float nxy1 = mix(rv.y, rv.w, v);
1004         // Interpolate the two last results along z
1005         float nxyz = mix(nxy0, nxy1, w);
1006
1007         return nxyz;
1008 }
1009
1010 static float dir = 0.02;
1011 static float perz = -100;
1012 static int pery = 0;
1013 static unsigned char curbgColor[3] = { 0, 0, 0 };
1014
1015 static int cdirection(unsigned char a, unsigned char b) {
1016         if (a == b)
1017                 return 0;
1018         else if (a > b)
1019                 return -1;
1020         else
1021                 return 1;
1022 }
1023
1024 void guiDrawBGPlasma() {
1025         int x, y;
1026
1027         // transition the colors
1028         curbgColor[0] += cdirection(curbgColor[0], gTheme->bgColor[0]);
1029         curbgColor[1] += cdirection(curbgColor[1], gTheme->bgColor[1]);
1030         curbgColor[2] += cdirection(curbgColor[2], gTheme->bgColor[2]);
1031
1032         // it's PLASMA_ROWS_PER_FRAME rows a frame to stop being a resource hog
1033         if (pery >= PLASMA_H) {
1034                 pery = 0;
1035                 perz += dir;
1036
1037                 if (perz > 100.0f || perz < -100.0f)
1038                         dir = -dir;
1039         }
1040
1041         u32 *buf = gBackgroundTex.Mem + PLASMA_W * pery;
1042         int ymax = pery + PLASMA_ROWS_PER_FRAME;
1043
1044         if (ymax > PLASMA_H)
1045                 ymax = PLASMA_H;
1046
1047         for (y = pery; y < ymax; y++) {
1048                 for (x = 0; x < PLASMA_W; x++) {
1049                         u32 fper = guiCalcPerlin((float) (2 * x) / PLASMA_W, (float) (2 * y) / PLASMA_H, perz) * 0x080 + 0x080;
1050
1051                         *buf = GS_SETREG_RGBA(
1052                                         (u32)(fper * curbgColor[0]) >> 8,
1053                                         (u32)(fper * curbgColor[1]) >> 8,
1054                                         (u32)(fper * curbgColor[2]) >> 8,
1055                                         0x080);
1056
1057                         ++buf;
1058                 }
1059
1060         }
1061
1062         pery = ymax;
1063         rmDrawPixmap(&gBackgroundTex, 0, 0, ALIGN_NONE, screenWidth, screenHeight, SCALING_NONE, gDefaultCol);
1064 }
1065
1066 int guiDrawIconAndText(int iconId, int textId, int font, int x, int y, u64 color) {
1067         GSTEXTURE* iconTex = thmGetTexture(iconId);
1068         if (iconTex && iconTex->Mem) {
1069                 rmDrawPixmap(iconTex, x, y, ALIGN_NONE, iconTex->Width, iconTex->Height, SCALING_RATIO, gDefaultCol);
1070                 x += iconTex->Width + 2;
1071         }
1072
1073         x = fntRenderString(font, x, y, ALIGN_NONE, 0, 0, _l(textId), color);
1074
1075         return x;
1076 }
1077
1078 static void guiDrawOverlays() {
1079         // are there any pending operations?
1080         int pending = ioHasPendingRequests();
1081
1082         if (!pending) {
1083                 if (bfadeout > 0x0)
1084                         bfadeout -= 0x08;
1085                 else
1086                         bfadeout = 0x0;
1087         } else {
1088                 if (bfadeout < 0x080)
1089                         bfadeout += 0x20;
1090         }
1091
1092         if (bfadeout > 0)
1093                 guiDrawBusy();
1094
1095 #ifdef __DEBUG
1096         // fps meter
1097         char fps[20];
1098
1099         if (time_since_last != 0)
1100                 snprintf(fps, 20, "%3d ms %3.1f FPS", time_render, 1000.0f / (float) time_since_last);
1101         else
1102                 snprintf(fps, 20, "%3d ms ----- FPS", time_render);
1103
1104         fntRenderString(FNT_DEFAULT, screenWidth - 90, 30, ALIGN_CENTER, 0, 0, fps, GS_SETREG_RGBA(0x060, 0x060, 0x060, 0x060));
1105 #endif
1106 }
1107
1108 static void guiReadPads() {
1109         if (readPads())
1110                 guiInactiveFrames = 0;
1111         else
1112                 guiInactiveFrames++;
1113 }
1114
1115 // renders the screen and handles inputs. Also handles screen transitions between numerous
1116 // screen handlers. For now we only have left-to right screen transition
1117 static void guiShow() {
1118         // is there a transmission effect going on or are
1119         // we in a normal rendering state?
1120         if (screenHandlerTarget) {
1121                 // advance the effect
1122
1123                 // render the old screen, transposed
1124                 rmSetTransposition(transIndex * transitionX, transIndex * transitionY);
1125                 screenHandler->renderScreen();
1126
1127                 // render new screen transposed again
1128                 rmSetTransposition((transIndex - transMax) * transitionX, (transIndex - transMax) * transitionY);
1129                 screenHandlerTarget->renderScreen();
1130
1131                 // reset transposition to zero
1132                 rmSetTransposition(0, 0);
1133
1134                 // move the transition indicator forward
1135                 transIndex += (min(transIndex, transMax - transIndex) >> 1) + 1;
1136
1137                 if (transIndex > transMax) {
1138                         transitionX = 0;
1139                         transitionY = 0;
1140                         screenHandler = screenHandlerTarget;
1141                         screenHandlerTarget = NULL;
1142                 }
1143         } else
1144                 // render with the set screen handler
1145                 screenHandler->renderScreen();
1146 }
1147
1148 void guiIntroLoop(void) {
1149         int endIntro = 0;
1150         while (!endIntro) {
1151                 guiStartFrame();
1152
1153                 guiReadPads();
1154
1155                 if (wfadeout < 0x0FF)
1156                         guiShow();
1157
1158                 if (gInitComplete)
1159                         wfadeout--;
1160
1161                 if (wfadeout > 0)
1162                         guiRenderGreeting();
1163                 else
1164                         endIntro = 1;
1165
1166                 guiHandleDeferredOps();
1167
1168                 guiEndFrame();
1169
1170                 if (!screenHandlerTarget && screenHandler)
1171                         screenHandler->handleInput();
1172         }
1173 }
1174
1175 void guiMainLoop(void) {
1176         while (!gTerminate) {
1177                 guiStartFrame();
1178
1179                 // Read the pad states to prepare for input processing in the screen handler
1180                 guiReadPads();
1181
1182                 // handle inputs and render screen
1183                 guiShow();
1184
1185                 // Render overlaying gui thingies :)
1186                 guiDrawOverlays();
1187
1188                 // handle deferred operations
1189                 guiHandleDeferredOps();
1190
1191                 guiEndFrame();
1192
1193                 // if not transiting, handle input
1194                 // done here so we can use renderman if needed
1195                 if (!screenHandlerTarget && screenHandler)
1196                         screenHandler->handleInput();
1197
1198                 if (gFrameHook)
1199                         gFrameHook();
1200         }
1201 }
1202
1203 void guiSetFrameHook(gui_callback_t cback) {
1204         gFrameHook = cback;
1205 }
1206
1207 void guiSwitchScreen(int target, int transition) {
1208         if (transition == TRANSITION_LEFT) {
1209                 transitionX = 1;
1210                 transMax = screenWidth;
1211         } else if (transition == TRANSITION_RIGHT) {
1212                 transitionX = -1;
1213                 transMax = screenWidth;
1214         } else if (transition == TRANSITION_UP) {
1215                 transitionY = 1;
1216                 transMax = screenHeight;
1217         } else if (transition == TRANSITION_DOWN) {
1218                 transitionY = -1;
1219                 transMax = screenHeight;
1220         }
1221         transIndex = 0;
1222
1223         screenHandlerTarget = &screenHandlers[target];
1224 }
1225
1226 struct gui_update_t *guiOpCreate(gui_op_type_t type) {
1227         struct gui_update_t *op = (struct gui_update_t *) malloc(sizeof(struct gui_update_t));
1228         memset(op, 0, sizeof(struct gui_update_t));
1229         op->type = type;
1230         return op;
1231 }
1232
1233 void guiUpdateScrollSpeed(void) {
1234         // sanitize the settings
1235         if ((gScrollSpeed < 0) || (gScrollSpeed > 2))
1236                 gScrollSpeed = 1;
1237
1238         // update the pad delays for KEY_UP and KEY_DOWN
1239         // default delay is 7
1240         // fast - 100 ms
1241         // medium - 300 ms
1242         // slow - 500 ms
1243         setButtonDelay(KEY_UP, 500 - gScrollSpeed * 200); // 0,1,2 -> 500, 300, 100
1244         setButtonDelay(KEY_DOWN, 500 - gScrollSpeed * 200);
1245 }
1246
1247 void guiUpdateScreenScale(void) {
1248         if (gWideScreen)
1249                 wideScreenScale = 0.75f;
1250         else
1251                 wideScreenScale = 1.0f;
1252
1253         // apply the scaling to renderman and font rendering
1254         rmSetAspectRatio(wideScreenScale, 1.0f);
1255         fntSetAspectRatio(wideScreenScale, 1.0f);
1256 }
1257
1258 int guiMsgBox(const char* text, int addAccept, struct UIItem *ui) {
1259         int terminate = 0;
1260         while (!terminate) {
1261                 guiStartFrame();
1262
1263                 readPads();
1264
1265                 if (getKeyOn(KEY_CIRCLE))
1266                         terminate = 1;
1267                 else if (getKeyOn(KEY_CROSS))
1268                         terminate = 2;
1269
1270                 if (ui)
1271                         diaRenderUI(ui, screenHandler->inMenu, NULL, 0);
1272                 else
1273                         guiShow();
1274
1275                 rmDrawRect(0, 0, screenWidth, screenHeight, gColDarker);
1276
1277                 rmDrawLine(50, 75, screenWidth - 50, 75, gColWhite);
1278                 rmDrawLine(50, 410, screenWidth - 50, 410, gColWhite);
1279
1280                 fntRenderString(FNT_DEFAULT, screenWidth >> 1, gTheme->usedHeight >> 1, ALIGN_CENTER, 0, 0, text, gTheme->textColor);
1281                 guiDrawIconAndText(CIRCLE_ICON, _STR_O_BACK, FNT_DEFAULT, 500, 417, gTheme->selTextColor);
1282                 if (addAccept)
1283                         guiDrawIconAndText(CROSS_ICON, _STR_X_ACCEPT, FNT_DEFAULT, 70, 417, gTheme->selTextColor);
1284
1285                 guiEndFrame();
1286         }
1287
1288         return terminate - 1;
1289 }
1290
1291 void guiHandleDeferedIO(int *ptr, const unsigned char* message, int type, void *data) {
1292         ioPutRequest(type, data);
1293
1294         while (*ptr)
1295                 guiRenderTextScreen(message);
1296 }
1297
1298 void guiRenderTextScreen(const unsigned char* message) {
1299         guiStartFrame();
1300
1301         guiShow();
1302
1303         rmDrawRect(0, 0, screenWidth, screenHeight, gColDarker);
1304
1305         fntRenderString(FNT_DEFAULT, screenWidth >> 1, gTheme->usedHeight >> 1, ALIGN_CENTER, 0, 0, message, gTheme->textColor);
1306
1307         guiDrawOverlays();
1308
1309         guiEndFrame();
1310 }