#include <gccore.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <dirent.h>
#include <time.h>
#include <stdlib.h>

#include "usbloader/wbfs.h"
#include "usbloader/wdvd.h"
#include "usbloader/partition_usbloader.h"
#include "usbloader/usbstorage2.h"
#include "usbloader/GameList.h"
#include "language/gettext.h"
#include "libwiigui/gui.h"
#include "libwiigui/gui_diskcover.h"
#include "libwiigui/Text.hpp"
#include "network/networkops.h"
#include "network/http.h"
#include "prompts/PromptWindows.h"
#include "prompts/gameinfo.h"
#include "mload/mload.h"
#include "fatmounter.h"
#include "listfiles.h"
#include "menu.h"
#include "menu.h"
#include "filelist.h"
#include "sys.h"
#include "wpad.h"
#include "wad/wad.h"
#include "unzip/unzip.h"
#include "zlib.h"
#include "svnrev.h"
#include "audio.h"
#include "xml/xml.h"
#include "language/UpdateLanguage.h"
#include "gecko.h"
#include "lstub.h"
#include "bannersound.h"
#include "buildtype.h"

/*** Variables that are also used extern ***/
int cntMissFiles = 0;

/*** Variables used only in this file ***/
static char missingFiles[500][12];

/*** Extern variables ***/
extern GuiWindow * mainWindow;
extern GuiSound * bgMusic;
s32 gameSelected = 0, gameStart = 0;
extern float gamesize;
extern u8 shutdown;
extern u8 reset;
extern u8 mountMethod;
extern struct discHdr *dvdheader;
extern char game_partition[6];

/*** Extern functions ***/
extern void ResumeGui();
extern void HaltGui();

/****************************************************************************
 * OnScreenNumpad
 *
 * Opens an on-screen numpad window, with the data entered being stored
 * into the specified variable.
 ***************************************************************************/
int OnScreenNumpad( char * var, u32 maxlen )
{
    int save = -1;

    GuiNumpad numpad( var, maxlen );

    GuiSound btnSoundOver( button_over_pcm, button_over_pcm_size, Settings.sfxvolume );
    // because destroy GuiSound must wait while sound playing is finished, we use a global sound
    if ( !btnClick2 ) btnClick2 = new GuiSound( button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume );

    char imgPath[100];
    snprintf( imgPath, sizeof( imgPath ), "%sbutton_dialogue_box.png", Settings.theme_path );
    GuiImageData btnOutline( imgPath, button_dialogue_box_png );

    GuiTrigger trigA;
    trigA.SetSimpleTrigger( -1, WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A, PAD_BUTTON_A );
    GuiTrigger trigB;
    trigB.SetSimpleTrigger( -1, WPAD_BUTTON_B | WPAD_CLASSIC_BUTTON_B, PAD_BUTTON_B );

    GuiText okBtnTxt( tr( "OK" ), 22, THEME.prompttext );
    GuiImage okBtnImg( &btnOutline );
    if ( Settings.wsprompt == yes )
    {
        okBtnTxt.SetWidescreen( Settings.widescreen );
        okBtnImg.SetWidescreen( Settings.widescreen );
    }
    GuiButton okBtn( &okBtnImg, &okBtnImg, 0, 4, 5, -15, &trigA, &btnSoundOver, btnClick2, 1 );
    okBtn.SetLabel( &okBtnTxt );
    GuiText cancelBtnTxt( tr( "Cancel" ), 22, THEME.prompttext );
    GuiImage cancelBtnImg( &btnOutline );
    if ( Settings.wsprompt == yes )
    {
        cancelBtnTxt.SetWidescreen( Settings.widescreen );
        cancelBtnImg.SetWidescreen( Settings.widescreen );
    }
    GuiButton cancelBtn( &cancelBtnImg, &cancelBtnImg, 1, 4, -5, -15, &trigA, &btnSoundOver, btnClick2, 1 );
    cancelBtn.SetLabel( &cancelBtnTxt );
    cancelBtn.SetTrigger( &trigB );

    numpad.Append( &okBtn );
    numpad.Append( &cancelBtn );

    HaltGui();
    mainWindow->SetState( STATE_DISABLED );
    mainWindow->Append( &numpad );
    mainWindow->ChangeFocus( &numpad );
    ResumeGui();

    while ( save == -1 )
    {
        VIDEO_WaitVSync();

        if ( okBtn.GetState() == STATE_CLICKED )
            save = 1;
        else if ( cancelBtn.GetState() == STATE_CLICKED )
            save = 0;
    }

    if ( save == 1 )
    {
        snprintf( var, maxlen, "%s", numpad.kbtextstr );
    }

    HaltGui();
    mainWindow->Remove( &numpad );
    mainWindow->SetState( STATE_DEFAULT );
    ResumeGui();
    gprintf( "\t%s", ( save == 1 ? "saved" : "discarded" ) );
    return save;
}

/****************************************************************************
 * OnScreenKeyboard
 *
 * Opens an on-screen keyboard window, with the data entered being stored
 * into the specified variable.
 ***************************************************************************/
int OnScreenKeyboard( char * var, u32 maxlen, int min )
{

    int save = -1;
    int keyset = 0;
    if ( Settings.keyset == us ) keyset = 0;
    else if ( Settings.keyset == dvorak ) keyset = 1;
    else if ( Settings.keyset == euro ) keyset = 2;
    else if ( Settings.keyset == azerty ) keyset = 3;
    else if ( Settings.keyset == qwerty ) keyset = 4;

    gprintf( "\nOnScreenKeyboard(%s, %i, %i) \n\tkeyset = %i", var, maxlen, min, keyset );

    GuiKeyboard keyboard( var, maxlen, min, keyset );

    GuiSound btnSoundOver( button_over_pcm, button_over_pcm_size, Settings.sfxvolume );
    // because destroy GuiSound must wait while sound playing is finished, we use a global sound
    if ( !btnClick2 ) btnClick2 = new GuiSound( button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume );
    //  GuiSound btnClick(button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume);

    char imgPath[100];
    snprintf( imgPath, sizeof( imgPath ), "%sbutton_dialogue_box.png", Settings.theme_path );
    GuiImageData btnOutline( imgPath, button_dialogue_box_png );

    GuiTrigger trigA;
    trigA.SetSimpleTrigger( -1, WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A, PAD_BUTTON_A );
    GuiTrigger trigB;
    trigB.SetSimpleTrigger( -1, WPAD_BUTTON_B | WPAD_CLASSIC_BUTTON_B, PAD_BUTTON_B );

    GuiText okBtnTxt( tr( "OK" ), 22, THEME.prompttext );
    GuiImage okBtnImg( &btnOutline );
    if ( Settings.wsprompt == yes )
    {
        okBtnTxt.SetWidescreen( Settings.widescreen );
        okBtnImg.SetWidescreen( Settings.widescreen );
    }
    GuiButton okBtn( &okBtnImg, &okBtnImg, 0, 4, 5, 15, &trigA, &btnSoundOver, btnClick2, 1 );
    okBtn.SetLabel( &okBtnTxt );
    GuiText cancelBtnTxt( tr( "Cancel" ), 22, THEME.prompttext );
    GuiImage cancelBtnImg( &btnOutline );
    if ( Settings.wsprompt == yes )
    {
        cancelBtnTxt.SetWidescreen( Settings.widescreen );
        cancelBtnImg.SetWidescreen( Settings.widescreen );
    }
    GuiButton cancelBtn( &cancelBtnImg, &cancelBtnImg, 1, 4, -5, 15, &trigA, &btnSoundOver, btnClick2, 1 );
    cancelBtn.SetLabel( &cancelBtnTxt );
    cancelBtn.SetTrigger( &trigB );

    keyboard.Append( &okBtn );
    keyboard.Append( &cancelBtn );

    HaltGui();
    mainWindow->SetState( STATE_DISABLED );
    mainWindow->Append( &keyboard );
    mainWindow->ChangeFocus( &keyboard );
    ResumeGui();

    while ( save == -1 )
    {
        VIDEO_WaitVSync();

        if ( okBtn.GetState() == STATE_CLICKED )
            save = 1;
        else if ( cancelBtn.GetState() == STATE_CLICKED )
            save = 0;
    }

    if ( save )
    {
        snprintf( var, maxlen, "%s", keyboard.kbtextstr );
    }

    HaltGui();
    mainWindow->Remove( &keyboard );
    mainWindow->SetState( STATE_DEFAULT );
    ResumeGui();
    gprintf( "\t%s", ( save ? "saved" : "discarded" ) );
    return save;
}

/****************************************************************************
 * WindowCredits
 * Display credits
 ***************************************************************************/
void WindowCredits()
{
    gprintf( "WindowCredits()\n" );

    int angle = 0;
    GuiSound * creditsMusic = NULL;

    bgMusic->Pause();

    creditsMusic = new GuiSound( credits_music_ogg, credits_music_ogg_size, 55 );
    creditsMusic->SetVolume( 60 );
    creditsMusic->SetLoop( 1 );
    creditsMusic->Play();

    bool exit = false;
    int i = 0;
    int y = 20;

    GuiWindow creditsWindow( screenwidth, screenheight );
    GuiWindow creditsWindowBox( 580, 448 );
    creditsWindowBox.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );

    GuiImageData creditsBox( credits_bg_png );
    GuiImage creditsBoxImg( &creditsBox );
    creditsBoxImg.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    creditsWindowBox.Append( &creditsBoxImg );

    GuiImageData star( little_star_png );
    GuiImage starImg( &star );
    starImg.SetWidescreen( Settings.widescreen ); //added
    starImg.SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    starImg.SetPosition( 505, 350 );

    int numEntries = 21;
    GuiText * txt[numEntries];

    txt[i] = new GuiText( tr( "Credits" ), 26, ( GXColor ) {255, 255, 255, 255} );
    txt[i]->SetAlignment( ALIGN_CENTRE, ALIGN_TOP );
    txt[i]->SetPosition( 0, 12 );
    i++;


#ifdef FULLCHANNEL
    char svnTmp[4];//did this to hide the M after the rev# that is made by altering it
    //to be ready to be in a full channel
    snprintf( svnTmp, sizeof( svnTmp ), "%s", GetRev() );
    char SvnRev[30];
    snprintf( SvnRev, sizeof( SvnRev ), "Rev%sc   IOS%u (Rev %u)", svnTmp, IOS_GetVersion(), IOS_GetRevision() );
#else
    char SvnRev[30];
    snprintf( SvnRev, sizeof( SvnRev ), "Rev%s   IOS%u (Rev %u)", GetRev(), IOS_GetVersion(), IOS_GetRevision() );
#endif




    txt[i] = new GuiText( SvnRev, 16, ( GXColor ) { 255, 255, 255, 255} );
    txt[i]->SetAlignment( ALIGN_RIGHT, ALIGN_TOP );
    txt[i]->SetPosition( 0, y );
    i++;
    y += 34;

    txt[i] = new GuiText( "USB Loader GX", 24, ( GXColor ) {255, 255, 255, 255} );
    txt[i]->SetAlignment( ALIGN_CENTRE, ALIGN_TOP );
    txt[i]->SetPosition( 0, y );
    i++;
    y += 26;

    txt[i] = new GuiText( tr( "Official Site:" ), 20, ( GXColor ) {255, 255, 255, 255} );
    txt[i]->SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    txt[i]->SetPosition( 10, y );
    i++;

    txt[i] = new GuiText( "http://code.google.com/p/usbloader-gui/", 20, ( GXColor ) {255, 255, 255, 255} );
    txt[i]->SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    txt[i]->SetPosition( 160, y );
    i++;
    y += 26;

    GuiText::SetPresets( 22, ( GXColor ) {255, 255, 255,  255}, 3000, FTGX_JUSTIFY_LEFT | FTGX_ALIGN_TOP, ALIGN_LEFT, ALIGN_TOP );

    txt[i] = new GuiText( tr( "Coding:" ) );
    txt[i]->SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    txt[i]->SetPosition( 10, y );
    i++;

    txt[i] = new GuiText( "dimok / nIxx / giantpune / ardi" );
    txt[i]->SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    txt[i]->SetPosition( 160, y );
    i++;
    y += 22;

    txt[i] = new GuiText( "hungyip84 / DrayX7 / lustar / r-win" );
    txt[i]->SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    txt[i]->SetPosition( 160, y );
    i++;
    y += 26;

    char text[100];

    txt[i] = new GuiText( tr( "Design:" ) );
    txt[i]->SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    txt[i]->SetPosition( 10, y );
    i++;

    txt[i] = new GuiText( "cyrex / NeoRame" );
    txt[i]->SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    txt[i]->SetPosition( 160, y );
    i++;
    y += 26;

    txt[i] = new GuiText( tr( "Big thanks to:" ) );
    txt[i]->SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    txt[i]->SetPosition( 10, y );
    i++;

    sprintf( text, "lustar %s", tr( "for WiiTDB and hosting covers / disc images" ) );
    txt[i] = new GuiText( text );
    txt[i]->SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    txt[i]->SetPosition( 160, y );
    i++;
    y += 22;

    sprintf( text, "CorneliousJD %s", tr( "for hosting the update files" ) );
    txt[i] = new GuiText( text );
    txt[i]->SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    txt[i]->SetPosition( 160, y );
    i++;
    y += 22;

    sprintf( text, "Kinyo %s", tr( "and translaters for language files updates" ) );
    txt[i] = new GuiText( text );
    txt[i]->SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    txt[i]->SetPosition( 160, y );
    i++;
    y += 22;

    sprintf( text, "Deak Phreak %s", tr( "for hosting the themes" ) );
    txt[i] = new GuiText( text );
    txt[i]->SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    txt[i]->SetPosition( 160, y );
    i++;
    y += 26;

    txt[i] = new GuiText( tr( "Special thanks to:" ) );
    txt[i]->SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    txt[i]->SetPosition( 10, y );
    i++;
    y += 22;

    sprintf( text, "Waninkoko, Kwiirk & Hermes %s", tr( "for the USB Loader source" ) );
    txt[i] = new GuiText( text );
    txt[i]->SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    txt[i]->SetPosition( 60, y );
    i++;
    y += 22;

    sprintf( text, "Tantric %s", tr( "for his awesome tool LibWiiGui" ) );
    txt[i] = new GuiText( text );
    txt[i]->SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    txt[i]->SetPosition( 60, y );
    i++;
    y += 22;

    sprintf( text, "Fishears/Nuke %s", tr( "for Ocarina" ) );
    txt[i] = new GuiText( text );
    txt[i]->SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    txt[i]->SetPosition( 60, y );
    i++;
    y += 22;

    sprintf( text, "WiiPower %s", tr( "for diverse patches" ) );
    txt[i] = new GuiText( text );
    txt[i]->SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    txt[i]->SetPosition( 60, y );
    i++;
    y += 22;

    sprintf( text, "Oggzee %s", tr( "for FAT/NTFS support" ) );
    txt[i] = new GuiText( text );
    txt[i]->SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    txt[i]->SetPosition( 60, y );
    i++;
    y += 22;

    for ( i = 0; i < numEntries; i++ )
        creditsWindowBox.Append( txt[i] );


    creditsWindow.Append( &creditsWindowBox );
    creditsWindow.Append( &starImg );

    creditsWindow.SetEffect( EFFECT_FADE, 30 );

    HaltGui();
    mainWindow->SetState( STATE_DISABLED );
    mainWindow->Append( &creditsWindow );
    ResumeGui();

    while ( !exit )
    {
        angle++;
        if ( angle > 360 )
            angle = 0;
        usleep( 12000 );
        starImg.SetAngle( angle );
        if ( ButtonsPressed() != 0 )
            exit = true;

    }

    creditsMusic->Stop();

    delete creditsMusic;

    creditsWindow.SetEffect( EFFECT_FADE, -30 );
    while ( creditsWindow.GetEffect() > 0 ) usleep( 50 );
    HaltGui();
    mainWindow->Remove( &creditsWindow );
    mainWindow->SetState( STATE_DEFAULT );
    for ( i = 0; i < numEntries; i++ )
    {
        delete txt[i];
        txt[i] = NULL;
    }
    ResumeGui();

    bgMusic->Resume();
}

/****************************************************************************
 * WindowScreensaver
 * Display screensaver
 ***************************************************************************/
int WindowScreensaver()
{
    gprintf( "WindowScreenSaver()\n" );
    int i = 0;
    bool exit = false;
    char imgPath[100];//uncomment for themable screensaver

    /* initialize random seed: */
    srand ( time( NULL ) );

    snprintf( imgPath, sizeof( imgPath ), "%sscreensaver.png", Settings.theme_path );//uncomment for themable screensaver
    GuiImageData GXlogo( imgPath, gxlogo_png );//uncomment for themable screensaver
    //GuiImageData GXlogo(gxlogo_png);//comment for themable screensaver
    GuiImage GXlogoImg( &GXlogo );
    GXlogoImg.SetPosition( 172, 152 );
    GXlogoImg.SetAlignment( ALIGN_LEFT, ALIGN_TOP );

    GuiImage BackgroundImg( 640, 480, ( GXColor ) {0, 0, 0, 255} );
    BackgroundImg.SetPosition( 0, 0 );
    BackgroundImg.SetAlignment( ALIGN_LEFT, ALIGN_TOP );

    GuiWindow screensaverWindow( screenwidth, screenheight );
    screensaverWindow.Append( &BackgroundImg );
    screensaverWindow.Append( &GXlogoImg );

    HaltGui();
    mainWindow->SetState( STATE_DISABLED );
    mainWindow->Append( &screensaverWindow );
    ResumeGui();

    while ( !exit )
    {
        i++;
        if ( IsWpadConnected() )
        {
            exit = true;
        }
        /* Set position only every 400000th loop */
        if ( ( i % 8000000 ) == 0 )
        {
            /* Set random position */
            GXlogoImg.SetPosition( ( rand() % 345 ), ( rand() % 305 ) );
        }

    }

    HaltGui();
    mainWindow->Remove( &screensaverWindow );
    mainWindow->SetState( STATE_DEFAULT );
    ResumeGui();
    return 1;
}

/****************************************************************************
 * WindowPrompt
 *
 * Displays a prompt window to user, with information, an error message, or
 * presenting a user with a choice of up to 4 Buttons.
 *
 * Give him 1 Title, 1 Subtitle and 4 Buttons
 * If title/subtitle or one of the buttons is not needed give him a 0 on that
 * place.
 ***************************************************************************/
