snes9xgx/source/ngc/filesel.cpp

683 lines
17 KiB
C++
Raw Normal View History

/****************************************************************************
* Snes9x 1.51 Nintendo Wii/Gamecube Port
2008-08-14 00:44:59 +02:00
*
* softdev July 2006
* svpe June 2007
* crunchy2 May-July 2007
2008-09-23 06:54:53 +02:00
* Michniewski 2008
* Tantric August 2008
*
* filesel.cpp
*
* Generic file routines - reading, writing, browsing
***************************************************************************/
#include <gccore.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <wiiuse/wpad.h>
#include <sys/dir.h>
#include <malloc.h>
#ifdef HW_RVL
2008-08-23 05:20:54 +02:00
extern "C" {
#include <di/di.h>
2008-08-23 05:20:54 +02:00
}
#endif
#include "snes9x.h"
#include "memmap.h"
2008-09-09 19:36:48 +02:00
#include "snes9xGX.h"
#include "dvd.h"
2008-08-07 07:19:17 +02:00
#include "menudraw.h"
#include "video.h"
#include "aram.h"
#include "networkop.h"
2008-08-07 07:33:24 +02:00
#include "fileop.h"
2008-08-12 05:25:16 +02:00
#include "memcardop.h"
#include "input.h"
#include "gcunzip.h"
BROWSERINFO browser;
BROWSERENTRY * browserList = NULL; // list of files/folders in browser
2008-08-16 02:02:08 +02:00
char rootdir[10];
static char szpath[MAXPATHLEN];
static bool inSz = false;
2008-09-27 09:57:03 +02:00
unsigned long SNESROMSize = 0;
2008-09-27 09:13:52 +02:00
/****************************************************************************
* autoLoadMethod()
* Auto-determines and sets the load method
* Returns method set
****************************************************************************/
int autoLoadMethod()
{
2008-12-18 19:36:30 +01:00
ShowAction ("Attempting to determine load method...");
2008-08-12 05:25:16 +02:00
int method = 0;
2008-12-18 19:36:30 +01:00
if(ChangeInterface(METHOD_SD, SILENT))
method = METHOD_SD;
2008-12-18 19:36:30 +01:00
else if(ChangeInterface(METHOD_USB, SILENT))
method = METHOD_USB;
2008-12-18 19:36:30 +01:00
else if(ChangeInterface(METHOD_DVD, SILENT))
method = METHOD_DVD;
2008-12-18 19:36:30 +01:00
else if(ChangeInterface(METHOD_SMB, SILENT))
method = METHOD_SMB;
else
2008-12-18 19:36:30 +01:00
WaitPrompt("Unable to auto-determine load method!");
if(GCSettings.LoadMethod == METHOD_AUTO)
GCSettings.LoadMethod = method; // save method found for later use
return method;
}
/****************************************************************************
* autoSaveMethod()
* Auto-determines and sets the save method
* Returns method set
****************************************************************************/
int autoSaveMethod(bool silent)
{
if(!silent)
ShowAction ("Attempting to determine save method...");
int method = 0;
2008-08-12 05:25:16 +02:00
2008-12-18 19:36:30 +01:00
if(ChangeInterface(METHOD_SD, SILENT))
method = METHOD_SD;
2008-12-18 19:36:30 +01:00
else if(ChangeInterface(METHOD_USB, SILENT))
method = METHOD_USB;
2008-08-08 10:13:13 +02:00
else if(TestCard(CARD_SLOTA, SILENT))
method = METHOD_MC_SLOTA;
2008-08-08 10:13:13 +02:00
else if(TestCard(CARD_SLOTB, SILENT))
method = METHOD_MC_SLOTB;
2008-12-18 19:36:30 +01:00
else if(ChangeInterface(METHOD_SMB, SILENT))
method = METHOD_SMB;
else if(!silent)
2008-12-18 19:36:30 +01:00
WaitPrompt("Unable to auto-determine save method!");
if(GCSettings.SaveMethod == METHOD_AUTO)
GCSettings.SaveMethod = method; // save method found for later use
return method;
}
/****************************************************************************
* ResetBrowser()
* Clears the file browser memory, and allocates one initial entry
***************************************************************************/
void ResetBrowser()
{
browser.selIndex = browser.pageIndex = 0;
// Clear any existing values
if(browserList != NULL)
{
free(browserList);
browserList = NULL;
}
// set aside space for 1 entry
browserList = (BROWSERENTRY *)malloc(sizeof(BROWSERENTRY));
memset(browserList, 0, sizeof(BROWSERENTRY));
}
/****************************************************************************
* UpdateDirName()
* Update curent directory name for file browser
***************************************************************************/
2008-08-16 02:02:08 +02:00
int UpdateDirName(int method)
{
int size=0;
2008-09-27 09:13:52 +02:00
char * test;
char temp[1024];
2008-11-12 08:50:39 +01:00
// update DVD directory
2008-08-16 02:02:08 +02:00
if(method == METHOD_DVD)
SetDVDdirectory(browserList[browser.selIndex].offset, browserList[browser.selIndex].length);
2008-08-16 02:02:08 +02:00
/* current directory doesn't change */
if (strcmp(browserList[browser.selIndex].filename,".") == 0)
{
return 0;
}
/* go up to parent directory */
else if (strcmp(browserList[browser.selIndex].filename,"..") == 0)
{
/* determine last subdirectory namelength */
sprintf(temp,"%s",browser.dir);
test = strtok(temp,"/");
while (test != NULL)
{
size = strlen(test);
test = strtok(NULL,"/");
}
/* remove last subdirectory name */
size = strlen(browser.dir) - size - 1;
browser.dir[size] = 0;
return 1;
}
/* Open a directory */
else
{
/* test new directory namelength */
if ((strlen(browser.dir)+1+strlen(browserList[browser.selIndex].filename)) < MAXPATHLEN)
{
/* update current directory name */
sprintf(browser.dir, "%s/%s",browser.dir, browserList[browser.selIndex].filename);
return 1;
}
else
{
2008-12-18 19:36:30 +01:00
WaitPrompt("Directory name is too long!");
return -1;
}
}
}
2008-11-12 08:50:39 +01:00
bool MakeFilePath(char filepath[], int type, int method)
2008-10-14 11:21:34 +02:00
{
2008-11-12 08:50:39 +01:00
char file[512];
char folder[1024];
2008-10-14 11:21:34 +02:00
char temppath[MAXPATHLEN];
2008-11-12 08:50:39 +01:00
if(type == FILE_ROM)
2008-10-14 11:21:34 +02:00
{
2008-11-12 08:50:39 +01:00
// Check path length
if ((strlen(browser.dir)+1+strlen(browserList[browser.selIndex].filename)) >= MAXPATHLEN)
2008-11-12 08:50:39 +01:00
{
2008-12-18 19:36:30 +01:00
WaitPrompt("Maximum filepath length reached!");
2008-11-12 08:50:39 +01:00
filepath[0] = 0;
return false;
}
2008-10-14 11:21:34 +02:00
else
2008-11-12 08:50:39 +01:00
{
sprintf(temppath, "%s/%s",browser.dir,browserList[browser.selIndex].filename);
2008-11-12 08:50:39 +01:00
}
2008-10-14 11:21:34 +02:00
}
else
{
2008-11-12 08:50:39 +01:00
switch(type)
{
case FILE_SRAM:
sprintf(folder, GCSettings.SaveFolder);
sprintf(file, "%s.srm", Memory.ROMFilename);
break;
case FILE_SNAPSHOT:
sprintf(folder, GCSettings.SaveFolder);
sprintf(file, "%s.frz", Memory.ROMFilename);
break;
case FILE_CHEAT:
sprintf(folder, GCSettings.CheatFolder);
sprintf(file, "%s.cht", Memory.ROMFilename);
break;
case FILE_PREF:
sprintf(folder, appPath);
2008-11-12 08:50:39 +01:00
sprintf(file, "%s", PREF_FILE_NAME);
break;
}
switch(method)
{
case METHOD_MC_SLOTA:
case METHOD_MC_SLOTB:
sprintf (temppath, "%s", file);
temppath[31] = 0; // truncate filename
break;
2008-12-18 19:36:30 +01:00
default:
sprintf (temppath, "%s/%s", folder, file);
break;
2008-11-12 08:50:39 +01:00
}
}
strcpy(filepath, temppath);
return true;
}
/****************************************************************************
* FileSortCallback
*
* Quick sort callback to sort file entries with the following order:
* .
* ..
* <dirs>
* <files>
***************************************************************************/
int FileSortCallback(const void *f1, const void *f2)
{
/* Special case for implicit directories */
if(((BROWSERENTRY *)f1)->filename[0] == '.' || ((BROWSERENTRY *)f2)->filename[0] == '.')
{
if(strcmp(((BROWSERENTRY *)f1)->filename, ".") == 0) { return -1; }
if(strcmp(((BROWSERENTRY *)f2)->filename, ".") == 0) { return 1; }
if(strcmp(((BROWSERENTRY *)f1)->filename, "..") == 0) { return -1; }
if(strcmp(((BROWSERENTRY *)f2)->filename, "..") == 0) { return 1; }
}
/* If one is a file and one is a directory the directory is first. */
if(((BROWSERENTRY *)f1)->isdir && !(((BROWSERENTRY *)f2)->isdir)) return -1;
if(!(((BROWSERENTRY *)f1)->isdir) && ((BROWSERENTRY *)f2)->isdir) return 1;
return stricmp(((BROWSERENTRY *)f1)->filename, ((BROWSERENTRY *)f2)->filename);
}
/****************************************************************************
* IsValidROM
*
* Checks if the specified file is a valid ROM
* For now we will just check the file extension and file size
* If the file is a zip, we will check the file extension / file size of the
* first file inside
***************************************************************************/
bool IsValidROM(int method)
{
// file size should be between 96K and 8MB
if(browserList[browser.selIndex].length < (1024*96) ||
browserList[browser.selIndex].length > (1024*1024*8))
{
2008-12-18 19:36:30 +01:00
WaitPrompt("Invalid file size!");
return false;
}
if (strlen(browserList[browser.selIndex].filename) > 4)
{
char * p = strrchr(browserList[browser.selIndex].filename, '.');
if (p != NULL)
{
2008-10-14 11:21:34 +02:00
if(stricmp(p, ".zip") == 0 && !inSz)
{
// we need to check the file extension of the first file in the archive
char * zippedFilename = GetFirstZipFilename (method);
2008-10-14 11:21:34 +02:00
if(zippedFilename == NULL) // we don't want to run strlen on NULL
p = NULL;
else if(strlen(zippedFilename) > 4)
p = strrchr(zippedFilename, '.');
else
p = NULL;
}
if(p != NULL)
{
if (stricmp(p, ".smc") == 0 ||
stricmp(p, ".fig") == 0 ||
2008-10-19 20:07:38 +02:00
stricmp(p, ".sfc") == 0 ||
stricmp(p, ".swc") == 0)
{
return true;
}
}
}
}
2008-12-18 19:36:30 +01:00
WaitPrompt("Unknown file type!");
return false;
}
2008-10-14 11:21:34 +02:00
/****************************************************************************
* IsSz
*
* Checks if the specified file is a 7z
***************************************************************************/
bool IsSz()
{
if (strlen(browserList[browser.selIndex].filename) > 4)
2008-10-14 11:21:34 +02:00
{
char * p = strrchr(browserList[browser.selIndex].filename, '.');
2008-10-14 11:21:34 +02:00
if (p != NULL)
if(stricmp(p, ".7z") == 0)
return true;
}
return false;
}
/****************************************************************************
* StripExt
*
* Strips an extension from a filename
***************************************************************************/
void StripExt(char* returnstring, char * inputstring)
{
char* loc_dot;
2008-08-07 07:19:17 +02:00
strcpy (returnstring, inputstring);
loc_dot = strrchr(returnstring,'.');
if (loc_dot != NULL)
2008-09-27 10:36:22 +02:00
*loc_dot = 0; // strip file extension
}
/****************************************************************************
* FileSelector
*
* Let user select a file from the listing
***************************************************************************/
int FileSelector (int method)
{
u32 p = 0;
u32 wp = 0;
u32 ph = 0;
u32 wh = 0;
signed char gc_ay = 0;
signed char gc_sx = 0;
signed char wm_ay = 0;
signed char wm_sx = 0;
2008-08-20 09:58:55 +02:00
int haverom = 0;
int redraw = 1;
int selectit = 0;
2008-08-20 09:58:55 +02:00
int scroll_delay = 0;
bool move_selection = 0;
#define SCROLL_INITIAL_DELAY 15
#define SCROLL_LOOP_DELAY 2
while (haverom == 0)
{
if (redraw)
ShowFiles (browserList, browser.numEntries, browser.pageIndex, browser.selIndex);
redraw = 0;
VIDEO_WaitVSync(); // slow things down a bit so we don't overread the pads
gc_ay = PAD_StickY (0);
gc_sx = PAD_SubStickX (0);
2008-08-20 09:58:55 +02:00
p = PAD_ButtonsDown (0);
ph = PAD_ButtonsHeld (0);
#ifdef HW_RVL
2008-10-03 23:52:57 +02:00
wm_ay = WPAD_Stick (0, 0, 1);
wm_sx = WPAD_Stick (0, 1, 0);
wp = WPAD_ButtonsDown (0);
wh = WPAD_ButtonsHeld (0);
#endif
/*** Check for exit combo ***/
if ( (gc_sx < -70) || (wm_sx < -70) || (wp & WPAD_BUTTON_HOME) || (wp & WPAD_CLASSIC_BUTTON_HOME) )
return 0;
/*** Check buttons, perform actions ***/
2008-08-12 05:25:16 +02:00
if ( (p & PAD_BUTTON_A) || selectit || (wp & (WPAD_BUTTON_A | WPAD_CLASSIC_BUTTON_A)) )
{
if ( selectit )
selectit = 0;
if (browserList[browser.selIndex].isdir) // This is directory
2008-08-12 05:25:16 +02:00
{
/* update current directory and set new entry list if directory has changed */
2008-10-14 11:21:34 +02:00
int status;
if(inSz && browser.selIndex == 0) // inside a 7z, requesting to leave
2008-10-14 11:21:34 +02:00
{
if(method == METHOD_DVD)
SetDVDdirectory(browserList[0].offset, browserList[0].length);
2008-10-14 11:21:34 +02:00
inSz = false;
status = 1;
SzClose();
}
else
{
status = UpdateDirName(method);
}
2008-08-12 05:25:16 +02:00
if (status == 1) // ok, open directory
{
switch (method)
{
case METHOD_DVD:
browser.numEntries = ParseDVDdirectory();
2008-12-18 19:36:30 +01:00
break;
2008-08-12 05:25:16 +02:00
2008-12-18 19:36:30 +01:00
default:
browser.numEntries = ParseDirectory();
2008-12-18 19:36:30 +01:00
break;
2008-08-12 05:25:16 +02:00
}
if (!browser.numEntries)
2008-08-12 05:25:16 +02:00
{
2008-12-18 19:36:30 +01:00
WaitPrompt ("Error reading directory!");
2008-10-14 11:21:34 +02:00
haverom = 1; // quit menu
2008-08-12 05:25:16 +02:00
}
}
else if (status == -1) // directory name too long
{
return 0; // quit menu
2008-08-12 05:25:16 +02:00
}
}
else // this is a file
{
2008-10-14 11:21:34 +02:00
// 7z file - let's open it up to select a file inside
if(IsSz())
2008-08-12 05:25:16 +02:00
{
2008-10-14 11:21:34 +02:00
// we'll store the 7z filepath for extraction later
2008-11-12 08:50:39 +01:00
if(!MakeFilePath(szpath, FILE_ROM, method))
2008-10-28 07:52:38 +01:00
return 0;
2008-11-12 08:50:39 +01:00
2008-12-18 19:36:30 +01:00
// add device to filepath
char fullpath[1024];
sprintf(fullpath, "%s%s", rootdir, szpath);
strcpy(szpath, fullpath);
2008-10-15 01:35:19 +02:00
int szfiles = SzParse(szpath, method);
if(szfiles)
{
browser.numEntries = szfiles;
2008-10-14 11:21:34 +02:00
inSz = true;
2008-10-15 01:35:19 +02:00
}
2008-10-15 08:35:14 +02:00
else
2008-12-18 19:36:30 +01:00
WaitPrompt("Error opening archive!");
2008-08-12 05:25:16 +02:00
}
else
{
2008-10-14 11:21:34 +02:00
// check that this is a valid ROM
if(!IsValidROM(method))
return 0;
// store the filename (w/o ext) - used for sram/freeze naming
StripExt(Memory.ROMFilename, browserList[browser.selIndex].filename);
2008-10-14 11:21:34 +02:00
2008-12-18 19:36:30 +01:00
ShowAction ("Loading...");
2008-10-14 11:21:34 +02:00
SNESROMSize = 0;
2008-11-12 08:50:39 +01:00
if(!inSz)
2008-10-14 11:21:34 +02:00
{
2008-11-12 08:50:39 +01:00
char filepath[1024];
2008-10-14 11:21:34 +02:00
2008-11-12 08:50:39 +01:00
if(!MakeFilePath(filepath, FILE_ROM, method))
return 0;
2008-10-14 11:21:34 +02:00
SNESROMSize = LoadFile ((char *)Memory.ROM, filepath, browserList[browser.selIndex].length, method, NOTSILENT);
2008-11-12 08:50:39 +01:00
}
else
{
switch (method)
{
case METHOD_DVD:
SNESROMSize = SzExtractFile(browserList[browser.selIndex].offset, (unsigned char *)Memory.ROM);
2008-11-12 08:50:39 +01:00
break;
2008-12-18 19:36:30 +01:00
default:
SNESROMSize = LoadSzFile(szpath, (unsigned char *)Memory.ROM);
2008-11-12 08:50:39 +01:00
break;
}
2008-10-14 11:21:34 +02:00
}
inSz = false;
if (SNESROMSize > 0)
return 1;
else
2008-12-18 19:36:30 +01:00
WaitPrompt("Error loading ROM!");
2008-08-12 05:25:16 +02:00
}
}
redraw = 1;
} // End of A
if ((p & PAD_BUTTON_B)
|| (wp & (WPAD_BUTTON_B | WPAD_CLASSIC_BUTTON_B)))
{
while ((PAD_ButtonsDown(0) & PAD_BUTTON_B)
#ifdef HW_RVL
|| (WPAD_ButtonsDown(0) & (WPAD_BUTTON_B | WPAD_CLASSIC_BUTTON_B))
#endif
)
VIDEO_WaitVSync();
if (strcmp(browserList[0].filename, "..") == 0)
{
browser.selIndex = 0;
selectit = 1;
}
else if (strcmp(browserList[1].filename, "..") == 0)
{
browser.selIndex = selectit = 1;
}
else
{
return 0;
}
} // End of B
if (((p | ph) & PAD_BUTTON_DOWN) || ((wp | wh) & (WPAD_BUTTON_DOWN
| WPAD_CLASSIC_BUTTON_DOWN)) || (gc_ay < -PADCAL) || (wm_ay
< -PADCAL))
{
if ((p & PAD_BUTTON_DOWN) || (wp & (WPAD_BUTTON_DOWN
| WPAD_CLASSIC_BUTTON_DOWN)))
{ /*** Button just pressed ***/
scroll_delay = SCROLL_INITIAL_DELAY; // reset scroll delay.
move_selection = 1; //continue (move selection)
}
else if (scroll_delay == 0)
{ /*** Button is held ***/
scroll_delay = SCROLL_LOOP_DELAY;
move_selection = 1; //continue (move selection)
}
else
{
scroll_delay--; // wait
}
if (move_selection)
{
browser.selIndex++;
if (browser.selIndex == browser.numEntries)
browser.selIndex = browser.pageIndex = 0;
if ((browser.selIndex - browser.pageIndex) >= PAGESIZE)
browser.pageIndex += PAGESIZE;
redraw = 1;
move_selection = 0;
}
} // End of down
if (((p | ph) & PAD_BUTTON_UP) || ((wp | wh) & (WPAD_BUTTON_UP
| WPAD_CLASSIC_BUTTON_UP)) || (gc_ay > PADCAL) || (wm_ay
> PADCAL))
{
if ((p & PAD_BUTTON_UP) || (wp & (WPAD_BUTTON_UP
| WPAD_CLASSIC_BUTTON_UP)))
{ /*** Button just pressed***/
scroll_delay = SCROLL_INITIAL_DELAY; // reset scroll delay.
move_selection = 1; //continue (move selection)
}
else if (scroll_delay == 0)
{ /*** Button is held ***/
scroll_delay = SCROLL_LOOP_DELAY;
move_selection = 1; //continue (move selection)
}
else
{
scroll_delay--; // wait
}
if (move_selection)
{
browser.selIndex--;
if (browser.selIndex < 0)
{
browser.selIndex = browser.numEntries - 1;
browser.pageIndex = browser.selIndex - PAGESIZE + 1;
}
if (browser.selIndex < browser.pageIndex)
browser.pageIndex -= PAGESIZE;
if (browser.pageIndex < 0)
browser.pageIndex = 0;
redraw = 1;
move_selection = 0;
}
} // End of Up
if ((p & PAD_BUTTON_LEFT) || (wp & (WPAD_BUTTON_LEFT
| WPAD_CLASSIC_BUTTON_LEFT)))
{
/*** Go back a page ***/
browser.selIndex -= PAGESIZE;
if (browser.selIndex < 0)
{
browser.selIndex = browser.numEntries - 1;
browser.pageIndex = browser.selIndex - PAGESIZE + 1;
}
if (browser.selIndex < browser.pageIndex)
browser.pageIndex -= PAGESIZE;
if (browser.pageIndex < 0)
browser.pageIndex = 0;
redraw = 1;
}
if ((p & PAD_BUTTON_RIGHT) || (wp & (WPAD_BUTTON_RIGHT
| WPAD_CLASSIC_BUTTON_RIGHT)))
{
/*** Go forward a page ***/
browser.selIndex += PAGESIZE;
if (browser.selIndex > browser.numEntries - 1)
browser.selIndex = browser.pageIndex = 0;
if ((browser.selIndex - browser.pageIndex) >= PAGESIZE)
browser.pageIndex += PAGESIZE;
redraw = 1;
}
}
return 0;
}
/****************************************************************************
2008-12-18 19:36:30 +01:00
* OpenROM
* Opens device specified by method, displays a list of ROMS
***************************************************************************/
int
2008-12-18 19:36:30 +01:00
OpenROM (int method)
{
2008-12-18 19:36:30 +01:00
if(method == METHOD_AUTO)
method = autoLoadMethod();
2008-12-18 19:36:30 +01:00
if(ChangeInterface(method, NOTSILENT))
{
// change current dir to roms directory
switch(method)
{
2008-12-18 19:36:30 +01:00
case METHOD_DVD:
browser.dir[0] = 0;
browser.numEntries = ParseDVDdirectory(); // Parse root directory
2008-12-18 19:36:30 +01:00
SwitchDVDFolder(GCSettings.LoadFolder); // switch to ROM folder
break;
default:
sprintf(browser.dir, "/%s", GCSettings.LoadFolder);
browser.numEntries = ParseDirectory(); // Parse root directory
2008-12-18 19:36:30 +01:00
break;
}
if (browser.numEntries > 0)
{
// Select an entry
return FileSelector (method);
}
else
{
// no entries found
2008-12-18 19:36:30 +01:00
WaitPrompt ("No Files Found!");
return 0;
}
}
return 0;
}