/**

* Test program for PhysicsFS, using wxWidgets. May only work on Unix.

*

* Please see the file LICENSE.txt in the source's root directory.

*

* This file written by Ryan C. Gordon.

*/

#if ( (defined(__MACH__)) && (defined(__APPLE__)) )

#define PLATFORM_MACOSX 1

#include <Carbon/Carbon.h>

#endif

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <errno.h>

#include <wx/wx.h>

#include <wx/treectrl.h>

#include "physfs.h"

#define TEST_VER_MAJOR 2

#define TEST_VER_MINOR 0

#define TEST_VER_PATCH 0

//static PHYSFS_uint32 do_buffer_size = 0;

enum WxTestPhysfsMenuCommands

{

// start with standard menu items, since using the wxIDs will map them

// to sane things in the platform's UI (gnome icons in GTK+, moves the

// about and quit items to the Apple menu on Mac OS X, etc).

MENUCMD_About = wxID_ABOUT,

MENUCMD_Quit = wxID_EXIT,

// non-standard menu items go here.

MENUCMD_Init = wxID_HIGHEST,

MENUCMD_Deinit,

MENUCMD_AddArchive,

MENUCMD_Mount,

MENUCMD_Remove,

MENUCMD_GetCDs,

MENUCMD_SetWriteDir,

MENUCMD_PermitSymLinks,

MENUCMD_SetSaneConfig,

MENUCMD_MkDir,

MENUCMD_Delete,

MENUCMD_Cat,

MENUCMD_SetBuffer,

MENUCMD_StressBuffer,

MENUCMD_Append,

MENUCMD_Write,

MENUCMD_GetLastError,

/*

{ "getdirsep", cmd_getdirsep, 0, NULL },

{ "getsearchpath", cmd_getsearchpath, 0, NULL },

{ "getbasedir", cmd_getbasedir, 0, NULL },

{ "getuserdir", cmd_getuserdir, 0, NULL },

{ "getwritedir", cmd_getwritedir, 0, NULL },

{ "getrealdir", cmd_getrealdir, 1, "<fileToFind>" },

{ "exists", cmd_exists, 1, "<fileToCheck>" },

{ "isdir", cmd_isdir, 1, "<fileToCheck>" },

{ "issymlink", cmd_issymlink, 1, "<fileToCheck>" },

{ "filelength", cmd_filelength, 1, "<fileToCheck>" },

{ "getlastmodtime", cmd_getlastmodtime, 1, "<fileToExamine>" },

*/

};

class WxTestPhysfsFrame : public wxFrame

{

public:

WxTestPhysfsFrame(const wxChar *argv0);

void rebuildTree();

void onMenuInit(wxCommandEvent &evt);

void onMenuDeinit(wxCommandEvent &evt);

void onMenuAddArchive(wxCommandEvent &evt);

void onMenuGetCDs(wxCommandEvent &evt);

void onMenuPermitSymLinks(wxCommandEvent &evt);

private:

wxTreeCtrl *fileTree;

wxTreeItemId stateItem;

wxTreeItemId fsItem;

int err(int success);

void fillFileSystemTree(const char *path, const wxTreeItemId &item);

void doInit(const char *argv0);

void doDeinit();

DECLARE_EVENT_TABLE()

};

BEGIN_EVENT_TABLE(WxTestPhysfsFrame, wxFrame)

EVT_MENU(MENUCMD_Init, WxTestPhysfsFrame::onMenuInit)

EVT_MENU(MENUCMD_Deinit, WxTestPhysfsFrame::onMenuDeinit)

EVT_MENU(MENUCMD_AddArchive, WxTestPhysfsFrame::onMenuAddArchive)

EVT_MENU(MENUCMD_GetCDs, WxTestPhysfsFrame::onMenuGetCDs)

EVT_MENU(MENUCMD_PermitSymLinks, WxTestPhysfsFrame::onMenuPermitSymLinks)

END_EVENT_TABLE()

// This is the the Application itself.

class WxTestPhysfsApp : public wxApp

{

public:

WxTestPhysfsApp() : mainWindow(NULL) { /* no-op. */ }

virtual bool OnInit();

private:

WxTestPhysfsFrame *mainWindow;

};

DECLARE_APP(WxTestPhysfsApp)

static inline char *newstr(const char *str)

{

char *retval = NULL;

if (str != NULL)

{

retval = new char[strlen(str) + 1];

strcpy(retval, str);

} // if

return retval;

} // newstr

static char *newutf8(const wxString &wxstr)