int WindowPrompt( const char *title, const char *msg, const char *btn1Label,
                  const char *btn2Label, const char *btn3Label,
                  const char *btn4Label, int wait )
{
    int choice = -1;
    int count = wait;
    gprintf( "WindowPrompt( %s, %s, %s, %s, %s, %s, %i ): ", title, msg, btn1Label, btn2Label, btn3Label, btn4Label, wait );


    GuiWindow promptWindow( 472, 320 );
    promptWindow.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    promptWindow.SetPosition( 0, -10 );

    GuiSound btnSoundOver( button_over_pcm, button_over_pcm_size, Settings.sfxvolume );
    // because destroy GuiSound must wait while sound playing is finished, we use a global sound
    if ( !btnClick2 ) btnClick2 = new GuiSound( button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume );
    //  GuiSound btnClick(button_click2_pcm, button_click2_pcm_size,  Settings.sfxvolume);
    char imgPath[100];
    snprintf( imgPath, sizeof( imgPath ), "%sbutton_dialogue_box.png", Settings.theme_path );
    GuiImageData btnOutline( imgPath, button_dialogue_box_png );
    snprintf( imgPath, sizeof( imgPath ), "%sdialogue_box.png", Settings.theme_path );
    GuiImageData dialogBox( imgPath, dialogue_box_png );


    GuiTrigger trigA;
    trigA.SetSimpleTrigger( -1, WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A, PAD_BUTTON_A );
    GuiTrigger trigB;
    trigB.SetButtonOnlyTrigger( -1, WPAD_BUTTON_B | WPAD_CLASSIC_BUTTON_B, PAD_BUTTON_B );

    GuiImage dialogBoxImg( &dialogBox );
    if ( Settings.wsprompt == yes )
    {
        dialogBoxImg.SetWidescreen( Settings.widescreen );
    }

    GuiText titleTxt( title, 26, THEME.prompttext );
    titleTxt.SetAlignment( ALIGN_CENTRE, ALIGN_TOP );
    titleTxt.SetPosition( 0, 55 );
    GuiText msgTxt( msg, 22, THEME.prompttext );
    msgTxt.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    msgTxt.SetPosition( 0, -40 );
    msgTxt.SetMaxWidth( 430 );

    GuiText btn1Txt( btn1Label, 22, THEME.prompttext );
    GuiImage btn1Img( &btnOutline );
    if ( Settings.wsprompt == yes )
    {
        btn1Txt.SetWidescreen( Settings.widescreen );
        btn1Img.SetWidescreen( Settings.widescreen );
    }

    GuiButton btn1( &btn1Img, &btn1Img, 0, 3, 0, 0, &trigA, &btnSoundOver, btnClick2, 1 );
    btn1.SetLabel( &btn1Txt );
    btn1.SetState( STATE_SELECTED );

    GuiText btn2Txt( btn2Label, 22, THEME.prompttext );
    GuiImage btn2Img( &btnOutline );
    if ( Settings.wsprompt == yes )
    {
        btn2Txt.SetWidescreen( Settings.widescreen );
        btn2Img.SetWidescreen( Settings.widescreen );
    }
    GuiButton btn2( &btn2Img, &btn2Img, 0, 3, 0, 0, &trigA, &btnSoundOver, btnClick2, 1 );
    btn2.SetLabel( &btn2Txt );
    if ( !btn3Label && !btn4Label )
        btn2.SetTrigger( &trigB );

    GuiText btn3Txt( btn3Label, 22, THEME.prompttext );
    GuiImage btn3Img( &btnOutline );
    if ( Settings.wsprompt == yes )
    {
        btn3Txt.SetWidescreen( Settings.widescreen );
        btn3Img.SetWidescreen( Settings.widescreen );
    }
    GuiButton btn3( &btn3Img, &btn3Img, 0, 3, 0, 0, &trigA, &btnSoundOver, btnClick2, 1 );
    btn3.SetLabel( &btn3Txt );
    if ( !btn4Label )
        btn3.SetTrigger( &trigB );

    GuiText btn4Txt( btn4Label, 22, THEME.prompttext );
    GuiImage btn4Img( &btnOutline );
    if ( Settings.wsprompt == yes )
    {
        btn4Txt.SetWidescreen( Settings.widescreen );
        btn4Img.SetWidescreen( Settings.widescreen );
    }
    GuiButton btn4( &btn4Img, &btn4Img, 0, 3, 0, 0, &trigA, &btnSoundOver, btnClick2, 1 );
    btn4.SetLabel( &btn4Txt );
    if ( btn4Label )
        btn4.SetTrigger( &trigB );

    if ( ( Settings.wsprompt == yes ) && ( Settings.widescreen ) )  /////////////adjust buttons for widescreen
    {
        msgTxt.SetMaxWidth( 330 );

        if ( btn2Label && !btn3Label && !btn4Label )
        {
            btn1.SetAlignment( ALIGN_LEFT, ALIGN_BOTTOM );
            btn1.SetPosition( 70, -80 );
            btn2.SetAlignment( ALIGN_RIGHT, ALIGN_BOTTOM );
            btn2.SetPosition( -70, -80 );
            btn3.SetAlignment( ALIGN_RIGHT, ALIGN_BOTTOM );
            btn3.SetPosition( -70, -55 );
            btn4.SetAlignment( ALIGN_LEFT, ALIGN_BOTTOM );
            btn4.SetPosition( 70, -55 );
        }
        else if ( btn2Label && btn3Label && !btn4Label )
        {
            btn1.SetAlignment( ALIGN_LEFT, ALIGN_BOTTOM );
            btn1.SetPosition( 70, -120 );
            btn2.SetAlignment( ALIGN_RIGHT, ALIGN_BOTTOM );
            btn2.SetPosition( -70, -120 );
            btn3.SetAlignment( ALIGN_CENTRE, ALIGN_BOTTOM );
            btn3.SetPosition( 0, -55 );
            btn4.SetAlignment( ALIGN_LEFT, ALIGN_BOTTOM );
            btn4.SetPosition( 70, -55 );
        }
        else if ( btn2Label && btn3Label && btn4Label )
        {
            btn1.SetAlignment( ALIGN_LEFT, ALIGN_BOTTOM );
            btn1.SetPosition( 70, -120 );
            btn2.SetAlignment( ALIGN_RIGHT, ALIGN_BOTTOM );
            btn2.SetPosition( -70, -120 );
            btn3.SetAlignment( ALIGN_LEFT, ALIGN_BOTTOM );
            btn3.SetPosition( 70, -55 );
            btn4.SetAlignment( ALIGN_RIGHT, ALIGN_BOTTOM );
            btn4.SetPosition( -70, -55 );
        }
        else if ( !btn2Label && btn3Label && btn4Label )
        {
            btn1.SetAlignment( ALIGN_CENTRE, ALIGN_BOTTOM );
            btn1.SetPosition( 0, -120 );
            btn2.SetAlignment( ALIGN_RIGHT, ALIGN_BOTTOM );
            btn2.SetPosition( -70, -120 );
            btn3.SetAlignment( ALIGN_LEFT, ALIGN_BOTTOM );
            btn3.SetPosition( 70, -55 );
            btn4.SetAlignment( ALIGN_RIGHT, ALIGN_BOTTOM );
            btn4.SetPosition( -70, -55 );
        }
        else
        {
            btn1.SetAlignment( ALIGN_CENTRE, ALIGN_BOTTOM );
            btn1.SetPosition( 0, -80 );
            btn2.SetAlignment( ALIGN_LEFT, ALIGN_BOTTOM );
            btn2.SetPosition( 70, -120 );
            btn3.SetAlignment( ALIGN_RIGHT, ALIGN_BOTTOM );
            btn3.SetPosition( -70, -55 );
            btn4.SetAlignment( ALIGN_LEFT, ALIGN_BOTTOM );
            btn4.SetPosition( 70, -55 );
        }
    }
    else
    {

        if ( btn2Label && !btn3Label && !btn4Label )
        {
            btn1.SetAlignment( ALIGN_LEFT, ALIGN_BOTTOM );
            btn1.SetPosition( 40, -45 );
            btn2.SetAlignment( ALIGN_RIGHT, ALIGN_BOTTOM );
            btn2.SetPosition( -40, -45 );
            btn3.SetAlignment( ALIGN_LEFT, ALIGN_BOTTOM );
            btn3.SetPosition( 50, -65 );
            btn4.SetAlignment( ALIGN_RIGHT, ALIGN_BOTTOM );
            btn4.SetPosition( -50, -65 );
        }
        else if ( btn2Label && btn3Label && !btn4Label )
        {
            btn1.SetAlignment( ALIGN_LEFT, ALIGN_BOTTOM );
            btn1.SetPosition( 50, -120 );
            btn2.SetAlignment( ALIGN_RIGHT, ALIGN_BOTTOM );
            btn2.SetPosition( -50, -120 );
            btn3.SetAlignment( ALIGN_CENTRE, ALIGN_BOTTOM );
            btn3.SetPosition( 0, -65 );
            btn4.SetAlignment( ALIGN_RIGHT, ALIGN_BOTTOM );
            btn4.SetPosition( -50, -65 );
        }
        else if ( btn2Label && btn3Label && btn4Label )
        {
            btn1.SetAlignment( ALIGN_LEFT, ALIGN_BOTTOM );
            btn1.SetPosition( 50, -120 );
            btn2.SetAlignment( ALIGN_RIGHT, ALIGN_BOTTOM );
            btn2.SetPosition( -50, -120 );
            btn3.SetAlignment( ALIGN_LEFT, ALIGN_BOTTOM );
            btn3.SetPosition( 50, -65 );
            btn4.SetAlignment( ALIGN_RIGHT, ALIGN_BOTTOM );
            btn4.SetPosition( -50, -65 );
        }
        else if ( !btn2Label && btn3Label && btn4Label )
        {
            btn1.SetAlignment( ALIGN_CENTRE, ALIGN_BOTTOM );
            btn1.SetPosition( 0, -120 );
            btn2.SetAlignment( ALIGN_RIGHT, ALIGN_BOTTOM );
            btn2.SetPosition( -50, -120 );
            btn3.SetAlignment( ALIGN_LEFT, ALIGN_BOTTOM );
            btn3.SetPosition( 50, -65 );
            btn4.SetAlignment( ALIGN_RIGHT, ALIGN_BOTTOM );
            btn4.SetPosition( -50, -65 );
        }
        else
        {
            btn1.SetAlignment( ALIGN_CENTRE, ALIGN_BOTTOM );
            btn1.SetPosition( 0, -45 );
            btn2.SetAlignment( ALIGN_LEFT, ALIGN_BOTTOM );
            btn2.SetPosition( 50, -120 );
            btn3.SetAlignment( ALIGN_LEFT, ALIGN_BOTTOM );
            btn3.SetPosition( 50, -65 );
            btn4.SetAlignment( ALIGN_RIGHT, ALIGN_BOTTOM );
            btn4.SetPosition( -50, -65 );
        }

    }

    GuiTrigger trigZ;
    trigZ.SetButtonOnlyTrigger( -1, WPAD_NUNCHUK_BUTTON_Z | WPAD_CLASSIC_BUTTON_ZL, PAD_TRIGGER_Z );

    GuiButton screenShotBtn( 0, 0 );
    screenShotBtn.SetPosition( 0, 0 );
    screenShotBtn.SetTrigger( &trigZ );

    promptWindow.Append( &dialogBoxImg );
    promptWindow.Append( &titleTxt );
    promptWindow.Append( &msgTxt );
    promptWindow.Append( &screenShotBtn );

    if ( btn1Label )
        promptWindow.Append( &btn1 );
    if ( btn2Label )
        promptWindow.Append( &btn2 );
    if ( btn3Label )
        promptWindow.Append( &btn3 );
    if ( btn4Label )
        promptWindow.Append( &btn4 );

    promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_IN, 50 );
    HaltGui();
    mainWindow->SetState( STATE_DISABLED );
    mainWindow->Append( &promptWindow );
    mainWindow->ChangeFocus( &promptWindow );
    ResumeGui();

    while ( choice == -1 )
    {
        VIDEO_WaitVSync();
        if ( shutdown == 1 )
        {
            wiilight( 0 );
            Sys_Shutdown();
        }
        if ( reset == 1 )
            Sys_Reboot();
        if ( btn1.GetState() == STATE_CLICKED )
        {
            choice = 1;
        }
        else if ( btn2.GetState() == STATE_CLICKED )
        {
            if ( !btn3Label )
                choice = 0;
            else
                choice = 2;
        }
        else if ( btn3.GetState() == STATE_CLICKED )
        {
            if ( !btn4Label )
                choice = 0;
            else
                choice = 3;
        }
        else if ( btn4.GetState() == STATE_CLICKED )
        {
            choice = 0;
        }
        else if ( screenShotBtn.GetState() == STATE_CLICKED )
	{
            screenShotBtn.ResetState();
	    ScreenShot();
        }
        if ( count > 0 )count--;
        if ( count == 0 ) choice = 1;
    }

    promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_OUT, 50 );
    while ( promptWindow.GetEffect() > 0 ) usleep( 50 );
    HaltGui();
    mainWindow->Remove( &promptWindow );
    mainWindow->SetState( STATE_DEFAULT );
    ResumeGui();
    gprintf( " %i\n", choice );

    return choice;
}

/****************************************************************************
 * WindowExitPrompt
 *
 * Displays a prompt window to user, with information, an error message, or
 * presenting a user with a choice of up to 4 Buttons.
 *
 * Give him 1 Titel, 1 Subtitel and 4 Buttons
 * If titel/subtitle or one of the buttons is not needed give him a 0 on that
 * place.
 ***************************************************************************/
int WindowExitPrompt()
{
    gprintf( "WindowExitPrompt()\n" );

    GuiSound * homein = NULL;
    homein = new GuiSound( menuin_ogg, menuin_ogg_size, Settings.sfxvolume );
    homein->SetVolume( Settings.sfxvolume );
    homein->SetLoop( 0 );
    homein->Play();

    GuiSound * homeout = NULL;
    homeout = new GuiSound( menuout_ogg, menuout_ogg_size, Settings.sfxvolume );
    homeout->SetVolume( Settings.sfxvolume );
    homeout->SetLoop( 0 );

    int choice = -1;
    char imgPath[100];

    u64 oldstub = getStubDest();
    loadStub();
    if ( oldstub != 0x00010001554c4e52ll && oldstub != 0x00010001554e454fll )
        Set_Stub( oldstub );

    GuiWindow promptWindow( 640, 480 );
    promptWindow.SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    promptWindow.SetPosition( 0, 0 );
    GuiSound btnSoundOver( button_over_pcm, button_over_pcm_size, Settings.sfxvolume );
    // because destroy GuiSound must wait while sound playing is finished, we use a global sound
    if ( !btnClick2 ) btnClick2 = new GuiSound( button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume );
    //  GuiSound btnClick(button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume);

    GuiImageData top( exit_top_png );
    GuiImageData topOver( exit_top_over_png );
    GuiImageData bottom( exit_bottom_png );
    GuiImageData bottomOver( exit_bottom_over_png );
    GuiImageData button( exit_button_png );
    GuiImageData wiimote( wiimote_png );
    GuiImageData close( closebutton_png );

    snprintf( imgPath, sizeof( imgPath ), "%sbattery_white.png", Settings.theme_path );
    GuiImageData battery( imgPath, battery_white_png );
    snprintf( imgPath, sizeof( imgPath ), "%sbattery_bar_white.png", Settings.theme_path );
    GuiImageData batteryBar( imgPath, battery_bar_white_png );
    snprintf( imgPath, sizeof( imgPath ), "%sbattery_red.png", Settings.theme_path );
    GuiImageData batteryRed( imgPath, battery_red_png );
    snprintf( imgPath, sizeof( imgPath ), "%sbattery_bar_red.png", Settings.theme_path );
    GuiImageData batteryBarRed( imgPath, battery_bar_red_png );

    int i = 0, ret = 0, level;
    char txt[3];
    GuiText * batteryTxt[4];
    GuiImage * batteryImg[4];
    GuiImage * batteryBarImg[4];
    GuiButton * batteryBtn[4];

    for ( i = 0; i < 4; i++ )
    {

        sprintf( txt, "P%d", i + 1 );

        batteryTxt[i] = new GuiText( txt, 22, ( GXColor ) {255, 255, 255, 255} );
        batteryTxt[i]->SetAlignment( ALIGN_LEFT, ALIGN_MIDDLE );
        batteryImg[i] = new GuiImage( &battery );
        batteryImg[i]->SetAlignment( ALIGN_LEFT, ALIGN_MIDDLE );
        batteryImg[i]->SetPosition( 36, 0 );
        batteryImg[i]->SetTile( 0 );
        batteryBarImg[i] = new GuiImage( &batteryBar );
        batteryBarImg[i]->SetAlignment( ALIGN_LEFT, ALIGN_MIDDLE );
        batteryBarImg[i]->SetPosition( 33, 0 );

        batteryBtn[i] = new GuiButton( 40, 20 );
        batteryBtn[i]->SetLabel( batteryTxt[i] );
        batteryBtn[i]->SetImage( batteryBarImg[i] );
        batteryBtn[i]->SetIcon( batteryImg[i] );
        batteryBtn[i]->SetAlignment( ALIGN_LEFT, ALIGN_MIDDLE );
        batteryBtn[i]->SetRumble( false );
        batteryBtn[i]->SetAlpha( 70 );
        batteryBtn[i]->SetEffect( EFFECT_SLIDE_BOTTOM | EFFECT_SLIDE_IN, 50 );
    }

    batteryBtn[0]->SetPosition( 180, 150 );
    batteryBtn[1]->SetPosition( 284, 150 );
    batteryBtn[2]->SetPosition( 388, 150 );
    batteryBtn[3]->SetPosition( 494, 150 );

    GuiTrigger trigA;
    trigA.SetSimpleTrigger( -1, WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A, PAD_BUTTON_A );
    GuiTrigger trigB;
    trigB.SetButtonOnlyTrigger( -1, WPAD_BUTTON_B | WPAD_CLASSIC_BUTTON_B, PAD_BUTTON_B );
    GuiTrigger trigHome;
    trigHome.SetButtonOnlyTrigger( -1, WPAD_BUTTON_HOME | WPAD_CLASSIC_BUTTON_HOME, 0 );

    GuiText titleTxt( tr( "HOME Menu" ), 36, ( GXColor ) {255, 255, 255, 255} );
    titleTxt.SetAlignment( ALIGN_CENTRE, ALIGN_TOP );
    titleTxt.SetPosition( -180, 40 );
    titleTxt.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_IN, 50 );

    GuiText closeTxt( tr( "Close" ), 28, ( GXColor ) {0, 0, 0, 255} );
    closeTxt.SetPosition( 10, 3 );
    GuiImage closeImg( &close );
    if ( Settings.wsprompt == yes )
    {
        closeTxt.SetWidescreen( Settings.widescreen );
        closeImg.SetWidescreen( Settings.widescreen );
    }
    GuiButton closeBtn( close.GetWidth(), close.GetHeight() );
    closeBtn.SetImage( &closeImg );
    closeBtn.SetAlignment( ALIGN_CENTRE, ALIGN_TOP );
    closeBtn.SetPosition( 190, 30 );
    closeBtn.SetLabel( &closeTxt );
    closeBtn.SetRumble( false );
    closeBtn.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_IN, 50 );

    GuiImage btn1Img( &top );
    GuiImage btn1OverImg( &topOver );
    GuiButton btn1( &btn1Img, &btn1OverImg, 0, 3, 0, 0, &trigA, &btnSoundOver, btnClick2, 0 );
    btn1.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_IN, 50 );

    GuiText btn2Txt( tr( "Back to Loader" ), 28, ( GXColor ) {0, 0, 0, 255} );
    GuiImage btn2Img( &button );
    if ( Settings.wsprompt == yes )
    {
        btn2Txt.SetWidescreen( Settings.widescreen );
        btn2Img.SetWidescreen( Settings.widescreen );
    }
    GuiButton btn2( &btn2Img, &btn2Img, 2, 5, -150, 0, &trigA, &btnSoundOver, btnClick2, 1 );
    btn2.SetLabel( &btn2Txt );
    btn2.SetEffect( EFFECT_SLIDE_LEFT | EFFECT_SLIDE_IN, 50 );
    btn2.SetRumble( false );
    btn2.SetPosition( -150, 0 );


    GuiText btn3Txt( tr( "Wii Menu" ), 28, ( GXColor ) {0, 0, 0, 255} );
    GuiImage btn3Img( &button );
    if ( Settings.wsprompt == yes )
    {
        btn3Txt.SetWidescreen( Settings.widescreen );
        btn3Img.SetWidescreen( Settings.widescreen );
    }
    GuiButton btn3( &btn3Img, &btn3Img, 2, 5, 150, 0, &trigA, &btnSoundOver, btnClick2, 1 );
    btn3.SetLabel( &btn3Txt );
    btn3.SetEffect( EFFECT_SLIDE_RIGHT | EFFECT_SLIDE_IN, 50 );
    btn3.SetRumble( false );
    btn3.SetPosition( 150, 0 );

    GuiImage btn4Img( &bottom );
    GuiImage btn4OverImg( &bottomOver );
    GuiButton btn4( &btn4Img, &btn4OverImg, 0, 4, 0, 0, &trigA, &btnSoundOver, btnClick2, 0 );
    btn4.SetTrigger( &trigB );
    btn4.SetTrigger( &trigHome );
    btn4.SetEffect( EFFECT_SLIDE_BOTTOM | EFFECT_SLIDE_IN, 50 );

    GuiImage wiimoteImg( &wiimote );
    if ( Settings.wsprompt == yes )
    {
        wiimoteImg.SetWidescreen( Settings.widescreen );
    }
    wiimoteImg.SetAlignment( ALIGN_LEFT, ALIGN_BOTTOM );
    wiimoteImg.SetEffect( EFFECT_SLIDE_BOTTOM | EFFECT_SLIDE_IN, 50 );
    wiimoteImg.SetPosition( 50, 210 );

    promptWindow.Append( &btn2 );
    promptWindow.Append( &btn3 );
    promptWindow.Append( &btn4 );
    promptWindow.Append( &btn1 );
    promptWindow.Append( &closeBtn );
    promptWindow.Append( &titleTxt );
    promptWindow.Append( &wiimoteImg );

    promptWindow.Append( batteryBtn[0] );
    promptWindow.Append( batteryBtn[1] );
    promptWindow.Append( batteryBtn[2] );
    promptWindow.Append( batteryBtn[3] );

    HaltGui();
    mainWindow->SetState( STATE_DISABLED );
    mainWindow->Append( &promptWindow );
    mainWindow->ChangeFocus( &promptWindow );
    ResumeGui();

    while ( choice == -1 )
    {
        VIDEO_WaitVSync();

        for ( i = 0; i < 4; i++ )
        {
            if ( WPAD_Probe( i, NULL ) == WPAD_ERR_NONE )   // controller connected
            {
                level = ( userInput[i].wpad.battery_level / 100.0 ) * 4;
                if ( level > 4 ) level = 4;

                if ( level <= 1 )
                {
                    batteryBarImg[i]->SetImage( &batteryBarRed );
                    batteryImg[i]->SetImage( &batteryRed );
                }
                else
                {
                    batteryBarImg[i]->SetImage( &batteryBar );
                }

                batteryImg[i]->SetTile( level );

                batteryBtn[i]->SetAlpha( 255 );
            }
            else   // controller not connected
            {
                batteryImg[i]->SetTile( 0 );
                batteryImg[i]->SetImage( &battery );
                batteryBtn[i]->SetAlpha( 70 );
            }
        }


        if ( shutdown == 1 )
        {
            wiilight( 0 );
            Sys_Shutdown();
        }
        if ( reset == 1 )
            Sys_Reboot();
        if ( btn1.GetState() == STATE_CLICKED )
        {
            choice = 1;
            btn1.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_OUT, 50 );
            closeBtn.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_OUT, 50 );
            btn4.SetEffect( EFFECT_SLIDE_BOTTOM | EFFECT_SLIDE_OUT, 50 );
            btn2.SetEffect( EFFECT_SLIDE_LEFT | EFFECT_SLIDE_OUT, 50 );
            btn3.SetEffect( EFFECT_SLIDE_RIGHT | EFFECT_SLIDE_OUT, 50 );
            titleTxt.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_OUT, 50 );
            wiimoteImg.SetEffect( EFFECT_SLIDE_BOTTOM | EFFECT_SLIDE_OUT, 50 );

            for ( int i = 0; i < 4; i++ )
                batteryBtn[i]->SetEffect( EFFECT_SLIDE_BOTTOM | EFFECT_SLIDE_OUT, 50 );

        }
        else if ( btn4.GetState() == STATE_SELECTED )
        {
            wiimoteImg.SetPosition( 50, 165 );
        }
        else if ( btn2.GetState() == STATE_CLICKED )
        {
            ret = WindowPrompt( tr( "Are you sure?" ), 0, tr( "Yes" ), tr( "No" ) );
            if ( ret == 1 )
            {

                choice = 2;
            }
            HaltGui();
            mainWindow->SetState( STATE_DISABLED );
            promptWindow.SetState( STATE_DEFAULT );
            mainWindow->ChangeFocus( &promptWindow );
            ResumeGui();
            btn2.ResetState();
        }
        else if ( btn3.GetState() == STATE_CLICKED )
        {
            ret = WindowPrompt( tr( "Are you sure?" ), 0, tr( "Yes" ), tr( "No" ) );
            if ( ret == 1 )
            {
                choice = 3;
            }
            HaltGui();
            mainWindow->SetState( STATE_DISABLED );
            promptWindow.SetState( STATE_DEFAULT );
            mainWindow->ChangeFocus( &promptWindow );
            ResumeGui();
            btn3.ResetState();
        }
        else if ( btn4.GetState() == STATE_CLICKED )
        {
            btn1.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_OUT, 50 );
            closeBtn.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_OUT, 50 );
            btn4.SetEffect( EFFECT_SLIDE_BOTTOM | EFFECT_SLIDE_OUT, 50 );
            btn2.SetEffect( EFFECT_SLIDE_LEFT | EFFECT_SLIDE_OUT, 50 );
            btn3.SetEffect( EFFECT_SLIDE_RIGHT | EFFECT_SLIDE_OUT, 50 );
            titleTxt.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_OUT, 50 );
            wiimoteImg.SetEffect( EFFECT_SLIDE_BOTTOM | EFFECT_SLIDE_OUT, 50 );

            for ( int i = 0; i < 4; i++ )
                batteryBtn[i]->SetEffect( EFFECT_SLIDE_BOTTOM | EFFECT_SLIDE_OUT, 50 );

            choice = 0;
        }
        else if ( btn4.GetState() != STATE_SELECTED )
        {
            wiimoteImg.SetPosition( 50, 210 );
        }
    }
    homeout->Play();
    while ( btn1.GetEffect() > 0 ) usleep( 50 );
    while ( promptWindow.GetEffect() > 0 ) usleep( 50 );
    HaltGui();
    homein->Stop();
    delete homein;
    mainWindow->Remove( &promptWindow );
    mainWindow->SetState( STATE_DEFAULT );
    while ( homeout->IsPlaying() > 0 ) usleep( 50 );
    homeout->Stop();
    delete homeout;
    ResumeGui();
    return choice;
}

