| /* |
| * Copyright (C) 2004, 2005, 2006, 2008 Apple Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE COMPUTER, INC. OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #import "config.h" |
| #import "ClipboardMac.h" |
| |
| #import "DOMElementInternal.h" |
| #import "DragClient.h" |
| #import "DragController.h" |
| #import "Editor.h" |
| #import "FoundationExtras.h" |
| #import "FileList.h" |
| #import "Frame.h" |
| #import "Image.h" |
| #import "Page.h" |
| #import "Pasteboard.h" |
| #import "RenderImage.h" |
| #import "SecurityOrigin.h" |
| #import "WebCoreSystemInterface.h" |
| |
| #ifdef BUILDING_ON_TIGER |
| typedef unsigned NSUInteger; |
| #endif |
| |
| namespace WebCore { |
| |
| ClipboardMac::ClipboardMac(bool forDragging, NSPasteboard *pasteboard, ClipboardAccessPolicy policy, Frame *frame) |
| : Clipboard(policy, forDragging) |
| , m_pasteboard(pasteboard) |
| , m_frame(frame) |
| { |
| m_changeCount = [m_pasteboard.get() changeCount]; |
| } |
| |
| ClipboardMac::~ClipboardMac() |
| { |
| } |
| |
| bool ClipboardMac::hasData() |
| { |
| return m_pasteboard && [m_pasteboard.get() types] && [[m_pasteboard.get() types] count] > 0; |
| } |
| |
| static NSString *cocoaTypeFromHTMLClipboardType(const String& type) |
| { |
| String qType = type.stripWhiteSpace(); |
| |
| // two special cases for IE compatibility |
| if (qType == "Text") |
| return NSStringPboardType; |
| if (qType == "URL") |
| return NSURLPboardType; |
| |
| // Ignore any trailing charset - JS strings are Unicode, which encapsulates the charset issue |
| if (qType == "text/plain" || qType.startsWith("text/plain;")) |
| return NSStringPboardType; |
| if (qType == "text/uri-list") |
| // special case because UTI doesn't work with Cocoa's URL type |
| return NSURLPboardType; // note special case in getData to read NSFilenamesType |
| |
| // Try UTI now |
| NSString *mimeType = qType; |
| RetainPtr<CFStringRef> utiType(AdoptCF, UTTypeCreatePreferredIdentifierForTag(kUTTagClassMIMEType, (CFStringRef)mimeType, NULL)); |
| if (utiType) { |
| CFStringRef pbType = UTTypeCopyPreferredTagWithClass(utiType.get(), kUTTagClassNSPboardType); |
| if (pbType) |
| return HardAutorelease(pbType); |
| } |
| |
| // No mapping, just pass the whole string though |
| return qType; |
| } |
| |
| static String utiTypeFromCocoaType(NSString *type) |
| { |
| RetainPtr<CFStringRef> utiType(AdoptCF, UTTypeCreatePreferredIdentifierForTag(kUTTagClassNSPboardType, (CFStringRef)type, NULL)); |
| if (utiType) { |
| RetainPtr<CFStringRef> mimeType(AdoptCF, UTTypeCopyPreferredTagWithClass(utiType.get(), kUTTagClassMIMEType)); |
| if (mimeType) |
| return String(mimeType.get()); |
| } |
| return String(); |
| } |
| |
| static void addHTMLClipboardTypesForCocoaType(HashSet<String>& resultTypes, NSString *cocoaType, NSPasteboard *pasteboard) |
| { |
| // UTI may not do these right, so make sure we get the right, predictable result |
| if ([cocoaType isEqualToString:NSStringPboardType]) { |
| resultTypes.add("text/plain"); |
| return; |
| } |
| if ([cocoaType isEqualToString:NSURLPboardType]) { |
| resultTypes.add("text/uri-list"); |
| return; |
| } |
| if ([cocoaType isEqualToString:NSFilenamesPboardType]) { |
| // If file list is empty, add nothing. |
| // Note that there is a chance that the file list count could have changed since we grabbed the types array. |
| // However, this is not really an issue for us doing a sanity check here. |
| NSArray *fileList = [pasteboard propertyListForType:NSFilenamesPboardType]; |
| if ([fileList count]) { |
| // It is unknown if NSFilenamesPboardType always implies NSURLPboardType in Cocoa, |
| // but NSFilenamesPboardType should imply both 'text/uri-list' and 'Files' |
| resultTypes.add("text/uri-list"); |
| resultTypes.add("Files"); |
| } |
| return; |
| } |
| String utiType = utiTypeFromCocoaType(cocoaType); |
| if (!utiType.isEmpty()) { |
| resultTypes.add(utiType); |
| return; |
| } |
| // No mapping, just pass the whole string though |
| resultTypes.add(cocoaType); |
| } |
| |
| void ClipboardMac::clearData(const String& type) |
| { |
| if (policy() != ClipboardWritable) |
| return; |
| |
| // note NSPasteboard enforces changeCount itself on writing - can't write if not the owner |
| |
| NSString *cocoaType = cocoaTypeFromHTMLClipboardType(type); |
| if (cocoaType) |
| [m_pasteboard.get() setString:@"" forType:cocoaType]; |
| } |
| |
| void ClipboardMac::clearAllData() |
| { |
| if (policy() != ClipboardWritable) |
| return; |
| |
| // note NSPasteboard enforces changeCount itself on writing - can't write if not the owner |
| |
| [m_pasteboard.get() declareTypes:[NSArray array] owner:nil]; |
| } |
| |
| static NSArray *absoluteURLsFromPasteboardFilenames(NSPasteboard* pasteboard, bool onlyFirstURL = false) |
| { |
| NSArray *fileList = [pasteboard propertyListForType:NSFilenamesPboardType]; |
| |
| // FIXME: Why does this code need to guard against bad values on the pasteboard? |
| ASSERT(!fileList || [fileList isKindOfClass:[NSArray class]]); |
| if (!fileList || ![fileList isKindOfClass:[NSArray class]] || ![fileList count]) |
| return nil; |
| |
| NSUInteger count = onlyFirstURL ? 1 : [fileList count]; |
| NSMutableArray *urls = [NSMutableArray array]; |
| for (NSUInteger i = 0; i < count; i++) { |
| NSString *string = [fileList objectAtIndex:i]; |
| |
| ASSERT([string isKindOfClass:[NSString class]]); // Added to understand why this if code is here |
| if (![string isKindOfClass:[NSString class]]) |
| return nil; // Non-string object in the list, bail out! FIXME: When can this happen? |
| |
| NSURL *url = [NSURL fileURLWithPath:string]; |
| [urls addObject:[url absoluteString]]; |
| } |
| return urls; |
| } |
| |
| static NSArray *absoluteURLsFromPasteboard(NSPasteboard* pasteboard, bool onlyFirstURL = false) |
| { |
| // NOTE: We must always check [availableTypes containsObject:] before accessing pasteboard data |
| // or CoreFoundation will printf when there is not data of the corresponding type. |
| NSArray *availableTypes = [pasteboard types]; |
| |
| // Try NSFilenamesPboardType because it contains a list |
| if ([availableTypes containsObject:NSFilenamesPboardType]) { |
| if (NSArray* absoluteURLs = absoluteURLsFromPasteboardFilenames(pasteboard, onlyFirstURL)) |
| return absoluteURLs; |
| } |
| |
| // Fallback to NSURLPboardType (which is a single URL) |
| if ([availableTypes containsObject:NSURLPboardType]) { |
| if (NSURL *url = [NSURL URLFromPasteboard:pasteboard]) |
| return [NSArray arrayWithObject:[url absoluteString]]; |
| } |
| |
| // No file paths on the pasteboard, return nil |
| return nil; |
| } |
| |
| String ClipboardMac::getData(const String& type, bool& success) const |
| { |
| success = false; |
| if (policy() != ClipboardReadable) |
| return String(); |
| |
| NSString *cocoaType = cocoaTypeFromHTMLClipboardType(type); |
| NSString *cocoaValue = nil; |
| |
| // Grab the value off the pasteboard corresponding to the cocoaType |
| if ([cocoaType isEqualToString:NSURLPboardType]) { |
| // "URL" and "text/url-list" both map to NSURLPboardType in cocoaTypeFromHTMLClipboardType(), "URL" only wants the first URL |
| bool onlyFirstURL = (type == "URL"); |
| NSArray *absoluteURLs = absoluteURLsFromPasteboard(m_pasteboard.get(), onlyFirstURL); |
| cocoaValue = [absoluteURLs componentsJoinedByString:@"\n"]; |
| } else if ([cocoaType isEqualToString:NSStringPboardType]) { |
| cocoaValue = [[m_pasteboard.get() stringForType:cocoaType] precomposedStringWithCanonicalMapping]; |
| } else if (cocoaType) |
| cocoaValue = [m_pasteboard.get() stringForType:cocoaType]; |
| |
| // Enforce changeCount ourselves for security. We check after reading instead of before to be |
| // sure it doesn't change between our testing the change count and accessing the data. |
| if (cocoaValue && m_changeCount == [m_pasteboard.get() changeCount]) { |
| success = true; |
| return cocoaValue; |
| } |
| |
| return String(); |
| } |
| |
| bool ClipboardMac::setData(const String &type, const String &data) |
| { |
| if (policy() != ClipboardWritable) |
| return false; |
| // note NSPasteboard enforces changeCount itself on writing - can't write if not the owner |
| |
| NSString *cocoaType = cocoaTypeFromHTMLClipboardType(type); |
| NSString *cocoaData = data; |
| |
| if ([cocoaType isEqualToString:NSURLPboardType]) { |
| [m_pasteboard.get() addTypes:[NSArray arrayWithObject:NSURLPboardType] owner:nil]; |
| NSURL *url = [[NSURL alloc] initWithString:cocoaData]; |
| [url writeToPasteboard:m_pasteboard.get()]; |
| |
| if ([url isFileURL] && m_frame->document()->securityOrigin()->canLoadLocalResources()) { |
| [m_pasteboard.get() addTypes:[NSArray arrayWithObject:NSFilenamesPboardType] owner:nil]; |
| NSArray *fileList = [NSArray arrayWithObject:[url path]]; |
| [m_pasteboard.get() setPropertyList:fileList forType:NSFilenamesPboardType]; |
| } |
| |
| [url release]; |
| return true; |
| } |
| |
| if (cocoaType) { |
| // everything else we know of goes on the pboard as a string |
| [m_pasteboard.get() addTypes:[NSArray arrayWithObject:cocoaType] owner:nil]; |
| return [m_pasteboard.get() setString:cocoaData forType:cocoaType]; |
| } |
| |
| return false; |
| } |
| |
| HashSet<String> ClipboardMac::types() const |
| { |
| if (policy() != ClipboardReadable && policy() != ClipboardTypesReadable) |
| return HashSet<String>(); |
| |
| NSArray *types = [m_pasteboard.get() types]; |
| |
| // Enforce changeCount ourselves for security. We check after reading instead of before to be |
| // sure it doesn't change between our testing the change count and accessing the data. |
| if (m_changeCount != [m_pasteboard.get() changeCount]) |
| return HashSet<String>(); |
| |
| HashSet<String> result; |
| NSUInteger count = [types count]; |
| // FIXME: This loop could be split into two stages. One which adds all the HTML5 specified types |
| // and a second which adds all the extra types from the cocoa clipboard (which is Mac-only behavior). |
| for (NSUInteger i = 0; i < count; i++) { |
| NSString *pbType = [types objectAtIndex:i]; |
| if ([pbType isEqualToString:@"NeXT plain ascii pasteboard type"]) |
| continue; // skip this ancient type that gets auto-supplied by some system conversion |
| |
| addHTMLClipboardTypesForCocoaType(result, pbType, m_pasteboard.get()); |
| } |
| |
| return result; |
| } |
| |
| // FIXME: We could cache the computed fileList if necessary |
| // Currently each access gets a new copy, setData() modifications to the |
| // clipboard are not reflected in any FileList objects the page has accessed and stored |
| PassRefPtr<FileList> ClipboardMac::files() const |
| { |
| if (policy() != ClipboardReadable) |
| return FileList::create(); |
| |
| NSArray *absoluteURLs = absoluteURLsFromPasteboardFilenames(m_pasteboard.get()); |
| NSUInteger count = [absoluteURLs count]; |
| |
| RefPtr<FileList> fileList = FileList::create(); |
| for (NSUInteger x = 0; x < count; x++) { |
| NSURL *absoluteURL = [NSURL URLWithString:[absoluteURLs objectAtIndex:x]]; |
| ASSERT([absoluteURL isFileURL]); |
| fileList->append(File::create([absoluteURL path])); |
| } |
| return fileList.release(); // We will always return a FileList, sometimes empty |
| } |
| |
| // The rest of these getters don't really have any impact on security, so for now make no checks |
| |
| void ClipboardMac::setDragImage(CachedImage* img, const IntPoint &loc) |
| { |
| setDragImage(img, 0, loc); |
| } |
| |
| void ClipboardMac::setDragImageElement(Node *node, const IntPoint &loc) |
| { |
| setDragImage(0, node, loc); |
| } |
| |
| void ClipboardMac::setDragImage(CachedImage* image, Node *node, const IntPoint &loc) |
| { |
| if (policy() == ClipboardImageWritable || policy() == ClipboardWritable) { |
| if (m_dragImage) |
| m_dragImage->removeClient(this); |
| m_dragImage = image; |
| if (m_dragImage) |
| m_dragImage->addClient(this); |
| |
| m_dragLoc = loc; |
| m_dragImageElement = node; |
| |
| if (dragStarted() && m_changeCount == [m_pasteboard.get() changeCount]) { |
| NSPoint cocoaLoc; |
| NSImage* cocoaImage = dragNSImage(cocoaLoc); |
| if (cocoaImage) { |
| // Dashboard wants to be able to set the drag image during dragging, but Cocoa does not allow this. |
| // Instead we must drop down to the CoreGraphics API. |
| wkSetDragImage(cocoaImage, cocoaLoc); |
| |
| // Hack: We must post an event to wake up the NSDragManager, which is sitting in a nextEvent call |
| // up the stack from us because the CoreFoundation drag manager does not use the run loop by itself. |
| // This is the most innocuous event to use, per Kristen Forster. |
| NSEvent* ev = [NSEvent mouseEventWithType:NSMouseMoved location:NSZeroPoint |
| modifierFlags:0 timestamp:0 windowNumber:0 context:nil eventNumber:0 clickCount:0 pressure:0]; |
| [NSApp postEvent:ev atStart:YES]; |
| } |
| } |
| // Else either 1) we haven't started dragging yet, so we rely on the part to install this drag image |
| // as part of getting the drag kicked off, or 2) Someone kept a ref to the clipboard and is trying to |
| // set the image way too late. |
| } |
| } |
| |
| void ClipboardMac::writeRange(Range* range, Frame* frame) |
| { |
| ASSERT(range); |
| ASSERT(frame); |
| Pasteboard::writeSelection(m_pasteboard.get(), range, frame->editor()->smartInsertDeleteEnabled() && frame->selectionGranularity() == WordGranularity, frame); |
| } |
| |
| void ClipboardMac::writePlainText(const String& text) |
| { |
| Pasteboard::writePlainText(m_pasteboard.get(), text); |
| } |
| |
| void ClipboardMac::writeURL(const KURL& url, const String& title, Frame* frame) |
| { |
| ASSERT(frame); |
| ASSERT(m_pasteboard); |
| Pasteboard::writeURL(m_pasteboard.get(), nil, url, title, frame); |
| } |
| |
| #if ENABLE(DRAG_SUPPORT) |
| void ClipboardMac::declareAndWriteDragImage(Element* element, const KURL& url, const String& title, Frame* frame) |
| { |
| ASSERT(frame); |
| if (Page* page = frame->page()) |
| page->dragController()->client()->declareAndWriteDragImage(m_pasteboard.get(), kit(element), url, title, frame); |
| } |
| #endif // ENABLE(DRAG_SUPPORT) |
| |
| DragImageRef ClipboardMac::createDragImage(IntPoint& loc) const |
| { |
| NSPoint nsloc = {loc.x(), loc.y()}; |
| DragImageRef result = dragNSImage(nsloc); |
| loc = (IntPoint)nsloc; |
| return result; |
| } |
| |
| NSImage *ClipboardMac::dragNSImage(NSPoint& loc) const |
| { |
| NSImage *result = nil; |
| if (m_dragImageElement) { |
| if (m_frame) { |
| NSRect imageRect; |
| NSRect elementRect; |
| result = m_frame->snapshotDragImage(m_dragImageElement.get(), &imageRect, &elementRect); |
| // Client specifies point relative to element, not the whole image, which may include child |
| // layers spread out all over the place. |
| loc.x = elementRect.origin.x - imageRect.origin.x + m_dragLoc.x(); |
| loc.y = elementRect.origin.y - imageRect.origin.y + m_dragLoc.y(); |
| loc.y = imageRect.size.height - loc.y; |
| } |
| } else if (m_dragImage) { |
| result = m_dragImage->image()->getNSImage(); |
| |
| loc = m_dragLoc; |
| loc.y = [result size].height - loc.y; |
| } |
| return result; |
| } |
| |
| } |
