| /* |
| * Copyright (C) 2007 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. |
| */ |
| |
| #include "config.h" |
| #include "ClipboardUtilitiesWin.h" |
| |
| #include "KURL.h" |
| #include "CString.h" |
| #include "DocumentFragment.h" |
| #include "markup.h" |
| #include "PlatformString.h" |
| #include "TextEncoding.h" |
| #include <CoreFoundation/CoreFoundation.h> |
| #include <wtf/RetainPtr.h> |
| #include <shlwapi.h> |
| #include <wininet.h> // for INTERNET_MAX_URL_LENGTH |
| |
| namespace WebCore { |
| |
| FORMATETC* cfHDropFormat() |
| { |
| static FORMATETC urlFormat = {CF_HDROP, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}; |
| return &urlFormat; |
| } |
| |
| static bool getWebLocData(IDataObject* dataObject, String& url, String* title) |
| { |
| bool succeeded = false; |
| WCHAR filename[MAX_PATH]; |
| WCHAR urlBuffer[INTERNET_MAX_URL_LENGTH]; |
| |
| STGMEDIUM medium; |
| if (FAILED(dataObject->GetData(cfHDropFormat(), &medium))) |
| return false; |
| |
| HDROP hdrop = (HDROP)GlobalLock(medium.hGlobal); |
| |
| if (!hdrop) |
| return false; |
| |
| if (!DragQueryFileW(hdrop, 0, filename, ARRAYSIZE(filename))) |
| goto exit; |
| |
| if (_wcsicmp(PathFindExtensionW(filename), L".url")) |
| goto exit; |
| |
| if (!GetPrivateProfileStringW(L"InternetShortcut", L"url", 0, urlBuffer, ARRAYSIZE(urlBuffer), filename)) |
| goto exit; |
| |
| if (title) { |
| PathRemoveExtension(filename); |
| *title = String((UChar*)filename); |
| } |
| |
| url = String((UChar*)urlBuffer); |
| succeeded = true; |
| |
| exit: |
| // Free up memory. |
| DragFinish(hdrop); |
| GlobalUnlock(medium.hGlobal); |
| return succeeded; |
| } |
| |
| static String extractURL(const String &inURL, String* title) |
| { |
| String url = inURL; |
| int splitLoc = url.find('\n'); |
| if (splitLoc > 0) { |
| if (title) |
| *title = url.substring(splitLoc+1); |
| url.truncate(splitLoc); |
| } else if (title) |
| *title = url; |
| return url; |
| } |
| |
| //Firefox text/html |
| static FORMATETC* texthtmlFormat() |
| { |
| static UINT cf = RegisterClipboardFormat(L"text/html"); |
| static FORMATETC texthtmlFormat = {cf, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}; |
| return &texthtmlFormat; |
| } |
| |
| HGLOBAL createGlobalData(const KURL& url, const String& title) |
| { |
| String mutableURL(url.string()); |
| String mutableTitle(title); |
| SIZE_T size = mutableURL.length() + mutableTitle.length() + 2; // +1 for "\n" and +1 for null terminator |
| HGLOBAL cbData = ::GlobalAlloc(GPTR, size * sizeof(UChar)); |
| |
| if (cbData) { |
| PWSTR buffer = (PWSTR)::GlobalLock(cbData); |
| swprintf_s(buffer, size, L"%s\n%s", mutableURL.charactersWithNullTermination(), mutableTitle.charactersWithNullTermination()); |
| ::GlobalUnlock(cbData); |
| } |
| return cbData; |
| } |
| |
| HGLOBAL createGlobalData(String str) |
| { |
| SIZE_T size = (str.length() + 1) * sizeof(UChar); |
| HGLOBAL cbData = ::GlobalAlloc(GPTR, size); |
| if (cbData) { |
| void* buffer = ::GlobalLock(cbData); |
| memcpy(buffer, str.charactersWithNullTermination(), size); |
| ::GlobalUnlock(cbData); |
| } |
| return cbData; |
| } |
| |
| HGLOBAL createGlobalData(CString str) |
| { |
| SIZE_T size = str.length() * sizeof(char); |
| HGLOBAL cbData = ::GlobalAlloc(GPTR, size + 1); |
| if (cbData) { |
| char* buffer = static_cast<char*>(::GlobalLock(cbData)); |
| memcpy(buffer, str.data(), size); |
| buffer[size] = 0; |
| ::GlobalUnlock(cbData); |
| } |
| return cbData; |
| } |
| |
| // Documentation for the CF_HTML format is available at http://msdn.microsoft.com/workshop/networking/clipboard/htmlclipboard.asp |
| DeprecatedCString markupToCF_HTML(const String& markup, const String& srcURL) |
| { |
| if (!markup.length()) |
| return DeprecatedCString(); |
| |
| DeprecatedCString cf_html ("Version:0.9"); |
| DeprecatedCString startHTML ("\nStartHTML:"); |
| DeprecatedCString endHTML ("\nEndHTML:"); |
| DeprecatedCString startFragment ("\nStartFragment:"); |
| DeprecatedCString endFragment ("\nEndFragment:"); |
| DeprecatedCString sourceURL ("\nSourceURL:"); |
| |
| bool shouldFillSourceURL = !srcURL.isEmpty() && (srcURL != "about:blank"); |
| if (shouldFillSourceURL) |
| sourceURL.append(srcURL.utf8().data()); |
| |
| DeprecatedCString startMarkup ("\n<HTML>\n<BODY>\n<!--StartFragment-->\n"); |
| DeprecatedCString endMarkup ("\n<!--EndFragment-->\n</BODY>\n</HTML>"); |
| |
| // calculate offsets |
| const unsigned UINT_MAXdigits = 10; // number of digits in UINT_MAX in base 10 |
| unsigned startHTMLOffset = cf_html.length() + startHTML.length() + endHTML.length() + startFragment.length() + endFragment.length() + (shouldFillSourceURL ? sourceURL.length() : 0) + (4*UINT_MAXdigits); |
| unsigned startFragmentOffset = startHTMLOffset + startMarkup.length(); |
| CString markupUTF8 = markup.utf8(); |
| unsigned endFragmentOffset = startFragmentOffset + markupUTF8.length(); |
| unsigned endHTMLOffset = endFragmentOffset + endMarkup.length(); |
| |
| // fill in needed data |
| startHTML.append(String::format("%010u", startHTMLOffset).deprecatedString().utf8()); |
| endHTML.append(String::format("%010u", endHTMLOffset).deprecatedString().utf8()); |
| startFragment.append(String::format("%010u", startFragmentOffset).deprecatedString().utf8()); |
| endFragment.append(String::format("%010u", endFragmentOffset).deprecatedString().utf8()); |
| startMarkup.append(markupUTF8.data()); |
| |
| // create full cf_html string from the fragments |
| cf_html.append(startHTML); |
| cf_html.append(endHTML); |
| cf_html.append(startFragment); |
| cf_html.append(endFragment); |
| if (shouldFillSourceURL) |
| cf_html.append(sourceURL); |
| cf_html.append(startMarkup); |
| cf_html.append(endMarkup); |
| |
| return cf_html; |
| } |
| |
| String urlToMarkup(const KURL& url, const String& title) |
| { |
| String markup("<a href=\""); |
| markup.append(url.string()); |
| markup.append("\">"); |
| markup.append(title); |
| markup.append("</a>"); |
| return markup; |
| } |
| |
| void replaceNewlinesWithWindowsStyleNewlines(String& str) |
| { |
| static const UChar Newline = '\n'; |
| static const String WindowsNewline("\r\n"); |
| str.replace(Newline, WindowsNewline); |
| } |
| |
| void replaceNBSPWithSpace(String& str) |
| { |
| static const UChar NonBreakingSpaceCharacter = 0xA0; |
| static const UChar SpaceCharacter = ' '; |
| str.replace(NonBreakingSpaceCharacter, SpaceCharacter); |
| } |
| |
| FORMATETC* urlWFormat() |
| { |
| static UINT cf = RegisterClipboardFormat(L"UniformResourceLocatorW"); |
| static FORMATETC urlFormat = {cf, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}; |
| return &urlFormat; |
| } |
| |
| FORMATETC* urlFormat() |
| { |
| static UINT cf = RegisterClipboardFormat(L"UniformResourceLocator"); |
| static FORMATETC urlFormat = {cf, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}; |
| return &urlFormat; |
| } |
| |
| FORMATETC* plainTextFormat() |
| { |
| static FORMATETC textFormat = {CF_TEXT, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}; |
| return &textFormat; |
| } |
| |
| FORMATETC* plainTextWFormat() |
| { |
| static FORMATETC textFormat = {CF_UNICODETEXT, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}; |
| return &textFormat; |
| } |
| |
| FORMATETC* filenameWFormat() |
| { |
| static UINT cf = RegisterClipboardFormat(L"FileNameW"); |
| static FORMATETC urlFormat = {cf, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}; |
| return &urlFormat; |
| } |
| |
| FORMATETC* filenameFormat() |
| { |
| static UINT cf = RegisterClipboardFormat(L"FileName"); |
| static FORMATETC urlFormat = {cf, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}; |
| return &urlFormat; |
| } |
| |
| //MSIE HTML Format |
| FORMATETC* htmlFormat() |
| { |
| static UINT cf = RegisterClipboardFormat(L"HTML Format"); |
| static FORMATETC htmlFormat = {cf, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}; |
| return &htmlFormat; |
| } |
| |
| FORMATETC* smartPasteFormat() |
| { |
| static UINT cf = RegisterClipboardFormat(L"WebKit Smart Paste Format"); |
| static FORMATETC htmlFormat = {cf, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL}; |
| return &htmlFormat; |
| } |
| |
| static bool urlFromPath(CFStringRef path, String& url) |
| { |
| if (!path) |
| return false; |
| |
| RetainPtr<CFURLRef> cfURL(AdoptCF, CFURLCreateWithFileSystemPath(0, path, kCFURLWindowsPathStyle, false)); |
| if (!cfURL) |
| return false; |
| |
| url = String(CFURLGetString(cfURL.get())); |
| return true; |
| } |
| |
| String getURL(IDataObject* dataObject, bool& success, String* title) |
| { |
| STGMEDIUM store; |
| String url; |
| success = false; |
| if (getWebLocData(dataObject, url, title)) { |
| success = true; |
| return url; |
| } else if (SUCCEEDED(dataObject->GetData(urlWFormat(), &store))) { |
| //URL using unicode |
| UChar* data = (UChar*)GlobalLock(store.hGlobal); |
| url = extractURL(String(data), title); |
| GlobalUnlock(store.hGlobal); |
| ReleaseStgMedium(&store); |
| success = true; |
| } else if (SUCCEEDED(dataObject->GetData(urlFormat(), &store))) { |
| //URL using ascii |
| char* data = (char*)GlobalLock(store.hGlobal); |
| url = extractURL(String(data), title); |
| GlobalUnlock(store.hGlobal); |
| ReleaseStgMedium(&store); |
| success = true; |
| } else if (SUCCEEDED(dataObject->GetData(filenameWFormat(), &store))) { |
| //file using unicode |
| wchar_t* data = (wchar_t*)GlobalLock(store.hGlobal); |
| if (data && data[0] && (PathFileExists(data) || PathIsUNC(data))) { |
| RetainPtr<CFStringRef> pathAsCFString(AdoptCF, CFStringCreateWithCharacters(kCFAllocatorDefault, (const UniChar*)data, wcslen(data))); |
| if (urlFromPath(pathAsCFString.get(), url)) { |
| if (title) |
| *title = url; |
| success = true; |
| } |
| } |
| GlobalUnlock(store.hGlobal); |
| ReleaseStgMedium(&store); |
| } else if (SUCCEEDED(dataObject->GetData(filenameFormat(), &store))) { |
| //filename using ascii |
| char* data = (char*)GlobalLock(store.hGlobal); |
| if (data && data[0] && (PathFileExistsA(data) || PathIsUNCA(data))) { |
| RetainPtr<CFStringRef> pathAsCFString(AdoptCF, CFStringCreateWithCString(kCFAllocatorDefault, data, kCFStringEncodingASCII)); |
| if (urlFromPath(pathAsCFString.get(), url)) { |
| if (title) |
| *title = url; |
| success = true; |
| } |
| } |
| GlobalUnlock(store.hGlobal); |
| ReleaseStgMedium(&store); |
| } |
| return url; |
| } |
| |
| String getPlainText(IDataObject* dataObject, bool& success) |
| { |
| STGMEDIUM store; |
| String text; |
| success = false; |
| if (SUCCEEDED(dataObject->GetData(plainTextWFormat(), &store))) { |
| //unicode text |
| UChar* data = (UChar*)GlobalLock(store.hGlobal); |
| text = String(data); |
| GlobalUnlock(store.hGlobal); |
| ReleaseStgMedium(&store); |
| success = true; |
| } else if (SUCCEEDED(dataObject->GetData(plainTextFormat(), &store))) { |
| //ascii text |
| char* data = (char*)GlobalLock(store.hGlobal); |
| text = String(data); |
| GlobalUnlock(store.hGlobal); |
| ReleaseStgMedium(&store); |
| success = true; |
| } else { |
| //If a file is dropped on the window, it does not provide either of the |
| //plain text formats, so here we try to forcibly get a url. |
| text = getURL(dataObject, success); |
| success = true; |
| } |
| return text; |
| } |
| |
| PassRefPtr<DocumentFragment> fragmentFromFilenames(Document*, const IDataObject*) |
| { |
| //FIXME: We should be able to create fragments from files |
| return 0; |
| } |
| |
| bool containsFilenames(const IDataObject*) |
| { |
| //FIXME: We'll want to update this once we can produce fragments from files |
| return false; |
| } |
| |
| //Convert a String containing CF_HTML formatted text to a DocumentFragment |
| PassRefPtr<DocumentFragment> fragmentFromCF_HTML(Document* doc, const String& cf_html) |
| { |
| // obtain baseURL if present |
| String srcURLStr("sourceURL:"); |
| String srcURL; |
| unsigned lineStart = cf_html.find(srcURLStr, 0, false); |
| if (lineStart != -1) { |
| unsigned srcEnd = cf_html.find("\n", lineStart, false); |
| unsigned srcStart = lineStart+srcURLStr.length(); |
| String rawSrcURL = cf_html.substring(srcStart, srcEnd-srcStart); |
| replaceNBSPWithSpace(rawSrcURL); |
| srcURL = rawSrcURL.stripWhiteSpace(); |
| } |
| |
| // find the markup between "<!--StartFragment -->" and "<!--EndFragment -->", accounting for browser quirks |
| unsigned markupStart = cf_html.find("<html", 0, false); |
| unsigned tagStart = cf_html.find("startfragment", markupStart, false); |
| unsigned fragmentStart = cf_html.find('>', tagStart) + 1; |
| unsigned tagEnd = cf_html.find("endfragment", fragmentStart, false); |
| unsigned fragmentEnd = cf_html.reverseFind('<', tagEnd); |
| String markup = cf_html.substring(fragmentStart, fragmentEnd - fragmentStart).stripWhiteSpace(); |
| |
| return createFragmentFromMarkup(doc, markup, srcURL).releaseRef(); |
| } |
| |
| |
| PassRefPtr<DocumentFragment> fragmentFromHTML(Document* doc, IDataObject* data) |
| { |
| if (!doc || !data) |
| return 0; |
| |
| STGMEDIUM store; |
| String html; |
| String srcURL; |
| if (SUCCEEDED(data->GetData(htmlFormat(), &store))) { |
| //MS HTML Format parsing |
| char* data = (char*)GlobalLock(store.hGlobal); |
| SIZE_T dataSize = ::GlobalSize(store.hGlobal); |
| String cf_html(UTF8Encoding().decode(data, dataSize)); |
| GlobalUnlock(store.hGlobal); |
| ReleaseStgMedium(&store); |
| if (PassRefPtr<DocumentFragment> fragment = fragmentFromCF_HTML(doc, cf_html)) |
| return fragment; |
| } |
| if (SUCCEEDED(data->GetData(texthtmlFormat(), &store))) { |
| //raw html |
| UChar* data = (UChar*)GlobalLock(store.hGlobal); |
| html = String(data); |
| GlobalUnlock(store.hGlobal); |
| ReleaseStgMedium(&store); |
| return createFragmentFromMarkup(doc, html, srcURL); |
| } |
| |
| return 0; |
| } |
| |
| bool containsHTML(IDataObject* data) |
| { |
| return SUCCEEDED(data->QueryGetData(texthtmlFormat())) || SUCCEEDED(data->QueryGetData(htmlFormat())); |
| } |
| |
| } // namespace WebCore |