void SetupFavoriteButton( GuiButton *btnFavorite, int xPos, GuiImage *img, GuiSound *sndOver, GuiSound *sndClick, GuiTrigger *trig )
{
    btnFavorite->SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    btnFavorite->SetPosition( xPos, -60 );
    btnFavorite->SetImage( img );
    btnFavorite->SetSoundOver( sndOver );
    btnFavorite->SetSoundClick( sndClick );
    btnFavorite->SetTrigger( trig );
    btnFavorite->SetEffectGrow();
}

u8 SetFavorite( GuiButton *fav1, GuiButton *fav2, GuiButton *fav3, GuiButton *fav4, GuiButton *fav5, u8* gameId, u8 favorite )
{
    struct Game_NUM * game_num = CFG_get_game_num( gameId );
    if ( game_num )
    {
        favoritevar = game_num->favorite;
        playcount = game_num->count;
    }
    else
    {
        favoritevar = 0;
        playcount = 0;
    }
    favoritevar = ( favorite == favoritevar ) ? 0 : favorite; // Press the current rank to reset the rank
    CFG_save_game_num( gameId );
    return favoritevar;
}

void SetFavoriteImages( GuiImage *b1, GuiImage *b2, GuiImage *b3, GuiImage *b4, GuiImage *b5, GuiImageData *on, GuiImageData *off )
{
    b1->SetImage( favoritevar >= 1 ? on : off );
    b2->SetImage( favoritevar >= 2 ? on : off );
    b3->SetImage( favoritevar >= 3 ? on : off );
    b4->SetImage( favoritevar >= 4 ? on : off );
    b5->SetImage( favoritevar >= 5 ? on : off );
}

/****************************************************************************
 * GameWindowPrompt
 *
 * Displays a prompt window to user, with information, an error message, or
 * presenting a user with a choice
 ***************************************************************************/
