static void
__rbosa_raise_potential_app_error (AEDesc *reply)
{
OSErr error;
AEDesc errorNumDesc;
AEDesc errorStringDesc;
int errorNum;
const char * errorMsg;
char exception[128];
if (AEGetParamDesc (reply, keyErrorNumber, typeSInt32, &errorNumDesc) != noErr)
return;
if (AEGetDescData (&errorNumDesc, &errorNum, sizeof errorNum) != noErr) {
AEDisposeDesc (&errorNumDesc);
return;
}
if (errorNum == noErr)
return;
/* The reply is an application error. */
errorMsg = error_code_to_string(errorNum);
if (errorMsg == NULL)
errorMsg = "Unknown error";
exception[0] = '\0';
error = AEGetParamDesc (reply, keyErrorString, typeChar, &errorStringDesc);
if (error == noErr) {
Size size;
size = AEGetDescDataSize (&errorStringDesc);
if (size > 0) {
char *msg;
msg = (char *)malloc (size + 1);
if (msg != NULL) {
if (AEGetDescData (&errorStringDesc, msg, size) == noErr) {
msg[size] = '\0';
snprintf (exception, sizeof exception, "application returned error: %s (%d), with message: %s", errorMsg, errorNum, msg);
}
free (msg);
}
}
AEDisposeDesc (&errorStringDesc);
}
if (exception[0] == '\0')
snprintf (exception, sizeof exception, "application returned error: %s (%d)", errorMsg, errorNum);
AEDisposeDesc (&errorNumDesc);
rb_raise (rb_eRuntimeError, exception);
}
static VALUE
rbosa_element_eql (VALUE self, VALUE other)
{
AEDesc * self_desc;
AEDesc * other_desc;
Size data_size;
void * self_data;
void * other_data;
OSErr error;
Boolean ok;
if (!rb_obj_is_kind_of (other, rb_class_real (rb_class_of (self))))
return Qfalse;
self_desc = rbosa_element_aedesc (self);
other_desc = rbosa_element_aedesc (other);
if (self_desc == other_desc)
return Qtrue;
if (self_desc->descriptorType != other_desc->descriptorType)
return Qfalse;
data_size = AEGetDescDataSize (self_desc);
if (data_size != AEGetDescDataSize (other_desc))
return Qfalse;
self_data = (void *)malloc (data_size);
other_data = (void *)malloc (data_size);
ok = 0;
if (self_data == NULL || other_data == NULL)
rb_fatal ("cannot allocate memory");
error = AEGetDescData (self_desc, self_data, data_size);
if (error != noErr)
goto bails;
error = AEGetDescData (other_desc, other_data, data_size);
if (error != noErr)
goto bails;
ok = memcmp (self_data, other_data, data_size) == 0;
bails:
free (self_data);
free (other_data);
return CBOOL2RVAL (ok);
}
pascal OSErr MoreAEGetCFStringFromDescriptor(const AEDesc* pAEDesc, CFStringRef* pCFStringRef)
{
AEDesc uniAEDesc = {typeNull, NULL};
OSErr anErr;
if (NULL == pCFStringRef)
return paramErr;
anErr = AECoerceDesc(pAEDesc, typeUnicodeText, &uniAEDesc);
if (noErr == anErr)
{
if (typeUnicodeText == uniAEDesc.descriptorType)
{
Size bufSize = AEGetDescDataSize(&uniAEDesc);
Ptr buf = NewPtr(bufSize);
if ((noErr == (anErr = MemError())) && (NULL != buf))
{
anErr = AEGetDescData(&uniAEDesc, buf, bufSize);
if (noErr == anErr)
*pCFStringRef = CFStringCreateWithCharacters(kCFAllocatorDefault, (UniChar*) buf, bufSize / (Size) sizeof(UniChar));
DisposePtr(buf);
}
}
MoreAEDisposeDesc(&uniAEDesc);
}
return (anErr);
}//end MoreAEGetCFStringFromDescriptor
static VALUE
__rbosa_class_from_desc_data (VALUE app, AEDesc res)
{
DescType data;
Size datasize;
VALUE classes, klass;
classes = rb_ivar_get (app, sClasses);
if (NIL_P (classes))
return Qnil;
klass = Qnil;
datasize = AEGetDescDataSize (&res);
/* This should always be a four-byte code. */
if (datasize != sizeof (DescType))
return Qnil;
if (AEGetDescData (&res, &data, datasize) == noErr) {
char dtStr[5];
*(DescType *)dtStr = CFSwapInt32HostToBig (data);
klass = rb_hash_aref (classes, rb_str_new (dtStr, 4));
}
return klass;
}
static pascal Boolean NavOpenFilterProc(AEDesc *item, void *info, NavCallBackUserData callBackUD, NavFilterModes filterMode)
{
OSStatus status;
Boolean outCanOpenAsMovie;
Boolean canViewItem = false;
if (!item->descriptorType == typeFSRef) return false;
if (((NavFileOrFolderInfo*)info)->isFolder == true) return true;
FSRef fsRef;
status = AEGetDescData(item, &fsRef, sizeof(fsRef));
if (status != noErr) throw PianoGameError(WSTRING(L"Couldn't get item description. Error code: " << static_cast<int>(status)));
const static int BufferSize(1024);
char path_buffer[BufferSize];
status = FSRefMakePath(&fsRef, (UInt8*)path_buffer, BufferSize);
if (status != noErr) throw PianoGameError(WSTRING(L"Couldn't get file path. Error code: " << static_cast<int>(status)));
std::string path(path_buffer);
if (path.length() < 5) return false;
std::string path_lower(StringLower<std::string>(path));
bool allowed = false;
const static std::string allowed1(".mid");
const static std::string allowed2(".midi");
allowed = allowed || (path_lower.substr(path_lower.length() - allowed1.length()) == allowed1);
allowed = allowed || (path_lower.substr(path_lower.length() - allowed2.length()) == allowed2);
return allowed;
}
OSErr getURLFromUTextDesc(const AEDesc *utdesc_p, CFURLRef *urlRef_p)
{
OSErr err;
Size theLength = AEGetDescDataSize(utdesc_p);
UInt8 *theData = malloc(theLength);
err = AEGetDescData(utdesc_p, theData, theLength);
if (err != noErr) goto bail;
CFStringRef pathStr = CFStringCreateWithBytes(NULL, theData, theLength, kCFStringEncodingUnicode, false);
CFURLPathStyle pathStyle;
if (CFStringHasPrefix(pathStr, CFSTR("/"))) {
pathStyle = kCFURLPOSIXPathStyle;
}
else {
pathStyle = kCFURLHFSPathStyle;
}
*urlRef_p = CFURLCreateWithFileSystemPath(NULL, pathStr, pathStyle, true);
CFRelease(pathStr);
bail:
free(theData);
return err;
}
Boolean nav_file_filter(AEDesc *theItem,void *info,void *callBackUD,NavFilterModes filterMode)
{
char *c,filename[256];
NavFileOrFolderInfo *filefolder;
AEDesc desc;
HFSUniStr255 uniname;
CFStringRef cfstr;
FSRef fref;
if ((theItem->descriptorType!=typeFSS) && (theItem->descriptorType!=typeFSRef)) return(FALSE);
filefolder=(NavFileOrFolderInfo*)info;
if (filefolder->isFolder) return(TRUE);
AECoerceDesc(theItem,typeFSRef,&desc);
AEGetDescData(&desc,(void*)&fref,sizeof(FSRef));
AEDisposeDesc(&desc);
FSGetCatalogInfo(&fref,kFSCatInfoNone,NULL,&uniname,NULL,NULL);
cfstr=CFStringCreateWithCharacters(kCFAllocatorDefault,uniname.unicode,uniname.length);
CFStringGetCString(cfstr,filename,256,kCFStringEncodingMacRoman);
CFRelease(cfstr);
c=strchr(filename,'.');
if (c==NULL) return(FALSE);
return(strcasecmp((c+1),nav_filetype)==0);
}
pascal Boolean findImageFilterProc(AEDesc* theItem, void* info,
NavCallBackUserData callBackUD,
NavFilterModes filterMode)
{
#pragma unused(filterMode,callBackUD)
NavFileOrFolderInfo* theInfo = (NavFileOrFolderInfo*)info;
if (theItem->descriptorType == typeFSRef) {
char checkSuffix[256],pathName[1024];
OSErr error;
Boolean check;
FSRef theFSRef;
if (theInfo->isFolder)
return true;
if (theInfo->fileAndFolder.fileInfo.finderInfo.fdType == 'STim')
return true;
error = AEGetDescData(theItem,&theFSRef,sizeof(FSRef));
if (error != noErr)
return true;
PathToFileViaFSRef(pathName, 1024, &theFSRef,kCFStringEncodingUTF8);
getLastPathComponentInCurrentEncoding(pathName,checkSuffix,kCFStringEncodingUTF8);
check = IsImageName(checkSuffix);
if (check)
return true;
else {
return false;
}
}
return true;
}
static VALUE
rbosa_element_data (int argc, VALUE *argv, VALUE self)
{
VALUE coerce_type;
AEDesc coerced_desc;
AEDesc * desc;
OSErr error;
void * data;
Size datasize;
VALUE retval;
bool to_4cc;
rb_scan_args (argc, argv, "01", &coerce_type);
to_4cc = false;
desc = rbosa_element_aedesc (self);
if (!NIL_P (coerce_type)) {
FourCharCode code;
code = RVAL2FOURCHAR (coerce_type);
error = AECoerceDesc (desc, code, &coerced_desc);
if (error != noErr)
rb_raise (rb_eRuntimeError, "Cannot coerce desc to type %s : %s (%d)",
RVAL2CSTR (coerce_type), error_code_to_string (error), error);
desc = &coerced_desc;
to_4cc = code == 'type';
}
datasize = AEGetDescDataSize (desc);
data = (void *)malloc (datasize);
if (data == NULL)
rb_fatal ("cannot allocate memory");
error = AEGetDescData (desc, data, datasize);
if (error == noErr) {
if (to_4cc)
*(DescType*)data = CFSwapInt32HostToBig (*(DescType*)data);
retval = rb_str_new (data, datasize);
}
else {
retval = Qnil;
}
if (!NIL_P (coerce_type))
AEDisposeDesc (&coerced_desc);
free (data);
if (error != noErr)
rb_raise (rb_eRuntimeError, "Cannot get desc data : %s (%d)",
error_code_to_string (error), error);
return retval;
}
OSStatus getFSRefFromAE(const AppleEvent *ev, AEKeyword theKey, FSRef *ref_p)
{
AEDesc givenDesc;
OSStatus err = AEGetParamDesc(ev, keyDirectObject, typeFSRef, &givenDesc);
#if useLog
showAEDesc(&givenDesc);
#endif
err = AEGetDescData(&givenDesc, ref_p, sizeof(FSRef));
AEDisposeDesc(&givenDesc);
return err;
}
static OSStatus GetFSRefFromAEDesc( AEDesc* fileObject, FSRef* returnRef )
{
OSStatus theErr = noErr;
AEDesc theDesc;
if ((theErr = AECoerceDesc( fileObject, typeFSRef, &theDesc )) == noErr)
{
theErr = AEGetDescData( &theDesc, returnRef, sizeof ( FSRef ) );
AEDisposeDesc( &theDesc );
}
return theErr;
}
pascal Boolean CrossPlatformFilterCallback(
AEDesc *theItem,
void *info,
void *callBackUD,
NavFilterModes filterMode )
{
OpenUserDataRecPtr data = (OpenUserDataRecPtr) callBackUD ;
if (filterMode == kNavFilteringBrowserList)
{
// We allow navigation to all folders. For files, we check against the current
// filter string.
// However, packages should be dealt with like files and not like folders. So
// check if a folder is a package before deciding what to do.
NavFileOrFolderInfo* theInfo = (NavFileOrFolderInfo*) info ;
FSRef fsref;
if ( theInfo->isFolder )
{
// check bundle bit (using Finder Services - used by OS9 on some bundles)
FSCatalogInfo catalogInfo;
if (FSGetCatalogInfo (&fsref, kFSCatInfoFinderInfo, &catalogInfo, NULL, NULL, NULL) != noErr)
return true;
// Check bundle item (using Launch Services - used by OS-X through info.plist or APP)
LSItemInfoRecord lsInfo;
if (LSCopyItemInfoForRef(&fsref, kLSRequestBasicFlagsOnly, &lsInfo ) != noErr)
return true;
// If it's not a bundle, then it's a normal folder and it passes our filter
FileInfo *fileInfo = (FileInfo *) catalogInfo.finderInfo;
if ( !(fileInfo->finderFlags & kHasBundle) &&
!(lsInfo.flags & (kLSItemInfoIsApplication | kLSItemInfoIsPackage)) )
return true;
}
else
{
AECoerceDesc (theItem, typeFSRef, theItem);
if ( AEGetDescData (theItem, &fsref, sizeof (FSRef)) == noErr)
{
wxString file = wxMacFSRefToPath( &fsref ) ;
return CheckFile( file , theInfo->fileAndFolder.fileInfo.finderInfo.fdType , data ) ;
}
}
}
return true;
}
static PyObject *AEDesc_get_data(AEDescObject *self, void *closure)
{
PyObject *res;
Size size;
char *ptr;
OSErr err;
size = AEGetDescDataSize(&self->ob_itself);
if ( (res = PyBytes_FromStringAndSize(NULL, size)) == NULL )
return NULL;
if ( (ptr = PyBytes_AsString(res)) == NULL )
return NULL;
if ( (err=AEGetDescData(&self->ob_itself, ptr, size)) < 0 )
return AE_MacOSError(err);
return res;
}
static boolean getdescdata (AEDesc *desc, Handle *h) {
/*
PBS 03/14/02: get data from AEDesc's data handle as
a handle. The handle is allocated here. Caller
will dispose of handle, unless this function returns false.
*/
Size len;
len = AEGetDescDataSize (desc);
/* kw - 2005-12-12 - we should return at least a zero sized handle
if (len < 1) {
*h = nil;
return (false);
}
*/
if (!newclearhandle (len, h)) {
*h = nil;
return (false);
}
lockhandle (*h);
if (AEGetDescData (desc, **h, len) != noErr) {
disposehandle (*h);
*h = nil;
return (false);
} /*if*/
unlockhandle (*h);
return (true);
} /*getdescdata*/
pascal Boolean CrossPlatformFilterCallback(
AEDesc *theItem,
void *info,
void *callBackUD,
NavFilterModes filterMode )
{
bool display = true;
OpenUserDataRecPtr data = (OpenUserDataRecPtr) callBackUD ;
if (filterMode == kNavFilteringBrowserList)
{
NavFileOrFolderInfo* theInfo = (NavFileOrFolderInfo*) info ;
if ( !theInfo->isFolder )
{
AECoerceDesc (theItem, typeFSRef, theItem);
FSRef fsref ;
if ( AEGetDescData (theItem, &fsref, sizeof (FSRef)) == noErr )
{
#if 1
memcpy( &fsref , *theItem->dataHandle , sizeof(FSRef) ) ;
wxString file = wxMacFSRefToPath( &fsref ) ;
display = CheckFile( file , theInfo->fileAndFolder.fileInfo.finderInfo.fdType , data ) ;
#else
CFStringRef itemUTI = NULL;
OSStatus status = LSCopyItemAttribute (&fsref, kLSRolesAll, kLSItemContentType, (CFTypeRef*)&itemUTI);
if (status == noErr)
{
display = UTTypeConformsTo (itemUTI, CFSTR("public.text") );
CFRelease (itemUTI);
}
#endif
}
}
}
return display;
}
static Boolean qt_mac_nav_filter(AEDesc *theItem, void *info,
void *myd, NavFilterModes)
{
qt_mac_nav_filter_type *t = (qt_mac_nav_filter_type *)myd;
if(!t || !t->filts || t->index >= t->filts->count())
return true;
NavFileOrFolderInfo *theInfo = (NavFileOrFolderInfo *)info;
QString file;
qt_mac_filter_name *fn = t->filts->at(t->index);
if(!fn)
return true;
if(theItem->descriptorType == typeFSRef) {
FSRef ref;
AEGetDescData(theItem, &ref, sizeof(ref));
if(!str_buffer) {
qAddPostRoutine(cleanup_str_buffer);
str_buffer = (UInt8 *)malloc(1024);
}
FSRefMakePath(&ref, str_buffer, 1024);
file = QString::fromUtf8((const char *)str_buffer);
int slsh = file.lastIndexOf(QLatin1Char('/'));
if(slsh != -1)
file = file.right(file.length() - slsh - 1);
}
QStringList reg = fn->regxp.split(QLatin1String(";"));
for(QStringList::Iterator it = reg.begin(); it != reg.end(); ++it) {
QRegExp rg((*it), false, true);
#ifdef DEBUG_FILEDIALOG_FILTERS
qDebug("Q3FileDialog:%d, asked to filter.. %s (%s)", __LINE__,
file.latin1(), (*it).latin1());
#endif
if(rg.exactMatch(file))
return true;
}
return (theInfo->isFolder && !file.endsWith(QLatin1String(".app")));
}
CFStringRef CFStringCreateWithAEDesc(const AEDesc *desc, OSErr *errPtr)
{
CFStringEncoding encodeKey;
CFStringRef result = NULL;
Boolean isExternalRepresentation = false;
void *dataPtr = NULL;
switch (desc->descriptorType) {
case typeChar:
encodeKey = CFStringGetSystemEncoding();
break;
case typeUTF8Text:
encodeKey = kCFStringEncodingUTF8;
break;
case typeUnicodeText:
encodeKey = kCFStringEncodingUnicode;
break;
case typeUTF16ExternalRepresentation:
encodeKey = kCFStringEncodingUTF16;
isExternalRepresentation = true;
break;
default :
goto bail;
}
Size dataSize = AEGetDescDataSize (desc);
dataPtr = malloc(dataSize);
*errPtr = AEGetDescData(desc, dataPtr, dataSize);
if (noErr != *errPtr) {
goto bail;
}
result = CFStringCreateWithBytes(kCFAllocatorDefault, dataPtr, dataSize, encodeKey, isExternalRepresentation);
bail:
if (dataPtr) free(dataPtr);
return result;
}
Boolean LLFilePicker::navOpenFilterProc(AEDesc *theItem, void *info, void *callBackUD, NavFilterModes filterMode)
{
Boolean result = true;
ELoadFilter filter = *((ELoadFilter*) callBackUD);
OSStatus error = noErr;
if (filterMode == kNavFilteringBrowserList && filter != FFLOAD_ALL && (theItem->descriptorType == typeFSRef || theItem->descriptorType == typeFSS))
{
// navInfo is only valid for typeFSRef and typeFSS
NavFileOrFolderInfo *navInfo = (NavFileOrFolderInfo*) info;
if (!navInfo->isFolder)
{
AEDesc desc;
error = AECoerceDesc(theItem, typeFSRef, &desc);
if (error == noErr)
{
FSRef fileRef;
error = AEGetDescData(&desc, &fileRef, sizeof(fileRef));
if (error == noErr)
{
LSItemInfoRecord fileInfo;
error = LSCopyItemInfoForRef(&fileRef, kLSRequestExtension | kLSRequestTypeCreator, &fileInfo);
if (error == noErr)
{
if (filter == FFLOAD_IMAGE)
{
if (fileInfo.filetype != 'JPEG' && fileInfo.filetype != 'JPG ' &&
fileInfo.filetype != 'BMP ' && fileInfo.filetype != 'TGA ' &&
fileInfo.filetype != 'BMPf' && fileInfo.filetype != 'TPIC' &&
fileInfo.filetype != 'PNG ' &&
(fileInfo.extension && (CFStringCompare(fileInfo.extension, CFSTR("jpeg"), kCFCompareCaseInsensitive) != kCFCompareEqualTo &&
CFStringCompare(fileInfo.extension, CFSTR("jpg"), kCFCompareCaseInsensitive) != kCFCompareEqualTo &&
CFStringCompare(fileInfo.extension, CFSTR("bmp"), kCFCompareCaseInsensitive) != kCFCompareEqualTo &&
CFStringCompare(fileInfo.extension, CFSTR("tga"), kCFCompareCaseInsensitive) != kCFCompareEqualTo &&
CFStringCompare(fileInfo.extension, CFSTR("png"), kCFCompareCaseInsensitive) != kCFCompareEqualTo))
)
{
result = false;
}
}
else if (filter == FFLOAD_WAV)
{
if (fileInfo.filetype != 'WAVE' && fileInfo.filetype != 'WAV ' &&
(fileInfo.extension && (CFStringCompare(fileInfo.extension, CFSTR("wave"), kCFCompareCaseInsensitive) != kCFCompareEqualTo &&
CFStringCompare(fileInfo.extension, CFSTR("wav"), kCFCompareCaseInsensitive) != kCFCompareEqualTo))
)
{
result = false;
}
}
else if (filter == FFLOAD_ANIM)
{
if (fileInfo.filetype != 'BVH ' &&
(fileInfo.extension && (CFStringCompare(fileInfo.extension, CFSTR("bvh"), kCFCompareCaseInsensitive) != kCFCompareEqualTo))
)
{
result = false;
}
}
#ifdef _CORY_TESTING
else if (filter == FFLOAD_GEOMETRY)
{
if (fileInfo.filetype != 'SLG ' &&
(fileInfo.extension && (CFStringCompare(fileInfo.extension, CFSTR("slg"), kCFCompareCaseInsensitive) != kCFCompareEqualTo))
)
{
result = false;
}
}
#endif
else if (filter == FFLOAD_SLOBJECT)
{
llwarns << "*** navOpenFilterProc: FFLOAD_SLOBJECT NOT IMPLEMENTED ***" << llendl;
}
else if (filter == FFLOAD_RAW)
{
if (fileInfo.filetype != '\?\?\?\?' &&
(fileInfo.extension && (CFStringCompare(fileInfo.extension, CFSTR("raw"), kCFCompareCaseInsensitive) != kCFCompareEqualTo))
)
{
result = false;
}
}
if (fileInfo.extension)
{
CFRelease(fileInfo.extension);
}
}
}
AEDisposeDesc(&desc);
}
}
}
return result;
}
void userActionCallback ( NavCBRecPtr callBackParms ) {
OSStatus err;
long int n;
NavReplyRecord * nReply = new NavReplyRecord;
err = NavDialogGetReply ( callBackParms->context, nReply );
if ( err != noErr ) {
NavDisposeReply( nReply );
return;
}
NavUserAction userAction;
userAction = NavDialogGetUserAction( callBackParms->context );
switch ( userAction ) {
case kNavUserActionOpen:
AECountItems( &(nReply->selection), &n ) ;
if ( n != 0 ) {
AEKeyword aeKey;
AEDesc record;
FSRef fref;
char newfilename[512];
openfD = new fileData();
fileData * newfD = openfD;
for ( int i = 0; i < n ; i++ ) {
if ( i != 0 ) {
newfD->next = new fileData();
newfD = newfD->next;
}
AEGetNthDesc (&(nReply->selection), i+1, typeFSRef, &aeKey, &record );
err = AEGetDescData( &record, ( void * )( &fref ), sizeof( FSRef ) );
FSRefMakePath( &fref, (UInt8*)newfilename, 512);
fprintf(stderr, "open: %s\n", newfilename );
newfD->fileName = newfilename;
newfD->isDir = false;
}
}
break;
case kNavUserActionSaveAs:
AECountItems( &(nReply->selection), &n ) ;
if ( n != 0 ) {
AEKeyword aeKey;
AEDesc record;
FSRef fref;
char newfilename[512];
char fileSaveName[512];
savefD = new fileData();
for ( int i = 0; i < n ; i++ ) {
AEGetNthDesc (&(nReply->selection), i+1, typeFSRef, &aeKey, &record );
err = AEGetDescData( &record, ( void * )( &fref ), sizeof( FSRef ) );
FSRefMakePath( &fref, (UInt8*)newfilename, 512);
fprintf(stderr, "save: %s\n", newfilename );
savefD->fileName = newfilename;
savefD->isDir = false;
const char * fname = CFStringGetCStringPtr( nReply->saveFileName, kCFStringEncodingASCII );
if ( fname ) {
fprintf(stderr, "file is %s\n", fname);
savefD->fileName += "/";
savefD->fileName += fname;
}
else {
CFStringGetCString ( nReply->saveFileName, (char*)fileSaveName, 512, kCFStringEncodingASCII );
savefD->fileName += "/";
savefD->fileName += fileSaveName;
fprintf(stderr, "no filename given\n");
}
}
}
break;
}
NavDisposeReply( nReply );
}
PPOpenPanel::ReturnCodes PPOpenPanel::runModal()
{
ReturnCodes result = ReturnCodeCANCEL;
OSStatus err = noErr;
NavDialogRef theOpenDialog;
NavDialogCreationOptions dialogOptions;
if ((err = NavGetDefaultDialogCreationOptions(&dialogOptions)) == noErr)
{
dialogOptions.modality = kWindowModalityAppModal;
dialogOptions.windowTitle = CFStringCreateWithCString(NULL, caption, kCFStringEncodingASCII);
err = NavCreateChooseFileDialog(&dialogOptions, NULL, NULL, NULL, NULL, NULL, &theOpenDialog);
if (theOpenDialog)
{
err = NavDialogRun(theOpenDialog);
NavReplyRecord reply;
err = NavDialogGetReply (theOpenDialog, &reply);
if (err == noErr)
{
// retrieve filename
AEDesc actualDesc;
FSRef fileToOpen;
//HFSUniStr255 theFileName;
//CFStringRef fileNameCFString;
err = AECoerceDesc(&reply.selection, typeFSRef, &actualDesc);
err = AEGetDescData(&actualDesc, reinterpret_cast<void*>(&fileToOpen), sizeof(FSRef));
// gib ihm
int len = PATH_MAX;
char* buffer = new char[PATH_MAX+1];
FSRefMakePath (&fileToOpen, (UInt8*)buffer, len);
fileName = buffer;
delete[] buffer;
result = ReturnCodeOK;
NavDisposeReply(&reply);
}
NavDialogDispose(theOpenDialog);
}
if (dialogOptions.windowTitle)
CFRelease(dialogOptions.windowTitle);
}
return result;
}
static PyObject *AE_AddressDescToPath(PyObject *_self, PyObject *_args)
{
AEDesc desc;
ProcessSerialNumber psn;
pid_t pid;
OSType creatorType = kLSUnknownCreator;
Size cSize;
char *cStr;
CFStringRef bundleID = NULL;
FSRef fsref;
UInt8 path[PATH_MAX];
PyObject* pathObj;
OSStatus err;
if (!PyArg_ParseTuple(_args, "O&",
AE_AEDesc_Convert, &desc))
return NULL;
switch (desc.descriptorType) {
case typeKernelProcessID:
err = AEGetDescData(&desc, &pid, sizeof(pid));
if (err) return AE_MacOSError(err);
err = GetProcessForPID(pid, &psn);
if (err) return AE_MacOSError(err);
err = GetProcessBundleLocation(&psn, &fsref);
if (err) return AE_MacOSError(err);
break;
case typeProcessSerialNumber:
err = AEGetDescData(&desc, &psn, sizeof(psn));
if (err) return AE_MacOSError(err);
err = GetProcessBundleLocation(&psn, &fsref);
if (err) return AE_MacOSError(err);
break;
case typeApplSignature:
err = AEGetDescData(&desc, &creatorType, sizeof(creatorType));
if (err) return AE_MacOSError(err);
err = LSFindApplicationForInfo(creatorType, bundleID, NULL, &fsref, NULL);
if (err) return AE_MacOSError(err);
break;
case typeApplicationBundleID:
cSize = AEGetDescDataSize(&desc);
cStr = malloc((size_t)cSize);
if (!cStr) return AE_MacOSError(errAECoercionFail);
err = AEGetDescData(&desc, cStr, cSize);
if (err) return AE_MacOSError(err);
bundleID = CFStringCreateWithBytes(NULL, (UInt8 *)cStr, (CFIndex)cSize, kCFStringEncodingUTF8, 0);
free(cStr);
if (!bundleID) return AE_MacOSError(errAECoercionFail);
err = LSFindApplicationForInfo(creatorType, bundleID, NULL, &fsref, NULL);
if (err) return AE_MacOSError(err);
break;
case typeMachPort: // unsupported
case typeApplicationURL: // unsupported (remote applications)
default:
return AE_MacOSError(errAECoercionFail);
}
err = FSRefMakePath(&fsref, path, sizeof(path));
if (err) return AE_MacOSError(err);
pathObj = PyUnicode_DecodeUTF8((char *)path, strlen((char *)path), NULL);
return Py_BuildValue("O", pathObj);
}
static OSStatus DoFSRefSave(const OurSaveDialogData *dialogDataP,
NavReplyRecord* reply, AEDesc *actualDescP)
{
OSStatus err = noErr;
FSRef fileRefParent;
if ((err = AEGetDescData( actualDescP, &fileRefParent, sizeof( FSRef ) )) == noErr )
{
// get the name data and its length:
HFSUniStr255 nameBuffer;
UniCharCount sourceLength = 0;
sourceLength = (UniCharCount)CFStringGetLength( reply->saveFileName );
CFStringGetCharacters( reply->saveFileName, CFRangeMake( 0, sourceLength ),
(UniChar*)&nameBuffer.unicode );
if ( sourceLength > 0 )
{
if ( reply->replacing )
{
// delete the file we are replacing:
FSRef fileToDelete;
if ((err = FSMakeFSRefUnicode( &fileRefParent, sourceLength, nameBuffer.unicode,
kTextEncodingUnicodeDefault, &fileToDelete )) == noErr )
{
err = FSDeleteObject( &fileToDelete );
if ( err == fBsyErr ){
DoErrorAlert(fBsyErr, kMyDeleteErrorFormatStrKey);
}
}
}
if ( err == noErr )
{
// create the file based on Unicode, but we can write the file's data with an FSSpec:
FSSpec newFileSpec;
// get the FSSpec back so we can write the file's data
if ((err = FSCreateFileUnicode( &fileRefParent, sourceLength,
nameBuffer.unicode,
kFSCatInfoNone,
NULL,
NULL,
&newFileSpec)) == noErr)
{
FInfo fileInfo;
fileInfo.fdType = kFileTypePDF;
fileInfo.fdCreator = kFileCreator;
err = FSpSetFInfo( &newFileSpec, &fileInfo );
// now that we have the FSSpec, we can proceed with the save operation:
if(!err){
FSRef fsRef;
err = FSpMakeFSRef(&newFileSpec, &fsRef); // make an FSRef
if(!err){
CFURLRef saveURL = CFURLCreateFromFSRef(NULL, &fsRef);
if(saveURL){
// delete the file we just made for making the FSRef
err = FSpDelete(&newFileSpec);
if(!err)
err = MakePDFDocument(dialogDataP->parentWindow,
dialogDataP->documentDataP,
saveURL);
if(!err)
err = NavCompleteSave( reply, kNavTranslateInPlace );
if(err){
// an error ocurred saving the file, so delete the copy
// left over:
(void)FSpDelete( &newFileSpec );
DoErrorAlert(err, kMyWriteErrorFormatStrKey);
}
CFRelease(saveURL);
}else{
// delete the file we just made for making the FSRe
(void)FSpDelete(&newFileSpec);
err = kCantCreateSaveURL;
DoErrorAlert(err, kMyCreateURLErrorFormatStrKey);
}
}
}
}
}
}
}
return err;
}
OSErr _hs_getData(const AEDesc* input, void* dataPtr, size_t maxSize) {
AEGetDescData(input, dataPtr, maxSize);
}
void AddRecordedEvents(PRECORDER_PARM prec, OSAEvent *ptheEvent)
{
HWND hwndMle = WinWindowFromID(prec->hwnd, IDD_ODDISPLAYEVENTS);
PCHAR pszMleBuf = NULL;
IPT lOffset = 0;
ULONG cbCopied;
ULONG ulAction;
ULONG cbLength;
ULONG bufSize = 1024;
ULONG dataSize = 0;
AEDesc result;
PID pid;
Size size;
CHAR szAppName[CCHMAXPATH];
ULONG cbAppName = CCHMAXPATH;
ULONG eventClass;
ULONG eventID;
PSZ pszTemp;
DescType dtype;
OSErr err;
pszMleBuf = (PCHAR) calloc(1,bufSize);
/* Zero-fill the buffer using memset, a C run-time function */
memset(pszMleBuf, 0, bufSize);
/* Set the MLE import-export buffer */
WinSendMsg(hwndMle,
MLM_SETIMPORTEXPORT,
MPFROMP(pszMleBuf),
MPFROMSHORT((USHORT) bufSize));
/* Find out how much text is in the MLE */
cbLength = (ULONG) WinSendMsg(hwndMle,
MLM_QUERYFORMATTEXTLENGTH,
MPFROMLONG(lOffset),
MPFROMLONG((-1)));
lOffset = cbLength + 1; /* insert text at end */
/* format event into buffer */
//Get the applications PID
err = AEGetAttributeDesc(ptheEvent,keyAddressAttr,typeWildCard,&result);
size = sizeof(PID);
err = AEGetDescData(&result, &dtype, (Ptr) &pid, (Size) sizeof(PID), &size);
AEDisposeDesc(&result);
err = AEGetAppName(pid, szAppName, &cbAppName);
//Get Event class
err = AEGetAttributeDesc(ptheEvent,keyEventClassAttr,typeWildCard,&result);
size = sizeof(ULONG);
err = AEGetDescData(&result, &dtype, (Ptr) &eventClass, (Size) sizeof(ULONG), &size);
AEDisposeDesc(&result);
//Get Event id
err = AEGetAttributeDesc(ptheEvent,keyEventIDAttr,typeWildCard,&result);
size = sizeof(ULONG);
err = AEGetDescData(&result, &dtype, (Ptr) &eventID, (Size) sizeof(ULONG), &size);
AEDisposeDesc(&result);
strcpy(pszMleBuf,"******************************\n");
strcat(pszMleBuf,"\n");
strcat(pszMleBuf, "Application: ");
strcat(pszMleBuf,szAppName);
strcat(pszMleBuf,"\n");
strcat(pszMleBuf,"Event Class: ");
pszTemp = pszMleBuf+strlen(pszMleBuf);
memcpy(pszTemp,&eventClass,sizeof(ULONG));
pszTemp+=sizeof(ULONG);
pszTemp = NULL;
strcat(pszMleBuf,"\n");
strcat(pszMleBuf,"Event ID: ");
pszTemp = pszMleBuf+strlen(pszMleBuf);
memcpy(pszTemp,&eventID,sizeof(ULONG));
pszTemp+=sizeof(ULONG);
pszTemp = NULL;
strcat(pszMleBuf,"\n");
strcat(pszMleBuf,"******************************\n");
dataSize = strlen(pszMleBuf);
cbCopied = (ULONG) WinSendMsg(hwndMle,
MLM_IMPORT,
MPFROMP( &lOffset),
MPFROMLONG(dataSize));
free((PVOID) pszMleBuf);
}
OSStatus BeginSave( NavDialogRef inDialog, NavReplyRecord* outReply, FSRef* outFileRef )
{
OSStatus status = paramErr;
AEDesc dirDesc;
AEKeyword keyword;
CFIndex len;
require( outReply, Return );
require( outFileRef, Return );
status = NavDialogGetReply( inDialog, outReply );
nrequire( status, Return );
status = AEGetNthDesc( &outReply->selection, 1, typeWildCard, &keyword, &dirDesc );
nrequire( status, DisposeReply );
len = CFStringGetLength( outReply->saveFileName );
if ( dirDesc.descriptorType == typeFSRef )
{
const UInt32 kMaxNameLen = 255;
FSRef dirRef;
UniChar name[ kMaxNameLen ];
if ( len > kMaxNameLen )
{
len = kMaxNameLen;
}
status = AEGetDescData( &dirDesc, &dirRef, sizeof( dirRef ));
nrequire( status, DisposeDesc );
CFStringGetCharacters( outReply->saveFileName, CFRangeMake( 0, len ), &name[0] );
status = FSMakeFSRefUnicode( &dirRef, len, &name[0], GetApplicationTextEncoding(), outFileRef );
if (status == fnfErr )
{
// file is not there yet - create it and return FSRef
status = FSCreateFileUnicode( &dirRef, len, &name[0], 0, NULL, outFileRef, NULL );
}
else
{
// looks like file is there. Just make sure there is no error
nrequire( status, DisposeDesc );
}
}
else if ( dirDesc.descriptorType == typeFSS )
{
FSSpec theSpec;
status = AEGetDescData( &dirDesc, &theSpec, sizeof( FSSpec ));
nrequire( status, DisposeDesc );
if ( CFStringGetPascalString( outReply->saveFileName, &(theSpec.name[0]),
sizeof( StrFileName ), GetApplicationTextEncoding()))
{
status = FSpMakeFSRef(&theSpec, outFileRef);
nrequire( status, DisposeDesc );
status = FSpCreate( &theSpec, 0, 0, smSystemScript );
nrequire( status, DisposeDesc );
}
else
{
status = bdNamErr;
nrequire( status, DisposeDesc );
}
}
DisposeDesc:
AEDisposeDesc( &dirDesc );
DisposeReply:
if ( status != noErr )
{
NavDisposeReply( outReply );
}
Return:
return status;
}
static OSErr
ScriptHandler(
const AppleEvent *event,
AppleEvent *reply,
SRefCon handlerRefcon)
{
OSStatus theErr;
AEDescList theDesc;
int tclErr = -1;
Tcl_Interp *interp = (Tcl_Interp *) handlerRefcon;
char errString[128];
/*
* The do script event receives one parameter that should be data or a
* file.
*/
theErr = AEGetParamDesc(event, keyDirectObject, typeWildCard,
&theDesc);
if (theErr != noErr) {
sprintf(errString, "AEDoScriptHandler: GetParamDesc error %d",
(int)theErr);
theErr = AEPutParamPtr(reply, keyErrorString, typeChar, errString,
strlen(errString));
} else if (MissedAnyParameters(event)) {
/*
* Return error if parameter is missing.
*/
sprintf(errString, "AEDoScriptHandler: extra parameters");
AEPutParamPtr(reply, keyErrorString, typeChar, errString,
strlen(errString));
theErr = -1771;
} else if (theDesc.descriptorType == (DescType) typeChar) {
/*
* We've had some data sent to us. Evaluate it.
*/
Tcl_DString encodedText;
short i;
Size size = AEGetDescDataSize(&theDesc);
char *data = ckalloc(size + 1);
AEGetDescData(&theDesc, data, size);
data[size] = 0;
for (i = 0; i < size; i++) {
if (data[i] == '\r') {
data[i] = '\n';
}
}
AEReplaceDescData(theDesc.descriptorType, data, size + 1, &theDesc);
Tcl_ExternalToUtfDString(NULL, data, size, &encodedText);
tclErr = Tcl_EvalEx(interp, Tcl_DStringValue(&encodedText),
Tcl_DStringLength(&encodedText), TCL_EVAL_GLOBAL);
Tcl_DStringFree(&encodedText);
} else if (theDesc.descriptorType == (DescType) typeAlias) {
/*
* We've had a file sent to us. Source it.
*/
Boolean dummy;
FSRef file;
Size theSize = AEGetDescDataSize(&theDesc);
AliasPtr alias = (AliasPtr) ckalloc(theSize);
if (alias) {
AEGetDescData(&theDesc, alias, theSize);
theErr = FSResolveAlias(NULL, &alias, &file, &dummy);
ckfree((char*)alias);
} else {
theErr = memFullErr;
}
if (theErr == noErr) {
Tcl_DString scriptName;
theErr = FSRefToDString(&file, &scriptName);
if (theErr == noErr) {
Tcl_EvalFile(interp, Tcl_DStringValue(&scriptName));
Tcl_DStringFree(&scriptName);
}
} else {
sprintf(errString, "AEDoScriptHandler: file not found");
AEPutParamPtr(reply, keyErrorString, typeChar, errString,
strlen(errString));
}
} else {
/*
* Umm, don't recognize what we've got...
*/
sprintf(errString, "AEDoScriptHandler: invalid script type '%-4.4s',"
" must be 'alis' or 'TEXT'", (char*) &theDesc.descriptorType);
AEPutParamPtr(reply, keyErrorString, typeChar, errString,
strlen(errString));
theErr = -1770;
}
/*
* If we actually go to run Tcl code - put the result in the reply.
*/
if (tclErr >= 0) {
int reslen;
const char *result =
Tcl_GetStringFromObj(Tcl_GetObjResult(interp), &reslen);
if (tclErr == TCL_OK) {
AEPutParamPtr(reply, keyDirectObject, typeChar, result, reslen);
} else {
AEPutParamPtr(reply, keyErrorString, typeChar, result, reslen);
AEPutParamPtr(reply, keyErrorNumber, typeSInt32, (Ptr) &tclErr,
sizeof(int));
}
}
AEDisposeDesc(&theDesc);
return theErr;
}
static OSErr aplEventHdlr(const AppleEvent *thisEvt, AppleEvent *thisReply, SInt32 iRefCon)
{
AEKeyword aeListKeyword;
AEDesc aeContents, aeSubDesc;
SInt32 iAEListLen, i;
FSSpec fileSpec;
FSRef fileRef;
OSErr iErr;
bool bOK;
switch (iRefCon)
{
case FOUR_CHAR_CODE('PREF'):
if (!isPrefsWinVisible()) { showPrefsWin(); }
return noErr;
case FOUR_CHAR_CODE('QUIT'):
return errAEEventNotHandled;
case FOUR_CHAR_CODE('OPEN'):
if (noErr == (iErr = AEGetParamDesc(thisEvt, keyDirectObject, typeFSRef, &aeContents)))
{
/* Direct FSR case (usual for OS X) */
if (noErr != (iErr = AEGetDescData(&aeContents, &fileRef, sizeof(FSRef))))
{
AEDisposeDesc(&aeContents);
fprintf(stderr, "aplEventHdlr() - AEGetDescData() failed (FSRef case), returning %lu!\n", (unsigned long) iErr);
return noErr;
}
attemptOpen(&fileRef); /* See FroggCtrl.cpp */
AEDisposeDesc(&aeContents);
return noErr;
}
if (iErr != errAECoercionFail)
{
fprintf(stderr, "aplEventHdlr() - AEGetParamDesc(typeFSRef) returned %lu, instead of noErr or errAECoercionFail!\n", (unsigned long) iErr);
return noErr;
}
else if (noErr == (iErr = AEGetParamDesc(thisEvt, keyDirectObject, typeFSS, &aeContents)))
{
/* Two-step FSS case (OS9 and Folders) */
if (noErr != (iErr = AEGetDescData(&aeContents, &fileSpec, sizeof(FSSpec))))
{
AEDisposeDesc(&aeContents);
fprintf(stderr, "aplEventHdlr() - AEGetDescData() failed (FSSpec case), returning %lu!\n", (unsigned long) iErr);
return noErr;
}
if (noErr != (iErr = FSpMakeFSRef(&fileSpec, &fileRef)))
{
AEDisposeDesc(&aeContents);
fprintf(stderr, "aplEventHdlr() - FSpMakeFSRef() failed (FSSpec case), returning %lu!\n", (unsigned long) iErr);
return noErr;
}
attemptOpen(&fileRef); /* See FroggCtrl.cpp */
AEDisposeDesc(&aeContents);
return noErr;
}
if (iErr != errAECoercionFail)
{
fprintf(stderr, "aplEventHdlr() - AEGetParamDesc(typeFSS) returned %lu, instead of noErr or errAECoercionFail!\n", (unsigned long) iErr);
return noErr;
}
else if (noErr == (iErr = AEGetParamDesc(thisEvt, keyDirectObject, typeAEList, &aeContents)))
{
/* Last resort: we might have gotten a whole list of files. */
/* Find the first FSRef or FSSpec descriptor in the list if */
/* any, and open that as a single file. */
if (noErr != (iErr = AECountItems(&aeContents, &iAEListLen)))
{
AEDisposeDesc(&aeContents);
fprintf(stderr, "aplEventHdlr() - AECountItems() failed (AEList case), returning %lu!\n", (unsigned long) iErr);
return noErr;
}
bOK = false;
for (i = 0; i < iAEListLen; i++)
{
if (noErr == (iErr = AEGetNthDesc(&aeContents, i, typeFSRef, &aeListKeyword, &aeSubDesc)))
{
/* Found an FSRef object inside the list. */
if (noErr != (iErr = AEGetDescData(&aeSubDesc, &fileRef, sizeof(FSRef))))
{
AEDisposeDesc(&aeSubDesc);
fprintf(stderr, "aplEventHdlr() - AEGetDescData() failed (AEList->FSRef case), returning %lu!\n", (unsigned long) iErr);
break;
}
bOK = true;
attemptOpen(&fileRef); /* See FroggCtrl.cpp */
AEDisposeDesc(&aeSubDesc);
break;
}
else if (noErr == (iErr = AEGetNthDesc(&aeContents, i, typeFSS, &aeListKeyword, &aeSubDesc)))
{
/* Found an FSSpec object inside the list. */
if (noErr != (iErr = AEGetDescData(&aeSubDesc, &fileSpec, sizeof(FSSpec))))
{
AEDisposeDesc(&aeSubDesc);
fprintf(stderr, "aplEventHdlr() - AEGetDescData() failed (AEList->FSSpec case), returning %lu!\n", (unsigned long) iErr);
break;
}
if (noErr != (iErr = FSpMakeFSRef(&fileSpec, &fileRef)))
{
AEDisposeDesc(&aeSubDesc);
fprintf(stderr, "aplEventHdlr() - FSpMakeFSRef() failed (AEList->FSSpec case), returning %lu!\n", (unsigned long) iErr);
break;
}
bOK = true;
attemptOpen(&fileRef); /* See FroggCtrl.cpp */
AEDisposeDesc(&aeSubDesc);
break;
}
}
AEDisposeDesc(&aeContents);
return (bOK ? ((OSErr) noErr) : ((OSErr) errAEEventNotHandled));
}
if (iErr != errAECoercionFail)
{
fprintf(stderr, "aplEventHdlr() - AEGetParamDesc(typeAEList) returned %lu, instead of noErr or errAECoercionFail!\n", (unsigned long) iErr);
return noErr;
}
else
{
/* Umm... what the hell were we sent? */
return errAEEventNotHandled;
}
default:
return errAEEventNotHandled;
}
}
