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; } }