int GameWindowPrompt()
{
    int choice = -1, angle = 0;
    f32 size = 0.0;
    char ID[5];
    char IDFull[7];

    GuiSound * gameSound = NULL;

    gprintf( "GameWindowPrompt()\n" );
    GuiWindow promptWindow( 472, 320 );
    promptWindow.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    promptWindow.SetPosition( 0, -10 );
    GuiSound btnSoundOver( button_over_pcm, button_over_pcm_size, Settings.sfxvolume );
    // because destroy GuiSound must wait while sound playing is finished, we use a global sound
    if ( !btnClick2 ) btnClick2 = new GuiSound( button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume );
    //  GuiSound btnClick(button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume);

    char imgPath[100];
    snprintf( imgPath, sizeof( imgPath ), "%sbutton_dialogue_box.png", Settings.theme_path );
    GuiImageData btnOutline( imgPath, button_dialogue_box_png );

    snprintf( imgPath, sizeof( imgPath ), "%sfavorite.png", Settings.theme_path );
    GuiImageData imgFavorite( imgPath, favorite_png );
    snprintf( imgPath, sizeof( imgPath ), "%snot_favorite.png", Settings.theme_path );
    GuiImageData imgNotFavorite( imgPath, not_favorite_png );

    snprintf( imgPath, sizeof( imgPath ), "%sstartgame_arrow_left.png", Settings.theme_path );
    GuiImageData imgLeft( imgPath, startgame_arrow_left_png );
    snprintf( imgPath, sizeof( imgPath ), "%sstartgame_arrow_right.png", Settings.theme_path );
    GuiImageData imgRight( imgPath, startgame_arrow_right_png );

    GuiTrigger trigA;
    trigA.SetSimpleTrigger( -1, WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A, PAD_BUTTON_A );
    GuiTrigger trigB;
    trigB.SetButtonOnlyTrigger( -1, WPAD_BUTTON_B | WPAD_CLASSIC_BUTTON_B, PAD_BUTTON_B );
    GuiTrigger trigL;
    trigL.SetButtonOnlyTrigger( -1, WPAD_BUTTON_LEFT | WPAD_CLASSIC_BUTTON_LEFT, PAD_BUTTON_LEFT );
    GuiTrigger trigR;
    trigR.SetButtonOnlyTrigger( -1, WPAD_BUTTON_RIGHT | WPAD_CLASSIC_BUTTON_RIGHT, PAD_BUTTON_RIGHT );
    GuiTrigger trigPlus;
    trigPlus.SetButtonOnlyTrigger( -1, WPAD_BUTTON_PLUS | WPAD_CLASSIC_BUTTON_PLUS, 0 );
    GuiTrigger trigMinus;
    trigMinus.SetButtonOnlyTrigger( -1, WPAD_BUTTON_MINUS | WPAD_CLASSIC_BUTTON_MINUS, 0 );
    GuiTrigger trigZ;
    trigZ.SetButtonOnlyTrigger( -1, WPAD_NUNCHUK_BUTTON_Z | WPAD_CLASSIC_BUTTON_ZL, PAD_TRIGGER_Z );

    GuiButton screenShotBtn( 0, 0 );
    screenShotBtn.SetPosition( 0, 0 );
    screenShotBtn.SetTrigger( &trigZ );

    if ( Settings.widescreen )
        snprintf( imgPath, sizeof( imgPath ), "%swdialogue_box_startgame.png", Settings.theme_path );
    else
        snprintf( imgPath, sizeof( imgPath ), "%sdialogue_box_startgame.png", Settings.theme_path );

    GuiImageData dialogBox( imgPath, Settings.widescreen ? wdialogue_box_startgame_png : dialogue_box_startgame_png );
    GuiImage dialogBoxImg( &dialogBox );

    GuiTooltip nameBtnTT( tr( "Rename Game on WBFS" ) );
    if ( Settings.wsprompt == yes )
        nameBtnTT.SetWidescreen( Settings.widescreen );
    GuiText nameTxt( "", 22, THEME.prompttext );
    if ( Settings.wsprompt == yes )
        nameTxt.SetWidescreen( Settings.widescreen );
    nameTxt.SetMaxWidth( 350, SCROLL_HORIZONTAL );
    GuiButton nameBtn( 120, 50 );
    nameBtn.SetLabel( &nameTxt );
//  nameBtn.SetLabelOver(&nameTxt);
    nameBtn.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    nameBtn.SetPosition( 0, -122 );
    nameBtn.SetSoundOver( &btnSoundOver );
    nameBtn.SetSoundClick( btnClick2 );
    if ( !mountMethod ) nameBtn.SetToolTip( &nameBtnTT, 24, -30, ALIGN_LEFT );

    if ( Settings.godmode == 1 && !mountMethod )
    {
        nameBtn.SetTrigger( &trigA );
        nameBtn.SetEffectGrow();
    }

    GuiText sizeTxt( ( char* ) NULL, 22, THEME.prompttext ); //TODO: get the size here
    sizeTxt.SetAlignment( ALIGN_RIGHT, ALIGN_TOP );
    sizeTxt.SetPosition( -60, 70 );

//  GuiImage diskImg;
    GuiDiskCover diskImg;
    diskImg.SetWidescreen( Settings.widescreen );
    diskImg.SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    diskImg.SetAngle( angle );
    GuiDiskCover diskImg2;
    diskImg2.SetWidescreen( Settings.widescreen );
    diskImg2.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    diskImg2.SetPosition( 0, -20 );
    diskImg2.SetAngle( angle );
    diskImg2.SetBeta( 180 );

    GuiText playcntTxt( ( char* ) NULL, 18, THEME.info );
    playcntTxt.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    playcntTxt.SetPosition( -115, 45 );

    GuiButton btn1( 160, 160 );
    btn1.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    btn1.SetPosition( 0, -20 );
    btn1.SetImage( &diskImg );

    btn1.SetSoundOver( &btnSoundOver );
    btn1.SetSoundClick( btnClick2 );
    btn1.SetTrigger( &trigA );
    btn1.SetState( STATE_SELECTED );

    GuiText btn2Txt( tr( "Back" ), 22, THEME.prompttext );
    GuiImage btn2Img( &btnOutline );
    if ( Settings.wsprompt == yes )
    {
        btn2Txt.SetWidescreen( Settings.widescreen );
        btn2Img.SetWidescreen( Settings.widescreen );
    }
    GuiButton btn2( &btn2Img, &btn2Img, 1, 5, 0, 0, &trigA, &btnSoundOver, btnClick2, 1 );
    if ( Settings.godmode == 1 && mountMethod != 2 && mountMethod != 3 )
    {
        btn2.SetAlignment( ALIGN_RIGHT, ALIGN_BOTTOM );
        btn2.SetPosition( -50, -40 );
    }
    else
    {
        btn2.SetAlignment( ALIGN_CENTRE, ALIGN_BOTTOM );
        btn2.SetPosition( 0, -40 );
    }

    btn2.SetLabel( &btn2Txt );
    btn2.SetTrigger( &trigB );

    GuiText btn3Txt( tr( "Settings" ), 22, THEME.prompttext );
    GuiImage btn3Img( &btnOutline );
    if ( Settings.wsprompt == yes )
    {
        btn3Txt.SetWidescreen( Settings.widescreen );
        btn3Img.SetWidescreen( Settings.widescreen );
    }
    GuiButton btn3( &btn3Img, &btn3Img, 0, 4, 50, -40, &trigA, &btnSoundOver, btnClick2, 1 );
    btn3.SetLabel( &btn3Txt );

    GuiImage btnFavoriteImg1;
    btnFavoriteImg1.SetWidescreen( Settings.widescreen );
    GuiImage btnFavoriteImg2;
    btnFavoriteImg2.SetWidescreen( Settings.widescreen );
    GuiImage btnFavoriteImg3;
    btnFavoriteImg3.SetWidescreen( Settings.widescreen );
    GuiImage btnFavoriteImg4;
    btnFavoriteImg4.SetWidescreen( Settings.widescreen );
    GuiImage btnFavoriteImg5;
    btnFavoriteImg5.SetWidescreen( Settings.widescreen );

    //GuiButton btnFavorite(&btnFavoriteImg,&btnFavoriteImg, 2, 5, -125, -60, &trigA, &btnSoundOver, &btnClick,1);
    GuiButton btnFavorite1( imgFavorite.GetWidth(), imgFavorite.GetHeight() );
    GuiButton btnFavorite2( imgFavorite.GetWidth(), imgFavorite.GetHeight() );
    GuiButton btnFavorite3( imgFavorite.GetWidth(), imgFavorite.GetHeight() );
    GuiButton btnFavorite4( imgFavorite.GetWidth(), imgFavorite.GetHeight() );
    GuiButton btnFavorite5( imgFavorite.GetWidth(), imgFavorite.GetHeight() );

    SetupFavoriteButton( &btnFavorite1, -198, &btnFavoriteImg1, &btnSoundOver, btnClick2, &trigA );
    SetupFavoriteButton( &btnFavorite2, -171, &btnFavoriteImg2, &btnSoundOver, btnClick2, &trigA );
    SetupFavoriteButton( &btnFavorite3, -144, &btnFavoriteImg3, &btnSoundOver, btnClick2, &trigA );
    SetupFavoriteButton( &btnFavorite4, -117, &btnFavoriteImg4, &btnSoundOver, btnClick2, &trigA );
    SetupFavoriteButton( &btnFavorite5,  -90, &btnFavoriteImg5, &btnSoundOver, btnClick2, &trigA );

    GuiImage btnLeftImg( &imgLeft );
    if ( Settings.wsprompt == yes )
    {
        btnLeftImg.SetWidescreen( Settings.widescreen );
    }
    GuiButton btnLeft( &btnLeftImg, &btnLeftImg, 0, 5, 20, 0, &trigA, &btnSoundOver, btnClick2, 1 );
    btnLeft.SetTrigger( &trigL );
    btnLeft.SetTrigger( &trigMinus );

    GuiImage btnRightImg( &imgRight );
    if ( Settings.wsprompt == yes )
    {
        btnRightImg.SetWidescreen( Settings.widescreen );
    }
    GuiButton btnRight( &btnRightImg, &btnRightImg, 1, 5, -20, 0, &trigA, &btnSoundOver, btnClick2, 1 );
    btnRight.SetTrigger( &trigR );
    btnRight.SetTrigger( &trigPlus );

    promptWindow.Append( &dialogBoxImg );
    promptWindow.Append( &nameBtn );
    promptWindow.Append( &playcntTxt );
    promptWindow.Append( &screenShotBtn );
    promptWindow.Append( &btn2 );
    if ( !mountMethod )//stuff we don't show if it is a DVD mounted
    {
        promptWindow.Append( &sizeTxt );
        promptWindow.Append( &btnLeft );
        promptWindow.Append( &btnRight );
        promptWindow.Append( &btnFavorite1 );
        promptWindow.Append( &btnFavorite2 );
        promptWindow.Append( &btnFavorite3 );
        promptWindow.Append( &btnFavorite4 );
        promptWindow.Append( &btnFavorite5 );
    }

    //check if unlocked
    if ( Settings.godmode == 1 && mountMethod != 2 && mountMethod != 3 )
    {
        promptWindow.Append( &btn3 );
    }

    promptWindow.Append( &diskImg2 );
    promptWindow.Append( &btn1 );

    short changed = -1;
    GuiImageData * diskCover = NULL;
    GuiImageData * diskCover2 = NULL;

    promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_IN, 50 );

    while ( changed )
    {
        if ( changed == 1 )
        {
            promptWindow.SetEffect( EFFECT_SLIDE_LEFT | EFFECT_SLIDE_IN, 50 );
        }
        else if ( changed == 2 )
        {
            promptWindow.SetEffect( EFFECT_SLIDE_RIGHT | EFFECT_SLIDE_IN, 50 );
        }
        else if ( changed == 3 || changed == 4 )
        {
            if ( diskCover2 )
                delete diskCover2;
            diskCover2 = NULL;
            if ( diskCover )
                diskCover2 = diskCover;
            diskCover = NULL;
        }

        //load disc image based or what game is seleted
        struct discHdr * header = ( mountMethod == 1 || mountMethod == 2 ? dvdheader : gameList[gameSelected] );
        if ( Settings.gamesoundvolume > 0 )
        {
            if ( gameSound )
            {
                gameSound->Stop();
                delete gameSound;
                gameSound = NULL;
            }
            u32 gameSoundDataLen;
            const u8 *gameSoundData = LoadBannerSound( header->id, &gameSoundDataLen );
            if ( gameSoundData )
            {
                gameSound = new GuiSound( gameSoundData, gameSoundDataLen, Settings.gamesoundvolume, false, true );
                bgMusic->SetVolume( 0 );
                if ( Settings.gamesound == 2 )
                    gameSound->SetLoop( 1 );
                gameSound->Play();
            }
        }
        snprintf ( ID, sizeof( ID ), "%c%c%c", header->id[0], header->id[1], header->id[2] );
        snprintf ( IDFull, sizeof( IDFull ), "%c%c%c%c%c%c", header->id[0], header->id[1], header->id[2], header->id[3], header->id[4], header->id[5] );

	gprintf( "\t%s\n", IDFull );
        if ( diskCover )
            delete diskCover;



        snprintf( imgPath, sizeof( imgPath ), "%s%s.png", Settings.disc_path, IDFull ); //changed to current full id
        diskCover = new GuiImageData( imgPath, 0 );

        if ( !diskCover->GetImage() )
        {
            delete diskCover;
            snprintf( imgPath, sizeof( imgPath ), "%s%s.png", Settings.disc_path, ID ); //changed to current id
            diskCover = new GuiImageData( imgPath, 0 );


            if ( !diskCover->GetImage() )
            {
                snprintf ( ID, sizeof( ID ), "%c%c%c%c", header->id[0], header->id[1], header->id[2], header->id[3] );

                delete diskCover;
                snprintf( imgPath, sizeof( imgPath ), "%s%s.png", Settings.disc_path, ID ); //changed to current id
                diskCover = new GuiImageData( imgPath, 0 );
                if ( !diskCover->GetImage() )
                {
                    delete diskCover;
                    snprintf( imgPath, sizeof( imgPath ), "%snodisc.png", Settings.theme_path ); //changed to nodisc.png
                    diskCover = new GuiImageData( imgPath, nodisc_png );
                }
            }
        }



        if ( changed == 3 )
        {
            diskImg.SetImage( diskCover2 );
            diskImg.SetBeta( 0 );
            diskImg.SetBetaRotateEffect( -90, 15 );
            diskImg2.SetImage( diskCover );
            diskImg2.SetAngle( diskImg.GetAngle() );
            diskImg2.SetBeta( 180 );
            diskImg2.SetBetaRotateEffect( -90, 15 );
            sizeTxt.SetEffect( EFFECT_FADE, -17 );
            nameTxt.SetEffect( EFFECT_FADE, -17 );
            ResumeGui();
            while ( nameTxt.GetEffect() > 0 || diskImg.GetBetaRotateEffect() ) usleep( 50 );
            HaltGui();
            diskImg.SetImage( diskCover );
            diskImg.SetBeta( 90 );
            diskImg.SetBetaRotateEffect( -90, 15 );
            diskImg2.SetImage( diskCover2 );
            diskImg2.SetBeta( 270 );
            diskImg2.SetBetaRotateEffect( -90, 15 );
            sizeTxt.SetEffect( EFFECT_FADE, 17 );
            nameTxt.SetEffect( EFFECT_FADE, 17 );
        }
        else if ( changed == 4 )
        {
            diskImg.SetImage( diskCover2 );
            diskImg.SetBeta( 0 );
            diskImg.SetBetaRotateEffect( 90, 15 );
            diskImg2.SetImage( diskCover );
            diskImg2.SetAngle( diskImg.GetAngle() );
            diskImg2.SetBeta( 180 );
            diskImg2.SetBetaRotateEffect( 90, 15 );
            sizeTxt.SetEffect( EFFECT_FADE, -17 );
            nameTxt.SetEffect( EFFECT_FADE, -17 );
            ResumeGui();
            while ( nameTxt.GetEffect() > 0 || diskImg.GetBetaRotateEffect() ) usleep( 50 );
            HaltGui();
            diskImg.SetImage( diskCover );
            diskImg.SetBeta( 270 );
            diskImg.SetBetaRotateEffect( 90, 15 );
            diskImg2.SetImage( diskCover2 );
            diskImg2.SetBeta( 90 );
            diskImg2.SetBetaRotateEffect( 90, 15 );
            sizeTxt.SetEffect( EFFECT_FADE, 17 );
            nameTxt.SetEffect( EFFECT_FADE, 17 );
        }
        else
            diskImg.SetImage( diskCover );

        if ( !mountMethod )
        {
            WBFS_GameSize( header->id, &size );
            sizeTxt.SetTextf( "%.2fGB", size ); //set size text;
        }

        nameTxt.SetText( get_title( header ) );

        struct Game_NUM* game_num = CFG_get_game_num( header->id );
        if ( game_num )
        {
            playcount = game_num->count;
            favoritevar = game_num->favorite;
        }
        else
        {
            playcount = 0;
            favoritevar = 0;
        }
        playcntTxt.SetTextf( "%s: %i", tr( "Play Count" ), playcount );
        SetFavoriteImages( &btnFavoriteImg1, &btnFavoriteImg2, &btnFavoriteImg3, &btnFavoriteImg4, &btnFavoriteImg5, &imgFavorite, &imgNotFavorite );

        nameTxt.SetPosition( 0, 1 );

        if ( changed != 3 && changed != 4 ) // changed==3 or changed==4 --> only Resume the GUI
        {
            HaltGui();
            mainWindow->SetState( STATE_DISABLED );
            mainWindow->Append( &promptWindow );
            mainWindow->ChangeFocus( &promptWindow );
        }
        ResumeGui();

        changed = 0;
        while ( choice == -1 )
        {
            VIDEO_WaitVSync ();

            diskImg.SetSpin( btn1.GetState() == STATE_SELECTED );
            diskImg2.SetSpin( btn1.GetState() == STATE_SELECTED );
            if ( shutdown == 1 ) //for power button
            {
                promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_OUT, 50 );
                mainWindow->SetState( STATE_DEFAULT );
                while ( promptWindow.GetEffect() > 0 ) usleep( 50 );
                HaltGui();
                mainWindow->Remove( &promptWindow );
                ResumeGui();
                wiilight( 0 );
                Sys_Shutdown();
            }

            if ( reset == 1 ) //for reset button
                Sys_Reboot();

            if ( gameSound )
            {
                if ( !gameSound->IsPlaying() )
                {
                    if ( Settings.gamesound == 1 )
                        bgMusic->SetVolume( Settings.volume );
                }
            }

            if ( btn1.GetState() == STATE_CLICKED )
            {
                //playcounter
                struct Game_NUM* game_num = CFG_get_game_num( header->id );
                if ( game_num )
                {
                    favoritevar = game_num->favorite;
                    playcount = game_num->count;
                }
                else
                {
                    favoritevar = 0;
                    playcount = 0;
                }
                playcount += 1;
                if ( isInserted( bootDevice ) )
                {
                    CFG_save_game_num( header->id );
                }

                choice = 1;
            }

            else if ( btn2.GetState() == STATE_CLICKED ) //back
            {
                choice = 0;
                promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_OUT, 50 );
                mainWindow->SetState( STATE_DEFAULT );
                wiilight( 0 );
            }

            else if ( btn3.GetState() == STATE_CLICKED ) //settings
            {
                choice = 2;
                promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_OUT, 50 );
            }

            else if ( nameBtn.GetState() == STATE_CLICKED ) //rename
            {
                choice = 3;
                promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_OUT, 50 );
            }
            else if ( btnFavorite1.GetState() == STATE_CLICKED )  //switch favorite
            {
                if ( isInserted( bootDevice ) )
                {
                    SetFavorite( &btnFavorite1, &btnFavorite2, &btnFavorite3, &btnFavorite4, &btnFavorite5, header->id, 1 );
                    SetFavoriteImages( &btnFavoriteImg1, &btnFavoriteImg2, &btnFavoriteImg3, &btnFavoriteImg4, &btnFavoriteImg5, &imgFavorite, &imgNotFavorite );
                }
                btnFavorite1.ResetState();
            }
            else if ( btnFavorite2.GetState() == STATE_CLICKED )  //switch favorite
            {
                if ( isInserted( bootDevice ) )
                {
                    SetFavorite( &btnFavorite1, &btnFavorite2, &btnFavorite3, &btnFavorite4, &btnFavorite5, header->id, 2 );
                    SetFavoriteImages( &btnFavoriteImg1, &btnFavoriteImg2, &btnFavoriteImg3, &btnFavoriteImg4, &btnFavoriteImg5, &imgFavorite, &imgNotFavorite );
                }
                btnFavorite2.ResetState();
            }
            else if ( btnFavorite3.GetState() == STATE_CLICKED )  //switch favorite
            {
                if ( isInserted( bootDevice ) )
                {
                    SetFavorite( &btnFavorite1, &btnFavorite2, &btnFavorite3, &btnFavorite4, &btnFavorite5, header->id, 3 );
                    SetFavoriteImages( &btnFavoriteImg1, &btnFavoriteImg2, &btnFavoriteImg3, &btnFavoriteImg4, &btnFavoriteImg5, &imgFavorite, &imgNotFavorite );
                }
                btnFavorite3.ResetState();
            }
            else if ( btnFavorite4.GetState() == STATE_CLICKED )  //switch favorite
            {
                if ( isInserted( bootDevice ) )
                {
                    SetFavorite( &btnFavorite1, &btnFavorite2, &btnFavorite3, &btnFavorite4, &btnFavorite5, header->id, 4 );
                    SetFavoriteImages( &btnFavoriteImg1, &btnFavoriteImg2, &btnFavoriteImg3, &btnFavoriteImg4, &btnFavoriteImg5, &imgFavorite, &imgNotFavorite );
                }
                btnFavorite4.ResetState();
            }
            else if ( btnFavorite5.GetState() == STATE_CLICKED )  //switch favorite
            {
                if ( isInserted( bootDevice ) )
                {
                    SetFavorite( &btnFavorite1, &btnFavorite2, &btnFavorite3, &btnFavorite4, &btnFavorite5, header->id, 5 );
                    SetFavoriteImages( &btnFavoriteImg1, &btnFavoriteImg2, &btnFavoriteImg3, &btnFavoriteImg4, &btnFavoriteImg5, &imgFavorite, &imgNotFavorite );
                }
                btnFavorite5.ResetState();
            }
            else if ( screenShotBtn.GetState() == STATE_CLICKED )
	    {
                screenShotBtn.ResetState();
		ScreenShot();
            }
            // this next part is long because nobody could agree on what the left/right buttons should do
            else if ( ( btnRight.GetState() == STATE_CLICKED ) && ( Settings.xflip == no ) )  //next game
            {
                promptWindow.SetEffect( EFFECT_SLIDE_RIGHT | EFFECT_SLIDE_OUT, 50 );
                changed = 1;
                btnClick2->Play();
                gameSelected = ( gameSelected + 1 ) % gameList.size();
                btnRight.ResetState();
                break;
            }

            else if ( ( btnLeft.GetState() == STATE_CLICKED ) && ( Settings.xflip == no ) )  //previous game
            {
                promptWindow.SetEffect( EFFECT_SLIDE_LEFT | EFFECT_SLIDE_OUT, 50 );
                changed = 2;
                btnClick2->Play();
                gameSelected = ( gameSelected - 1 + gameList.size() ) % gameList.size();
                btnLeft.ResetState();
                break;
            }

            else if ( ( btnRight.GetState() == STATE_CLICKED ) && ( Settings.xflip == yes ) )  //previous game
            {
                promptWindow.SetEffect( EFFECT_SLIDE_LEFT | EFFECT_SLIDE_OUT, 50 );
                changed = 2;
                btnClick2->Play();
                gameSelected = ( gameSelected - 1 + gameList.size() ) % gameList.size();
                btnRight.ResetState();
                break;
            }

            else if ( ( btnLeft.GetState() == STATE_CLICKED ) && ( Settings.xflip == yes ) )  //next game
            {
                promptWindow.SetEffect( EFFECT_SLIDE_RIGHT | EFFECT_SLIDE_OUT, 50 );
                changed = 1;
                btnClick2->Play();
                gameSelected = ( gameSelected + 1 ) % gameList.size();
                btnLeft.ResetState();
                break;
            }

            else if ( ( btnRight.GetState() == STATE_CLICKED ) && ( Settings.xflip == sysmenu ) )  //previous game
            {
                promptWindow.SetEffect( EFFECT_SLIDE_LEFT | EFFECT_SLIDE_OUT, 50 );
                changed = 2;
                btnClick2->Play();
                gameSelected = ( gameSelected + 1 ) % gameList.size();
                btnRight.ResetState();
                break;
            }

            else if ( ( btnLeft.GetState() == STATE_CLICKED ) && ( Settings.xflip == sysmenu ) )  //next game
            {
                promptWindow.SetEffect( EFFECT_SLIDE_RIGHT | EFFECT_SLIDE_OUT, 50 );
                changed = 1;
                btnClick2->Play();
                gameSelected = ( gameSelected - 1 + gameList.size() ) % gameList.size();
                btnLeft.ResetState();
                break;
            }

            else if ( ( btnRight.GetState() == STATE_CLICKED ) && ( Settings.xflip == wtf ) )  //previous game
            {
                promptWindow.SetEffect( EFFECT_SLIDE_RIGHT | EFFECT_SLIDE_OUT, 50 );
                changed = 1;
                btnClick2->Play();
                gameSelected = ( gameSelected - 1 + gameList.size() ) % gameList.size();
                btnRight.ResetState();
                break;
            }

            else if ( ( btnLeft.GetState() == STATE_CLICKED ) && ( Settings.xflip == wtf ) )  //next game
            {
                promptWindow.SetEffect( EFFECT_SLIDE_LEFT | EFFECT_SLIDE_OUT, 50 );
                changed = 2;
                btnClick2->Play();
                gameSelected = ( gameSelected + 1 ) % gameList.size();
                btnLeft.ResetState();
                break;
            }

            else if ( ( btnRight.GetState() == STATE_CLICKED ) && ( Settings.xflip == disk3d ) )  //next game
            {
//              diskImg.SetBetaRotateEffect(45, 90);
                changed = 3;
                btnClick2->Play();
                gameSelected = ( gameSelected + 1 ) % gameList.size();
                btnRight.ResetState();
                break;
            }

            else if ( ( btnLeft.GetState() == STATE_CLICKED ) && ( Settings.xflip == disk3d ) )  //previous game
            {
//              diskImg.SetBetaRotateEffect(-45, 90);
//              promptWindow.SetEffect(EFFECT_SLIDE_LEFT | EFFECT_SLIDE_OUT, 1/*50*/);
                changed = 4;
                btnClick2->Play();
                gameSelected = ( gameSelected - 1 + gameList.size() ) % gameList.size();
                btnLeft.ResetState();
                break;
            }
        }


        while ( promptWindow.GetEffect() > 0 ) usleep( 50 );
        HaltGui();
        if ( changed != 3 && changed != 4 ) // changed==3 or changed==4 --> only Halt the GUI
        {
            mainWindow->Remove( &promptWindow );
            ResumeGui();
        }
    }
    delete diskCover;
    delete diskCover2;

    if ( gameSound )
    {
        gameSound->Stop();
        delete gameSound;
        gameSound = NULL;
    }
    bgMusic->SetVolume( Settings.volume );

    gprintf( "\tret: %i\n", choice );
    return choice;
}

/****************************************************************************
 * DiscWait
 ***************************************************************************/
int
DiscWait( const char *title, const char *msg, const char *btn1Label, const char *btn2Label, int IsDeviceWait )
{
    int i = 30, ret = 0;
    u32 cover = 0;

    GuiWindow promptWindow( 472, 320 );
    promptWindow.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    promptWindow.SetPosition( 0, -10 );
    GuiSound btnSoundOver( button_over_pcm, button_over_pcm_size, Settings.sfxvolume );
    // because destroy GuiSound must wait while sound playing is finished, we use a global sound
    if ( !btnClick2 ) btnClick2 = new GuiSound( button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume );
    //  GuiSound btnClick(button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume);

    char imgPath[100];
    snprintf( imgPath, sizeof( imgPath ), "%sbutton_dialogue_box.png", Settings.theme_path );
    GuiImageData btnOutline( imgPath, button_dialogue_box_png );
    snprintf( imgPath, sizeof( imgPath ), "%sdialogue_box.png", Settings.theme_path );
    GuiImageData dialogBox( imgPath, dialogue_box_png );
    GuiTrigger trigA;
    trigA.SetSimpleTrigger( -1, WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A, PAD_BUTTON_A );
    GuiTrigger trigB;
    trigB.SetButtonOnlyTrigger( -1, WPAD_BUTTON_B | WPAD_CLASSIC_BUTTON_B, PAD_BUTTON_B );

    GuiImage dialogBoxImg( &dialogBox );
    if ( Settings.wsprompt == yes )
    {
        dialogBoxImg.SetWidescreen( Settings.widescreen );
    }

    GuiText titleTxt( title, 26, THEME.prompttext );
    titleTxt.SetAlignment( ALIGN_CENTRE, ALIGN_TOP );
    titleTxt.SetPosition( 0, 60 );
    GuiText msgTxt( msg, 22, THEME.prompttext );
    msgTxt.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    msgTxt.SetPosition( 0, -40 );
    msgTxt.SetMaxWidth( 430 );

    GuiText btn1Txt( btn1Label, 22, THEME.prompttext );
    GuiImage btn1Img( &btnOutline );
    if ( Settings.wsprompt == yes )
    {
        btn1Txt.SetWidescreen( Settings.widescreen );
        btn1Img.SetWidescreen( Settings.widescreen );
    }
    GuiButton btn1( &btn1Img, &btn1Img, 1, 5, 0, 0, &trigA, &btnSoundOver, btnClick2, 1 );

    if ( btn2Label )
    {
        btn1.SetAlignment( ALIGN_LEFT, ALIGN_BOTTOM );
        btn1.SetPosition( 40, -45 );
    }
    else
    {
        btn1.SetAlignment( ALIGN_CENTRE, ALIGN_BOTTOM );
        btn1.SetPosition( 0, -45 );
    }

    btn1.SetLabel( &btn1Txt );
    btn1.SetTrigger( &trigB );
    btn1.SetState( STATE_SELECTED );

    GuiText btn2Txt( btn2Label, 22, THEME.prompttext );
    GuiImage btn2Img( &btnOutline );
    if ( Settings.wsprompt == yes )
    {
        btn2Txt.SetWidescreen( Settings.widescreen );
        btn2Img.SetWidescreen( Settings.widescreen );
    }
    GuiButton btn2( &btn2Img, &btn2Img, 1, 4, -20, -25, &trigA, &btnSoundOver, btnClick2, 1 );
    btn2.SetLabel( &btn2Txt );

    if ( ( Settings.wsprompt == yes ) && ( Settings.widescreen ) )  /////////////adjust buttons for widescreen
    {
        msgTxt.SetMaxWidth( 380 );
        if ( btn2Label )
        {
            btn1.SetAlignment( ALIGN_LEFT, ALIGN_BOTTOM );
            btn2.SetPosition( -70, -80 );
            btn1.SetPosition( 70, -80 );
        }
        else
        {
            btn1.SetAlignment( ALIGN_CENTRE, ALIGN_BOTTOM );
            btn1.SetPosition( 0, -80 );
        }
    }

    GuiText timerTxt( ( char* ) NULL, 26, THEME.prompttext );
    timerTxt.SetAlignment( ALIGN_CENTRE, ALIGN_TOP );
    timerTxt.SetPosition( 0, 160 );

    promptWindow.Append( &dialogBoxImg );
    promptWindow.Append( &titleTxt );
    promptWindow.Append( &msgTxt );

    if ( btn1Label )
        promptWindow.Append( &btn1 );
    if ( btn2Label )
        promptWindow.Append( &btn2 );
    if ( IsDeviceWait )
        promptWindow.Append( &timerTxt );

    promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_IN, 50 );
    HaltGui();
    mainWindow->SetState( STATE_DISABLED );
    mainWindow->Append( &promptWindow );
    mainWindow->ChangeFocus( &promptWindow );
    ResumeGui();

    if ( IsDeviceWait )
    {
        while ( i >= 0 )
        {
            VIDEO_WaitVSync();
            timerTxt.SetTextf( "%u %s", i, tr( "seconds left" ) );
            /* HaltGui();
             if (Settings.cios == ios222) {
                 ret = IOS_ReloadIOS(222);
                 load_ehc_module();
             } else {
                 ret = IOS_ReloadIOS(249);
             }
             ResumeGui();*/
            sleep( 1 );
            USBDevice_deInit();
            USBDevice_Init();
            ret = WBFS_Init( WBFS_DEVICE_USB );
            if ( ret >= 0 )
                break;


            i--;
        }
    }
    else
    {
        while ( !( cover & 0x2 ) )
        {
            VIDEO_WaitVSync();
            if ( btn1.GetState() == STATE_CLICKED )
            {
                btn1.ResetState();
                break;
            }
            ret = WDVD_GetCoverStatus( &cover );
            if ( ret < 0 )
                break;
        }
    }

    promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_OUT, 50 );
    while ( promptWindow.GetEffect() > 0 ) usleep( 50 );
    HaltGui();
    mainWindow->Remove( &promptWindow );
    mainWindow->SetState( STATE_DEFAULT );
    ResumeGui();
    return ret;
}

/****************************************************************************
 * FormatingPartition
 ***************************************************************************/
