bool Shell::Initialise(const Rocket::Core::String& path)
{
gettimeofday(&start_time, NULL);
InputMacOSX::Initialise();
// Find the location of the executable.
CFBundleRef bundle = CFBundleGetMainBundle();
CFURLRef executable_url = CFBundleCopyExecutableURL(bundle);
CFStringRef executable_posix_file_name = CFURLCopyFileSystemPath(executable_url, kCFURLPOSIXPathStyle);
CFIndex max_length = CFStringGetMaximumSizeOfFileSystemRepresentation(executable_posix_file_name);
char* executable_file_name = new char[max_length];
if (!CFStringGetFileSystemRepresentation(executable_posix_file_name, executable_file_name, max_length))
executable_file_name[0] = 0;
executable_path = Rocket::Core::String(executable_file_name);
executable_path = executable_path.Substring(0, executable_path.RFind("/") + 1);
delete[] executable_file_name;
CFRelease(executable_posix_file_name);
CFRelease(executable_url);
file_interface = new ShellFileInterface(executable_path + "../../../" + path);
Rocket::Core::SetFileInterface(file_interface);
return true;
}
static inline const char *
_bs_main_bundle_bs_path(void)
{
static bool done = false;
static char *path = NULL;
/* XXX not thread-safe */
if (!done) {
CFBundleRef bundle;
done = true;
bundle = CFBundleGetMainBundle();
if (bundle != NULL) {
CFURLRef url;
url = CFBundleCopyResourceURL(bundle, CFSTR("BridgeSupport"),
NULL, NULL);
if (url != NULL) {
CFStringRef str = CFURLCopyPath(url);
path = (char *)malloc(sizeof(char) * PATH_MAX);
ASSERT_ALLOC(path);
CFStringGetFileSystemRepresentation(str, path, PATH_MAX);
CFRelease(str);
CFRelease(url);
}
}
}
return path;
}
std::string GetBundleDirectory()
{
CFURLRef BundleRef;
char AppBundlePath[MAXPATHLEN];
// Get the main bundle for the app
BundleRef = CFBundleCopyBundleURL(CFBundleGetMainBundle());
CFStringRef BundlePath = CFURLCopyFileSystemPath(BundleRef, kCFURLPOSIXPathStyle);
CFStringGetFileSystemRepresentation(BundlePath, AppBundlePath, sizeof(AppBundlePath));
CFRelease(BundleRef);
CFRelease(BundlePath);
return AppBundlePath;
}
void get_my_path(char s[PATH_MAX])
{
CFBundleRef mainBundle = CFBundleGetMainBundle();
CFURLRef executableURL = CFBundleCopyExecutableURL(mainBundle);
CFStringRef executablePathString = CFURLCopyFileSystemPath(executableURL, kCFURLPOSIXPathStyle);
CFRelease(executableURL);
CFStringGetFileSystemRepresentation(executablePathString, s, PATH_MAX-1);
CFRelease(executablePathString);
char *x;
x = strrchr(s, '/');
if(x) x[1] = 0;
}
/**
* 実行している自身のディレクトリパス取得
* @return 実行ディレクトリフルパス
*/
std::string getBinaryDir()
{
const int MAXPATHLEN = 4096;
char exepath[MAXPATHLEN] = {};
#if _WIN32
wchar_t app_full_path[1024];
DWORD length = GetModuleFileNameW(NULL, app_full_path, sizeof(app_full_path) / sizeof(wchar_t));
std::wstring str(app_full_path, length);
const char16_t* p = reinterpret_cast<const char16_t*>(str.c_str());
std::u16string u16str(p);
// utf16 to utf8
std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
std::string stdstr = convert.to_bytes(u16str);
std::string::size_type pos = stdstr.find_last_of("\\");
if (pos != std::string::npos) {
std::string basepath = stdstr.substr(0, pos + 1);
return basepath;
}
return stdstr;
#elif __APPLE__
#if __MAC_OS_X_VERSION_MAX_ALLOWED >= 1012
uint32_t size = sizeof(exepath);
int ret = _NSGetExecutablePath(exepath, &size);
if (0 != ret) {
return ""; // FIXME(IDS):
}
#else
CFBundleRef bundle = CFBundleGetMainBundle();
CFURLRef executableURL = CFBundleCopyExecutableURL(bundle);
CFStringRef executablePath = CFURLCopyFileSystemPath(executableURL, kCFURLPOSIXPathStyle);
CFStringGetMaximumSizeOfFileSystemRepresentation(executablePath);
CFStringGetFileSystemRepresentation(executablePath, exepath, MAXPATHLEN);
CFRelease(executablePath);
CFRelease(executableURL);
#endif
#else // Linux
readlink("/proc/self/exe", exepath, sizeof(exepath));
#endif
// for Mac & Linux
std::string fullpath(exepath);
size_t t = fullpath.rfind("/");
if (t != std::string::npos) {
fullpath = fullpath.substr(0, t + 1);
}
return fullpath;
}
char* _CFFSCreateRepresentation(CFStringRef path) {
if (!path) {
errno = EINVAL;
return NULL;
}
CFIndex length = CFStringGetMaximumSizeOfFileSystemRepresentation(path);
char* buffer = (char*)malloc(length);
if (!buffer) {
return NULL;
}
if (!CFStringGetFileSystemRepresentation(path, buffer, length)) {
free(buffer);
errno = ENAMETOOLONG;
return NULL;
}
return buffer;
}
CString fileSystemRepresentation(const String& path)
{
RetainPtr<CFStringRef> cfString = path.createCFString();
if (!cfString)
return CString();
CFIndex size = CFStringGetMaximumSizeOfFileSystemRepresentation(cfString.get());
Vector<char> buffer(size);
if (!CFStringGetFileSystemRepresentation(cfString.get(), buffer.data(), buffer.size())) {
LOG_ERROR("Failed to get filesystem representation to create CString from cfString");
return CString();
}
return CString(buffer.data(), strlen(buffer.data()));
}
static CFIndex CFURLEnumeratorPushURL(CFURLEnumeratorRef enumerator, CFURLRef url, CFErrorRef *error) {
char path[PATH_MAX] = { 0 };
CFStringRef urlPath = CFURLCopyPath(url);
Boolean success = CFStringGetFileSystemRepresentation(urlPath, path, PATH_MAX);
if (!success) {
cocoaError(error, -1, url, urlPath);
CFRelease(urlPath);
return kCFNotFound;
}
DIR *dir = opendir(path);
if (dir == NULL) {
posixError(error, url, urlPath);
CFRelease(urlPath);
return kCFNotFound;
}
CFMutableArrayRef fileInfos = CFArrayCreateMutable(kCFAllocatorDefault, 0, &kCFTypeArrayCallBacks);
struct dirent *current = NULL;
while ((current = readdir(dir)) != NULL) {
if (strcmp(current->d_name, ".") == 0 || strcmp(current->d_name, "..") == 0) {
continue;
}
CFMutableDictionaryRef fileInfo = CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFStringRef fileName = CFStringCreateWithBytes(kCFAllocatorDefault, current->d_name, strlen(current->d_name), kCFStringEncodingUTF8, false);
CFDictionarySetValue(fileInfo, fileInfoNameKey, fileName);
CFDictionarySetValue(fileInfo, fileInfoIsDirKey, current->d_type == DT_DIR ? kCFBooleanTrue : kCFBooleanFalse);
CFArrayAppendValue(fileInfos, fileInfo);
CFRelease(fileName);
CFRelease(fileInfo);
}
CFArraySortValues(fileInfos, CFRangeMake(0, CFArrayGetCount(fileInfos)), _compareFileInfo, nil);
CFArrayAppendValue(enumerator->urlStack, url);
CFArrayAppendValue(enumerator->dirFileInfos, fileInfos);
CFRelease(urlPath);
CFRelease(fileInfos);
closedir(dir);
return CFArrayGetCount(enumerator->urlStack);
}
/* Return the string value suitable for use with posix file system calls for
KEY found in PLIST. NULL will be returned if KEY does not have a valid value
in the the property list, if the value is not a string, or if there were
errors extracting the value for KEY. */
const char *
macosx_get_plist_posix_value(const void *plist, const char* key)
{
char *value = NULL;
CFStringRef cf_key;
CFStringRef cf_value;
if (plist == NULL)
return NULL;
cf_key = (CFStringRef)CFStringCreateWithCString(kCFAllocatorDefault, key,
kCFStringEncodingUTF8);
cf_value = (CFStringRef)CFDictionaryGetValue((CFDictionaryRef)plist,
cf_key);
if ((cf_value != NULL) && (CFGetTypeID(cf_value) == CFStringGetTypeID()))
{
CFIndex max_value_len;
max_value_len = CFStringGetMaximumSizeOfFileSystemRepresentation(cf_value);
if (max_value_len > 0)
{
value = (char *)xmalloc(max_value_len + 1);
if (value)
{
if (!CFStringGetFileSystemRepresentation(cf_value, value,
max_value_len))
{
/* We failed to get a file system representation
of the bundle executable, just free the buffer
we malloc'ed. */
xfree(value);
value = NULL;
}
}
}
}
if (cf_key) {
CFRelease(cf_key);
}
return value;
}
int prFileRealPath(struct VMGlobals* g, int numArgsPushed )
{
PyrSlot *a = g->sp - 1, *b = g->sp;
char ipath[PATH_MAX];
char opath[PATH_MAX];
int err;
err = slotStrVal(b, ipath, PATH_MAX);
if (err) return err;
bool isAlias = false;
if(sc_ResolveIfAlias(ipath, opath, isAlias, PATH_MAX)!=0) {
return errFailed;
}
boost::system::error_code error_code;
boost::filesystem::path p = boost::filesystem::canonical(opath,error_code);
if(error_code) {
SetNil(a);
return errNone;
}
strcpy(opath,p.string().c_str());
#if SC_DARWIN
CFStringRef cfstring =
CFStringCreateWithCString(NULL,
opath,
kCFStringEncodingUTF8);
err = !CFStringGetFileSystemRepresentation(cfstring, opath, PATH_MAX);
CFRelease(cfstring);
if (err) return errFailed;
#endif // SC_DARWIN
PyrString* pyrString = newPyrString(g->gc, opath, 0, true);
SetObject(a, pyrString);
return errNone;
}
sdmmd_return_t SDMMD_stream_image(SDMMD_AMConnectionRef connection, CFStringRef path, CFStringRef image_type)
{
sdmmd_return_t result = kAMDSuccess;
char fspath[0x400] = {0};
Boolean fsRep = CFStringGetFileSystemRepresentation(path, fspath, 0x400);
if (fsRep) {
struct stat fileStat;
lstat(fspath, &fileStat);
CFNumberRef size = CFNumberCreate(kCFAllocatorDefault, 0xb, &fileStat.st_size);
CFMutableDictionaryRef streamDict = SDMMD_create_dict();
CFDictionarySetValue(streamDict, CFSTR("Command"), CFSTR("ReceiveBytes"));
CFDictionarySetValue(streamDict, CFSTR("ImageType"), image_type);
CFDictionarySetValue(streamDict, CFSTR("ImageSize"), size);
result = SDMMD_ServiceSendMessage(SDMMD_TranslateConnectionToSocket(connection), streamDict, kCFPropertyListXMLFormat_v1_0);
CFSafeRelease(streamDict);
CFSafeRelease(size);
CheckErrorAndReturn(result);
CFDictionaryRef response;
result = SDMMD_ServiceReceiveMessage(SDMMD_TranslateConnectionToSocket(connection), (CFPropertyListRef *)&response);
CheckErrorAndReturn(result);
if (response) {
result = SDMMD__ErrorHandler(SDMMD_ImageMounterErrorConvert, response);
CheckErrorAndReturn(result);
CFTypeRef status = CFDictionaryGetValue(response, CFSTR("Status"));
if (status) {
if (CFStringCompare(status, CFSTR("ReceiveBytesAck"), 0) == 0) {
// block code
CFDataRef image_file = CFDataCreateFromPath(path);
uint64_t offset = 0;
uint64_t remainder = 0;
while (offset < fileStat.st_size) {
remainder = (fileStat.st_size - offset);
remainder = (remainder > kDeveloperImageStreamSize ? kDeveloperImageStreamSize : remainder);
CFRange current_read = CFRangeMake((CFIndex)offset, (CFIndex)remainder);
CFDataRef image_stream = CFDataCreateFromSubrangeOfData(image_file, current_read);
result = SDMMD_DirectServiceSend(SDMMD_TranslateConnectionToSocket(connection), image_stream);
CheckErrorAndReturn(result);
offset += remainder;
CFSafeRelease(image_stream);
}
CFDictionaryRef getStatus;
result = SDMMD_ServiceReceiveMessage(SDMMD_TranslateConnectionToSocket(connection), (CFPropertyListRef *)&getStatus);
if (result == 0) {
result = SDMMD__ErrorHandler(SDMMD_ImageMounterErrorConvert, response);
CheckErrorAndReturn(result);
CFTypeRef streamStatus = CFDictionaryGetValue(getStatus, CFSTR("Status"));
if (streamStatus) {
if (CFStringCompare(streamStatus, CFSTR("Complete"), 0x0) == 0) {
result = kAMDSuccess;
}
}
}
CFSafeRelease(getStatus);
CFSafeRelease(image_file);
}
}
else {
result = kAMDUndefinedError;
}
}
else {
result = kAMDReadError;
}
}
else {
result = kAMDNoResourcesError;
}
ExitLabelAndReturn(result);
}
// Returns the current directory
std::string GetCurrentDir()
{
// Get the current working directory (getcwd uses malloc)
#ifdef _WIN32
wchar_t *dir;
if (!(dir = _wgetcwd(nullptr, 0))) {
#else
char *dir;
if (!(dir = getcwd(nullptr, 0))) {
#endif
LOG_ERROR(Common_Filesystem, "GetCurrentDirectory failed: %s",
GetLastErrorMsg());
return nullptr;
}
#ifdef _WIN32
std::string strDir = Common::UTF16ToUTF8(dir);
#else
std::string strDir = dir;
#endif
free(dir);
return strDir;
}
// Sets the current directory to the given directory
bool SetCurrentDir(const std::string &directory)
{
#ifdef _WIN32
return _wchdir(Common::UTF8ToUTF16W(directory).c_str()) == 0;
#else
return chdir(directory.c_str()) == 0;
#endif
}
#if defined(__APPLE__)
std::string GetBundleDirectory()
{
CFURLRef BundleRef;
char AppBundlePath[MAXPATHLEN];
// Get the main bundle for the app
BundleRef = CFBundleCopyBundleURL(CFBundleGetMainBundle());
CFStringRef BundlePath = CFURLCopyFileSystemPath(BundleRef, kCFURLPOSIXPathStyle);
CFStringGetFileSystemRepresentation(BundlePath, AppBundlePath, sizeof(AppBundlePath));
CFRelease(BundleRef);
CFRelease(BundlePath);
return AppBundlePath;
}
#endif
#ifdef _WIN32
std::string& GetExeDirectory()
{
static std::string exe_path;
if (exe_path.empty())
{
wchar_t wchar_exe_path[2048];
GetModuleFileNameW(nullptr, wchar_exe_path, 2048);
exe_path = Common::UTF16ToUTF8(wchar_exe_path);
exe_path = exe_path.substr(0, exe_path.find_last_of('\\'));
}
return exe_path;
}
#else
/**
* @return The user’s home directory on POSIX systems
*/
static const std::string& GetHomeDirectory() {
static std::string home_path;
if (home_path.empty()) {
const char* envvar = getenv("HOME");
if (envvar) {
home_path = envvar;
} else {
auto pw = getpwuid(getuid());
ASSERT_MSG(pw, "$HOME isn’t defined, and the current user can’t be found in /etc/passwd.");
home_path = pw->pw_dir;
}
}
return home_path;
}
/**
* Follows the XDG Base Directory Specification to get a directory path
* @param envvar The XDG environment variable to get the value from
* @return The directory path
* @sa http://standards.freedesktop.org/basedir-spec/basedir-spec-latest.html
*/
static const std::string GetUserDirectory(const std::string& envvar) {
const char* directory = getenv(envvar.c_str());
std::string user_dir;
if (directory) {
user_dir = directory;
} else {
std::string subdirectory;
if (envvar == "XDG_DATA_HOME")
subdirectory = DIR_SEP ".local" DIR_SEP "share";
else if (envvar == "XDG_CONFIG_HOME")
subdirectory = DIR_SEP ".config";
else if (envvar == "XDG_CACHE_HOME")
subdirectory = DIR_SEP ".cache";
else
ASSERT_MSG(false, "Unknown XDG variable %s.", envvar.c_str());
user_dir = GetHomeDirectory() + subdirectory;
}
ASSERT_MSG(!user_dir.empty(), "User directory %s musn’t be empty.", envvar.c_str());
ASSERT_MSG(user_dir[0] == '/', "User directory %s must be absolute.", envvar.c_str());
return user_dir;
}
#endif
std::string GetSysDirectory()
{
std::string sysDir;
#if defined (__APPLE__)
sysDir = GetBundleDirectory();
sysDir += DIR_SEP;
sysDir += SYSDATA_DIR;
#else
sysDir = SYSDATA_DIR;
#endif
sysDir += DIR_SEP;
LOG_DEBUG(Common_Filesystem, "Setting to %s:", sysDir.c_str());
return sysDir;
}
// Returns a string with a Citra data dir or file in the user's home
// directory. To be used in "multi-user" mode (that is, installed).
const std::string& GetUserPath(const unsigned int DirIDX, const std::string &newPath)
{
static std::string paths[NUM_PATH_INDICES];
// Set up all paths and files on the first run
if (paths[D_USER_IDX].empty())
{
#ifdef _WIN32
paths[D_USER_IDX] = GetExeDirectory() + DIR_SEP USERDATA_DIR DIR_SEP;
paths[D_CONFIG_IDX] = paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
paths[D_CACHE_IDX] = paths[D_USER_IDX] + CACHE_DIR DIR_SEP;
#else
if (FileUtil::Exists(ROOT_DIR DIR_SEP USERDATA_DIR)) {
paths[D_USER_IDX] = ROOT_DIR DIR_SEP USERDATA_DIR DIR_SEP;
paths[D_CONFIG_IDX] = paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
paths[D_CACHE_IDX] = paths[D_USER_IDX] + CACHE_DIR DIR_SEP;
} else {
std::string data_dir = GetUserDirectory("XDG_DATA_HOME");
std::string config_dir = GetUserDirectory("XDG_CONFIG_HOME");
std::string cache_dir = GetUserDirectory("XDG_CACHE_HOME");
paths[D_USER_IDX] = data_dir + DIR_SEP EMU_DATA_DIR DIR_SEP;
paths[D_CONFIG_IDX] = config_dir + DIR_SEP EMU_DATA_DIR DIR_SEP;
paths[D_CACHE_IDX] = cache_dir + DIR_SEP EMU_DATA_DIR DIR_SEP;
}
#endif
paths[D_GAMECONFIG_IDX] = paths[D_USER_IDX] + GAMECONFIG_DIR DIR_SEP;
paths[D_MAPS_IDX] = paths[D_USER_IDX] + MAPS_DIR DIR_SEP;
paths[D_SDMC_IDX] = paths[D_USER_IDX] + SDMC_DIR DIR_SEP;
paths[D_NAND_IDX] = paths[D_USER_IDX] + NAND_DIR DIR_SEP;
paths[D_SYSDATA_IDX] = paths[D_USER_IDX] + SYSDATA_DIR DIR_SEP;
paths[D_SHADERCACHE_IDX] = paths[D_USER_IDX] + SHADERCACHE_DIR DIR_SEP;
paths[D_SHADERS_IDX] = paths[D_USER_IDX] + SHADERS_DIR DIR_SEP;
paths[D_STATESAVES_IDX] = paths[D_USER_IDX] + STATESAVES_DIR DIR_SEP;
paths[D_SCREENSHOTS_IDX] = paths[D_USER_IDX] + SCREENSHOTS_DIR DIR_SEP;
paths[D_DUMP_IDX] = paths[D_USER_IDX] + DUMP_DIR DIR_SEP;
paths[D_DUMPFRAMES_IDX] = paths[D_DUMP_IDX] + DUMP_FRAMES_DIR DIR_SEP;
paths[D_DUMPAUDIO_IDX] = paths[D_DUMP_IDX] + DUMP_AUDIO_DIR DIR_SEP;
paths[D_DUMPTEXTURES_IDX] = paths[D_DUMP_IDX] + DUMP_TEXTURES_DIR DIR_SEP;
paths[D_LOGS_IDX] = paths[D_USER_IDX] + LOGS_DIR DIR_SEP;
paths[F_DEBUGGERCONFIG_IDX] = paths[D_CONFIG_IDX] + DEBUGGER_CONFIG;
paths[F_LOGGERCONFIG_IDX] = paths[D_CONFIG_IDX] + LOGGER_CONFIG;
paths[F_MAINLOG_IDX] = paths[D_LOGS_IDX] + MAIN_LOG;
}
if (!newPath.empty())
{
if (!FileUtil::IsDirectory(newPath))
{
LOG_ERROR(Common_Filesystem, "Invalid path specified %s", newPath.c_str());
return paths[DirIDX];
}
else
{
paths[DirIDX] = newPath;
}
switch (DirIDX)
{
case D_ROOT_IDX:
paths[D_USER_IDX] = paths[D_ROOT_IDX] + DIR_SEP;
paths[D_SYSCONF_IDX] = paths[D_USER_IDX] + SYSCONF_DIR + DIR_SEP;
paths[F_SYSCONF_IDX] = paths[D_SYSCONF_IDX] + SYSCONF;
break;
case D_USER_IDX:
paths[D_USER_IDX] = paths[D_ROOT_IDX] + DIR_SEP;
paths[D_CONFIG_IDX] = paths[D_USER_IDX] + CONFIG_DIR DIR_SEP;
paths[D_GAMECONFIG_IDX] = paths[D_USER_IDX] + GAMECONFIG_DIR DIR_SEP;
paths[D_MAPS_IDX] = paths[D_USER_IDX] + MAPS_DIR DIR_SEP;
paths[D_CACHE_IDX] = paths[D_USER_IDX] + CACHE_DIR DIR_SEP;
paths[D_SDMC_IDX] = paths[D_USER_IDX] + SDMC_DIR DIR_SEP;
paths[D_NAND_IDX] = paths[D_USER_IDX] + NAND_DIR DIR_SEP;
paths[D_SHADERCACHE_IDX] = paths[D_USER_IDX] + SHADERCACHE_DIR DIR_SEP;
paths[D_SHADERS_IDX] = paths[D_USER_IDX] + SHADERS_DIR DIR_SEP;
paths[D_STATESAVES_IDX] = paths[D_USER_IDX] + STATESAVES_DIR DIR_SEP;
paths[D_SCREENSHOTS_IDX] = paths[D_USER_IDX] + SCREENSHOTS_DIR DIR_SEP;
paths[D_DUMP_IDX] = paths[D_USER_IDX] + DUMP_DIR DIR_SEP;
paths[D_DUMPFRAMES_IDX] = paths[D_DUMP_IDX] + DUMP_FRAMES_DIR DIR_SEP;
paths[D_DUMPAUDIO_IDX] = paths[D_DUMP_IDX] + DUMP_AUDIO_DIR DIR_SEP;
paths[D_DUMPTEXTURES_IDX] = paths[D_DUMP_IDX] + DUMP_TEXTURES_DIR DIR_SEP;
paths[D_LOGS_IDX] = paths[D_USER_IDX] + LOGS_DIR DIR_SEP;
paths[D_SYSCONF_IDX] = paths[D_USER_IDX] + SYSCONF_DIR DIR_SEP;
paths[F_EMUCONFIG_IDX] = paths[D_CONFIG_IDX] + EMU_CONFIG;
paths[F_DEBUGGERCONFIG_IDX] = paths[D_CONFIG_IDX] + DEBUGGER_CONFIG;
paths[F_LOGGERCONFIG_IDX] = paths[D_CONFIG_IDX] + LOGGER_CONFIG;
paths[F_MAINLOG_IDX] = paths[D_LOGS_IDX] + MAIN_LOG;
break;
case D_CONFIG_IDX:
paths[F_EMUCONFIG_IDX] = paths[D_CONFIG_IDX] + EMU_CONFIG;
paths[F_DEBUGGERCONFIG_IDX] = paths[D_CONFIG_IDX] + DEBUGGER_CONFIG;
paths[F_LOGGERCONFIG_IDX] = paths[D_CONFIG_IDX] + LOGGER_CONFIG;
break;
case D_DUMP_IDX:
paths[D_DUMPFRAMES_IDX] = paths[D_DUMP_IDX] + DUMP_FRAMES_DIR DIR_SEP;
paths[D_DUMPAUDIO_IDX] = paths[D_DUMP_IDX] + DUMP_AUDIO_DIR DIR_SEP;
paths[D_DUMPTEXTURES_IDX] = paths[D_DUMP_IDX] + DUMP_TEXTURES_DIR DIR_SEP;
break;
case D_LOGS_IDX:
paths[F_MAINLOG_IDX] = paths[D_LOGS_IDX] + MAIN_LOG;
}
}
return paths[DirIDX];
}
size_t WriteStringToFile(bool text_file, const std::string &str, const char *filename)
{
return FileUtil::IOFile(filename, text_file ? "w" : "wb").WriteBytes(str.data(), str.size());
}
size_t ReadFileToString(bool text_file, const char *filename, std::string &str)
{
IOFile file(filename, text_file ? "r" : "rb");
if (!file)
return false;
str.resize(static_cast<u32>(file.GetSize()));
return file.ReadArray(&str[0], str.size());
}
void mui_init(){
#if TARGET_OS_IPHONE
if( mui::MuiConfig::detectRetina ){
ofAppiOSWindow * w = ofAppiOSWindow::getInstance();
if( w->isRetinaEnabled() ){
mui::MuiConfig::scaleFactor = 2;
mui::MuiConfig::useRetinaAssets = true;
}
}
#endif
//TODO: allow retina in osx too!
Poco::Path appPath;
#if TARGET_OS_IPHONE
// http://www.cocoabuilder.com/archive/cocoa/193451-finding-out-executable-location-from-c-program.html
CFBundleRef bundle = CFBundleGetMainBundle();
CFURLRef url = CFBundleCopyExecutableURL(bundle); // CFBundleCopyResourcesDirectoryURL(bundle);
CFURLRef absolute = CFURLCopyAbsoluteURL(url);
CFStringRef path = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);
CFIndex maxLength = CFStringGetMaximumSizeOfFileSystemRepresentation(path);
char *result = (char*)malloc(maxLength);
if(result) {
if(!CFStringGetFileSystemRepresentation(path,result, maxLength)) {
free(result);
result = NULL;
}
}
CFRelease(path);
CFRelease(url);
CFRelease(absolute);
appPath = Poco::Path(result);
appPath = appPath.parent();
#elif TARGET_OS_MAC
// http://www.cocoabuilder.com/archive/cocoa/193451-finding-out-executable-location-from-c-program.html
CFBundleRef bundle = CFBundleGetMainBundle();
CFURLRef url = CFBundleCopyExecutableURL(bundle); // CFBundleCopyResourcesDirectoryURL(bundle);
CFURLRef absolute = CFURLCopyAbsoluteURL(url);
CFStringRef path = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle);
CFIndex maxLength = CFStringGetMaximumSizeOfFileSystemRepresentation(path);
char *result = (char*)malloc(maxLength);
if(result) {
if(!CFStringGetFileSystemRepresentation(path,result, maxLength)) {
free(result);
result = NULL;
}
}
CFRelease(path);
CFRelease(url);
CFRelease(absolute);
appPath = Poco::Path(result);
appPath = appPath.parent().parent().pushDirectory("Resources");
if( mui::MuiConfig::detectRetina ){
ofAppGLFWWindow * window = dynamic_cast<ofAppGLFWWindow*>(ofGetWindowPtr());
if( window != NULL ){
mui::MuiConfig::scaleFactor = window->getPixelScreenCoordScale();
}
}
#else
appPath = Poco::Path(ofToDataPath("", true));
#endif
mui::MuiConfig::dataPath = appPath.absolute();
}
static char * vmd_get_vmddir(void) {
OSErr rc = 0;
FSSpec spec;
FSRef ref;
UInt8 *path = NULL;
char *bundledir = NULL;
char *vmddir = NULL;
char *tmp = NULL;
bundledir = (char *) malloc(2048 * sizeof(UInt8));
memset(bundledir, 0, 2048 * sizeof(UInt8));
#if defined(ARCH_MACOSXX86_64)
//
// CoreFoundation/Cocoa-based application bundle path query code
//
CFBundleRef mainbundle = CFBundleGetMainBundle();
if (mainbundle != NULL) {
#if 1
CFURLRef appurl = CFBundleCopyBundleURL(mainbundle);
#else
CFURLRef appurl = CFBundleCopyExecutableURL(mainbundle);
#endif
CFStringRef cfpath = CFURLCopyFileSystemPath(appurl, kCFURLPOSIXPathStyle);
if (CFStringGetFileSystemRepresentation(cfpath, bundledir, 2048 * sizeof(UInt8) - 1) == true) {
// printf("MacOS X Bundle path: %s\n", bundledir);
// Truncate bundle path to parent bundle directory,
// if needed, when the executable is launched by double clicking
// the application bundle in the GUI. When the application
// is launched directly via scripts etc, the main bundle path
// returned from the previous calls already points to the parent
// directory of the VMD executable.
if (strstr(bundledir, "/Contents/Resources/VMD.app")) {
if ((tmp = strrchr(bundledir, '/')) != NULL) {
tmp[0] = '\0';
}
if ((tmp = strrchr(bundledir, '/')) != NULL) {
tmp[0] = '\0';
}
if ((tmp = strrchr(bundledir, '/')) != NULL) {
tmp[0] = '\0';
}
// add path to main VMD directory from the outermost bundle container
strcat(bundledir, "/Contents/vmd");
}
vmddir = (char *) malloc(strlen(bundledir) + 1 + strlen("/vmd"));
strcpy(vmddir, bundledir);
}
free(bundledir);
CFRelease(appurl);
CFRelease(cfpath);
}
if (!vmddir) {
printf("WARNING: Failed to get path for main VMD application bundle...\n");
vmddir = getenv("VMDDIR");
}
#else
//
// Carbon-based application bundle path query code
//
#if 0
if (!(rc = GetApplicationPackageFSSpecFromBundle(&spec))) {
#else
if (!(rc = GetApplicationBundleFSSpec(&spec))) {
#endif
rc = FSpMakeFSRef(&spec, &ref);
if (rc) printf("makefsref OSErr: %d\n", rc);
rc = FSRefMakePath(&ref,(UInt8 *) bundledir, 2048);
if (rc) printf("makepath OSErr: %d\n", rc);
} else {
printf("getappbundlepath OSErr: %d\n", rc);
}
if (rc) {
free(bundledir);
return NULL;
}
// truncate bundle path to parent bundle directory
if ((tmp = strrchr(bundledir, '/')) != NULL) {
tmp[0] = '\0';
}
if ((tmp = strrchr(bundledir, '/')) != NULL) {
tmp[0] = '\0';
}
// add "/vmd" to parent bundle directory
vmddir = (char *) malloc(strlen(bundledir) + 1 + strlen("/vmd"));
strcpy(vmddir, bundledir);
strcat(vmddir, "/vmd");
free(bundledir);
#endif
return (char *) vmddir;
}
#if 1
int macosxvmdstart(int argc, char **argv) {
#else
int main(int argc, char **argv) {
#endif
char tmp[8192];
char * vmddir;
int i;
vmddir = vmd_get_vmddir();
if (vmddir == NULL) {
return -1; // fail and exit
}
#if 0
if (!getenv("MACOSXVMDSTARTUP")) {
int startterminal=1; // be default, we start one...
setenv("MACOSXVMDSTARTUP", "1", 1);
// check for -dispdev text, in which case we don't start a terminal...
for (i=0; i < argc; i++) {
if (!strupcmp(argv[i], "-dispdev")) {
if (argc > i+1) {
if (!strupcmp(argv[i+1], "text")) {
startterminal=0;
}
}
}
}
if (startterminal) {
char cmdbuf[16384];
sprintf(cmdbuf, "\"%s/vmd_MACOSX\"", vmddir);
if (argc > 1) {
for (i=1; i < argc; i++) {
strcat(cmdbuf, " ");
strcat(cmdbuf, argv[i]);
}
}
strcat(cmdbuf, " &");
printf("Executing VMD startup command: %s\n", cmdbuf);
exit(system(cmdbuf));
}
}
#endif
if (!getenv("VMDDIR")) {
setenv("VMDDIR", vmddir, 1);
}
if (!getenv("TCL_LIBRARY")) {
strcpy(tmp, vmddir);
strcat(tmp, "/scripts/tcl");
setenv("TCL_LIBRARY", tmp, 1);
}
if (!getenv("TK_LIBRARY")) {
strcpy(tmp, vmddir);
strcat(tmp, "/scripts/tk");
setenv("TK_LIBRARY", tmp, 1);
}
if (!getenv("PYTHONPATH")) {
strcpy(tmp, vmddir);
strcat(tmp, "/scripts/python");
setenv("PYTHONPATH", tmp, 1);
} else {
strcpy(tmp, getenv("PYTHONPATH"));
strcat(tmp, ":");
strcat(tmp, vmddir);
strcat(tmp, "/scripts/python");
setenv("PYTHONPATH", tmp, 1);
}
if (!getenv("STRIDE_BIN")) {
strcpy(tmp, vmddir);
#if defined(ARCH_MACOSXX86_64)
strcat(tmp, "/stride_MACOSXX86_64");
#elif defined(ARCH_MACOSXX86)
strcat(tmp, "/stride_MACOSXX86");
#else
strcat(tmp, "/stride_MACOSX");
#endif
setenv("STRIDE_BIN", tmp, 1);
}
if (!getenv("SURF_BIN")) {
strcpy(tmp, vmddir);
#if defined(ARCH_MACOSXX86_64)
strcat(tmp, "/surf_MACOSXX86_64");
#elif defined(ARCH_MACOSXX86)
strcat(tmp, "/surf_MACOSXX86");
#else
strcat(tmp, "/surf_MACOSX");
#endif
setenv("SURF_BIN", tmp, 1);
}
if (!getenv("TACHYON_BIN")) {
strcpy(tmp, vmddir);
#if defined(ARCH_MACOSXX86_64)
strcat(tmp, "/tachyon_MACOSXX86_64");
#elif defined(ARCH_MACOSXX86)
strcat(tmp, "/tachyon_MACOSXX86");
#else
strcat(tmp, "/tachyon_MACOSX");
#endif
setenv("TACHYON_BIN", tmp, 1);
}
return 0;
}