{

#if wxUSE_UNICODE

size_t len = wxstr.Len() + 1;

char *utf8text = new char[len * 6];

wxConvUTF8.WC2MB(utf8text, wxstr, len);

return utf8text;

#else

return newstr(wxstr);

#endif

} // newutf8

WxTestPhysfsFrame::WxTestPhysfsFrame(const wxChar *argv0)

: wxFrame(NULL, -1, wxT("WxTestPhysfs"))

{

this->CreateStatusBar();

wxMenuBar *menuBar = new wxMenuBar;

wxMenu *stuffMenu = new wxMenu;

stuffMenu->Append(MENUCMD_Init, wxT("&Init"));

stuffMenu->Append(MENUCMD_Deinit, wxT("&Deinit"));

stuffMenu->Append(MENUCMD_AddArchive, wxT("&Add Archive"));

stuffMenu->Append(MENUCMD_Mount, wxT("&Mount Archive"));

stuffMenu->Append(MENUCMD_Remove, wxT("&Remove Archive"));

stuffMenu->Append(MENUCMD_GetCDs, wxT("&Get CD-ROM drives"));

stuffMenu->Append(MENUCMD_SetWriteDir, wxT("&Set Write Dir"));

stuffMenu->Append(MENUCMD_SetSaneConfig, wxT("Set Sane &Config"));

stuffMenu->Append(MENUCMD_MkDir, wxT("M&kDir"));

stuffMenu->Append(MENUCMD_Delete, wxT("D&elete"));

stuffMenu->Append(MENUCMD_Cat, wxT("&Cat"));

stuffMenu->Append(MENUCMD_SetBuffer, wxT("Set &Buffer"));

stuffMenu->Append(MENUCMD_StressBuffer, wxT("Stress &Test Buffer"));

stuffMenu->Append(MENUCMD_Append, wxT("&Append"));

stuffMenu->Append(MENUCMD_Write, wxT("&Write"));

stuffMenu->Append(MENUCMD_Write, wxT("&Update getLastError"));

stuffMenu->AppendCheckItem(MENUCMD_PermitSymLinks, wxT("&Permit symlinks"));

menuBar->Append(stuffMenu, wxT("&Stuff"));

//wxMenu *helpMenu = new wxMenu;

//helpMenu->Append(MENUCMD_About, wxT("&About\tF1"));

//menuBar->Append(helpMenu, wxT("&Help"));

this->SetMenuBar(menuBar);

this->fileTree = new wxTreeCtrl(this, -1);

// The sizer just makes sure that fileTree owns whole client area.

wxBoxSizer *sizer = new wxBoxSizer(wxVERTICAL);

sizer->Add(this->fileTree, 1, wxALL | wxEXPAND | wxALIGN_CENTRE);

sizer->SetItemMinSize(this->fileTree, 1, 1);

this->SetSizer(sizer);

char *utf8argv0 = newutf8(wxString(argv0));

this->doInit(utf8argv0);

delete[] utf8argv0;

} // WxTestPhysfsFrame::WxTestPhysfsFrame

int WxTestPhysfsFrame::err(int success)

{

if (success)

this->SetStatusText(wxT(""));

else

this->SetStatusText(wxString(PHYSFS_getLastError(), wxConvUTF8));

return success;

} // WxTestPhysfsFrame::err

void WxTestPhysfsFrame::fillFileSystemTree(const char *path,

const wxTreeItemId &item)

{

char **rc = PHYSFS_enumerateFiles(path);

char **i;

wxTreeItemId id;

if (rc == NULL)

{

const wxString quote(wxT("'"));

wxString str(wxT("Enumeration error: "));

str << quote << wxString(PHYSFS_getLastError(), wxConvUTF8) << quote;

id = this->fileTree->AppendItem(item, str);

this->fileTree->SetItemTextColour(id, wxColour(255, 0, 0));

} // if

else

{

for (i = rc; *i != NULL; i++)

{

id = this->fileTree->AppendItem(item, wxString(*i, wxConvUTF8));

const int len = strlen(path) + strlen(*i) + 2;

char *fname = new char[len];

const char *origdir = path;

if (strcmp(origdir, "/") == 0)

origdir = "";

snprintf(fname, len, "%s/%s", origdir, *i);

if (PHYSFS_isDirectory(fname))

{

this->fileTree->SetItemTextColour(id, wxColour(0, 0, 255));

this->fillFileSystemTree(fname, id);

} // if

else if (PHYSFS_isSymbolicLink(fname))

{

this->fileTree->SetItemTextColour(id, wxColour(0, 255, 0));

} // else if

else // ...file.

{

} // else

delete[] fname;

} // for

PHYSFS_freeList(rc);

} // else

} // fillFileSystemTree

