/** * Inspect the global pasteboard for new content. Check if there is some type * that is supported by vbox and return it. * * @param pPasteboardRef Reference to the global pasteboard. * @param pfFormats Pointer for the bit combination of the * supported types. * @param pbChanged True if something has changed after the * last call. * * @returns IPRT status code. (Always VINF_SUCCESS atm.) */ int queryNewPasteboardFormats(PasteboardRef pPasteboard, uint32_t *pfFormats, bool *pfChanged) { Log(("queryNewPasteboardFormats\n")); OSStatus err = noErr; *pfChanged = true; PasteboardSyncFlags syncFlags; /* Make sure all is in sync */ syncFlags = PasteboardSynchronize(pPasteboard); /* If nothing changed return */ if (!(syncFlags & kPasteboardModified)) { *pfChanged = false; return VINF_SUCCESS; } /* Are some items in the pasteboard? */ ItemCount itemCount; err = PasteboardGetItemCount(pPasteboard, &itemCount); if (itemCount < 1) return VINF_SUCCESS; /* The id of the first element in the pasteboard */ int rc = VINF_SUCCESS; PasteboardItemID itemID; if (!(err = PasteboardGetItemIdentifier(pPasteboard, 1, &itemID))) { /* Retrieve all flavors in the pasteboard, maybe there * is something we can use. */ CFArrayRef flavorTypeArray; if (!(err = PasteboardCopyItemFlavors(pPasteboard, itemID, &flavorTypeArray))) { CFIndex flavorCount; flavorCount = CFArrayGetCount(flavorTypeArray); for (CFIndex flavorIndex = 0; flavorIndex < flavorCount; flavorIndex++) { CFStringRef flavorType; flavorType = static_cast <CFStringRef>(CFArrayGetValueAtIndex(flavorTypeArray, flavorIndex)); /* Currently only unicode supported */ if (UTTypeConformsTo(flavorType, kUTTypeUTF8PlainText) || UTTypeConformsTo(flavorType, kUTTypeUTF16PlainText)) { Log(("Unicode flavor detected.\n")); *pfFormats |= VBOX_SHARED_CLIPBOARD_FMT_UNICODETEXT; } else if (UTTypeConformsTo(flavorType, kUTTypeBMP)) { Log(("BMP flavor detected.\n")); *pfFormats |= VBOX_SHARED_CLIPBOARD_FMT_BITMAP; } } CFRelease(flavorTypeArray); } } Log(("queryNewPasteboardFormats: rc = %02X\n", rc)); return rc; }
bool wxDataFormat::operator==(const wxDataFormat& format) const { if (IsStandard() || format.IsStandard()) return ( format.m_type == m_type ); else return ( UTTypeConformsTo( (CFStringRef) m_format , (CFStringRef) format.m_format ) ); }
char* _applegetsnarf(void) { char *s, *t; CFArrayRef flavors; CFDataRef data; CFIndex nflavor, ndata, j; CFStringRef type; ItemCount nitem; PasteboardItemID id; PasteboardSyncFlags flags; UInt32 i; /* fprint(2, "applegetsnarf\n"); */ qlock(&clip.lk); if(clip.apple == nil){ if(PasteboardCreate(kPasteboardClipboard, &clip.apple) != noErr){ fprint(2, "apple pasteboard create failed\n"); qunlock(&clip.lk); return nil; } } flags = PasteboardSynchronize(clip.apple); if(flags&kPasteboardClientIsOwner){ s = strdup(clip.buf); qunlock(&clip.lk); return s; } if(PasteboardGetItemCount(clip.apple, &nitem) != noErr){ fprint(2, "apple pasteboard get item count failed\n"); qunlock(&clip.lk); return nil; } for(i=1; i<=nitem; i++){ if(PasteboardGetItemIdentifier(clip.apple, i, &id) != noErr) continue; if(PasteboardCopyItemFlavors(clip.apple, id, &flavors) != noErr) continue; nflavor = CFArrayGetCount(flavors); for(j=0; j<nflavor; j++){ type = (CFStringRef)CFArrayGetValueAtIndex(flavors, j); if(!UTTypeConformsTo(type, CFSTR("public.utf16-plain-text"))) continue; if(PasteboardCopyItemFlavorData(clip.apple, id, type, &data) != noErr) continue; ndata = CFDataGetLength(data); qunlock(&clip.lk); s = smprint("%.*S", ndata/2, (Rune*)CFDataGetBytePtr(data)); CFRelease(flavors); CFRelease(data); for(t=s; *t; t++) if(*t == '\r') *t = '\n'; return s; } CFRelease(flavors); } qunlock(&clip.lk); return nil; }
static bool isPackage(const QFileSystemMetaData &data, const QFileSystemEntry &entry) { if (!data.isDirectory()) return false; QFileInfo info(entry.filePath()); QString suffix = info.suffix(); if (suffix.length() > 0) { // First step: is the extension known ? CFStringRef extensionRef = QCFString::toCFStringRef(suffix); CFStringRef uniformTypeIdentifier = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, extensionRef, NULL); if (UTTypeConformsTo(uniformTypeIdentifier, kUTTypeBundle)) return true; // Second step: check if an application knows the package type CFStringRef path = QCFString::toCFStringRef(entry.filePath()); QCFType<CFURLRef> url = CFURLCreateWithFileSystemPath(0, path, kCFURLPOSIXPathStyle, true); UInt32 type, creator; // Well created packages have the PkgInfo file if (CFBundleGetPackageInfoInDirectory(url, &type, &creator)) return true; // Find if an application other than Finder claims to know how to handle the package QCFType<CFURLRef> application; LSGetApplicationForURL(url, kLSRolesEditor|kLSRolesViewer|kLSRolesViewer, NULL, &application); if (application) { QCFType<CFBundleRef> bundle = CFBundleCreate(kCFAllocatorDefault, application); CFStringRef identifier = CFBundleGetIdentifier(bundle); QString applicationId = QCFString::toQString(identifier); if (applicationId != QLatin1String("com.apple.finder")) return true; } } // Third step: check if the directory has the package bit set FSRef packageRef; FSPathMakeRef((UInt8 *)entry.nativeFilePath().constData(), &packageRef, NULL); FSCatalogInfo catalogInfo; FSGetCatalogInfo(&packageRef, kFSCatInfoFinderInfo, &catalogInfo, NULL, NULL, NULL); FolderInfo *folderInfo = reinterpret_cast<FolderInfo *>(catalogInfo.finderInfo); return folderInfo->finderFlags & kHasBundle; }
void wxDataFormat::SetId( NativeFormat format ) { if ( m_format != 0 ) { CFRelease( (CFStringRef) m_format ); m_format = 0; } m_format = (NativeFormat) CFStringCreateCopy(NULL, (CFStringRef)format); if ( UTTypeConformsTo( (CFStringRef)format, kUTTypeHTML ) ) { m_type = wxDF_HTML; } if ( UTTypeConformsTo( (CFStringRef)format, kUTTypeUTF16PlainText ) ) { m_type = wxDF_UNICODETEXT; } else if ( UTTypeConformsTo( (CFStringRef)format,kUTTypeUTF16ExternalPlainText ) ) { m_type = wxDF_UNICODETEXT; } else if ( UTTypeConformsTo( (CFStringRef)format,kUTTypeUTF8PlainText ) ) { m_type = wxDF_UNICODETEXT; } else if ( UTTypeConformsTo( (CFStringRef)format, kUTTypePlainText ) ) { m_type = wxDF_TEXT; } else if ( UTTypeConformsTo( (CFStringRef)format, kUTTypeImage ) ) { m_type = wxDF_BITMAP; } else if ( UTTypeConformsTo( (CFStringRef)format, kUTTypePDF ) ) { m_type = wxDF_METAFILE; } else if ( UTTypeConformsTo( (CFStringRef)format, kUTTypeFileURL ) || UTTypeConformsTo( (CFStringRef)format, kPasteboardTypeFileURLPromise)) { m_type = wxDF_FILENAME; } else { m_type = wxDF_PRIVATE; m_id = wxCFStringRef( (CFStringRef) CFRetain((CFStringRef) format )).AsString(); } }
std::string copy_from_clipboard(const bool) { OSStatus err = noErr; PasteboardRef clipboard; PasteboardSyncFlags syncFlags; ItemCount count; err = PasteboardCreate(kPasteboardClipboard, &clipboard); if (err != noErr) return ""; syncFlags = PasteboardSynchronize(clipboard); if (syncFlags&kPasteboardModified) return ""; err = PasteboardGetItemCount(clipboard, &count); if (err != noErr) return ""; for (UInt32 k = 1; k <= count; k++) { PasteboardItemID itemID; CFArrayRef flavorTypeArray; CFIndex flavorCount; err = PasteboardGetItemIdentifier(clipboard, k, &itemID); if (err != noErr) return ""; err = PasteboardCopyItemFlavors(clipboard, itemID, &flavorTypeArray); if (err != noErr) return ""; flavorCount = CFArrayGetCount(flavorTypeArray); for (CFIndex j = 0; j < flavorCount; j++) { CFStringRef flavorType; CFDataRef flavorData; CFIndex flavorDataSize; flavorType = (CFStringRef)CFArrayGetValueAtIndex(flavorTypeArray, j); if (UTTypeConformsTo(flavorType, CFSTR("public.utf8-plain-text"))) { err = PasteboardCopyItemFlavorData(clipboard, itemID, flavorType, &flavorData); if (err != noErr) { CFRelease(flavorTypeArray); return ""; } flavorDataSize = CFDataGetLength(flavorData); std::string str; str.reserve(flavorDataSize); str.resize(flavorDataSize); CFDataGetBytes(flavorData, CFRangeMake(0, flavorDataSize), (UInt8 *)str.data()); for (unsigned int i = 0; i < str.size(); ++i) { if (str[i] == '\r') str[i] = '\n'; } return str; } } } return ""; }
static bool isPackage(const QFileSystemMetaData &data, const QFileSystemEntry &entry) { if (!data.isDirectory()) return false; QFileInfo info(entry.filePath()); QString suffix = info.suffix(); if (suffix.length() > 0) { // First step: is the extension known ? QCFType<CFStringRef> extensionRef = QCFString::toCFStringRef(suffix); QCFType<CFStringRef> uniformTypeIdentifier = UTTypeCreatePreferredIdentifierForTag(kUTTagClassFilenameExtension, extensionRef, NULL); if (UTTypeConformsTo(uniformTypeIdentifier, kUTTypeBundle)) return true; // Second step: check if an application knows the package type QCFType<CFStringRef> path = QCFString::toCFStringRef(entry.filePath()); QCFType<CFURLRef> url = CFURLCreateWithFileSystemPath(0, path, kCFURLPOSIXPathStyle, true); UInt32 type, creator; // Well created packages have the PkgInfo file if (CFBundleGetPackageInfoInDirectory(url, &type, &creator)) return true; #ifdef Q_OS_OSX // Find if an application other than Finder claims to know how to handle the package QCFType<CFURLRef> application; LSGetApplicationForURL(url, kLSRolesEditor|kLSRolesViewer|kLSRolesViewer, NULL, &application); if (application) { QCFType<CFBundleRef> bundle = CFBundleCreate(kCFAllocatorDefault, application); CFStringRef identifier = CFBundleGetIdentifier(bundle); QString applicationId = QCFString::toQString(identifier); if (applicationId != QLatin1String("com.apple.finder")) return true; } #endif } // Third step: check if the directory has the package bit set return hasResourcePropertyFlag(data, entry, kCFURLIsPackageKey); }
char *TCOD_sys_clipboard_get() { PasteboardSyncFlags syncFlags; ItemCount itemCount; PasteboardRef clipboard; UInt32 itemIndex; if (PasteboardCreate(kPasteboardClipboard, &clipboard) != noErr) return NULL; syncFlags = PasteboardSynchronize(clipboard); if (PasteboardGetItemCount(clipboard, &itemCount) != noErr) return NULL; if (itemCount == 0) return NULL; for(itemIndex = 1; itemIndex <= itemCount; itemIndex++) { PasteboardItemID itemID; CFArrayRef flavorTypeArray; CFIndex flavorCount; CFIndex flavorIndex; if (PasteboardGetItemIdentifier(clipboard, itemIndex, &itemID ) != noErr) return NULL; if (PasteboardCopyItemFlavors(clipboard, itemID, &flavorTypeArray) != noErr) return NULL; flavorCount = CFArrayGetCount(flavorTypeArray); for(flavorIndex = 0; flavorIndex < flavorCount; flavorIndex++) { CFStringRef flavorType; CFDataRef flavorData; CFIndex flavorDataSize; flavorType = (CFStringRef)CFArrayGetValueAtIndex(flavorTypeArray, flavorIndex); if (UTTypeConformsTo(flavorType, CFSTR("public.plain-text"))) { if (PasteboardCopyItemFlavorData(clipboard, itemID, flavorType, &flavorData) != noErr) { CFRelease(flavorData); return NULL; } flavorDataSize = CFDataGetLength( flavorData ); flavorDataSize = (flavorDataSize<254) ? flavorDataSize : 254; short dataIndex; for(dataIndex = 0; dataIndex <= flavorDataSize; dataIndex++) { clipboardText[dataIndex] = *(CFDataGetBytePtr(flavorData) + dataIndex); } clipboardText[flavorDataSize] = '\0'; clipboardText[flavorDataSize+1] = '\n'; CFRelease (flavorData); } } } return clipboardText; }
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 int Internal_isType(SDL_RWops* rw_ops, CFStringRef uti_string_to_test) { CGImageSourceRef image_source; CFStringRef uti_type; Boolean is_type; CFDictionaryRef hint_dictionary = NULL; hint_dictionary = CreateHintDictionary(uti_string_to_test); image_source = CreateCGImageSourceFromRWops(rw_ops, hint_dictionary); if(hint_dictionary != NULL) { CFRelease(hint_dictionary); } if(NULL == image_source) { return 0; } // This will get the UTI of the container, not the image itself. // Under most cases, this won't be a problem. // But if a person passes an icon file which contains a bmp, // the format will be of the icon file. // But I think the main SDL_image codebase has this same problem so I'm not going to worry about it. uti_type = CGImageSourceGetType(image_source); // CFShow(uti_type); // Unsure if we really want conformance or equality is_type = UTTypeConformsTo(uti_string_to_test, uti_type); CFRelease(image_source); return (int)is_type; }
void wxDataFormat::SetId( NativeFormat format ) { if ( m_format != 0 ) { CFRelease( (CFStringRef) m_format ); m_format = 0; } m_format = (NativeFormat) CFStringCreateCopy(NULL, (CFStringRef)format); if ( UTTypeConformsTo( (CFStringRef)format, CFSTR("public.utf16-plain-text") ) ) { m_type = wxDF_UNICODETEXT; } else if ( UTTypeConformsTo( (CFStringRef)format, CFSTR("public.plain-text") ) ) { m_type = wxDF_TEXT; } #if wxMAC_USE_CORE_GRAPHICS else if ( UTTypeConformsTo( (CFStringRef)format, CFSTR("public.tiff") ) ) { m_type = wxDF_BITMAP; } else if ( UTTypeConformsTo( (CFStringRef)format, CFSTR("com.adobe.pdf") ) ) { m_type = wxDF_METAFILE; } #else else if ( UTTypeConformsTo( (CFStringRef)format, CFSTR("com.apple.pict") ) ) { m_type = wxDF_METAFILE; } #endif else if ( UTTypeConformsTo( (CFStringRef)format, CFSTR("public.file-url") ) ) { m_type = wxDF_FILENAME; } else { m_type = wxDF_PRIVATE; m_id = wxMacCFStringHolder( (CFStringRef) CFRetain((CFStringRef) format )).AsString(); } }
oop QuartzWindow::get_scrap_text() { // See Pasteboard Manager Programming guide PasteboardRef clipboard; PasteboardSyncFlags syncFlags; CFDataRef textData = NULL; ItemCount itemCount; if ( PasteboardCreate(kPasteboardClipboard, &clipboard) != noErr || (PasteboardSynchronize(clipboard) & kPasteboardModified) || PasteboardGetItemCount(clipboard, &itemCount) != noErr ) return new_string("", 0); for( UInt32 itemIndex = 1; itemIndex <= itemCount; itemIndex++ ) { PasteboardItemID itemID = 0; CFArrayRef flavorTypeArray = NULL; CFIndex flavorCount = 0; if (PasteboardGetItemIdentifier(clipboard, itemIndex, &itemID) != noErr) continue; if (PasteboardCopyItemFlavors(clipboard, itemID, &flavorTypeArray) != noErr) continue; flavorCount = CFArrayGetCount(flavorTypeArray); for(CFIndex flavorIndex = 0; flavorIndex < flavorCount; flavorIndex++) { CFStringRef flavorType; CFDataRef flavorData; CFIndex flavorDataSize; char flavorText[256]; flavorType = (CFStringRef)CFArrayGetValueAtIndex( flavorTypeArray,// 6 flavorIndex ); if (UTTypeConformsTo(flavorType, kUTTypeOldMacText)) { if (PasteboardCopyItemFlavorData(clipboard, itemID, flavorType, &flavorData) != noErr) continue; flavorDataSize = CFDataGetLength(flavorData); // allocate new string. byteVectorOop r = Memory->byteVectorObj->cloneSize(flavorDataSize, CANFAIL); if (r->is_mark()) { CFRelease (flavorData); CFRelease (flavorTypeArray); return new_string("", 0); } // copy over CFDataGetBytes(flavorData, CFRangeMake(0,CFDataGetLength(flavorData)), (UInt8 *)r->bytes()); CFRelease(flavorData); CFRelease(flavorTypeArray); return r; } // else try next } CFRelease(flavorTypeArray); } }
bool wxDataObject::GetFromPasteboard( void * pb ) { PasteboardRef pasteboard = (PasteboardRef) pb; size_t formatcount = GetFormatCount() + 1; wxDataFormat *array = new wxDataFormat[ formatcount ]; array[0] = GetPreferredFormat(); GetAllFormats( &array[1] ); ItemCount itemCount = 0; wxString filenamesPassed; bool transferred = false; // we synchronize here once again, so we don't mind which flags get returned PasteboardSynchronize( pasteboard ); OSStatus err = PasteboardGetItemCount( pasteboard, &itemCount ); if ( err == noErr ) { for (size_t i = 0; !transferred && i < formatcount; i++) { // go through the data in our order of preference wxDataFormat dataFormat = array[ i ]; for( UInt32 itemIndex = 1; itemIndex <= itemCount && transferred == false ; itemIndex++ ) { PasteboardItemID itemID = 0; CFArrayRef flavorTypeArray = NULL; CFIndex flavorCount = 0; err = PasteboardGetItemIdentifier( pasteboard, itemIndex, &itemID ); if ( err != noErr ) continue; err = PasteboardCopyItemFlavors( pasteboard, itemID, &flavorTypeArray ); if ( err != noErr ) continue; flavorCount = CFArrayGetCount( flavorTypeArray ); for( CFIndex flavorIndex = 0; !transferred && flavorIndex < flavorCount ; flavorIndex++ ) { CFStringRef flavorType; CFDataRef flavorData; CFIndex flavorDataSize; flavorType = (CFStringRef)CFArrayGetValueAtIndex( flavorTypeArray, flavorIndex ); // avoid utf8 being treated closer to plain-text than unicode by forcing a conversion if ( UTTypeConformsTo(flavorType, CFSTR("public.utf8-plain-text") ) ) { flavorType = CFSTR("public.utf16-plain-text"); } wxDataFormat flavorFormat( (wxDataFormat::NativeFormat) flavorType ); if ( dataFormat == flavorFormat ) { err = PasteboardCopyItemFlavorData( pasteboard, itemID, flavorType , &flavorData ); if ( err == noErr ) { flavorDataSize = CFDataGetLength( flavorData ); if (dataFormat.GetType() == wxDF_FILENAME ) { // revert the translation and decomposition to arrive at a proper utf8 string again CFURLRef url = CFURLCreateWithBytes( kCFAllocatorDefault, CFDataGetBytePtr( flavorData ), flavorDataSize, kCFStringEncodingUTF8, NULL ); CFStringRef cfString = CFURLCopyFileSystemPath( url, kCFURLPOSIXPathStyle ); CFRelease( url ); CFMutableStringRef cfMutableString = CFStringCreateMutableCopy(NULL, 0, cfString); CFRelease( cfString ); CFStringNormalize(cfMutableString,kCFStringNormalizationFormC); wxString path = wxMacCFStringHolder(cfMutableString).AsString(); if (!path.empty()) filenamesPassed += path + wxT("\n"); } else { // because some data implementation expect trailing a trailing NUL, we add some headroom void *buf = malloc( flavorDataSize + 4 ); if ( buf ) { memset( buf, 0, flavorDataSize + 4 ); memcpy( buf, CFDataGetBytePtr( flavorData ), flavorDataSize ); if (dataFormat.GetType() == wxDF_TEXT) wxMacConvertNewlines10To13( (char*) buf ); SetData( flavorFormat, flavorDataSize, buf ); transferred = true; free( buf ); } } CFRelease (flavorData); } } else if ( dataFormat.GetType() == wxDF_UNICODETEXT && flavorFormat.GetType() == wxDF_TEXT ) { err = PasteboardCopyItemFlavorData( pasteboard, itemID, flavorType, &flavorData ); if ( err == noErr ) { flavorDataSize = CFDataGetLength( flavorData ); void *asciibuf = malloc( flavorDataSize + 1 ); if ( asciibuf ) { memset( asciibuf, 0, flavorDataSize + 1 ); memcpy( asciibuf, CFDataGetBytePtr( flavorData ), flavorDataSize ); CFRelease (flavorData); SetData( wxDF_TEXT, flavorDataSize, asciibuf ); transferred = true; free( asciibuf ); } else CFRelease (flavorData); } } } CFRelease( flavorTypeArray ); } if (filenamesPassed.length() > 0) { wxCharBuffer buf = filenamesPassed.fn_str(); SetData( wxDF_FILENAME, strlen( buf ), (const char*)buf ); transferred = true; } } } return transferred; }
//****************************************************************************** bool CClipboard::GetString( //Copies the system clipboard string into sClip //Returns: true on success, false otherwise. // //Params: string& sClip) //(out) { #ifdef WIN32 if (!OpenClipboard(NULL)) return false; HGLOBAL global = GetClipboardData(CF_TEXT); if (global == NULL) { CloseClipboard(); return false; } LPSTR data = (LPSTR)GlobalLock(global); sClip = data; GlobalUnlock(global); CloseClipboard(); return true; #elif defined(__linux__) || defined(__FreeBSD__) string u8clip; bool bSuccess; if ((bSuccess = GetStringUTF8(u8clip))) UTF8ToAscii(u8clip.c_str(), u8clip.length(), sClip); return bSuccess; #elif defined __APPLE__ ItemCount itemCount; PasteboardRef theClipboard; OSStatus err = PasteboardCreate(kPasteboardClipboard, &theClipboard); if (err != noErr) return false; PasteboardSynchronize( theClipboard ); PasteboardGetItemCount( theClipboard, &itemCount ); UInt32 itemIndex = 1; // should be 1 or the itemCount? PasteboardItemID itemID; CFArrayRef flavorTypeArray; CFIndex flavorCount; PasteboardGetItemIdentifier( theClipboard, itemIndex, &itemID ); PasteboardCopyItemFlavors( theClipboard, itemID, &flavorTypeArray ); flavorCount = CFArrayGetCount( flavorTypeArray ); for(CFIndex flavorIndex = 0 ; flavorIndex < flavorCount; flavorIndex++ ) { CFStringRef flavorType = (CFStringRef)CFArrayGetValueAtIndex( flavorTypeArray, flavorIndex ); if (UTTypeConformsTo(flavorType, CFSTR("public.utf8-plain-text"))) { CFDataRef flavorData; PasteboardCopyItemFlavorData( theClipboard, itemID,flavorType, &flavorData ); CFIndex flavorDataSize = CFDataGetLength( flavorData ); sClip.resize(flavorDataSize); memcpy(&sClip[0], flavorData, flavorDataSize); CFRelease (flavorData); break; } } CFRelease (flavorTypeArray); return true; #elif defined(__native_client__) return false; #else #warning How do you get system clipboard data on this system? return false; #endif }
static pascal OSStatus MultiCartPaneEventHandler (EventHandlerCallRef inHandlerRef, EventRef inEvent, void *inUserData) { OSStatus err, result = eventNotHandledErr; HIViewRef view; DragRef drag; PasteboardRef pasteboard; PasteboardItemID itemID; CFArrayRef array; CFStringRef flavorType; CFIndex numFlavors; ItemCount numItems; int index = *((int *) inUserData); switch (GetEventClass(inEvent)) { case kEventClassControl: { switch (GetEventKind(inEvent)) { case kEventControlDraw: { err = GetEventParameter(inEvent, kEventParamDirectObject, typeControlRef, NULL, sizeof(ControlRef), NULL, &view); if (err == noErr) { CGContextRef ctx; err = GetEventParameter(inEvent, kEventParamCGContextRef, typeCGContextRef, NULL, sizeof(CGContextRef), NULL, &ctx); if (err == noErr) { HIThemeFrameDrawInfo info; HIRect bounds, frame; HIViewGetBounds(view, &bounds); CGContextSetRGBFillColor(ctx, 1.0f, 1.0f, 1.0f, 1.0f); CGContextFillRect(ctx, bounds); info.version = 0; info.kind = kHIThemeFrameTextFieldSquare; info.state = kThemeStateInactive; info.isFocused = false; err = HIThemeDrawFrame(&bounds, &info, ctx, kHIThemeOrientationNormal); if (multiCartDragHilite == index && systemVersion >= 0x1040) { err = HIThemeSetStroke(kThemeBrushDragHilite, NULL, ctx, kHIThemeOrientationNormal); frame = CGRectInset(bounds, 1, 1); CGContextBeginPath(ctx); CGContextAddRect(ctx, frame); CGContextStrokePath(ctx); } } } result = noErr; break; } case kEventControlDragEnter: { err = GetEventParameter(inEvent, kEventParamDirectObject, typeControlRef, NULL, sizeof(ControlRef), NULL, &view); if (err == noErr) { err = GetEventParameter(inEvent, kEventParamDragRef, typeDragRef, NULL, sizeof(DragRef), NULL, &drag); if (err == noErr) { err = GetDragPasteboard(drag, &pasteboard); if (err == noErr) { err = PasteboardGetItemCount(pasteboard, &numItems); if (err == noErr && numItems == 1) { err = PasteboardGetItemIdentifier(pasteboard, 1, &itemID); if (err == noErr) { err = PasteboardCopyItemFlavors(pasteboard, itemID, &array); if (err == noErr) { numFlavors = CFArrayGetCount(array); for (CFIndex i = 0; i < numFlavors; i++) { flavorType = (CFStringRef) CFArrayGetValueAtIndex(array, i); if (UTTypeConformsTo(flavorType, CFSTR("public.file-url"))) { Boolean accept = true; err = SetEventParameter(inEvent, kEventParamControlWouldAcceptDrop, typeBoolean, sizeof(Boolean), &accept); if (err == noErr) { multiCartDragHilite = index; HIViewSetNeedsDisplay(view, true); result = noErr; } } } CFRelease(array); } } } } } } break; } case kEventControlDragWithin: { result = noErr; break; } case kEventControlDragLeave: { err = GetEventParameter(inEvent, kEventParamDirectObject, typeControlRef, NULL, sizeof(ControlRef), NULL, &view); if (err == noErr) { multiCartDragHilite = -1; HIViewSetNeedsDisplay(view, true); } result = noErr; break; } case kEventControlDragReceive: { err = GetEventParameter(inEvent, kEventParamDirectObject, typeControlRef, NULL, sizeof(ControlRef), NULL, &view); if (err == noErr) { err = GetEventParameter(inEvent, kEventParamDragRef, typeDragRef, NULL, sizeof(DragRef), NULL, &drag); if (err == noErr) { multiCartDragHilite = -1; HIViewSetNeedsDisplay(view, true); err = GetDragPasteboard(drag, &pasteboard); if (err == noErr) { err = PasteboardGetItemIdentifier(pasteboard, 1, &itemID); if (err == noErr) { err = PasteboardCopyItemFlavors(pasteboard, itemID, &array); if (err == noErr) { numFlavors = CFArrayGetCount(array); for (CFIndex i = 0; i < numFlavors; i++) { flavorType = (CFStringRef) CFArrayGetValueAtIndex(array, i); if (UTTypeConformsTo(flavorType, CFSTR("public.file-url"))) { CFDataRef flavorData; err = PasteboardCopyItemFlavorData(pasteboard, itemID, flavorType, &flavorData); if (err == noErr) { CFIndex dataSize; UInt8 *data; dataSize = CFDataGetLength(flavorData); data = (UInt8 *) malloc(dataSize); if (data) { CFDataGetBytes(flavorData, CFRangeMake(0, dataSize), data); HIViewRef ctl; HIViewID cid; CFStringRef str; CFURLRef url; GetControlID(view, &cid); cid.signature = 'MNAM'; HIViewFindByID(view, cid, &ctl); url = CFURLCreateWithBytes(kCFAllocatorDefault, data, dataSize, kCFStringEncodingUTF8, NULL); str = CFURLCopyLastPathComponent(url); SetStaticTextCFString(ctl, str, true); CFRelease(str); str = CFURLCopyFileSystemPath(url, kCFURLPOSIXPathStyle); if (multiCartPath[cid.id]) CFRelease(multiCartPath[cid.id]); multiCartPath[cid.id] = str; CFRelease(url); result = noErr; free(data); } CFRelease(flavorData); } } } CFRelease(array); } } } } } } } } } return (result); }
char *osd_get_clipboard_text(void) { char *result = NULL; /* core expects a malloced C string of uft8 data */ PasteboardRef pasteboard_ref; OSStatus err; PasteboardSyncFlags sync_flags; PasteboardItemID item_id; CFIndex flavor_count; CFArrayRef flavor_type_array; CFIndex flavor_index; ItemCount item_count; UInt32 item_index; Boolean success = false; err = PasteboardCreate(kPasteboardClipboard, &pasteboard_ref); if (!err) { sync_flags = PasteboardSynchronize( pasteboard_ref ); err = PasteboardGetItemCount(pasteboard_ref, &item_count ); for (item_index=1; item_index<=item_count; item_index++) { err = PasteboardGetItemIdentifier(pasteboard_ref, item_index, &item_id); if (!err) { err = PasteboardCopyItemFlavors(pasteboard_ref, item_id, &flavor_type_array); if (!err) { flavor_count = CFArrayGetCount(flavor_type_array); for (flavor_index = 0; flavor_index < flavor_count; flavor_index++) { CFStringRef flavor_type; CFDataRef flavor_data; CFStringEncoding encoding; CFStringRef string_ref; CFDataRef data_ref; CFIndex length; CFRange range; flavor_type = (CFStringRef)CFArrayGetValueAtIndex(flavor_type_array, flavor_index); if (UTTypeConformsTo (flavor_type, kUTTypeUTF16PlainText)) encoding = kCFStringEncodingUTF16; else if (UTTypeConformsTo (flavor_type, kUTTypeUTF8PlainText)) encoding = kCFStringEncodingUTF8; else if (UTTypeConformsTo (flavor_type, kUTTypePlainText)) encoding = kCFStringEncodingMacRoman; else continue; err = PasteboardCopyItemFlavorData(pasteboard_ref, item_id, flavor_type, &flavor_data); if( !err ) { string_ref = CFStringCreateFromExternalRepresentation (kCFAllocatorDefault, flavor_data, encoding); data_ref = CFStringCreateExternalRepresentation (kCFAllocatorDefault, string_ref, kCFStringEncodingUTF8, '?'); length = CFDataGetLength (data_ref); range = CFRangeMake (0,length); result = (char *)malloc (length+1); if (result != NULL) { CFDataGetBytes (data_ref, range, (unsigned char *)result); result[length] = 0; success = true; break; } CFRelease(data_ref); CFRelease(string_ref); CFRelease(flavor_data); } } CFRelease(flavor_type_array); } } if (success) break; } CFRelease(pasteboard_ref); } return result; }
// Sorry for the very long code, all nicer OS X APIs are coded in Objective C and not C! // Also it does very thorough error handling bool GetDataFromPasteboard( PasteboardRef inPasteboard, char* flavorText /* out */, const int bufSize ) { OSStatus err = noErr; PasteboardSyncFlags syncFlags; ItemCount itemCount; syncFlags = PasteboardSynchronize( inPasteboard ); //require_action( syncFlags & kPasteboardModified, PasteboardOutOfSync, // err = badPasteboardSyncErr ); err = PasteboardGetItemCount( inPasteboard, &itemCount ); require_noerr( err, CantGetPasteboardItemCount ); for (UInt32 itemIndex = 1; itemIndex <= itemCount; itemIndex++) { PasteboardItemID itemID; CFArrayRef flavorTypeArray; CFIndex flavorCount; err = PasteboardGetItemIdentifier( inPasteboard, itemIndex, &itemID ); require_noerr( err, CantGetPasteboardItemIdentifier ); err = PasteboardCopyItemFlavors( inPasteboard, itemID, &flavorTypeArray ); require_noerr( err, CantCopyPasteboardItemFlavors ); flavorCount = CFArrayGetCount( flavorTypeArray ); for (CFIndex flavorIndex = 0; flavorIndex < flavorCount; flavorIndex++) { CFStringRef flavorType; CFDataRef flavorData; CFIndex flavorDataSize; flavorType = (CFStringRef)CFArrayGetValueAtIndex(flavorTypeArray, flavorIndex); // we're only interested by text... if (UTTypeConformsTo(flavorType, CFSTR("public.utf8-plain-text"))) { err = PasteboardCopyItemFlavorData( inPasteboard, itemID, flavorType, &flavorData ); require_noerr( err, CantCopyFlavorData ); flavorDataSize = CFDataGetLength( flavorData ); flavorDataSize = (flavorDataSize<254) ? flavorDataSize : 254; if (flavorDataSize+2 > bufSize) { fprintf(stderr, "Cannot copy clipboard, contents is too big!\n"); return false; } for (short dataIndex = 0; dataIndex <= flavorDataSize; dataIndex++) { char byte = *(CFDataGetBytePtr( flavorData ) + dataIndex); flavorText[dataIndex] = byte; } flavorText[flavorDataSize] = '\0'; flavorText[flavorDataSize+1] = '\n'; CFRelease (flavorData); return true; } continue; CantCopyFlavorData: fprintf(stderr, "Cannot copy clipboard, CantCopyFlavorData!\n"); } CFRelease (flavorTypeArray); continue; CantCopyPasteboardItemFlavors: fprintf(stderr, "Cannot copy clipboard, CantCopyPasteboardItemFlavors!\n"); continue; CantGetPasteboardItemIdentifier: fprintf(stderr, "Cannot copy clipboard, CantGetPasteboardItemIdentifier!\n"); continue; } fprintf(stderr, "Cannot copy clipboard, found no acceptable flavour!\n"); return false; CantGetPasteboardItemCount: fprintf(stderr, "Cannot copy clipboard, CantGetPasteboardItemCount!\n"); return false; //PasteboardOutOfSync: fprintf(stderr, "Cannot copy clipboard, PasteboardOutOfSync!\n"); return false; }
void g2LabelEdit::PasteBuffer() { // Win32 implementation #ifdef _WIN32 // Attempt to open clipboard if(!OpenClipboard(GetForegroundWindow())) return; // Get the windows clipboard text buffer HGLOBAL ClipboardHandle = GetClipboardData(CF_TEXT); if(ClipboardHandle != NULL) { // Actually copy the text LPTSTR StringLock = (LPTSTR)GlobalLock(ClipboardHandle); if (StringLock != NULL) { // Copy as much as we can char TempClipBuffer[g2LabelEdit_TextBufferLength]; strncpy(TempClipBuffer, StringLock, g2LabelEdit_TextBufferLength - strlen(TextBuffer) - strlen(StringLock) - 1); // Copy the current text buffer char TempTextBuffer[g2LabelEdit_TextBufferLength]; strcpy(TempTextBuffer, TextBuffer); // Copy into the full buffer (only if text is small enough) if(strlen(TempTextBuffer) + strlen(TempClipBuffer) + 1 < g2LabelEdit_TextBufferLength) { char NewTextBuffer[g2LabelEdit_TextBufferLength]; sprintf(NewTextBuffer, "%s%s", TempTextBuffer, TempClipBuffer); SetText(NewTextBuffer); } // Release the lock GlobalUnlock(StringLock); } } // Close clipboard CloseClipboard(); // OSX implementation #elif __APPLE__ // Allocate or get a reference to the application's active clipboard PasteboardRef ClipboardHandle; if(PasteboardCreate(kPasteboardClipboard, &ClipboardHandle) != noErr) return; // Explicitly update (possibly not needed...) PasteboardSynchronize(ClipboardHandle); // Get the item count ItemCount ClipboardItems; if(PasteboardGetItemCount(ClipboardHandle, &ClipboardItems) != noErr) return; // Keep searching until we find valid text for(ItemCount ItemIndex = 1; ItemIndex <= ClipboardItems; ItemIndex++) { // Get item's ID PasteboardItemID ItemID; if(PasteboardGetItemIdentifier(ClipboardHandle, ItemIndex, &ItemID) != noErr) continue; // Get this item's data types CFArrayRef ItemTypes; if(PasteboardCopyItemFlavors(ClipboardHandle, ItemID, &ItemTypes) != noErr) continue; // For each data type for this clipboard item CFIndex ItemCount = CFArrayGetCount(ItemTypes); for(CFIndex ItemTypeIndex = 0; ItemTypeIndex < ItemCount; ItemTypeIndex++) { // Get the data type CFStringRef ItemType = (CFStringRef)CFArrayGetValueAtIndex(ItemTypes, ItemTypeIndex); // If we have any text-type, then paste and stop if(UTTypeConformsTo(ItemType, CFSTR("public.utf8-plain-text"))) { // Copy from clipboard CFDataRef ItemData; if(PasteboardCopyItemFlavorData(ClipboardHandle, ItemID, ItemType, &ItemData) != noErr) continue; // Paste into active buffer CFIndex DateLength = CFDataGetLength(ItemData); size_t StartIndex = strlen(TextBuffer); char NewTempBuffer[g2LabelEdit_TextBufferLength]; strcpy(NewTempBuffer, TextBuffer); for(CFIndex i = 0; (i < DateLength) && (StartIndex + i < g2LabelEdit_TextBufferLength); i++) { char byte = *(CFDataGetBytePtr(ItemData) + i); NewTempBuffer[StartIndex + i] = byte; } // Cap string and set to current buffer NewTempBuffer[StartIndex + DateLength] = '\0'; SetText(NewTempBuffer); SetCursorPos((int)strlen(NewTempBuffer)); // Release CFRelease(ItemData); // Pasted and done! return; } } } // Linux clipboard implementation #elif __linux__ // Paste into UI from linux buffer SetText(__LinuxClipboard); SetCursorPos((int)strlen(__LinuxClipboard)); #endif }
//****************************************************************************** bool CClipboard::GetString( //Copies the system clipboard string into sClip //Returns: true on success, false otherwise. // //Params: WSTRING& sClip) //(out) { #ifdef WIN32 if (!OpenClipboard(NULL)) return false; HGLOBAL global = GetClipboardData(CF_UNICODETEXT); if (global == NULL) { CloseClipboard(); return false; } LPWSTR data = (LPWSTR)GlobalLock(global); sClip = data; GlobalUnlock(global); CloseClipboard(); return true; #elif defined __APPLE__ PasteboardRef theClipboard; OSStatus err = PasteboardCreate(kPasteboardClipboard, &theClipboard); if (err != noErr) return false; ItemCount itemCount; PasteboardSynchronize(theClipboard); PasteboardGetItemCount(theClipboard, &itemCount); UInt32 itemIndex = 1; PasteboardItemID itemID; PasteboardGetItemIdentifier(theClipboard, itemIndex, &itemID); CFArrayRef flavorTypeArray; PasteboardCopyItemFlavors(theClipboard, itemID, &flavorTypeArray); CFIndex flavorCount = CFArrayGetCount(flavorTypeArray); for (CFIndex flavorIndex = 0; flavorIndex < flavorCount; flavorIndex++) { CFStringRef flavorType = (CFStringRef)CFArrayGetValueAtIndex(flavorTypeArray, flavorIndex); if (UTTypeConformsTo(flavorType, CFSTR("public.utf8-plain-text"))) { CFDataRef flavorData; PasteboardCopyItemFlavorData(theClipboard, itemID, flavorType, &flavorData); //CFIndex flavorDataSize = CFDataGetLength(flavorData); const string str = (char*)CFDataGetBytePtr(flavorData); UTF8ToUCS2(str.c_str(), str.size(), sClip); CFRelease(flavorData); break; } } CFRelease (flavorTypeArray); return true; #elif defined(__linux__) || defined(__FreeBSD__) string u8clip; bool bSuccess; if ((bSuccess = GetStringUTF8(u8clip))) UTF8ToUCS2(u8clip.c_str(), u8clip.length(), sClip); return bSuccess; #elif defined(__native_client__) // Do nothing. return false; #else #error CClipboard::GetString -- Unicode not implemented #endif }
static void osx_driver_getclipboard_loop( struct ts_display_t *display, struct ts_display_t *to) { if (!clip) PasteboardCreate(kPasteboardClipboard, &clip); if (!clip) return; ts_clipboard_clear(&display->clipboard); CFDataRef cfdata; OSStatus err = noErr; ItemCount nItems; uint32_t i; PasteboardSynchronize(clip); if ((err = PasteboardGetItemCount(clip, &nItems)) != noErr) { V1("apple pasteboard GetItemCount failed\n"); return; } for (i = 1; i <= nItems; ++i) { PasteboardItemID itemID; CFArrayRef flavorTypeArray; CFIndex flavorCount; if ((err = PasteboardGetItemIdentifier(clip, i, &itemID)) != noErr) { V1("can't get pasteboard item identifier\n"); return; } if ((err = PasteboardCopyItemFlavors(clip, itemID, &flavorTypeArray)) != noErr) { V1("Can't copy pasteboard item flavors\n"); return; } flavorCount = CFArrayGetCount(flavorTypeArray); CFIndex flavorIndex; for (flavorIndex = 0; flavorIndex < flavorCount; ++flavorIndex) { CFStringRef flavorType; flavorType = (CFStringRef) CFArrayGetValueAtIndex(flavorTypeArray, flavorIndex); if (UTTypeConformsTo(flavorType, CFSTR("public.utf8-plain-text"))) { if ((err = PasteboardCopyItemFlavorData(clip, itemID, CFSTR("public.utf8-plain-text"), &cfdata)) != noErr) { V1("apple pasteboard CopyItem failed\n"); return; } CFIndex length = CFDataGetLength(cfdata); uint8_t * data = malloc(length + 1); CFDataGetBytes(cfdata, CFRangeMake(0, length), data); data[length] = 0; V1 ("%s DATA %d!! '%s'\n", __func__, (int)length, data); ts_clipboard_add(&display->clipboard, "text", data, length); CFRelease(cfdata); } } CFRelease(flavorTypeArray); } if (display->clipboard.flavorCount) ts_display_setclipboard( to, &display->clipboard); }
char *osd_get_clipboard_text(void) { OSStatus err; PasteboardRef pasteboard_ref; err = PasteboardCreate(kPasteboardClipboard, &pasteboard_ref); if (err) return nullptr; PasteboardSynchronize(pasteboard_ref); ItemCount item_count; err = PasteboardGetItemCount(pasteboard_ref, &item_count); char *result = nullptr; // core expects a malloced C string of uft8 data for (UInt32 item_index = 1; (item_index <= item_count) && !result; item_index++) { PasteboardItemID item_id; err = PasteboardGetItemIdentifier(pasteboard_ref, item_index, &item_id); if (err) continue; CFArrayRef flavor_type_array; err = PasteboardCopyItemFlavors(pasteboard_ref, item_id, &flavor_type_array); if (err) continue; CFIndex const flavor_count = CFArrayGetCount(flavor_type_array); for (CFIndex flavor_index = 0; (flavor_index < flavor_count) && !result; flavor_index++) { CFStringRef const flavor_type = (CFStringRef)CFArrayGetValueAtIndex(flavor_type_array, flavor_index); CFStringEncoding encoding; if (UTTypeConformsTo(flavor_type, kUTTypeUTF16PlainText)) encoding = kCFStringEncodingUTF16; else if (UTTypeConformsTo (flavor_type, kUTTypeUTF8PlainText)) encoding = kCFStringEncodingUTF8; else if (UTTypeConformsTo (flavor_type, kUTTypePlainText)) encoding = kCFStringEncodingMacRoman; else continue; CFDataRef flavor_data; err = PasteboardCopyItemFlavorData(pasteboard_ref, item_id, flavor_type, &flavor_data); if (!err) { CFStringRef string_ref = CFStringCreateFromExternalRepresentation(kCFAllocatorDefault, flavor_data, encoding); CFDataRef data_ref = CFStringCreateExternalRepresentation (kCFAllocatorDefault, string_ref, kCFStringEncodingUTF8, '?'); CFRelease(string_ref); CFRelease(flavor_data); CFIndex const length = CFDataGetLength(data_ref); CFRange const range = CFRangeMake(0, length); result = reinterpret_cast<char *>(malloc(length + 1)); if (result) { CFDataGetBytes(data_ref, range, reinterpret_cast<unsigned char *>(result)); result[length] = 0; } CFRelease(data_ref); } } CFRelease(flavor_type_array); } CFRelease(pasteboard_ref); return result; }
bool wxDataObject::GetFromPasteboard( void * pb ) { PasteboardRef pasteboard = (PasteboardRef) pb; size_t formatcount = GetFormatCount(wxDataObject::Set); wxDataFormat *array = new wxDataFormat[ formatcount ]; GetAllFormats(array, wxDataObject::Set); ItemCount itemCount = 0; wxString filenamesPassed; bool transferred = false; bool pastelocationset = false; // we synchronize here once again, so we don't mind which flags get returned PasteboardSynchronize( pasteboard ); OSStatus err = PasteboardGetItemCount( pasteboard, &itemCount ); if ( err == noErr ) { for (size_t i = 0; !transferred && i < formatcount; i++) { // go through the data in our order of preference wxDataFormat dataFormat = array[ i ]; for( UInt32 itemIndex = 1; itemIndex <= itemCount && transferred == false ; itemIndex++ ) { PasteboardItemID itemID = 0; CFArrayRef flavorTypeArray = NULL; CFIndex flavorCount = 0; err = PasteboardGetItemIdentifier( pasteboard, itemIndex, &itemID ); if ( err != noErr ) continue; err = PasteboardCopyItemFlavors( pasteboard, itemID, &flavorTypeArray ); if ( err != noErr ) continue; flavorCount = CFArrayGetCount( flavorTypeArray ); for( CFIndex flavorIndex = 0; !transferred && flavorIndex < flavorCount ; flavorIndex++ ) { CFStringRef flavorType; CFDataRef flavorData; CFIndex flavorDataSize; flavorType = (CFStringRef)CFArrayGetValueAtIndex( flavorTypeArray, flavorIndex ); wxDataFormat flavorFormat( (wxDataFormat::NativeFormat) flavorType ); if ( dataFormat == flavorFormat ) { if ( UTTypeConformsTo( (CFStringRef)flavorType, kPasteboardTypeFileURLPromise) ) { if ( !pastelocationset ) { wxString tempdir = wxFileName::GetTempDir() + wxFILE_SEP_PATH + "wxtemp.XXXXXX"; char* result = mkdtemp((char*)tempdir.fn_str().data()); if (!result) continue; wxCFRef<CFURLRef> dest(CFURLCreateFromFileSystemRepresentation(NULL,(const UInt8*)result,strlen(result),true)); PasteboardSetPasteLocation(pasteboard, dest); pastelocationset = true; } } else if ( flavorFormat.GetType() != wxDF_PRIVATE ) { // indicate the expected format for the type, benefiting from native conversions eg utf8 -> utf16 flavorType = (CFStringRef) wxDataFormat( flavorFormat.GetType()).GetFormatId(); } err = PasteboardCopyItemFlavorData( pasteboard, itemID, flavorType , &flavorData ); if ( err == noErr ) { flavorDataSize = CFDataGetLength( flavorData ); if (dataFormat.GetType() == wxDF_FILENAME ) { // revert the translation and decomposition to arrive at a proper utf8 string again CFURLRef url = CFURLCreateWithBytes( kCFAllocatorDefault, CFDataGetBytePtr( flavorData ), flavorDataSize, kCFStringEncodingUTF8, NULL ); CFStringRef cfString = CFURLCopyFileSystemPath( url, kCFURLPOSIXPathStyle ); CFRelease( url ); CFMutableStringRef cfMutableString = CFStringCreateMutableCopy(NULL, 0, cfString); CFRelease( cfString ); CFStringNormalize(cfMutableString,kCFStringNormalizationFormC); wxString path = wxCFStringRef(cfMutableString).AsString(); if (!path.empty()) filenamesPassed += path + wxT("\n"); } else { // because some data implementation expect trailing a trailing NUL, we add some headroom void *buf = malloc( flavorDataSize + 4 ); if ( buf ) { memset( buf, 0, flavorDataSize + 4 ); memcpy( buf, CFDataGetBytePtr( flavorData ), flavorDataSize ); if (dataFormat.GetType() == wxDF_TEXT) wxMacConvertNewlines10To13( (char*) buf ); SetData( flavorFormat, flavorDataSize, buf ); transferred = true; free( buf ); } } CFRelease (flavorData); } } else if ( dataFormat.GetType() == wxDF_UNICODETEXT && flavorFormat.GetType() == wxDF_TEXT ) { err = PasteboardCopyItemFlavorData( pasteboard, itemID, flavorType, &flavorData ); if ( err == noErr ) { flavorDataSize = CFDataGetLength( flavorData ); void *asciibuf = malloc( flavorDataSize + 1 ); if ( asciibuf ) { memset( asciibuf, 0, flavorDataSize + 1 ); memcpy( asciibuf, CFDataGetBytePtr( flavorData ), flavorDataSize ); CFRelease (flavorData); SetData( wxDF_TEXT, flavorDataSize, asciibuf ); transferred = true; free( asciibuf ); } else CFRelease (flavorData); } } } CFRelease( flavorTypeArray ); } if ( !filenamesPassed.empty() ) { wxCharBuffer buf = filenamesPassed.fn_str(); SetData( wxDF_FILENAME, strlen( buf ), (const char*)buf ); transferred = true; } } } return transferred; }