int
FormatingPartition( const char *title, partitionEntry *entry )
{
    int ret;
    GuiWindow promptWindow( 472, 320 );
    promptWindow.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    promptWindow.SetPosition( 0, -10 );

    char imgPath[100];
    snprintf( imgPath, sizeof( imgPath ), "%sbutton_dialogue_box.png", Settings.theme_path );
    GuiImageData btnOutline( imgPath, button_dialogue_box_png );
    snprintf( imgPath, sizeof( imgPath ), "%sdialogue_box.png", Settings.theme_path );
    GuiImageData dialogBox( imgPath, dialogue_box_png );


    GuiTrigger trigA;
    trigA.SetSimpleTrigger( -1, WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A, PAD_BUTTON_A );

    GuiImage dialogBoxImg( &dialogBox );
    if ( Settings.wsprompt == yes )
    {
        dialogBoxImg.SetWidescreen( Settings.widescreen );
    }

    GuiText titleTxt( title, 26, THEME.prompttext );
    titleTxt.SetAlignment( ALIGN_CENTRE, ALIGN_TOP );
    titleTxt.SetPosition( 0, 60 );

    promptWindow.Append( &dialogBoxImg );
    promptWindow.Append( &titleTxt );


    promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_IN, 50 );
    HaltGui();
    mainWindow->SetState( STATE_DISABLED );
    mainWindow->Append( &promptWindow );
    mainWindow->ChangeFocus( &promptWindow );
    ResumeGui();

    VIDEO_WaitVSync();
    ret = WBFS_Format( entry->sector, entry->size );


    promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_OUT, 50 );
    while ( promptWindow.GetEffect() > 0 ) usleep( 50 );
    HaltGui();
    mainWindow->Remove( &promptWindow );
    mainWindow->SetState( STATE_DEFAULT );
    ResumeGui();
    return ret;
}


/****************************************************************************
 * SearchMissingImages
 ***************************************************************************/
bool SearchMissingImages( int choice2 )
{

    gprintf( "\nSearchMissingImages(%i)", choice2 );
    GuiWindow promptWindow( 472, 320 );
    promptWindow.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    promptWindow.SetPosition( 0, -10 );

    GuiSound btnSoundOver( button_over_pcm, button_over_pcm_size, Settings.sfxvolume );
    // because destroy GuiSound must wait while sound playing is finished, we use a global sound
    if ( !btnClick2 ) btnClick2 = new GuiSound( button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume );
    //  GuiSound btnClick(button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume);

    char imgPath[100];
    snprintf( imgPath, sizeof( imgPath ), "%sbutton_dialogue_box.png", Settings.theme_path );
    GuiImageData btnOutline( imgPath, button_dialogue_box_png );
    snprintf( imgPath, sizeof( imgPath ), "%sdialogue_box.png", Settings.theme_path );
    GuiImageData dialogBox( imgPath, dialogue_box_png );
    GuiTrigger trigA;
    trigA.SetSimpleTrigger( -1, WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A, PAD_BUTTON_A );

    GuiImage dialogBoxImg( &dialogBox );

    if ( Settings.wsprompt == yes )
    {
        dialogBoxImg.SetWidescreen( Settings.widescreen );
    }

    GuiText titleTxt( tr( "Checking existing artwork" ), 26, THEME.prompttext );
    titleTxt.SetAlignment( ALIGN_CENTRE, ALIGN_TOP );
    titleTxt.SetPosition( 0, 60 );

    char msg[20] = " ";
    GuiText msgTxt( msg, 22, THEME.prompttext );
    msgTxt.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    msgTxt.SetPosition( 0, -40 );

    promptWindow.Append( &dialogBoxImg );
    promptWindow.Append( &titleTxt );
    promptWindow.Append( &msgTxt );

    promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_IN, 50 );
    HaltGui();
    mainWindow->SetState( STATE_DISABLED );
    mainWindow->Append( &promptWindow );
    mainWindow->ChangeFocus( &promptWindow );
    ResumeGui();

    //make sure that all games are added to the gamelist
    gameList.LoadUnfiltered();

    cntMissFiles = 0;
    int i = 0;
    char filename[11];

    //add IDs of games that are missing covers to cntMissFiles
    bool found1 = false;
    bool found2 = false;
    bool found3 = false;
    for ( i = 0; i < gameList.size() && cntMissFiles < 500; i++ )
    {
        struct discHdr* header = gameList[i];
        if ( choice2 != 3 )
        {

            char *covers_path = choice2 == 1 ? Settings.covers2d_path : Settings.covers_path;

            snprintf ( filename, sizeof( filename ), "%c%c%c.png", header->id[0], header->id[1], header->id[2] );
            found2 = findfile( filename, covers_path );

            snprintf ( filename, sizeof( filename ), "%c%c%c%c.png", header->id[0], header->id[1], header->id[2], header->id[3] );
            found3 = findfile( filename, covers_path );

            snprintf( filename, sizeof( filename ), "%c%c%c%c%c%c.png", header->id[0], header->id[1], header->id[2],
                      header->id[3], header->id[4], header->id[5] ); //full id
            found1 = findfile( filename, covers_path );
            if ( !found1 && !found2 && !found3 ) //if could not find any image
            {
                snprintf( missingFiles[cntMissFiles], 11, "%s", filename );
                cntMissFiles++;
            }
        }
        else if ( choice2 == 3 )
        {
            snprintf ( filename, sizeof( filename ), "%c%c%c.png", header->id[0], header->id[1], header->id[2] );
            found2 = findfile( filename, Settings.disc_path );
            snprintf( filename, sizeof( filename ), "%c%c%c%c%c%c.png", header->id[0], header->id[1], header->id[2],
                      header->id[3], header->id[4], header->id[5] ); //full id
            found1 = findfile( filename, Settings.disc_path );
            if ( !found1 && !found2 )
            {
                snprintf( missingFiles[cntMissFiles], 11, "%s", filename );
                cntMissFiles++;
            }
        }
    }
    if ( cntMissFiles == 0 )
    {
        msgTxt.SetText( tr( "No file missing!" ) );
        sleep( 1 );
    }

    promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_OUT, 50 );
    while ( promptWindow.GetEffect() > 0 ) usleep( 50 );

    HaltGui();
    mainWindow->Remove( &promptWindow );
    mainWindow->SetState( STATE_DEFAULT );
    gameList.FilterList();
    ResumeGui();

    gprintf( " = %i", cntMissFiles );
    if ( cntMissFiles > 0 ) //&& !IsNetworkInit()) {
    {
        NetworkInitPrompt();
    }

    if ( cntMissFiles == 0 )
    {
        return false;
    }
    else
    {
        return true;
    }
}
/****************************************************************************
 * NetworkInitPrompt
 ***************************************************************************/
bool NetworkInitPrompt()
{

    gprintf( "\nNetworkinitPrompt()" );
    if ( IsNetworkInit() )
        return true;

    bool success = true;

    GuiWindow promptWindow( 472, 320 );
    promptWindow.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    promptWindow.SetPosition( 0, -10 );

    GuiSound btnSoundOver( button_over_pcm, button_over_pcm_size, Settings.sfxvolume );
    // because destroy GuiSound must wait while sound playing is finished, we use a global sound
    if ( !btnClick2 ) btnClick2 = new GuiSound( button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume );
    //  GuiSound btnClick(button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume);

    char imgPath[100];
    snprintf( imgPath, sizeof( imgPath ), "%sbutton_dialogue_box.png", Settings.theme_path );
    GuiImageData btnOutline( imgPath, button_dialogue_box_png );
    snprintf( imgPath, sizeof( imgPath ), "%sdialogue_box.png", Settings.theme_path );
    GuiImageData dialogBox( imgPath, dialogue_box_png );
    GuiTrigger trigA;
    trigA.SetSimpleTrigger( -1, WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A, PAD_BUTTON_A );

    GuiImage dialogBoxImg( &dialogBox );

    if ( Settings.wsprompt == yes )
    {
        dialogBoxImg.SetWidescreen( Settings.widescreen );
    }

    GuiText titleTxt( tr( "Initializing Network" ), 26, THEME.prompttext );
    titleTxt.SetAlignment( ALIGN_CENTRE, ALIGN_TOP );
    titleTxt.SetPosition( 0, 60 );

    char msg[20] = " ";
    GuiText msgTxt( msg, 22, THEME.prompttext );
    msgTxt.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    msgTxt.SetPosition( 0, -40 );

    GuiText btn1Txt( tr( "Cancel" ), 22, THEME.prompttext );
    GuiImage btn1Img( &btnOutline );
    if ( Settings.wsprompt == yes )
    {
        btn1Txt.SetWidescreen( Settings.widescreen );
        btn1Img.SetWidescreen( Settings.widescreen );
    }
    GuiButton btn1( &btn1Img, &btn1Img, 2, 4, 0, -45, &trigA, &btnSoundOver, btnClick2, 1 );
    btn1.SetLabel( &btn1Txt );
    btn1.SetState( STATE_SELECTED );

    if ( ( Settings.wsprompt == yes ) && ( Settings.widescreen ) )  /////////////adjust buttons for widescreen
    {
        btn1.SetAlignment( ALIGN_CENTRE, ALIGN_BOTTOM );
        btn1.SetPosition( 0, -80 );
    }

    promptWindow.Append( &dialogBoxImg );
    promptWindow.Append( &titleTxt );
    promptWindow.Append( &msgTxt );
    promptWindow.Append( &btn1 );

    promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_IN, 50 );
    HaltGui();
    mainWindow->SetState( STATE_DISABLED );
    mainWindow->Append( &promptWindow );
    mainWindow->ChangeFocus( &promptWindow );
    ResumeGui();

    while ( !IsNetworkInit() )
    {

        VIDEO_WaitVSync();

        Initialize_Network();

        if ( !IsNetworkInit() )
        {
            msgTxt.SetText( tr( "Could not initialize network!" ) );
            sleep( 3 );
            success = false;
            break;
        }

        if ( btn1.GetState() == STATE_CLICKED )
        {
            btn1.ResetState();
            success = false;
            break;
        }
    }

    promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_OUT, 50 );
    while ( promptWindow.GetEffect() > 0 ) usleep( 50 );

    HaltGui();
    mainWindow->Remove( &promptWindow );
    mainWindow->SetState( STATE_DEFAULT );
    ResumeGui();

    return success;
}

/****************************************************************************
 * ProgressDownloadWindow
 *
 * Opens a window, which displays progress to the user. Can either display a
 * progress bar showing % completion, or a throbber that only shows that an
 * action is in progress.
 ***************************************************************************/