void WxTestPhysfsFrame::rebuildTree()

{

const wxString dot(wxT("."));

const wxString quote(wxT("'"));

wxTreeItemId item;

wxString str;

const char *cstr = NULL;

const bool wasInit = PHYSFS_isInit() ? true : false;

this->fileTree->DeleteAllItems();

wxTreeItemId root = this->fileTree->AddRoot(wxT("PhysicsFS"));

this->stateItem = this->fileTree->AppendItem(root, wxT("Library state"));

str = wxT("Initialized: ");

str << ((wasInit) ? wxT("true") : wxT("false"));

this->fileTree->AppendItem(this->stateItem, str);

this->fileTree->Expand(this->stateItem);

this->fileTree->Expand(root);

// Fill in version information...

PHYSFS_Version ver;

item = this->stateItem;

str = wxT("wxtest_physfs version: ");

str << TEST_VER_MAJOR << dot << TEST_VER_MINOR << dot << TEST_VER_PATCH;

this->fileTree->AppendItem(item, str);

PHYSFS_VERSION(&ver);

str = wxT("Compiled against PhysicsFS version: ");

str << (int) ver.major << dot << (int) ver.minor << dot << ver.patch;

this->fileTree->AppendItem(item, str);

PHYSFS_getLinkedVersion(&ver);

str = wxT("Linked against PhysicsFS version: ");

str << (int) ver.major << dot << (int) ver.minor << dot << ver.patch;

this->fileTree->AppendItem(item, str);

if (!wasInit)

return; // nothing else to do before initialization...

str = wxT("Symbolic links permitted: ");

str << ((PHYSFS_symbolicLinksPermitted()) ? wxT("true") : wxT("false"));

this->fileTree->AppendItem(this->stateItem, str);

str = wxT("Native directory separator: ");

str << quote << wxString(PHYSFS_getDirSeparator(), wxConvUTF8) << quote;

this->fileTree->AppendItem(this->stateItem, str);

// Fill in supported archives...

item = this->fileTree->AppendItem(this->stateItem, wxT("Archivers"));

const PHYSFS_ArchiveInfo **arcs = PHYSFS_supportedArchiveTypes();

if (*arcs == NULL)

this->fileTree->AppendItem(item, wxT("(none)"));

else

{

const PHYSFS_ArchiveInfo **i;

for (i = arcs; *i != NULL; i++)

{

const wxString ext((*i)->extension, wxConvUTF8);

const wxString desc((*i)->description, wxConvUTF8);

const wxString auth((*i)->author, wxConvUTF8);

const wxString url((*i)->url, wxConvUTF8);

wxTreeItemId arcitem = this->fileTree->AppendItem(item, ext);

this->fileTree->AppendItem(arcitem, desc);

this->fileTree->AppendItem(arcitem, auth);

this->fileTree->AppendItem(arcitem, url);

} // for

} // else

// Fill in the standard paths...

item = this->fileTree->AppendItem(this->stateItem, wxT("Paths"));

str = wxT("Base directory: ");

str << quote << wxString(PHYSFS_getBaseDir(), wxConvUTF8) << quote;

this->fileTree->AppendItem(item, str);

str = wxT("User directory: ");

str << quote << wxString(PHYSFS_getUserDir(), wxConvUTF8) << quote;

this->fileTree->AppendItem(item, str);

str = wxT("Write directory: ");

if ((cstr = PHYSFS_getWriteDir()) == NULL)

str << wxT("(NULL)");

else

str << quote << wxString(cstr ? cstr : "(NULL)", wxConvUTF8) << quote;

this->fileTree->AppendItem(item, str);

//str = wxT("Preference directory: ");

//str << wxString(PHYSFS_getUserDir(), wxConvUTF8);

//this->fileTree->AppendItem(item, str);

// Fill in the CD-ROMs...

item = this->fileTree->AppendItem(this->stateItem, wxT("CD-ROMs"));

char **cds = PHYSFS_getCdRomDirs();

if (cds == NULL)

{

str = wxT("Error: ");

str << quote << wxString(PHYSFS_getLastError(), wxConvUTF8) << quote;

wxTreeItemId id = this->fileTree->AppendItem(item, str);

this->fileTree->SetItemTextColour(id, wxColour(255, 0, 0));

} // if

else

{

if (*cds == NULL)

this->fileTree->AppendItem(item, wxT("(none)"));

else

{

char **i;

for (i = cds; *i != NULL; i++)

this->fileTree->AppendItem(item, wxString(*i, wxConvUTF8));

} // else

PHYSFS_freeList(cds);

} // else

// Fill in search path...

item = this->fileTree->AppendItem(this->stateItem, wxT("Search path"));

char **sp = PHYSFS_getSearchPath();

if (sp == NULL)

{

str = wxT("Error: ");

str << quote << wxString(PHYSFS_getLastError(), wxConvUTF8) << quote;

wxTreeItemId id = this->fileTree->AppendItem(item, str);

this->fileTree->SetItemTextColour(id, wxColour(255, 0, 0));

} // if

else

{

if (*sp == NULL)

this->fileTree->AppendItem(item, wxT("(none)"));

else

{

char **i;

for (i = sp; *i != NULL; i++)

this->fileTree->AppendItem(item, wxString(*i, wxConvUTF8));

} // else

PHYSFS_freeList(sp);

} // else

// Now fill in the filesystem...

this->fsItem = this->fileTree->AppendItem(root, wxT("Filesystem"));

this->fillFileSystemTree("/", this->fsItem);

this->fileTree->Expand(this->fsItem);

} // WxTestPhysfsFrame::rebuildTree

