Source/WebCore/platform/win/ClipboardWin.cpp

   1 /*
   2  * Copyright (C) 2006, 2007 Apple Inc.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
  14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
  17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "config.h"
  27 #include "ClipboardWin.h"
  28
  29 #include "CachedImage.h"
  30 #include "ClipboardUtilitiesWin.h"
  31 #include "Document.h"
  32 #include "DragData.h"
  33 #include "Editor.h"
  34 #include "Element.h"
  35 #include "EventHandler.h"
  36 #include "FileList.h"
  37 #include "Frame.h"
  38 #include "FrameLoader.h"
  39 #include "FrameView.h"
  40 #include "HTMLNames.h"
  41 #include "HTMLParserIdioms.h"
  42 #include "Image.h"
  43 #include "MIMETypeRegistry.h"
  44 #include "NotImplemented.h"
  45 #include "Page.h"
  46 #include "Pasteboard.h"
  47 #include "PlatformMouseEvent.h"
  48 #include "PlatformString.h"
  49 #include "Range.h"
  50 #include "RenderImage.h"
  51 #include "ResourceResponse.h"
  52 #include "SharedBuffer.h"
  53 #include "WCDataObject.h"
  54 #include "markup.h"
  55 #include <shlwapi.h>
  56 #include <wininet.h>
  57 #include <wtf/RefPtr.h>
  58 #include <wtf/text/CString.h>
  59 #include <wtf/text/StringConcatenate.h>
  60 #include <wtf/text/StringHash.h>
  61
  62 using namespace std;
  63
  64 namespace WebCore {
  65
  66 using namespace HTMLNames;
  67
  68 // We provide the IE clipboard types (URL and Text), and the clipboard types specified in the WHATWG Web Applications 1.0 draft
  69 // see http://www.whatwg.org/specs/web-apps/current-work/ Section 6.3.5.3
  70
  71 enum ClipboardDataType { ClipboardDataTypeNone, ClipboardDataTypeURL, ClipboardDataTypeText, ClipboardDataTypeTextHTML };
  72
  73 static ClipboardDataType clipboardTypeFromMIMEType(const String& type)
  74 {
  75     String qType = type.stripWhiteSpace().lower();
  76
  77     // two special cases for IE compatibility
  78     if (qType == "text" || qType == "text/plain" || qType.startsWith("text/plain;"))
  79         return ClipboardDataTypeText;
  80     if (qType == "url" || qType == "text/uri-list")
  81         return ClipboardDataTypeURL;
  82     if (qType == "text/html")
  83         return ClipboardDataTypeTextHTML;
  84
  85     return ClipboardDataTypeNone;
  86 }
  87
  88 static inline FORMATETC* fileDescriptorFormat()
  89 {
  90     static UINT cf = RegisterClipboardFormat(CFSTR_FILEDESCRIPTOR);
  91     static FORMATETC fileDescriptorFormat = {cf, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL};
  92     return &fileDescriptorFormat;
  93 }
  94
  95 static inline FORMATETC* fileContentFormatZero()
  96 {
  97     static UINT cf = RegisterClipboardFormat(CFSTR_FILECONTENTS);
  98     static FORMATETC fileContentFormat = {cf, 0, DVASPECT_CONTENT, 0, TYMED_HGLOBAL};
  99     return &fileContentFormat;
 100 }
 101
 102 #if !OS(WINCE)
 103 static inline void pathRemoveBadFSCharacters(PWSTR psz, size_t length)
 104 {
 105     size_t writeTo = 0;
 106     size_t readFrom = 0;
 107     while (readFrom < length) {
 108         UINT type = PathGetCharType(psz[readFrom]);
 109         if (!psz[readFrom] || type & (GCT_LFNCHAR | GCT_SHORTCHAR))
 110             psz[writeTo++] = psz[readFrom];
 111
 112         readFrom++;
 113     }
 114     psz[writeTo] = 0;
 115 }
 116 #endif
 117
 118 static String filesystemPathFromUrlOrTitle(const String& url, const String& title, const UChar* extension, bool isLink)
 119 {
 120 #if OS(WINCE)
 121     notImplemented();
 122     return String();
 123 #else
 124     static const size_t fsPathMaxLengthExcludingNullTerminator = MAX_PATH - 1;
 125     bool usedURL = false;
 126     WCHAR fsPathBuffer[MAX_PATH];
 127     fsPathBuffer[0] = 0;
 128     int extensionLen = extension ? lstrlen(extension) : 0;
 129     int fsPathMaxLengthExcludingExtension = fsPathMaxLengthExcludingNullTerminator - extensionLen;
 130
 131     if (!title.isEmpty()) {
 132         size_t len = min<size_t>(title.length(), fsPathMaxLengthExcludingExtension);
 133         CopyMemory(fsPathBuffer, title.characters(), len * sizeof(UChar));
 134         fsPathBuffer[len] = 0;
 135         pathRemoveBadFSCharacters(fsPathBuffer, len);
 136     }
 137
 138     if (!lstrlen(fsPathBuffer)) {
 139         KURL kurl(ParsedURLString, url);
 140         usedURL = true;
 141         // The filename for any content based drag or file url should be the last element of
 142         // the path.  If we can't find it, or we're coming up with the name for a link
 143         // we just use the entire url.
 144         DWORD len = fsPathMaxLengthExcludingExtension;
 145         String lastComponent = kurl.lastPathComponent();
 146         if (kurl.isLocalFile() || (!isLink && !lastComponent.isEmpty())) {
 147             len = min<DWORD>(fsPathMaxLengthExcludingExtension, lastComponent.length());
 148             CopyMemory(fsPathBuffer, lastComponent.characters(), len * sizeof(UChar));
 149         } else {
 150             len = min<DWORD>(fsPathMaxLengthExcludingExtension, url.length());
 151             CopyMemory(fsPathBuffer, url.characters(), len * sizeof(UChar));
 152         }
 153         fsPathBuffer[len] = 0;
 154         pathRemoveBadFSCharacters(fsPathBuffer, len);
 155     }
 156
 157     if (!extension)
 158         return String(static_cast<UChar*>(fsPathBuffer));
 159
 160     if (!isLink && usedURL) {
 161         PathRenameExtension(fsPathBuffer, extension);
 162         return String(static_cast<UChar*>(fsPathBuffer));
 163     }
 164
 165     String result(static_cast<UChar*>(fsPathBuffer));
 166     result += String(extension);
 167     return result;
 168 #endif
 169 }
 170
 171 static HGLOBAL createGlobalImageFileContent(SharedBuffer* data)
 172 {
 173     HGLOBAL memObj = GlobalAlloc(GPTR, data->size());
 174     if (!memObj)
 175         return 0;
 176
 177     char* fileContents = (PSTR)GlobalLock(memObj);
 178
 179     CopyMemory(fileContents, data->data(), data->size());
 180
 181     GlobalUnlock(memObj);
 182
 183     return memObj;
 184 }
 185
 186 static HGLOBAL createGlobalHDropContent(const KURL& url, String& fileName, SharedBuffer* data)
 187 {
 188     if (fileName.isEmpty() || !data)
 189         return 0;
 190
 191     WCHAR filePath[MAX_PATH];
 192
 193     if (url.isLocalFile()) {
 194         String localPath = url.path();
 195         // windows does not enjoy a leading slash on paths
 196         if (localPath[0] == '/')
 197             localPath = localPath.substring(1);
 198         LPCWSTR localPathStr = localPath.charactersWithNullTermination();
 199         if (wcslen(localPathStr) + 1 < MAX_PATH)
 200             wcscpy_s(filePath, MAX_PATH, localPathStr);
 201         else
 202             return 0;
 203     } else {
 204 #if OS(WINCE)
 205         notImplemented();
 206         return 0;
 207 #else
 208         WCHAR tempPath[MAX_PATH];
 209         WCHAR extension[MAX_PATH];
 210         if (!::GetTempPath(WTF_ARRAY_LENGTH(tempPath), tempPath))
 211             return 0;
 212         if (!::PathAppend(tempPath, fileName.charactersWithNullTermination()))
 213             return 0;
 214         LPCWSTR foundExtension = ::PathFindExtension(tempPath);
 215         if (foundExtension) {
 216             if (wcscpy_s(extension, MAX_PATH, foundExtension))
 217                 return 0;
 218         } else
 219             *extension = 0;
 220         ::PathRemoveExtension(tempPath);
 221         for (int i = 1; i < 10000; i++) {
 222             if (swprintf_s(filePath, MAX_PATH, TEXT("%s-%d%s"), tempPath, i, extension) == -1)
 223                 return 0;
 224             if (!::PathFileExists(filePath))
 225                 break;
 226         }
 227         HANDLE tempFileHandle = CreateFile(filePath, GENERIC_READ | GENERIC_WRITE, 0, 0, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, 0);
 228         if (tempFileHandle == INVALID_HANDLE_VALUE)
 229             return 0;
 230
 231         // Write the data to this temp file.
 232         DWORD written;
 233         BOOL tempWriteSucceeded = WriteFile(tempFileHandle, data->data(), data->size(), &written, 0);
 234         CloseHandle(tempFileHandle);
 235         if (!tempWriteSucceeded)
 236             return 0;
 237 #endif
 238     }
 239
 240     SIZE_T dropFilesSize = sizeof(DROPFILES) + (sizeof(WCHAR) * (wcslen(filePath) + 2));
 241     HGLOBAL memObj = GlobalAlloc(GHND | GMEM_SHARE, dropFilesSize);
 242     if (!memObj)
 243         return 0;
 244
 245     DROPFILES* dropFiles = (DROPFILES*) GlobalLock(memObj);
 246     dropFiles->pFiles = sizeof(DROPFILES);
 247     dropFiles->fWide = TRUE;
 248     wcscpy((LPWSTR)(dropFiles + 1), filePath);
 249     GlobalUnlock(memObj);
 250
 251     return memObj;
 252 }
 253
 254 static HGLOBAL createGlobalImageFileDescriptor(const String& url, const String& title, CachedImage* image)
 255 {
 256     ASSERT_ARG(image, image);
 257     ASSERT(image->image()->data());
 258
 259     HRESULT hr = S_OK;
 260     HGLOBAL memObj = 0;
 261     String fsPath;
 262     memObj = GlobalAlloc(GPTR, sizeof(FILEGROUPDESCRIPTOR));
 263     if (!memObj)
 264         return 0;
 265
 266     FILEGROUPDESCRIPTOR* fgd = (FILEGROUPDESCRIPTOR*)GlobalLock(memObj);
 267     memset(fgd, 0, sizeof(FILEGROUPDESCRIPTOR));
 268     fgd->cItems = 1;
 269     fgd->fgd[0].dwFlags = FD_FILESIZE;
 270     fgd->fgd[0].nFileSizeLow = image->image()->data()->size();
 271
 272     const String& preferredTitle = title.isEmpty() ? image->response().suggestedFilename() : title;
 273     String extension = image->image()->filenameExtension();
 274     if (extension.isEmpty()) {
 275         // Do not continue processing in the rare and unusual case where a decoded image is not able
 276         // to provide a filename extension. Something tricky (like a bait-n-switch) is going on
 277         return 0;
 278     }
 279     extension.insert(".", 0);
 280     fsPath = filesystemPathFromUrlOrTitle(url, preferredTitle, extension.charactersWithNullTermination(), false);
 281
 282     if (fsPath.length() <= 0) {
 283         GlobalUnlock(memObj);
 284         GlobalFree(memObj);
 285         return 0;
 286     }
 287
 288     int maxSize = min(fsPath.length(), WTF_ARRAY_LENGTH(fgd->fgd[0].cFileName));
 289     CopyMemory(fgd->fgd[0].cFileName, (LPCWSTR)fsPath.characters(), maxSize * sizeof(UChar));
 290     GlobalUnlock(memObj);
 291
 292     return memObj;
 293 }
 294
 295
 296 // writeFileToDataObject takes ownership of fileDescriptor and fileContent
 297 static HRESULT writeFileToDataObject(IDataObject* dataObject, HGLOBAL fileDescriptor, HGLOBAL fileContent, HGLOBAL hDropContent)
 298 {
 299     HRESULT hr = S_OK;
 300     FORMATETC* fe;
 301     STGMEDIUM medium = {0};
 302     medium.tymed = TYMED_HGLOBAL;
 303
 304     if (!fileDescriptor || !fileContent)
 305         goto exit;
 306
 307     // Descriptor
 308     fe = fileDescriptorFormat();
 309
 310     medium.hGlobal = fileDescriptor;
 311
 312     if (FAILED(hr = dataObject->SetData(fe, &medium, TRUE)))
 313         goto exit;
 314
 315     // Contents
 316     fe = fileContentFormatZero();
 317     medium.hGlobal = fileContent;
 318     if (FAILED(hr = dataObject->SetData(fe, &medium, TRUE)))
 319         goto exit;
 320
 321 #if PLATFORM(CF)
 322     // HDROP
 323     if (hDropContent) {
 324         medium.hGlobal = hDropContent;
 325         hr = dataObject->SetData(cfHDropFormat(), &medium, TRUE);
 326     }
 327 #endif
 328
 329 exit:
 330     if (FAILED(hr)) {
 331         if (fileDescriptor)
 332             GlobalFree(fileDescriptor);
 333         if (fileContent)
 334             GlobalFree(fileContent);
 335         if (hDropContent)
 336             GlobalFree(hDropContent);
 337     }
 338     return hr;
 339 }
 340
 341 PassRefPtr<Clipboard> Clipboard::create(ClipboardAccessPolicy policy, DragData* dragData, Frame* frame)
 342 {
 343     if (dragData->platformData())
 344         return ClipboardWin::create(DragAndDrop, dragData->platformData(), policy, frame);
 345     return ClipboardWin::create(DragAndDrop, dragData->dragDataMap(), policy, frame);
 346 }
 347
 348 ClipboardWin::ClipboardWin(ClipboardType clipboardType, IDataObject* dataObject, ClipboardAccessPolicy policy, Frame* frame)
 349     : Clipboard(policy, clipboardType)
 350     , m_dataObject(dataObject)
 351     , m_writableDataObject(0)
 352     , m_frame(frame)
 353 {
 354 }
 355
 356 ClipboardWin::ClipboardWin(ClipboardType clipboardType, WCDataObject* dataObject, ClipboardAccessPolicy policy, Frame* frame)
 357     : Clipboard(policy, clipboardType)
 358     , m_dataObject(dataObject)
 359     , m_writableDataObject(dataObject)
 360     , m_frame(frame)
 361 {
 362 }
 363
 364 ClipboardWin::ClipboardWin(ClipboardType clipboardType, const DragDataMap& dataMap, ClipboardAccessPolicy policy, Frame* frame)
 365     : Clipboard(policy, clipboardType)
 366     , m_dataObject(0)
 367     , m_writableDataObject(0)
 368     , m_frame(frame)
 369     , m_dragDataMap(dataMap)
 370 {
 371 }
 372
 373 ClipboardWin::~ClipboardWin()
 374 {
 375 }
 376
 377 static bool writeURL(WCDataObject *data, const KURL& url, String title, bool withPlainText, bool withHTML)
 378 {
 379     ASSERT(data);
 380
 381     if (url.isEmpty())
 382         return false;
 383
 384     if (title.isEmpty()) {
 385         title = url.lastPathComponent();
 386         if (title.isEmpty())
 387             title = url.host();
 388     }
 389
 390     STGMEDIUM medium = {0};
 391     medium.tymed = TYMED_HGLOBAL;
 392
 393     medium.hGlobal = createGlobalData(url, title);
 394     bool success = false;
 395     if (medium.hGlobal && FAILED(data->SetData(urlWFormat(), &medium, TRUE)))
 396         ::GlobalFree(medium.hGlobal);
 397     else
 398         success = true;
 399
 400     if (withHTML) {
 401         Vector<char> cfhtmlData;
 402         markupToCFHTML(urlToMarkup(url, title), "", cfhtmlData);
 403         medium.hGlobal = createGlobalData(cfhtmlData);
 404         if (medium.hGlobal && FAILED(data->SetData(htmlFormat(), &medium, TRUE)))
 405             ::GlobalFree(medium.hGlobal);
 406         else
 407             success = true;
 408     }
 409
 410     if (withPlainText) {
 411         medium.hGlobal = createGlobalData(url.string());
 412         if (medium.hGlobal && FAILED(data->SetData(plainTextWFormat(), &medium, TRUE)))
 413             ::GlobalFree(medium.hGlobal);
 414         else
 415             success = true;
 416     }
 417
 418     return success;
 419 }
 420
 421 void ClipboardWin::clearData(const String& type)
 422 {
 423     // FIXME: Need to be able to write to the system clipboard <rdar://problem/5015941>
 424     ASSERT(isForDragAndDrop());
 425     if (policy() != ClipboardWritable || !m_writableDataObject)
 426         return;
 427
 428     ClipboardDataType dataType = clipboardTypeFromMIMEType(type);
 429
 430     if (dataType == ClipboardDataTypeURL) {
 431         m_writableDataObject->clearData(urlWFormat()->cfFormat);
 432         m_writableDataObject->clearData(urlFormat()->cfFormat);
 433     }
 434     if (dataType == ClipboardDataTypeText) {
 435         m_writableDataObject->clearData(plainTextFormat()->cfFormat);
 436         m_writableDataObject->clearData(plainTextWFormat()->cfFormat);
 437     }
 438
 439 }
 440
 441 void ClipboardWin::clearAllData()
 442 {
 443     // FIXME: Need to be able to write to the system clipboard <rdar://problem/5015941>
 444     ASSERT(isForDragAndDrop());
 445     if (policy() != ClipboardWritable)
 446         return;
 447
 448     m_writableDataObject = 0;
 449     WCDataObject::createInstance(&m_writableDataObject);
 450     m_dataObject = m_writableDataObject;
 451 }
 452
 453 String ClipboardWin::getData(const String& type, bool& success) const
 454 {
 455     success = false;
 456     if (policy() != ClipboardReadable || (!m_dataObject && m_dragDataMap.isEmpty()))
 457         return "";
 458
 459     ClipboardDataType dataType = clipboardTypeFromMIMEType(type);
 460     if (dataType == ClipboardDataTypeText)
 461         return m_dataObject ? getPlainText(m_dataObject.get(), success) : getPlainText(&m_dragDataMap);
 462     if (dataType == ClipboardDataTypeURL)
 463         return m_dataObject ? getURL(m_dataObject.get(), DragData::DoNotConvertFilenames, success) : getURL(&m_dragDataMap, DragData::DoNotConvertFilenames);
 464     else if (dataType == ClipboardDataTypeTextHTML) {
 465         String data = m_dataObject ? getTextHTML(m_dataObject.get(), success) : getTextHTML(&m_dragDataMap);
 466         if (success)
 467             return data;
 468         return m_dataObject ? getCFHTML(m_dataObject.get(), success) : getCFHTML(&m_dragDataMap);
 469     }
 470
 471     return "";
 472 }
 473
 474 bool ClipboardWin::setData(const String& type, const String& data)
 475 {
 476     // FIXME: Need to be able to write to the system clipboard <rdar://problem/5015941>
 477     ASSERT(isForDragAndDrop());
 478     if (policy() != ClipboardWritable || !m_writableDataObject)
 479         return false;
 480
 481     ClipboardDataType winType = clipboardTypeFromMIMEType(type);
 482
 483     if (winType == ClipboardDataTypeURL)
 484         return WebCore::writeURL(m_writableDataObject.get(), KURL(ParsedURLString, data), String(), false, true);
 485
 486     if (winType == ClipboardDataTypeText) {
 487         STGMEDIUM medium = {0};
 488         medium.tymed = TYMED_HGLOBAL;
 489         medium.hGlobal = createGlobalData(data);
 490         if (!medium.hGlobal)
 491             return false;
 492
 493         if (FAILED(m_writableDataObject->SetData(plainTextWFormat(), &medium, TRUE))) {
 494             ::GlobalFree(medium.hGlobal);
 495             return false;
 496         }
 497         return true;
 498     }
 499
 500     return false;
 501 }
 502
 503 static void addMimeTypesForFormat(HashSet<String>& results, const FORMATETC& format)
 504 {
 505     // URL and Text are provided for compatibility with IE's model
 506     if (format.cfFormat == urlFormat()->cfFormat || format.cfFormat == urlWFormat()->cfFormat) {
 507         results.add("URL");
 508         results.add("text/uri-list");
 509     }
 510
 511     if (format.cfFormat == plainTextWFormat()->cfFormat || format.cfFormat == plainTextFormat()->cfFormat) {
 512         results.add("Text");
 513         results.add("text/plain");
 514     }
 515 }
 516
 517 // extensions beyond IE's API
 518 HashSet<String> ClipboardWin::types() const
 519 {
 520     HashSet<String> results;
 521     if (policy() != ClipboardReadable && policy() != ClipboardTypesReadable)
 522         return results;
 523
 524     if (!m_dataObject && m_dragDataMap.isEmpty())
 525         return results;
 526
 527     if (m_dataObject) {
 528         COMPtr<IEnumFORMATETC> itr;
 529
 530         if (FAILED(m_dataObject->EnumFormatEtc(DATADIR_GET, &itr)))
 531             return results;
 532
 533         if (!itr)
 534             return results;
 535
 536         FORMATETC data;
 537
 538         // IEnumFORMATETC::Next returns S_FALSE if there are no more items.
 539         while (itr->Next(1, &data, 0) == S_OK)
 540             addMimeTypesForFormat(results, data);
 541     } else {
 542         for (DragDataMap::const_iterator it = m_dragDataMap.begin(); it != m_dragDataMap.end(); ++it) {
 543             FORMATETC data;
 544             data.cfFormat = (*it).first;
 545             addMimeTypesForFormat(results, data);
 546         }
 547     }
 548
 549     return results;
 550 }
 551
 552 PassRefPtr<FileList> ClipboardWin::files() const
 553 {
 554 #if OS(WINCE)
 555     notImplemented();
 556     return 0;
 557 #else
 558     RefPtr<FileList> files = FileList::create();
 559     if (policy() != ClipboardReadable && policy() != ClipboardTypesReadable)
 560         return files.release();
 561
 562     if (!m_dataObject && m_dragDataMap.isEmpty())
 563         return files.release();
 564
 565     if (m_dataObject) {
 566         STGMEDIUM medium;
 567         if (FAILED(m_dataObject->GetData(cfHDropFormat(), &medium)))
 568             return files.release();
 569
 570         HDROP hdrop = reinterpret_cast<HDROP>(GlobalLock(medium.hGlobal));
 571         if (!hdrop)
 572             return files.release();
 573
 574         WCHAR filename[MAX_PATH];
 575         UINT fileCount = DragQueryFileW(hdrop, 0xFFFFFFFF, 0, 0);
 576         for (UINT i = 0; i < fileCount; i++) {
 577             if (!DragQueryFileW(hdrop, i, filename, WTF_ARRAY_LENGTH(filename)))
 578                 continue;
 579             files->append(File::create(reinterpret_cast<UChar*>(filename)));
 580         }
 581
 582         GlobalUnlock(medium.hGlobal);
 583         ReleaseStgMedium(&medium);
 584         return files.release();
 585     }
 586     if (!m_dragDataMap.contains(cfHDropFormat()->cfFormat))
 587         return files.release();
 588     Vector<String> filesVector = m_dragDataMap.get(cfHDropFormat()->cfFormat);
 589     for (Vector<String>::iterator it = filesVector.begin(); it != filesVector.end(); ++it)
 590         files->append(File::create((*it).characters()));
 591     return files.release();
 592 #endif
 593 }
 594
 595 void ClipboardWin::setDragImage(CachedImage* image, Node *node, const IntPoint &loc)
 596 {
 597     if (policy() != ClipboardImageWritable && policy() != ClipboardWritable)
 598         return;
 599
 600     if (m_dragImage)
 601         m_dragImage->removeClient(this);
 602     m_dragImage = image;
 603     if (m_dragImage)
 604         m_dragImage->addClient(this);
 605
 606     m_dragLoc = loc;
 607     m_dragImageElement = node;
 608 }
 609
 610 void ClipboardWin::setDragImage(CachedImage* img, const IntPoint &loc)
 611 {
 612     setDragImage(img, 0, loc);
 613 }
 614
 615 void ClipboardWin::setDragImageElement(Node *node, const IntPoint &loc)
 616 {
 617     setDragImage(0, node, loc);
 618 }
 619
 620 DragImageRef ClipboardWin::createDragImage(IntPoint& loc) const
 621 {
 622     HBITMAP result = 0;
 623     if (m_dragImage) {
 624         result = createDragImageFromImage(m_dragImage->image());
 625         loc = m_dragLoc;
 626     } else if (m_dragImageElement) {
 627         Node* node = m_dragImageElement.get();
 628         result = node->document()->frame()->nodeImage(node);
 629         loc = m_dragLoc;
 630     }
 631     return result;
 632 }
 633
 634 static String imageToMarkup(const String& url)
 635 {
 636     String markup("<img src=\"");
 637     markup.append(url);
 638     markup.append("\"/>");
 639     return markup;
 640 }
 641
 642 static CachedImage* getCachedImage(Element* element)
 643 {
 644     // Attempt to pull CachedImage from element
 645     ASSERT(element);
 646     RenderObject* renderer = element->renderer();
 647     if (!renderer || !renderer->isImage())
 648         return 0;
 649
 650     RenderImage* image = toRenderImage(renderer);
 651     if (image->cachedImage() && !image->cachedImage()->errorOccurred())
 652         return image->cachedImage();
 653
 654     return 0;
 655 }
 656
 657 static void writeImageToDataObject(IDataObject* dataObject, Element* element, const KURL& url)
 658 {
 659     // Shove image data into a DataObject for use as a file
 660     CachedImage* cachedImage = getCachedImage(element);
 661     if (!cachedImage || !cachedImage->image() || !cachedImage->isLoaded())
 662         return;
 663
 664     SharedBuffer* imageBuffer = cachedImage->image()->data();
 665     if (!imageBuffer || !imageBuffer->size())
 666         return;
 667
 668     HGLOBAL imageFileDescriptor = createGlobalImageFileDescriptor(url.string(), element->getAttribute(altAttr), cachedImage);
 669     if (!imageFileDescriptor)
 670         return;
 671
 672     HGLOBAL imageFileContent = createGlobalImageFileContent(imageBuffer);
 673     if (!imageFileContent) {
 674         GlobalFree(imageFileDescriptor);
 675         return;
 676     }
 677
 678     String fileName = cachedImage->response().suggestedFilename();
 679     HGLOBAL hDropContent = createGlobalHDropContent(url, fileName, imageBuffer);
 680     if (!hDropContent) {
 681         GlobalFree(hDropContent);
 682         return;
 683     }
 684
 685     writeFileToDataObject(dataObject, imageFileDescriptor, imageFileContent, hDropContent);
 686 }
 687
 688 void ClipboardWin::declareAndWriteDragImage(Element* element, const KURL& url, const String& title, Frame* frame)
 689 {
 690     // Order is important here for Explorer's sake
 691     if (!m_writableDataObject)
 692          return;
 693     WebCore::writeURL(m_writableDataObject.get(), url, title, true, false);
 694
 695     writeImageToDataObject(m_writableDataObject.get(), element, url);
 696
 697     AtomicString imageURL = element->getAttribute(srcAttr);
 698     if (imageURL.isEmpty())
 699         return;
 700
 701     String fullURL = frame->document()->completeURL(stripLeadingAndTrailingHTMLSpaces(imageURL)).string();
 702     if (fullURL.isEmpty())
 703         return;
 704     STGMEDIUM medium = {0};
 705     medium.tymed = TYMED_HGLOBAL;
 706     ExceptionCode ec = 0;
 707
 708     // Put img tag on the clipboard referencing the image
 709     Vector<char> data;
 710     markupToCFHTML(imageToMarkup(fullURL), "", data);
 711     medium.hGlobal = createGlobalData(data);
 712     if (medium.hGlobal && FAILED(m_writableDataObject->SetData(htmlFormat(), &medium, TRUE)))
 713         ::GlobalFree(medium.hGlobal);
 714 }
 715
 716 void ClipboardWin::writeURL(const KURL& kurl, const String& titleStr, Frame*)
 717 {
 718     if (!m_writableDataObject)
 719          return;
 720     WebCore::writeURL(m_writableDataObject.get(), kurl, titleStr, true, true);
 721
 722     String url = kurl.string();
 723     ASSERT(url.containsOnlyASCII()); // KURL::string() is URL encoded.
 724
 725     String fsPath = filesystemPathFromUrlOrTitle(url, titleStr, L".URL", true);
 726     CString content = makeString("[InternetShortcut]\r\nURL=", url, "\r\n").ascii();
 727
 728     if (fsPath.length() <= 0)
 729         return;
 730
 731     HGLOBAL urlFileDescriptor = GlobalAlloc(GPTR, sizeof(FILEGROUPDESCRIPTOR));
 732     if (!urlFileDescriptor)
 733         return;
 734
 735     HGLOBAL urlFileContent = GlobalAlloc(GPTR, content.length());
 736     if (!urlFileContent) {
 737         GlobalFree(urlFileDescriptor);
 738         return;
 739     }
 740
 741     FILEGROUPDESCRIPTOR* fgd = static_cast<FILEGROUPDESCRIPTOR*>(GlobalLock(urlFileDescriptor));
 742     ZeroMemory(fgd, sizeof(FILEGROUPDESCRIPTOR));
 743     fgd->cItems = 1;
 744     fgd->fgd[0].dwFlags = FD_FILESIZE;
 745     fgd->fgd[0].nFileSizeLow = content.length();
 746
 747     unsigned maxSize = min(fsPath.length(), WTF_ARRAY_LENGTH(fgd->fgd[0].cFileName));
 748     CopyMemory(fgd->fgd[0].cFileName, fsPath.characters(), maxSize * sizeof(UChar));
 749     GlobalUnlock(urlFileDescriptor);
 750
 751     char* fileContents = static_cast<char*>(GlobalLock(urlFileContent));
 752     CopyMemory(fileContents, content.data(), content.length());
 753     GlobalUnlock(urlFileContent);
 754
 755     writeFileToDataObject(m_writableDataObject.get(), urlFileDescriptor, urlFileContent, 0);
 756 }
 757
 758 void ClipboardWin::writeRange(Range* selectedRange, Frame* frame)
 759 {
 760     ASSERT(selectedRange);
 761     if (!m_writableDataObject)
 762          return;
 763
 764     STGMEDIUM medium = {0};
 765     medium.tymed = TYMED_HGLOBAL;
 766     ExceptionCode ec = 0;
 767
 768     Vector<char> data;
 769     markupToCFHTML(createMarkup(selectedRange, 0, AnnotateForInterchange),
 770         selectedRange->startContainer(ec)->document()->url().string(), data);
 771     medium.hGlobal = createGlobalData(data);
 772     if (medium.hGlobal && FAILED(m_writableDataObject->SetData(htmlFormat(), &medium, TRUE)))
 773         ::GlobalFree(medium.hGlobal);
 774
 775     String str = frame->editor()->selectedText();
 776     replaceNewlinesWithWindowsStyleNewlines(str);
 777     replaceNBSPWithSpace(str);
 778     medium.hGlobal = createGlobalData(str);
 779     if (medium.hGlobal && FAILED(m_writableDataObject->SetData(plainTextWFormat(), &medium, TRUE)))
 780         ::GlobalFree(medium.hGlobal);
 781
 782     medium.hGlobal = 0;
 783     if (frame->editor()->canSmartCopyOrDelete())
 784         m_writableDataObject->SetData(smartPasteFormat(), &medium, TRUE);
 785 }
 786
 787 void ClipboardWin::writePlainText(const String& text)
 788 {
 789     if (!m_writableDataObject)
 790         return;
 791
 792     STGMEDIUM medium = {0};
 793     medium.tymed = TYMED_HGLOBAL;
 794     ExceptionCode ec = 0;
 795
 796     String str = text;
 797     replaceNewlinesWithWindowsStyleNewlines(str);
 798     replaceNBSPWithSpace(str);
 799     medium.hGlobal = createGlobalData(str);
 800     if (medium.hGlobal && FAILED(m_writableDataObject->SetData(plainTextWFormat(), &medium, TRUE)))
 801         ::GlobalFree(medium.hGlobal);
 802
 803     medium.hGlobal = 0;
 804 }
 805
 806 bool ClipboardWin::hasData()
 807 {
 808     if (!m_dataObject && m_dragDataMap.isEmpty())
 809         return false;
 810
 811     if (m_dataObject) {
 812         COMPtr<IEnumFORMATETC> itr;
 813         if (FAILED(m_dataObject->EnumFormatEtc(DATADIR_GET, &itr)))
 814             return false;
 815
 816         if (!itr)
 817             return false;
 818
 819         FORMATETC data;
 820
 821         // IEnumFORMATETC::Next returns S_FALSE if there are no more items.
 822         if (itr->Next(1, &data, 0) == S_OK) {
 823             // There is at least one item in the IDataObject
 824             return true;
 825         }
 826
 827         return false;
 828     }
 829     return !m_dragDataMap.isEmpty();
 830 }
 831
 832 void ClipboardWin::setExternalDataObject(IDataObject *dataObject)
 833 {
 834     ASSERT(isForDragAndDrop());
 835
 836     m_writableDataObject = 0;
 837     m_dataObject = dataObject;
 838 }
 839
 840 } // namespace WebCore