int
ProgressDownloadWindow( int choice2 )
{

    int i = 0, cntNotFound = 0;

    GuiWindow promptWindow( 472, 320 );
    promptWindow.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    promptWindow.SetPosition( 0, -10 );

    GuiSound btnSoundOver( button_over_pcm, button_over_pcm_size, Settings.sfxvolume );
    // because destroy GuiSound must wait while sound playing is finished, we use a global sound
    if ( !btnClick2 ) btnClick2 = new GuiSound( button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume );
    //  GuiSound btnClick(button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume);

    char imgPath[100];
    snprintf( imgPath, sizeof( imgPath ), "%sbutton_dialogue_box.png", Settings.theme_path );
    GuiImageData btnOutline( imgPath, button_dialogue_box_png );
    snprintf( imgPath, sizeof( imgPath ), "%sdialogue_box.png", Settings.theme_path );
    GuiImageData dialogBox( imgPath, dialogue_box_png );
    GuiTrigger trigA;
    trigA.SetSimpleTrigger( -1, WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A, PAD_BUTTON_A );

    GuiImage dialogBoxImg( &dialogBox );
    if ( Settings.wsprompt == yes )
    {
        dialogBoxImg.SetWidescreen( Settings.widescreen );
    }

    snprintf( imgPath, sizeof( imgPath ), "%sprogressbar_outline.png", Settings.theme_path );
    GuiImageData progressbarOutline( imgPath, progressbar_outline_png );
    GuiImage progressbarOutlineImg( &progressbarOutline );
    if ( Settings.wsprompt == yes )
    {
        progressbarOutlineImg.SetWidescreen( Settings.widescreen );
    }
    progressbarOutlineImg.SetAlignment( ALIGN_LEFT, ALIGN_MIDDLE );
    progressbarOutlineImg.SetPosition( 25, 40 );

    snprintf( imgPath, sizeof( imgPath ), "%sprogressbar_empty.png", Settings.theme_path );
    GuiImageData progressbarEmpty( imgPath, progressbar_empty_png );
    GuiImage progressbarEmptyImg( &progressbarEmpty );
    progressbarEmptyImg.SetAlignment( ALIGN_LEFT, ALIGN_MIDDLE );
    progressbarEmptyImg.SetPosition( 25, 40 );
    progressbarEmptyImg.SetTile( 100 );

    snprintf( imgPath, sizeof( imgPath ), "%sprogressbar.png", Settings.theme_path );
    GuiImageData progressbar( imgPath, progressbar_png );
    GuiImage progressbarImg( &progressbar );
    progressbarImg.SetAlignment( ALIGN_LEFT, ALIGN_MIDDLE );
    progressbarImg.SetPosition( 25, 40 );

    GuiText titleTxt( tr( "Downloading file" ), 26, THEME.prompttext );
    titleTxt.SetAlignment( ALIGN_CENTRE, ALIGN_TOP );
    titleTxt.SetPosition( 0, 60 );

    GuiText msgTxt( ( char* ) NULL, 20, THEME.prompttext );
    msgTxt.SetAlignment( ALIGN_CENTRE, ALIGN_TOP );
    msgTxt.SetPosition( 0, 130 );

    GuiText msg2Txt( ( char* ) NULL, 26, THEME.prompttext );
    msg2Txt.SetAlignment( ALIGN_CENTRE, ALIGN_TOP );
    msg2Txt.SetPosition( 0, 100 );

    GuiText prTxt( ( char* ) NULL, 26, THEME.prompttext );
    prTxt.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    prTxt.SetPosition( 0, 40 );

    GuiText btn1Txt( tr( "Cancel" ), 22, THEME.prompttext );
    GuiImage btn1Img( &btnOutline );
    if ( Settings.wsprompt == yes )
    {
        btn1Txt.SetWidescreen( Settings.widescreen );
        btn1Img.SetWidescreen( Settings.widescreen );
    }
    GuiButton btn1( &btn1Img, &btn1Img, 2, 4, 0, -45, &trigA, &btnSoundOver, btnClick2, 1 );
    btn1.SetLabel( &btn1Txt );
    btn1.SetState( STATE_SELECTED );

    if ( ( Settings.wsprompt == yes ) && ( Settings.widescreen ) )  /////////////adjust for widescreen
    {
        progressbarOutlineImg.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
        progressbarOutlineImg.SetPosition( 0, 40 );
        progressbarEmptyImg.SetPosition( 80, 40 );
        progressbarEmptyImg.SetTile( 78 );
        progressbarImg.SetPosition( 80, 40 );
    }

    promptWindow.Append( &dialogBoxImg );
    promptWindow.Append( &titleTxt );
    promptWindow.Append( &msgTxt );
    promptWindow.Append( &msg2Txt );
    promptWindow.Append( &progressbarEmptyImg );
    promptWindow.Append( &progressbarImg );
    promptWindow.Append( &progressbarOutlineImg );
    promptWindow.Append( &prTxt );
    promptWindow.Append( &btn1 );

    HaltGui();
    mainWindow->SetState( STATE_DISABLED );
    mainWindow->Append( &promptWindow );
    mainWindow->ChangeFocus( &promptWindow );
    ResumeGui();

    int offset = 0, tries = 0;
    int serverCnt3d = 1, serverCnt2d = 1, serverCntDisc = 2;

    char server3d[100];
    char serverDisc[100];
    char serverDiscCustom[100];
    char server2d[100];

    snprintf( server3d, sizeof( server3d ), "http://wiitdb.com/wiitdb/artwork/cover3D/" );
    snprintf( serverDisc, sizeof( serverDisc ), "http://wiitdb.com/wiitdb/artwork/disc/" );
    snprintf( serverDiscCustom, sizeof( serverDiscCustom ), "http://wiitdb.com/wiitdb/artwork/disccustom/" );
    snprintf( server2d, sizeof( server2d ), "http://wiitdb.com/wiitdb/artwork/cover/" );

    //check if directory exist and if not create one
    struct stat st;
    if ( stat( Settings.covers_path, &st ) != 0 )
    {
        if ( subfoldercreate( Settings.covers_path ) != 1 )
        {
            WindowPrompt( tr( "Error !" ), tr( "Can't create directory" ), tr( "OK" ) );
            cntMissFiles = 0;
        }
    }
    if ( stat( Settings.covers2d_path, &st ) != 0 )
    {
        if ( subfoldercreate( Settings.covers2d_path ) != 1 )
        {
            WindowPrompt( tr( "Error !" ), tr( "Can't create directory" ), tr( "OK" ) );
            cntMissFiles = 0;
        }
    }
    if ( stat( Settings.disc_path, &st ) != 0 )
    {
        if ( subfoldercreate( Settings.disc_path ) != 1 )
        {
            WindowPrompt( tr( "Error !" ), tr( "Can't create directory" ), tr( "OK" ) );
            cntMissFiles = 0;
        }
    }

    //int server = 1;
    while ( i < cntMissFiles )
    {
        tries = 0;
        prTxt.SetTextf( "%i%%", 100*i / cntMissFiles );

        if ( ( Settings.wsprompt == yes ) && ( Settings.widescreen ) )
        {
            //adjust for widescreen
            progressbarImg.SetPosition( 80, 40 );
            progressbarImg.SetTile( 80*i / cntMissFiles );
        }
        else
        {
            progressbarImg.SetTile( 100*i / cntMissFiles );
        }

        if ( cntMissFiles - i > 1 )msgTxt.SetTextf( "%i %s", cntMissFiles - i, tr( "files left" ) );
        else msgTxt.SetTextf( "%i %s", cntMissFiles - i, tr( "file left" ) );
        msg2Txt.SetTextf( "http://wiitdb.com : %s", missingFiles[i] );


        //download cover
        char imgPath[100];
        char URLFile[100];
        char tmp[75];
        sprintf( tmp, tr( "Not Found" ) );
        struct block file = downloadfile( URLFile );
        if ( choice2 == 2 )
        {
            while ( tries < serverCnt3d )
            {

                //Creates URL depending from which Country the game is
                switch ( missingFiles[i][3] )
                {
                    case 'J':
                        sprintf( URLFile, "%sJA/%s", server3d, missingFiles[i] );
                        break;
                    case 'W':
                        sprintf( URLFile, "%sZH/%s", server3d, missingFiles[i] );
                        break;
                    case 'K':
                        sprintf( URLFile, "%sKO/%s", server3d, missingFiles[i] );
                        break;
                    case 'P':
                    case 'D':
                    case 'F':
                    case 'I':
                    case 'S':
                    case 'H':
                    case 'U':
                    case 'X':
                    case 'Y':
                    case 'Z':
                        sprintf( URLFile, "%s%s/%s", server3d, Settings.db_language, missingFiles[i] );
                        break;
                    case 'E':
                        sprintf( URLFile, "%sUS/%s", server3d, missingFiles[i] );
                        break;
                }

                sprintf( imgPath, "%s%s", Settings.covers_path, missingFiles[i] );
                file = downloadfile( URLFile );

                if ( !( file.size == 36864 || file.size <= 1024 || file.size == 7386 || file.size <= 1174 || file.size == 4446 || file.data == NULL ) )
                {
                    break;
                }
                else
                {
                    sprintf( URLFile, "%sEN/%s", server3d, missingFiles[i] );
                    file = downloadfile( URLFile );
                    if ( !( file.size == 36864 || file.size <= 1024 || file.size == 7386 || file.size <= 1174 || file.size == 4446 || file.data == NULL ) )
                    {
                        break;
                    }
                }
                tries++;
            }

        }
        if ( choice2 == 3 )
        {
            while ( tries < serverCntDisc )
            {

                //Creates URL depending from which Country the game is
                switch ( missingFiles[i][3] )
                {
                    case 'J':
                        if ( Settings.discart == 0 )
                        {
                            sprintf( URLFile, "%sJA/%s", serverDisc, missingFiles[i] );
                        }
                        else if ( Settings.discart == 1 )
                        {
                            sprintf( URLFile, "%sJA/%s", serverDiscCustom, missingFiles[i] );
                        }
                        else if ( Settings.discart == 2 && tries == 0 )
                        {
                            sprintf( URLFile, "%sJA/%s", serverDisc, missingFiles[i] );
                        }
                        else if ( Settings.discart == 2 && tries == 1 )
                        {
                            sprintf( URLFile, "%sJA/%s", serverDiscCustom, missingFiles[i] );
                        }
                        else if ( Settings.discart == 3 && tries == 0 )
                        {
                            sprintf( URLFile, "%sJA/%s", serverDiscCustom, missingFiles[i] );
                        }
                        else if ( Settings.discart == 3 && tries == 1 )
                        {
                            sprintf( URLFile, "%sJA/%s", serverDisc, missingFiles[i] );
                        }
                        break;
                    case 'W':
                        if ( Settings.discart == 0 )
                        {
                            sprintf( URLFile, "%sZH/%s", serverDisc, missingFiles[i] );
                        }
                        else if ( Settings.discart == 1 )
                        {
                            sprintf( URLFile, "%sZH/%s", serverDiscCustom, missingFiles[i] );
                        }
                        else if ( Settings.discart == 2 && tries == 0 )
                        {
                            sprintf( URLFile, "%sZH/%s", serverDisc, missingFiles[i] );
                        }
                        else if ( Settings.discart == 2 && tries == 1 )
                        {
                            sprintf( URLFile, "%sZH/%s", serverDiscCustom, missingFiles[i] );
                        }
                        else if ( Settings.discart == 3 && tries == 0 )
                        {
                            sprintf( URLFile, "%sZH/%s", serverDiscCustom, missingFiles[i] );
                        }
                        else if ( Settings.discart == 3 && tries == 1 )
                        {
                            sprintf( URLFile, "%sZH/%s", serverDisc, missingFiles[i] );
                        }
                        break;
                    case 'K':
                        if ( Settings.discart == 0 )
                        {
                            sprintf( URLFile, "%sKO/%s", serverDisc, missingFiles[i] );
                        }
                        else if ( Settings.discart == 1 )
                        {
                            sprintf( URLFile, "%sKO/%s", serverDiscCustom, missingFiles[i] );
                        }
                        else if ( Settings.discart == 2 && tries == 0 )
                        {
                            sprintf( URLFile, "%sKO/%s", serverDisc, missingFiles[i] );
                        }
                        else if ( Settings.discart == 2 && tries == 1 )
                        {
                            sprintf( URLFile, "%sKO/%s", serverDiscCustom, missingFiles[i] );
                        }
                        else if ( Settings.discart == 3 && tries == 0 )
                        {
                            sprintf( URLFile, "%sKO/%s", serverDiscCustom, missingFiles[i] );
                        }
                        else if ( Settings.discart == 3 && tries == 1 )
                        {
                            sprintf( URLFile, "%sKO/%s", serverDisc, missingFiles[i] );
                        }
                        break;
                    case 'P':
                    case 'D':
                    case 'F':
                    case 'I':
                    case 'S':
                    case 'H':
                    case 'U':
                    case 'X':
                    case 'Y':
                    case 'Z':
                        if ( Settings.discart == 0 )
                        {
                            sprintf( URLFile, "%s%s/%s", serverDisc, Settings.db_language, missingFiles[i] );
                        }
                        else if ( Settings.discart == 1 )
                        {
                            sprintf( URLFile, "%s%s/%s", serverDiscCustom, Settings.db_language, missingFiles[i] );
                        }
                        else if ( Settings.discart == 2 && tries == 0 )
                        {
                            sprintf( URLFile, "%s%s/%s", serverDisc, Settings.db_language, missingFiles[i] );
                        }
                        else if ( Settings.discart == 2 && tries == 1 )
                        {
                            sprintf( URLFile, "%s%s/%s", serverDiscCustom, Settings.db_language, missingFiles[i] );
                        }
                        else if ( Settings.discart == 3 && tries == 0 )
                        {
                            sprintf( URLFile, "%s%s/%s", serverDiscCustom, Settings.db_language, missingFiles[i] );
                        }
                        else if ( Settings.discart == 3 && tries == 1 )
                        {
                            sprintf( URLFile, "%s%s/%s", serverDisc, Settings.db_language, missingFiles[i] );
                        }
                        break;
                    case 'E':
                        if ( Settings.discart == 0 )
                        {
                            sprintf( URLFile, "%sUS/%s", serverDisc, missingFiles[i] );
                        }
                        else if ( Settings.discart == 1 )
                        {
                            sprintf( URLFile, "%sUS/%s", serverDiscCustom, missingFiles[i] );
                        }
                        else if ( Settings.discart == 2 && tries == 0 )
                        {
                            sprintf( URLFile, "%sUS/%s", serverDisc, missingFiles[i] );
                        }
                        else if ( Settings.discart == 2 && tries == 1 )
                        {
                            sprintf( URLFile, "%sUS/%s", serverDiscCustom, missingFiles[i] );
                        }
                        else if ( Settings.discart == 3 && tries == 0 )
                        {
                            sprintf( URLFile, "%sUS/%s", serverDiscCustom, missingFiles[i] );
                        }
                        else if ( Settings.discart == 3 && tries == 1 )
                        {
                            sprintf( URLFile, "%sUS/%s", serverDisc, missingFiles[i] );
                        }
                        break;
                }

                sprintf( imgPath, "%s%s", Settings.disc_path, missingFiles[i] );
                file = downloadfile( URLFile );
                if ( !( file.size == 36864 || file.size <= 1024 || file.size == 7386 || file.size <= 1174 || file.size == 4446 || file.data == NULL ) )
                {
                    break;
                }
                else
                {
                    if ( Settings.discart == 0 )
                    {
                        sprintf( URLFile, "%sEN/%s", serverDisc, missingFiles[i] );
                    }
                    else if ( Settings.discart == 1 )
                    {
                        sprintf( URLFile, "%sEN/%s", serverDiscCustom, missingFiles[i] );
                    }
                    else if ( Settings.discart == 2 && tries == 0 )
                    {
                        sprintf( URLFile, "%sEN/%s", serverDisc, missingFiles[i] );
                    }
                    else if ( Settings.discart == 2 && tries == 1 )
                    {
                        sprintf( URLFile, "%sEN/%s", serverDiscCustom, missingFiles[i] );
                    }
                    else if ( Settings.discart == 3 && tries == 0 )
                    {
                        sprintf( URLFile, "%sEN/%s", serverDiscCustom, missingFiles[i] );
                    }
                    else if ( Settings.discart == 3 && tries == 1 )
                    {
                        sprintf( URLFile, "%sEN/%s", serverDisc, missingFiles[i] );
                    }
                    file = downloadfile( URLFile );
                    if ( !( file.size == 36864 || file.size <= 1024 || file.size == 7386 || file.size <= 1174 || file.size == 4446 || file.data == NULL ) )
                    {
                        break;
                    }
                }
                tries++;
            }
        }
        if ( choice2 == 1 )
        {
            while ( tries < serverCnt2d )
            {

                //Creates URL depending from which Country the game is
                switch ( missingFiles[i][3] )
                {
                    case 'J':
                        sprintf( URLFile, "%sJA/%s", server2d, missingFiles[i] );
                        break;
                    case 'W':
                        sprintf( URLFile, "%sZH/%s", server2d, missingFiles[i] );
                        break;
                    case 'K':
                        sprintf( URLFile, "%sKO/%s", server2d, missingFiles[i] );
                        break;
                    case 'P':
                    case 'D':
                    case 'F':
                    case 'I':
                    case 'S':
                    case 'H':
                    case 'U':
                    case 'X':
                    case 'Y':
                    case 'Z':
                        sprintf( URLFile, "%s%s/%s", server2d, Settings.db_language, missingFiles[i] );
                        break;
                    case 'E':
                        sprintf( URLFile, "%sUS/%s", server2d, missingFiles[i] );
                        break;
                }

                sprintf( imgPath, "%s%s", Settings.covers2d_path, missingFiles[i] );
                file = downloadfile( URLFile );

                if ( !( file.size == 36864 || file.size <= 1024 || file.size == 7386 || file.size <= 1174 || file.size == 4446 || file.data == NULL ) )
                {
                    break;
                }
                else
                {
                    sprintf( URLFile, "%sEN/%s", server2d, missingFiles[i] );
                    file = downloadfile( URLFile );
                    if ( !( file.size == 36864 || file.size <= 1024 || file.size == 7386 || file.size <= 1174 || file.size == 4446 || file.data == NULL ) )
                    {
                        break;
                    }
                }
                tries++;
            }
        }


        offset++;

        if ( file.size == 36864 || file.size <= 1024 || file.size <= 1174 || file.size == 7386 || file.size == 4446 || file.data == NULL )
        {
            cntNotFound++;
            i++;
        }
        else
        {
            if ( file.data != NULL )
            {
                // save png to sd card
                FILE *pfile = NULL;
                if ( ( pfile = fopen( imgPath, "wb" ) ) != NULL )
                {
                    fwrite( file.data, 1, file.size, pfile );
                    fclose ( pfile );
                }
                free( file.data );
            }
            i++;

        }

        if ( btn1.GetState() == STATE_CLICKED )
        {
            cntNotFound = cntMissFiles - i + cntNotFound;
            break;
        }
    }

    /**Temporary redownloading 1st image because of a fucking corruption bug **/
#if 0 // is no longer necessary, since libfat is fixed
    char URLFile[100];
    struct block file = downloadfile( URLFile );
    if ( choice2 == 2 )
    {
        while ( tries < serverCnt3d )
        {
            sprintf( URLFile, "%s%s", server3d, missingFiles[0] );
            sprintf( imgPath, "%s%s", Settings.covers_path, missingFiles[0] );
            file = downloadfile( URLFile );
            if ( !( file.size == 36864 || file.size <= 1024 || file.size <= 1174 || file.size == 7386 || file.size == 4446 || file.data == NULL ) )break;
            tries++;
        }

    }
    if ( choice2 == 3 )
    {
        while ( tries < serverCntDisc )
        {
            sprintf( URLFile, "%s%s", serverDisc, missingFiles[0] );
            sprintf( imgPath, "%s%s", Settings.disc_path, missingFiles[0] );
            file = downloadfile( URLFile );
            if ( !( file.size == 36864 || file.size <= 1024 || file.size <= 1174 || file.size == 7386 || file.size == 4446 || file.data == NULL ) )break;
            tries++;
        }
    }
    if ( choice2 == 1 )
    {
        while ( tries < serverCnt2d )
        {
            sprintf( URLFile, "%s%s", server2d, missingFiles[0] );
            sprintf( imgPath, "%s%s", Settings.covers2d_path, missingFiles[0] );
            file = downloadfile( URLFile );
            if ( !( file.size == 36864 || file.size <= 1024 || file.size <= 1174 || file.size == 7386 || file.size == 4446 || file.data == NULL ) )break;
            tries++;
        }
    }
    if ( file.size == 36864 || file.size <= 1024 || file.size == 7386 || file.size <= 1174 || file.size == 4446 || file.data == NULL )
    {
    }
    else
    {
        if ( file.data != NULL )
        {
            // save png to sd card
            FILE *pfile;
            pfile = fopen( imgPath, "wb" );
            fwrite( file.data, 1, file.size, pfile );
            fclose ( pfile );
            free( file.data );
        }
    }
#endif
    HaltGui();
    mainWindow->Remove( &promptWindow );
    mainWindow->SetState( STATE_DEFAULT );
    ResumeGui();

    if ( cntNotFound != 0 )
    {
        return cntNotFound;
    }
    else
    {
        return 0;
    }
}

/****************************************************************************
 * ProgressWindow
 *
 * Opens a window, which displays progress to the user. Can either display a
 * progress bar showing % completion, or a throbber that only shows that an
 * action is in progress.
 ***************************************************************************/
#define BLOCKSIZE    1024
/*bool unzipArchive(char * zipfilepath, char * unzipfolderpath)
{
   unzFile uf = unzOpen(zipfilepath);
   if (uf==NULL)
   {
   // printf("Cannot open %s, aborting\n",zipfilepath);
      return false;
   }
   //printf("%s opened\n",zipfilepath);
   if(chdir(unzipfolderpath)) // can't access dir
   {
    makedir(unzipfolderpath); // attempt to make dir
    if(chdir(unzipfolderpath)) // still can't access dir
      {
    //printf("Error changing into %s, aborting\n", unzipfolderpath);
    return false;
    }
   }
   extractZip(uf,0,1,0);
   unzCloseCurrentFile(uf);
   return true
}
*/

#ifdef FULLCHANNEL ///////////////////this is only used if  the dol is being compiled for a full channel
int ProgressUpdateWindow()
{
    int ret = 0, failed = 0;

    gprintf( "\nProgressUpdateWindow(full channel)" );
    GuiWindow promptWindow( 472, 320 );
    promptWindow.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    promptWindow.SetPosition( 0, -10 );

    GuiSound btnSoundOver( button_over_pcm, button_over_pcm_size, Settings.sfxvolume );
    // because destroy GuiSound must wait while sound playing is finished, we use a global sound
    if ( !btnClick2 ) btnClick2 = new GuiSound( button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume );
    //  GuiSound btnClick(button_click2_pcm, button_click2_pcm_size, SOUND_PCM, Settings.sfxvolume);

    char imgPath[100];
    snprintf( imgPath, sizeof( imgPath ), "%sbutton_dialogue_box.png", Settings.theme_path );
    GuiImageData btnOutline( imgPath, button_dialogue_box_png );
    snprintf( imgPath, sizeof( imgPath ), "%sdialogue_box.png", Settings.theme_path );
    GuiImageData dialogBox( imgPath, dialogue_box_png );
    GuiTrigger trigA;
    trigA.SetSimpleTrigger( -1, WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A, PAD_BUTTON_A );

    GuiImage dialogBoxImg( &dialogBox );
    if ( Settings.wsprompt == yes )
    {
        dialogBoxImg.SetWidescreen( Settings.widescreen );
    }

    snprintf( imgPath, sizeof( imgPath ), "%sprogressbar_outline.png", Settings.theme_path );
    GuiImageData progressbarOutline( imgPath, progressbar_outline_png );
    GuiImage progressbarOutlineImg( &progressbarOutline );
    if ( Settings.wsprompt == yes )
    {
        progressbarOutlineImg.SetWidescreen( Settings.widescreen );
    }
    progressbarOutlineImg.SetAlignment( ALIGN_LEFT, ALIGN_MIDDLE );
    progressbarOutlineImg.SetPosition( 25, 7 );

    snprintf( imgPath, sizeof( imgPath ), "%sprogressbar_empty.png", Settings.theme_path );
    GuiImageData progressbarEmpty( imgPath, progressbar_empty_png );
    GuiImage progressbarEmptyImg( &progressbarEmpty );
    progressbarEmptyImg.SetAlignment( ALIGN_LEFT, ALIGN_MIDDLE );
    progressbarEmptyImg.SetPosition( 25, 7 );
    progressbarEmptyImg.SetTile( 100 );

    snprintf( imgPath, sizeof( imgPath ), "%sprogressbar.png", Settings.theme_path );
    GuiImageData progressbar( imgPath, progressbar_png );
    GuiImage progressbarImg( &progressbar );
    progressbarImg.SetAlignment( ALIGN_LEFT, ALIGN_MIDDLE );
    progressbarImg.SetPosition( 25, 7 );

    char title[50];
    sprintf( title, "%s", tr( "Checking for Updates" ) );
    GuiText titleTxt( title, 26, THEME.prompttext );
    titleTxt.SetAlignment( ALIGN_CENTRE, ALIGN_TOP );
    titleTxt.SetPosition( 0, 50 );
    char msg[50];
    sprintf( msg, "%s", tr( "Initializing Network" ) );
    GuiText msgTxt( msg, 26, THEME.prompttext );
    msgTxt.SetAlignment( ALIGN_CENTRE, ALIGN_TOP );
    msgTxt.SetPosition( 0, 140 );
    char msg2[50] = " ";
    GuiText msg2Txt( msg2, 26, THEME.prompttext );
    msg2Txt.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    msg2Txt.SetPosition( 0, 50 );

    GuiText prTxt( NULL, 26, THEME.prompttext );
    prTxt.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    prTxt.SetPosition( 0, 7 );

    GuiText btn1Txt( tr( "Cancel" ), 22, THEME.prompttext );
    GuiImage btn1Img( &btnOutline );
    if ( Settings.wsprompt == yes )
    {
        btn1Txt.SetWidescreen( Settings.widescreen );
        btn1Img.SetWidescreen( Settings.widescreen );
    }
    GuiButton btn1( &btn1Img, &btn1Img, 2, 4, 0, -40, &trigA, &btnSoundOver, btnClick2, 1 );
    btn1.SetLabel( &btn1Txt );
    btn1.SetState( STATE_SELECTED );

    if ( ( Settings.wsprompt == yes ) && ( Settings.widescreen ) )  /////////////adjust for widescreen
    {
        progressbarOutlineImg.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
        progressbarOutlineImg.SetPosition( 0, 7 );
        progressbarEmptyImg.SetPosition( 80, 7 );
        progressbarEmptyImg.SetTile( 78 );
        progressbarImg.SetPosition( 80, 7 );
    }

    promptWindow.Append( &dialogBoxImg );
    promptWindow.Append( &titleTxt );
    promptWindow.Append( &msgTxt );
    promptWindow.Append( &msg2Txt );
    promptWindow.Append( &btn1 );

    promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_IN, 50 );

    HaltGui();
    mainWindow->SetState( STATE_DISABLED );
    mainWindow->Append( &promptWindow );
    mainWindow->ChangeFocus( &promptWindow );
    ResumeGui();

    struct stat st;
    if ( stat( Settings.update_path, &st ) != 0 )
    {
        if ( subfoldercreate( Settings.covers_path ) != 1 )
        {
            WindowPrompt( tr( "Error !" ), tr( "Can't create directory" ), tr( "OK" ) );
            ret = -1;
            failed = -1;
        }
    }

    if ( stat( Settings.titlestxt_path, &st ) != 0 )
    {
        if ( subfoldercreate( Settings.titlestxt_path ) != 1 )
        {
            WindowPrompt( tr( "Error !" ), tr( "Can't create directory" ), tr( "OK" ) );
            ret = -1;
            failed = -1;
        }
    }

    //make the URL to get XML based on our games
    char XMLurl[3540];
    build_XML_URL( XMLurl, sizeof( XMLurl ) );

    char dolpath[150];
