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