void WxTestPhysfsFrame::doInit(const char *argv0)

{

if (!this->err(PHYSFS_init(argv0)))

::wxMessageBox(wxT("PHYSFS_init() failed!"), wxT("wxTestPhysfs"));

this->rebuildTree();

} // WxTestPhysfsFrame::doInit

void WxTestPhysfsFrame::doDeinit()

{

if (!this->err(PHYSFS_deinit()))

::wxMessageBox(wxT("PHYSFS_deinit() failed!"), wxT("wxTestPhysfs"));

this->rebuildTree();

} // WxTestPhysfsFrame::doDeinit

void WxTestPhysfsFrame::onMenuInit(wxCommandEvent &evt)

{

wxString argv0(wxGetApp().argv[0] == NULL ? wxT("") : wxGetApp().argv[0]);

wxString str(wxGetTextFromUser(wxT("PHYSFS_init"),

wxT("argv[0]? (cancel for NULL)"), argv0));

char *cstr = str.IsEmpty() ? NULL : newutf8(str);

this->doInit(cstr);

delete[] cstr;

} // WxTestPhysfsFrame::onMenuInit

void WxTestPhysfsFrame::onMenuDeinit(wxCommandEvent &evt)

{

this->doDeinit();

} // WxTestPhysfsFrame::onMenuDeinit

void WxTestPhysfsFrame::onMenuAddArchive(wxCommandEvent &evt)

{

wxString arc = wxFileSelector(wxT("Choose archive to add"));

if (!arc.IsEmpty())

{

char *cstr = newutf8(arc);

// !!! FIXME: add to start/end?

if (!this->err(PHYSFS_addToSearchPath(cstr, 1)))

::wxMessageBox(wxT("PHYSFS_addToSearchPath() failed!"), wxT("wxTestPhysfs"));

delete[] cstr;

this->rebuildTree();

} // if

} // WxTestPhysfsFrame::onMenuAddArchive

void WxTestPhysfsFrame::onMenuGetCDs(wxCommandEvent &evt)

{

this->rebuildTree(); // This will call PHYSFS_getCdRomDirs()...

} // WxTestPhysfsFrame::onMenuGetCDs

void WxTestPhysfsFrame::onMenuPermitSymLinks(wxCommandEvent &evt)

{

PHYSFS_permitSymbolicLinks(evt.IsChecked() ? 1 : 0);

this->rebuildTree();

} // WxTestPhysfsFrame::onMenuPermitSymLinks

IMPLEMENT_APP(WxTestPhysfsApp)

bool WxTestPhysfsApp::OnInit()

{

#if PLATFORM_MACOSX

// This lets a stdio app become a GUI app. Otherwise, you won't get

// GUI events from the system and other things will fail to work.

// Putting the app in an application bundle does the same thing.

// TransformProcessType() is a 10.3+ API. SetFrontProcess() is 10.0+.

if (TransformProcessType != NULL) // check it as a weak symbol.

{

ProcessSerialNumber psn = { 0, kCurrentProcess };

TransformProcessType(&psn, kProcessTransformToForegroundApplication);

SetFrontProcess(&psn);

} // if

#endif

this->mainWindow = new WxTestPhysfsFrame(this->argv[0]);

this->mainWindow->Show(true);

SetTopWindow(this->mainWindow);

return true;

} // WxTestPhysfsApp::OnInit

// end of wxtest_physfs.cpp ...