//    char dolpathsuccess[150];//use coverspath as a folder for the update wad so we dont make a new folder and have to delete it
    snprintf( dolpath, sizeof( dolpath ), "%sULNR.wad", Settings.covers_path );
    //snprintf(dolpathsuccess, sizeof(dolpathsuccess), "%sUNEO.wad", Settings.covers_path);
    Initialize_Network();
    while ( !IsNetworkInit() )
    {

        VIDEO_WaitVSync();

        Initialize_Network();

        if ( IsNetworkInit() )
        {
            msgTxt.SetText( GetNetworkIP() );
        }
        else
        {
            msgTxt.SetText( tr( "Could not initialize network!" ) );
        }

        if ( btn1.GetState() == STATE_CLICKED )
        {
            ret = -1;
            failed = -1;
            btn1.ResetState();
            break;
        }
    }

    if ( IsNetworkInit() && ret >= 0 )
    {

        int newrev = CheckUpdate();

        if ( newrev > 0 )
        {
            FILE * pfile;
            sprintf( msg, "Rev%i %s.", newrev, tr( "available" ) );
            int choice = WindowPrompt( msg, 0, tr( "Update" ), tr( "Cancel" ) );
            if ( choice == 1 )
            {
                titleTxt.SetTextf( "%s USB Loader GX", tr( "Updating" ) );
                msgTxt.SetPosition( 0, 100 );
                msgTxt.SetTextf( "%s", tr( "Updating WiiTDB.zip" ) );

                char wiitdbpath[200];
                char wiitdbpathtmp[200];
                struct block file = downloadfile( XMLurl );
                if ( file.data != NULL )
                {
                    snprintf( wiitdbpath, sizeof( wiitdbpath ), "%swiitdb_%s.zip", Settings.titlestxt_path, game_partition );
                    snprintf( wiitdbpathtmp, sizeof( wiitdbpathtmp ), "%swiitmp_%s.zip", Settings.titlestxt_path, game_partition );
                    rename( wiitdbpath, wiitdbpathtmp );
                    pfile = fopen( wiitdbpath, "wb" );
                    fwrite( file.data, 1, file.size, pfile );
                    fclose( pfile );
                    free( file.data );
                    CloseXMLDatabase();
                    if ( OpenXMLDatabase( Settings.titlestxt_path, Settings.db_language, Settings.db_JPtoEN, true, Settings.titlesOverride == 1 ? true : false, true ) )   // open file, reload titles, keep in memory
                    {
                        remove( wiitdbpathtmp );
                    }
                    else
                    {
                        remove( wiitdbpath );
                        rename( wiitdbpathtmp, wiitdbpath );
                        OpenXMLDatabase( Settings.titlestxt_path, Settings.db_language, Settings.db_JPtoEN, true, Settings.titlesOverride == 1 ? true : false, true ); // open file, reload titles, keep in memory
                    }
                }

                msgTxt.SetTextf( "%s", tr( "Updating Language Files:" ) );
                updateLanguageFiles();
                promptWindow.Append( &progressbarEmptyImg );
                promptWindow.Append( &progressbarImg );
                promptWindow.Append( &progressbarOutlineImg );
                promptWindow.Append( &prTxt );
                msgTxt.SetTextf( "%s Rev%i wad.", tr( "Downloading" ), newrev );
                s32 filesize;
                if ( Settings.beta_upgrades )
                {
                    char url[255];
                    memset( &url, 0, 255 );
                    sprintf( ( char * ) &url, "http://usbloader-gui.googlecode.com/files/r%d.wad", newrev );
                    filesize = download_request( ( char * ) & url );
                }
                else
                {
                    filesize = download_request( "http://www.techjawa.com/usbloadergx/ULNR.file" );//for some reason it didn't download completely when saved as a wad.
                }

                if ( filesize > 0 )
                {

                    pfile = fopen( dolpath, "wb" );//here we save the txt as a wad
                    u8 * blockbuffer = new unsigned char[BLOCKSIZE];
                    for ( s32 i = 0; i < filesize; i += BLOCKSIZE )
                    {
                        usleep( 100 );
                        prTxt.SetTextf( "%i%%", ( 100*i / filesize ) + 1 );
                        if ( ( Settings.wsprompt == yes ) && ( Settings.widescreen ) )
                        {
                            progressbarImg.SetTile( 80*i / filesize );
                        }
                        else
                        {
                            progressbarImg.SetTile( 100*i / filesize );
                        }
                        msg2Txt.SetTextf( "%iKB/%iKB", i / 1024, filesize / 1024 );

                        if ( btn1.GetState() == STATE_CLICKED )
                        {
                            fclose( pfile );
                            remove( dolpath );
                            failed = -1;
                            btn1.ResetState();
                            break;
                        }

                        u32 blksize;
                        blksize = ( u32 )( filesize - i );
                        if ( blksize > BLOCKSIZE )
                            blksize = BLOCKSIZE;

                        ret = network_read( blockbuffer, blksize );
                        if ( ret != ( s32 ) blksize )
                        {
                            failed = -1;
                            ret = -1;
                            fclose( pfile );
                            remove( dolpath );
                            break;
                        }
                        fwrite( blockbuffer, 1, blksize, pfile );
                    }
                    fclose( pfile );
                    delete blockbuffer;
                    if ( !failed )
                    {
                    }
                }
                else
                {
                    failed = -1;
                }
            }
            else
            {
                ret = -1;
            }

        }
        else
        {
            WindowPrompt( tr( "No new updates." ), 0, tr( "OK" ) );
            ret = -1;
        }

    }
    promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_OUT, 50 );
    while ( promptWindow.GetEffect() > 0 ) usleep( 50 );

    HaltGui();
    mainWindow->Remove( &promptWindow );
    //mainWindow->SetState(STATE_DEFAULT);
    ResumeGui();
    CloseConnection();
    sleep( 1 );//sleep 1 because it froze without this for some reason

    if ( !failed && ret >= 0 )
    {

        FILE *wadFile = NULL;
        s32 error = 1;
        int diarhea = 0;
        char nipple[100];
        wadFile = fopen ( dolpath , "rb" );
        if ( wadFile == NULL )   //we can't open the file wad we just downloaded
        {
            sprintf( nipple, tr( "Unable to open the wad that was just downloaded (%s)." ), dolpath );
            WindowPrompt( tr( "Error !" ), nipple, tr( "OK" ) );
            failed = -1;
        }
        else
        {
            //sprintf(nipple, tr("The update wad has been saved as %s.  Now let's try to install it."),dolpath);
            //WindowPrompt(0,nipple, tr("OK"));
            gprintf( "\n\tinstall wad" );
            error = Wad_Install( wadFile );
            fclose( wadFile );
            if ( error == 0 )
            {
                diarhea = remove( dolpath );
                if ( diarhea )
                    WindowPrompt( tr( "Success" ), tr( "The wad file was installed.  But It could not be deleted from the SD card." ), tr( "OK" ) );
            }
            else
            {
                gprintf( " -> failed" );
                sprintf( nipple, tr( "The wad installation failed with error %ld" ), error );
                WindowPrompt( tr( "Error" ), nipple, tr( "OK" ) );
            }
        }

        if ( error )
            WindowPrompt( tr( "ERROR" ) , tr( "An Error occured" ), tr( "OK" ) );
        else
        {
            WindowPrompt( tr( "Restarting..." ), tr( "Successfully Updated thanks to www.techjawa.com" )  , 0, 0, 0, 0, 150 );
        }
        CloseXMLDatabase();
        ExitGUIThreads();
        ShutdownAudio();
        StopGX();
        gprintf( "\nRebooting" );
        WII_Initialize();
        WII_LaunchTitle( TITLE_ID( 0x00010001, 0x554c4e52 ) );
    }

    // promptWindow.SetEffect(EFFECT_SLIDE_TOP | EFFECT_SLIDE_OUT, 50);
    //while(promptWindow.GetEffect() > 0) usleep(50);

    HaltGui();
    //mainWindow->Remove(&promptWindow);
    mainWindow->SetState( STATE_DEFAULT );
    ResumeGui();

    if ( failed != 0 )
        return failed;

    return 1;
}
#else
int ProgressUpdateWindow()
{

    gprintf( "\nProgressUpdateWindow(not full channel)" );
    int ret = 0, failed = 0, updatemode = -1;

    GuiWindow promptWindow( 472, 320 );
    promptWindow.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    promptWindow.SetPosition( 0, -10 );

    GuiSound btnSoundOver( button_over_pcm, button_over_pcm_size, Settings.sfxvolume );
    // because destroy GuiSound must wait while sound playing is finished, we use a global sound
    if ( !btnClick2 ) btnClick2 = new GuiSound( button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume );
    //  GuiSound btnClick(button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume);

    char imgPath[100];
    snprintf( imgPath, sizeof( imgPath ), "%sbutton_dialogue_box.png", Settings.theme_path );
    GuiImageData btnOutline( imgPath, button_dialogue_box_png );
    snprintf( imgPath, sizeof( imgPath ), "%sdialogue_box.png", Settings.theme_path );
    GuiImageData dialogBox( imgPath, dialogue_box_png );
    GuiTrigger trigA;
    trigA.SetSimpleTrigger( -1, WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A, PAD_BUTTON_A );

    GuiImage dialogBoxImg( &dialogBox );
    if ( Settings.wsprompt == yes )
    {
        dialogBoxImg.SetWidescreen( Settings.widescreen );
    }

    snprintf( imgPath, sizeof( imgPath ), "%sprogressbar_outline.png", Settings.theme_path );
    GuiImageData progressbarOutline( imgPath, progressbar_outline_png );
    GuiImage progressbarOutlineImg( &progressbarOutline );
    if ( Settings.wsprompt == yes )
    {
        progressbarOutlineImg.SetWidescreen( Settings.widescreen );
    }
    progressbarOutlineImg.SetAlignment( ALIGN_LEFT, ALIGN_MIDDLE );
    progressbarOutlineImg.SetPosition( 25, 7 );

    snprintf( imgPath, sizeof( imgPath ), "%sprogressbar_empty.png", Settings.theme_path );
    GuiImageData progressbarEmpty( imgPath, progressbar_empty_png );
    GuiImage progressbarEmptyImg( &progressbarEmpty );
    progressbarEmptyImg.SetAlignment( ALIGN_LEFT, ALIGN_MIDDLE );
    progressbarEmptyImg.SetPosition( 25, 7 );
    progressbarEmptyImg.SetTile( 100 );

    snprintf( imgPath, sizeof( imgPath ), "%sprogressbar.png", Settings.theme_path );
    GuiImageData progressbar( imgPath, progressbar_png );
    GuiImage progressbarImg( &progressbar );
    progressbarImg.SetAlignment( ALIGN_LEFT, ALIGN_MIDDLE );
    progressbarImg.SetPosition( 25, 7 );

    char title[50];
    sprintf( title, "%s", tr( "Checking for Updates" ) );
    GuiText titleTxt( title, 26, THEME.prompttext );
    titleTxt.SetAlignment( ALIGN_CENTRE, ALIGN_TOP );
    titleTxt.SetPosition( 0, 50 );
    char msg[50];
    sprintf( msg, "%s", tr( "Initializing Network" ) );
    GuiText msgTxt( msg, 26, THEME.prompttext );
    msgTxt.SetAlignment( ALIGN_CENTRE, ALIGN_TOP );
    msgTxt.SetPosition( 0, 140 );
    char msg2[50] = " ";
    GuiText msg2Txt( msg2, 26, THEME.prompttext );
    msg2Txt.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    msg2Txt.SetPosition( 0, 50 );

    GuiText prTxt( ( char* ) NULL, 26, THEME.prompttext );
    prTxt.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    prTxt.SetPosition( 0, 7 );

    GuiText btn1Txt( tr( "Cancel" ), 22, THEME.prompttext );
    GuiImage btn1Img( &btnOutline );
    if ( Settings.wsprompt == yes )
    {
        btn1Txt.SetWidescreen( Settings.widescreen );
        btn1Img.SetWidescreen( Settings.widescreen );
    }
    GuiButton btn1( &btn1Img, &btn1Img, 2, 4, 0, -40, &trigA, &btnSoundOver, btnClick2, 1 );
    btn1.SetLabel( &btn1Txt );
    btn1.SetState( STATE_SELECTED );

    if ( ( Settings.wsprompt == yes ) && ( Settings.widescreen ) )  /////////////adjust for widescreen
    {
        progressbarOutlineImg.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
        progressbarOutlineImg.SetPosition( 0, 7 );
        progressbarEmptyImg.SetPosition( 80, 7 );
        progressbarEmptyImg.SetTile( 78 );
        progressbarImg.SetPosition( 80, 7 );
    }

    promptWindow.Append( &dialogBoxImg );
    promptWindow.Append( &titleTxt );
    promptWindow.Append( &msgTxt );
    promptWindow.Append( &msg2Txt );
    promptWindow.Append( &btn1 );

    promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_IN, 50 );

    HaltGui();
    mainWindow->SetState( STATE_DISABLED );
    mainWindow->Append( &promptWindow );
    mainWindow->ChangeFocus( &promptWindow );
    ResumeGui();

    struct stat st;
    if ( stat( Settings.update_path, &st ) != 0 )
    {
        if ( subfoldercreate( Settings.update_path ) != 1 )
        {
            WindowPrompt( tr( "Error !" ), tr( "Can't create directory" ), tr( "OK" ) );
            ret = -1;
            failed = -1;
        }
    }

    char dolpath[150];
    char dolpathsuccess[150];
    snprintf( dolpath, sizeof( dolpath ), "%sbootnew.dol", Settings.update_path );
    snprintf( dolpathsuccess, sizeof( dolpathsuccess ), "%sboot.dol", Settings.update_path );

    while ( !IsNetworkInit() )
    {

        VIDEO_WaitVSync();

        Initialize_Network();

        if ( IsNetworkInit() )
        {
            msgTxt.SetText( GetNetworkIP() );
        }
        else
        {
            msgTxt.SetText( tr( "Could not initialize network!" ) );
        }

        if ( btn1.GetState() == STATE_CLICKED )
        {
            ret = -1;
            failed = -1;
            btn1.ResetState();
            break;
        }
    }

    //make the URL to get XML based on our games
    char XMLurl[3540];
    build_XML_URL( XMLurl, sizeof( XMLurl ) );

    if ( IsNetworkInit() && ret >= 0 )
    {

        updatemode = WindowPrompt( tr( "What do you want to update?" ), 0, "USB Loader GX", tr( "WiiTDB Files" ), tr( "Language File" ), tr( "Cancel" ) );
        mainWindow->SetState( STATE_DISABLED );
        promptWindow.SetState( STATE_DEFAULT );
        mainWindow->ChangeFocus( &promptWindow );

        if ( updatemode == 1 )
        {

            int newrev = CheckUpdate();
            if ( newrev > 0 )
            {

                sprintf( msg, "Rev%i %s.", newrev, tr( "available" ) );
                int choice = WindowPrompt( msg, tr( "How do you want to update?" ), tr( "Update DOL" ), tr( "Update All" ), tr( "Cancel" ) );
                mainWindow->SetState( STATE_DISABLED );
                promptWindow.SetState( STATE_DEFAULT );
                mainWindow->ChangeFocus( &promptWindow );
                if ( choice == 1 || choice == 2 )
                {
                    titleTxt.SetTextf( "%s USB Loader GX", tr( "Updating" ) );
                    msgTxt.SetPosition( 0, 100 );
                    promptWindow.Append( &progressbarEmptyImg );
                    promptWindow.Append( &progressbarImg );
                    promptWindow.Append( &progressbarOutlineImg );
                    promptWindow.Append( &prTxt );
                    msgTxt.SetTextf( "%s Rev%i", tr( "Update to" ), newrev );

                    s32 filesize;
                    if ( Settings.beta_upgrades )
                    {
                        char url[255];
                        memset( &url, 0, 255 );
                        sprintf( ( char * ) &url, "http://usbloader-gui.googlecode.com/files/r%d.dol", newrev );
                        filesize = download_request( ( char * ) & url );
                    }
                    else
                    {
                        filesize = download_request( "http://www.techjawa.com/usbloadergx/boot.dol" );
                    }
                    if ( filesize > 0 )
                    {
                        FILE * pfile;
                        pfile = fopen( dolpath, "wb" );
                        u8 * blockbuffer = new unsigned char[BLOCKSIZE];
                        for ( s32 i = 0; i < filesize; i += BLOCKSIZE )
                        {
                            usleep( 100 );
                            prTxt.SetTextf( "%i%%", ( 100*i / filesize ) + 1 );
                            if ( ( Settings.wsprompt == yes ) && ( Settings.widescreen ) )
                            {
                                progressbarImg.SetTile( 80*i / filesize );
                            }
                            else
                            {
                                progressbarImg.SetTile( 100*i / filesize );
                            }
                            msg2Txt.SetTextf( "%iKB/%iKB", i / 1024, filesize / 1024 );

                            if ( btn1.GetState() == STATE_CLICKED )
                            {
                                fclose( pfile );
                                remove( dolpath );
                                failed = -1;
                                btn1.ResetState();
                                break;
                            }

                            u32 blksize;
                            blksize = ( u32 )( filesize - i );
                            if ( blksize > BLOCKSIZE )
                                blksize = BLOCKSIZE;

                            ret = network_read( blockbuffer, blksize );
                            if ( ret != ( s32 ) blksize )
                            {
                                failed = -1;
                                ret = -1;
                                fclose( pfile );
                                remove( dolpath );
                                break;
                            }
                            fwrite( blockbuffer, 1, blksize, pfile );
                        }
                        fclose( pfile );
                        delete blockbuffer;
                        if ( !failed )
                        {
                            //remove old
                            if ( checkfile( dolpathsuccess ) )
                            {
                                remove( dolpathsuccess );
                            }
                            //rename new to old
                            rename( dolpath, dolpathsuccess );

                            if ( choice == 2 )
                            {
                                //get the icon.png and the meta.xml
                                char xmliconpath[150];
                                struct block file = downloadfile( "http://www.techjawa.com/usbloadergx/meta.file" );
                                if ( file.data != NULL )
                                {
                                    sprintf( xmliconpath, "%smeta.xml", Settings.update_path );
                                    pfile = fopen( xmliconpath, "wb" );
                                    fwrite( file.data, 1, file.size, pfile );
                                    fclose( pfile );
                                    free( file.data );
                                }
                                file = downloadfile( "http://www.techjawa.com/usbloadergx/icon.png" );
                                if ( file.data != NULL )
                                {
                                    sprintf( xmliconpath, "%sicon.png", Settings.update_path );
                                    pfile = fopen( xmliconpath, "wb" );
                                    fwrite( file.data, 1, file.size, pfile );
                                    fclose( pfile );
                                    free( file.data );
                                }
                                msgTxt.SetTextf( "%s", tr( "Updating WiiTDB.zip" ) );
                                char wiitdbpath[200];
                                char wiitdbpathtmp[200];
                                file = downloadfile( XMLurl );
                                if ( file.data != NULL )
                                {
                                    subfoldercreate( Settings.titlestxt_path );
                                    snprintf( wiitdbpath, sizeof( wiitdbpath ), "%swiitdb_%s.zip", Settings.titlestxt_path, game_partition );
                                    snprintf( wiitdbpathtmp, sizeof( wiitdbpathtmp ), "%swiitmp_%s.zip", Settings.titlestxt_path, game_partition );
                                    rename( wiitdbpath, wiitdbpathtmp );
                                    pfile = fopen( wiitdbpath, "wb" );
                                    fwrite( file.data, 1, file.size, pfile );
                                    fclose( pfile );
                                    free( file.data );
                                    CloseXMLDatabase();
                                    if ( OpenXMLDatabase( Settings.titlestxt_path, Settings.db_language, Settings.db_JPtoEN, true, Settings.titlesOverride == 1 ? true : false, true ) )   // open file, reload titles, keep in memory
                                    {
                                        remove( wiitdbpathtmp );
                                    }
                                    else
                                    {
                                        remove( wiitdbpath );
                                        rename( wiitdbpathtmp, wiitdbpath );
                                        OpenXMLDatabase( Settings.titlestxt_path, Settings.db_language, Settings.db_JPtoEN, true, Settings.titlesOverride == 1 ? true : false, true ); // open file, reload titles, keep in memory
                                    }
                                }
                                msgTxt.SetTextf( "%s", tr( "Updating Language Files:" ) );
                                updateLanguageFiles();
                            }
                        }
                    }
                    else
                    {
                        failed = -1;
                    }
                }
                else
                {
                    ret = -1;
                }
            }
            else
            {
                WindowPrompt( tr( "No new updates." ), 0, tr( "OK" ) );
                ret = -1;
            }

        }
        else if ( updatemode == 2 )
        {
            msgTxt.SetTextf( "%s", tr( "Updating WiiTDB.zip" ) );
            char wiitdbpath[200];
            char wiitdbpathtmp[200];
            struct block file = downloadfile( XMLurl );
            if ( file.data != NULL )
            {
                subfoldercreate( Settings.titlestxt_path );
                snprintf( wiitdbpath, sizeof( wiitdbpath ), "%swiitdb_%s.zip", Settings.titlestxt_path, game_partition );
                snprintf( wiitdbpathtmp, sizeof( wiitdbpathtmp ), "%swiitmp_%s.zip", Settings.titlestxt_path, game_partition );
                rename( wiitdbpath, wiitdbpathtmp );
                FILE *pfile = fopen( wiitdbpath, "wb" );
                fwrite( file.data, 1, file.size, pfile );
                fclose( pfile );
                free( file.data );
                CloseXMLDatabase();
                if ( OpenXMLDatabase( Settings.titlestxt_path, Settings.db_language, Settings.db_JPtoEN, true, Settings.titlesOverride == 1 ? true : false, true ) )   // open file, reload titles, keep in memory
                {
                    remove( wiitdbpathtmp );
                }
                else
                {
                    remove( wiitdbpath );
                    rename( wiitdbpathtmp, wiitdbpath );
                    OpenXMLDatabase( Settings.titlestxt_path, Settings.db_language, Settings.db_JPtoEN, true, Settings.titlesOverride == 1 ? true : false, true ); // open file, reload titles, keep in memory
                }
            }
            ret = 1;
        }
        else if ( updatemode == 3 )
        {

            msgTxt.SetTextf( "%s", tr( "Updating Language Files..." ) );
            updateLanguageFiles();
            ret = 1;
        }
        else
        {
            ret = -1;
        }
    }

    CloseConnection();

    if ( !failed && ret >= 0 && updatemode == 1 )
    {
        WindowPrompt( tr( "Restarting..." ), tr( "Successfully Updated thanks to www.techjawa.com" )  , 0, 0, 0, 0, 150 );

        loadStub();
        Set_Stub_Split( 0x00010001, "UNEO" );
        Sys_BackToLoader();
    }
    else if ( updatemode > 0 && ret > 0 )
    {
        WindowPrompt( tr( "Successfully Updated" ) , 0, tr( "OK" ) );
    }

    promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_OUT, 50 );
    while ( promptWindow.GetEffect() > 0 ) usleep( 50 );

    HaltGui();
    mainWindow->Remove( &promptWindow );
    mainWindow->SetState( STATE_DEFAULT );
    ResumeGui();

    if ( failed != 0 )
        return failed;

    return 1;
}

#endif

int CodeDownload( const char *id )
{
    int ret = 0;

    GuiWindow promptWindow( 472, 320 );
    promptWindow.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    promptWindow.SetPosition( 0, -10 );

    GuiSound btnSoundOver( button_over_pcm, button_over_pcm_size, Settings.sfxvolume );
    // because destroy GuiSound must wait while sound playing is finished, we use a global sound
    if ( !btnClick2 ) btnClick2 = new GuiSound( button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume );
    //  GuiSound btnClick(button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume);

    char imgPath[100];
    snprintf( imgPath, sizeof( imgPath ), "%sbutton_dialogue_box.png", Settings.theme_path );
    GuiImageData btnOutline( imgPath, button_dialogue_box_png );
    snprintf( imgPath, sizeof( imgPath ), "%sdialogue_box.png", Settings.theme_path );
    GuiImageData dialogBox( imgPath, dialogue_box_png );
    GuiTrigger trigA;
    trigA.SetSimpleTrigger( -1, WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A, PAD_BUTTON_A );

    GuiImage dialogBoxImg( &dialogBox );
    if ( Settings.wsprompt == yes )
    {
        dialogBoxImg.SetWidescreen( Settings.widescreen );
    }



    char title[50];
    sprintf( title, "%s", tr( "Code Download" ) );
    GuiText titleTxt( title, 26, THEME.prompttext );
    titleTxt.SetAlignment( ALIGN_CENTRE, ALIGN_TOP );
    titleTxt.SetPosition( 0, 50 );
    char msg[50];
    sprintf( msg, "%s", tr( "Initializing Network" ) );
    GuiText msgTxt( msg, 26, THEME.prompttext );
    msgTxt.SetAlignment( ALIGN_CENTRE, ALIGN_TOP );
    msgTxt.SetPosition( 0, 140 );
    char msg2[50] = " ";
    GuiText msg2Txt( msg2, 26, THEME.prompttext );
    msg2Txt.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    msg2Txt.SetPosition( 0, 50 );

    GuiText btn1Txt( tr( "Cancel" ), 22, THEME.prompttext );
    GuiImage btn1Img( &btnOutline );
    if ( Settings.wsprompt == yes )
    {
        btn1Txt.SetWidescreen( Settings.widescreen );
        btn1Img.SetWidescreen( Settings.widescreen );
    }
    GuiButton btn1( &btn1Img, &btn1Img, 2, 4, 0, -40, &trigA, &btnSoundOver, btnClick2, 1 );
    btn1.SetLabel( &btn1Txt );
    btn1.SetState( STATE_SELECTED );

    promptWindow.Append( &dialogBoxImg );
    promptWindow.Append( &titleTxt );
    promptWindow.Append( &msgTxt );
    promptWindow.Append( &msg2Txt );
    promptWindow.Append( &btn1 );

    promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_IN, 50 );

    HaltGui();
    mainWindow->SetState( STATE_DISABLED );
    mainWindow->Append( &promptWindow );
    mainWindow->ChangeFocus( &promptWindow );
    ResumeGui();

    struct stat st;
    if ( stat( Settings.TxtCheatcodespath, &st ) != 0 )
    {
        if ( subfoldercreate( Settings.TxtCheatcodespath ) != 1 )
        {
            WindowPrompt( tr( "Error !" ), tr( "Can't create directory" ), tr( "OK" ) );
            ret = -1;
            goto exit;
        }
    }

    while ( !IsNetworkInit() )
    {

        VIDEO_WaitVSync();

        Initialize_Network();

        if ( IsNetworkInit() )
        {
            msgTxt.SetText( GetNetworkIP() );
        }
        else
        {
            msgTxt.SetText( tr( "Could not initialize network!" ) );
        }
        if ( btn1.GetState() == STATE_CLICKED )
        {
            ret = -1;
            btn1.ResetState();
            goto exit;
        }
    }

    if ( IsNetworkInit() && ret >= 0 )
    {

        char txtpath[150];
        snprintf( txtpath, sizeof( txtpath ), "%s%s.txt", Settings.TxtCheatcodespath, id );

        char codeurl[150];
        snprintf( codeurl, sizeof( codeurl ), "http://geckocodes.org/codes/R/%s.txt", id );

        struct block  file = downloadfile( codeurl );

        if ( file.size == 333 || file.size == 216 || file.size == 284 )
        {
            strcat( codeurl, tr( " is not on the server." ) );

            WindowPrompt( tr( "Error" ), codeurl, tr( "OK" ) );
            ret = -1;
            goto exit;
        }

        if ( file.data != NULL )
        {

            FILE * pfile;
            pfile = fopen( txtpath, "wb" );
            fwrite( file.data, 1, file.size, pfile );
            fclose( pfile );
            free( file.data );
            ret = 1;
            strcat( txtpath, tr( " has been Saved.  The text has not been verified.  Some of the code may not work right with each other.  If you experience trouble, open the text in a real text editor for more information." ) );

            WindowPrompt( 0, txtpath, tr( "OK" ) );
        }
        else
        {
            strcat( codeurl, tr( " could not be downloaded." ) );

            WindowPrompt( tr( "Error" ), codeurl, tr( "OK" ) );
            ret = -1;
        }

        CloseConnection();
    }
exit:
    promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_OUT, 50 );
    while ( promptWindow.GetEffect() > 0 ) usleep( 50 );

    HaltGui();
    mainWindow->Remove( &promptWindow );
    mainWindow->SetState( STATE_DEFAULT );
    ResumeGui();

    return ret;
}

char * GetMissingFiles()
{
    return ( char * ) missingFiles;
}




/****************************************************************************
 * HBCWindowPrompt
 *
 * Displays a prompt window to user, with information, an error message, or
 * presenting a user with a choice of up to 2 Buttons.
 *
 ***************************************************************************/
/* <name>
 <coder>
   <version>
   <release_date>
   <short_description>
   <long_description>
    SD:/APPS/FTPII/ICON.PNG*/

int
HBCWindowPrompt( const char *name, const char *coder, const char *version,
                 const char *release_date, const char *long_description, const char *iconPath, u64 filesize )
{
    int choice = -1;


    GuiWindow promptWindow( 472, 320 );
    promptWindow.SetAlignment( ALIGN_CENTRE, ALIGN_MIDDLE );
    promptWindow.SetPosition( 0, 6 );

    GuiTrigger trigA;
    trigA.SetSimpleTrigger( -1, WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A, PAD_BUTTON_A );
    GuiTrigger trigB;
    trigB.SetButtonOnlyTrigger( -1, WPAD_BUTTON_B | WPAD_CLASSIC_BUTTON_B, PAD_BUTTON_B );
    GuiTrigger trigU;
    trigU.SetButtonOnlyTrigger( -1, WPAD_BUTTON_UP | WPAD_CLASSIC_BUTTON_UP, PAD_BUTTON_UP );
    GuiTrigger trigD;
    trigD.SetButtonOnlyTrigger( -1, WPAD_BUTTON_DOWN | WPAD_CLASSIC_BUTTON_DOWN, PAD_BUTTON_DOWN );

    GuiSound btnSoundOver( button_over_pcm, button_over_pcm_size, Settings.sfxvolume );
    // because destroy GuiSound must wait while sound playing is finished, we use a global sound
    if ( !btnClick2 ) btnClick2 = new GuiSound( button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume );
    //  GuiSound btnClick(button_click2_pcm, button_click2_pcm_size, Settings.sfxvolume);
    char imgPath[100];
    snprintf( imgPath, sizeof( imgPath ), "%sbutton_dialogue_box.png", Settings.theme_path );
    GuiImageData btnOutline( imgPath, button_dialogue_box_png );
    snprintf( imgPath, sizeof( imgPath ), "%sdialogue_box.png", Settings.theme_path );
    GuiImageData dialogBox( imgPath, dialogue_box_png );
    snprintf( imgPath, sizeof( imgPath ), "%sbg_options.png", Settings.theme_path );
    GuiImageData whiteBox( imgPath, bg_options_png );

    snprintf( imgPath, sizeof( imgPath ), "%sscrollbar.png", Settings.theme_path );
    GuiImageData scrollbar( imgPath, scrollbar_png );
    GuiImage scrollbarImg( &scrollbar );
    scrollbarImg.SetAlignment( ALIGN_RIGHT, ALIGN_TOP );
    scrollbarImg.SetPosition( -40, 114 );
    scrollbarImg.SetSkew( 0, 0, 0, 0, 0, -120, 0, -120 );

    snprintf( imgPath, sizeof( imgPath ), "%sscrollbar_arrowdown.png", Settings.theme_path );
    GuiImageData arrowDown( imgPath, scrollbar_arrowdown_png );
    GuiImage arrowDownImg( &arrowDown );
    arrowDownImg.SetScale( .8 );

    snprintf( imgPath, sizeof( imgPath ), "%sscrollbar_arrowup.png", Settings.theme_path );
    GuiImageData arrowUp( imgPath, scrollbar_arrowup_png );
    GuiImage arrowUpImg ( &arrowUp );
    arrowUpImg.SetScale( .8 );

    GuiButton arrowUpBtn( arrowUpImg.GetWidth(), arrowUpImg.GetHeight() );
    arrowUpBtn.SetImage( &arrowUpImg );
    arrowUpBtn.SetAlignment( ALIGN_RIGHT, ALIGN_TOP );
    arrowUpBtn.SetPosition( -25, 91 );
    arrowUpBtn.SetTrigger( &trigA );
    arrowUpBtn.SetTrigger( &trigU );
    arrowUpBtn.SetEffectOnOver( EFFECT_SCALE, 50, 130 );
    arrowUpBtn.SetSoundClick( btnClick2 );

    GuiButton arrowDownBtn( arrowDownImg.GetWidth(), arrowDownImg.GetHeight() );
    arrowDownBtn.SetImage( &arrowDownImg );
    arrowDownBtn.SetAlignment( ALIGN_RIGHT, ALIGN_BOTTOM );
    arrowDownBtn.SetPosition( -25, -27 );
    arrowDownBtn.SetTrigger( &trigA );
    arrowDownBtn.SetTrigger( &trigD );
    arrowDownBtn.SetEffectOnOver( EFFECT_SCALE, 50, 130 );
    arrowDownBtn.SetSoundClick( btnClick2 );

    GuiImageData *iconData = NULL;
    GuiImage *iconImg = NULL;
    snprintf( imgPath, sizeof( imgPath ), "%s", iconPath );

    bool iconExist = checkfile( imgPath );
    if ( iconExist )
    {
        iconData = new GuiImageData ( iconPath, dialogue_box_png );
        iconImg = new GuiImage ( iconData );
        iconImg->SetAlignment( ALIGN_LEFT, ALIGN_TOP );
        iconImg->SetPosition( 45, 10 );
    }

    GuiImage dialogBoxImg( &dialogBox );
    dialogBoxImg.SetSkew( 0, -80, 0, -80, 0, 50, 0, 50 );

    GuiImage whiteBoxImg( &whiteBox );
    whiteBoxImg.SetPosition( 0, 110 );
    whiteBoxImg.SetAlignment( ALIGN_CENTRE, ALIGN_TOP );
    whiteBoxImg.SetSkew( 0, 0, 0, 0, 0, -120, 0, -120 );
    /*if (Settings.wsprompt == yes){
    dialogBoxImg.SetWidescreen(Settings.widescreen);
    }*/

    char tmp[510];

    GuiText nameTxt( name, 30 , THEME.prompttext );
    nameTxt.SetAlignment( ALIGN_CENTRE, ALIGN_TOP );
    nameTxt.SetPosition( 0, -15 );
    nameTxt.SetMaxWidth( 430, SCROLL_HORIZONTAL );


    if ( strcmp( coder, "" ) )
        snprintf( tmp, sizeof( tmp ), tr( "Coded by: %s" ), coder );
    GuiText coderTxt( tmp, 16, THEME.prompttext );
    coderTxt.SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    coderTxt.SetPosition( 180, 30 );
    coderTxt.SetMaxWidth( 280 );

    if ( strcmp( version, "" ) )
        snprintf( tmp, sizeof( tmp ), tr( "Version: %s" ), version );
    GuiText versionTxt( tmp, 16 , THEME.prompttext );
    versionTxt.SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    versionTxt.SetPosition( 40, 65 );
    versionTxt.SetMaxWidth( 430 );

    //if (release_date)
    //snprintf(tmp, sizeof(tmp), tr("Released: %s"),release_date);
    GuiText release_dateTxt( release_date, 16 , THEME.prompttext );
    release_dateTxt.SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    release_dateTxt.SetPosition( 40, 85 );
    release_dateTxt.SetMaxWidth( 430 );

    int pagesize = 6;
    Text long_descriptionTxt( long_description, 20, THEME.prompttext );
    long_descriptionTxt.SetAlignment( ALIGN_LEFT, ALIGN_TOP );
    long_descriptionTxt.SetPosition( 46, 117 );
    long_descriptionTxt.SetMaxWidth( 360 );
    long_descriptionTxt.SetLinesToDraw( pagesize );
    long_descriptionTxt.Refresh();

    //convert filesize from u64 to char and put unit of measurement after it
    char temp2[7];
    char filesizeCH[15];
    f32 sizeAdjusted;
    if ( filesize <= 1024.0 )
    {
        sizeAdjusted = filesize;
        snprintf( temp2, sizeof( temp2 ), "%.2f", sizeAdjusted );
        snprintf( filesizeCH, sizeof( filesizeCH ), "%s B", temp2 );

    }
    if ( filesize > 1024.0 )
    {
        sizeAdjusted = filesize / 1024.0;
        snprintf( temp2, sizeof( temp2 ), "%.2f", sizeAdjusted );
        snprintf( filesizeCH, sizeof( filesizeCH ), "%s KB", temp2 );

    }
    if ( filesize > 1048576.0 )
    {
        sizeAdjusted = filesize / 1048576.0;
        snprintf( temp2, sizeof( temp2 ), "%.2f", sizeAdjusted );
        snprintf( filesizeCH, sizeof( filesizeCH ), "%s MB", temp2 );

    }
    GuiText filesizeTxt( filesizeCH, 16, THEME.prompttext );
    filesizeTxt.SetAlignment( ALIGN_RIGHT, ALIGN_TOP );
    filesizeTxt.SetPosition( -40, 12 );

    GuiText btn1Txt( tr( "Load" ), 22, THEME.prompttext );
    GuiImage btn1Img( &btnOutline );
    if ( Settings.wsprompt == yes )
    {
        btn1Txt.SetWidescreen( Settings.widescreen );
        btn1Img.SetWidescreen( Settings.widescreen );
    }

    GuiButton btn1( &btn1Img, &btn1Img, 0, 3, 0, 0, &trigA, &btnSoundOver, btnClick2, 1 );
    btn1.SetLabel( &btn1Txt );
    btn1.SetState( STATE_SELECTED );

    GuiText btn2Txt( tr( "Back" ), 22, THEME.prompttext );
    GuiImage btn2Img( &btnOutline );
    if ( Settings.wsprompt == yes )
    {
        btn2Txt.SetWidescreen( Settings.widescreen );
        btn2Img.SetWidescreen( Settings.widescreen );
    }
    GuiButton btn2( &btn2Img, &btn2Img, 0, 3, 0, 0, &trigA, &btnSoundOver, btnClick2, 1 );
    btn2.SetLabel( &btn2Txt );
    btn2.SetTrigger( &trigB );


    btn1.SetAlignment( ALIGN_LEFT, ALIGN_BOTTOM );
    btn1.SetPosition( 40, 2 );
    btn2.SetAlignment( ALIGN_RIGHT, ALIGN_BOTTOM );
    btn2.SetPosition( -40, 2 );

    GuiTrigger trigZ;
    trigZ.SetButtonOnlyTrigger( -1, WPAD_NUNCHUK_BUTTON_Z | WPAD_CLASSIC_BUTTON_ZL, PAD_TRIGGER_Z );

    GuiButton screenShotBtn( 0, 0 );
    screenShotBtn.SetPosition( 0, 0 );
    screenShotBtn.SetTrigger( &trigZ );
    promptWindow.Append( &screenShotBtn );

    promptWindow.Append( &dialogBoxImg );
    if ( strcmp( long_description, "" ) )promptWindow.Append( &whiteBoxImg );
    if ( strcmp( long_description, "" ) )promptWindow.Append( &scrollbarImg );
    if ( strcmp( long_description, "" ) )promptWindow.Append( &arrowDownBtn );
    if ( strcmp( long_description, "" ) )promptWindow.Append( &arrowUpBtn );

    if ( strcmp( name, "" ) )promptWindow.Append( &nameTxt );
    if ( strcmp( version, "" ) )promptWindow.Append( &versionTxt );
    if ( strcmp( coder, "" ) )promptWindow.Append( &coderTxt );
    if ( strcmp( release_date, "" ) )promptWindow.Append( &release_dateTxt );
    if ( strcmp( long_description, "" ) )promptWindow.Append( &long_descriptionTxt );
    promptWindow.Append( &filesizeTxt );
    if ( iconExist )promptWindow.Append( iconImg );
    promptWindow.Append( &btn1 );
    promptWindow.Append( &btn2 );


    promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_IN, 50 );
    HaltGui();
    mainWindow->SetState( STATE_DISABLED );
    mainWindow->Append( &promptWindow );
    mainWindow->ChangeFocus( &promptWindow );
    ResumeGui();

    while ( choice == -1 )
    {
        VIDEO_WaitVSync();

        if ( shutdown == 1 )
        {
            wiilight( 0 );
            Sys_Shutdown();
        }
        else if ( reset == 1 )
        {
            wiilight( 0 );
            Sys_Reboot();
        }

        if ( btn1.GetState() == STATE_CLICKED )
            choice = 1;
        else if ( btn2.GetState() == STATE_CLICKED )
            choice = 0;

        else if ( screenShotBtn.GetState() == STATE_CLICKED )
        {
            gprintf( "\n\tscreenShotBtn clicked" );
            screenShotBtn.ResetState();
            ScreenShot();
            gprintf( "...It's easy, mmmmmmKay" );
        }
        else if ( arrowUpBtn.GetState() == STATE_CLICKED || arrowUpBtn.GetState() == STATE_HELD )
        {
            long_descriptionTxt.PreviousLine();

            usleep( 6000 );
            if ( !( ( ButtonsHold() & WPAD_BUTTON_UP ) || ( ButtonsHold() & PAD_BUTTON_UP ) ) )
                arrowUpBtn.ResetState();
        }
        else if ( arrowDownBtn.GetState() == STATE_CLICKED || arrowDownBtn.GetState() == STATE_HELD )
        {
            long_descriptionTxt.NextLine();

            usleep( 60000 );
            if ( !( ( ButtonsHold() & WPAD_BUTTON_DOWN ) || ( ButtonsHold() & PAD_BUTTON_DOWN ) ) )
                arrowDownBtn.ResetState();
        }
    }

    promptWindow.SetEffect( EFFECT_SLIDE_TOP | EFFECT_SLIDE_OUT, 50 );
    while ( promptWindow.GetEffect() > 0 ) usleep( 50 );
    HaltGui();
    mainWindow->Remove( &promptWindow );
    mainWindow->SetState( STATE_DEFAULT );
    ResumeGui();
    return choice;
}