mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-11-08 20:47:44 +00:00
1b83407ce9
This patch was automatically generated by the following script:
#!/bin/bash
# Command to convert PRUnichar to char16_t
function convert() {
echo "Converting $1 to $2..."
find . ! -wholename "*nsprpub*" \
! -wholename "*security/nss*" \
! -wholename "*modules/libmar*" \
! -wholename "*/.hg*" \
! -wholename "obj-ff-dbg*" \
! -name prtypes.h \
! -name Char16.h \
-type f \
\( -iname "*.cpp" \
-o -iname "*.h" \
-o -iname "*.c" \
-o -iname "*.cc" \
-o -iname "*.idl" \
-o -iname "*.ipdl" \
-o -iname "*.ipdlh" \
-o -iname "*.mm" \) | \
xargs -n 1 sed -i -e "s/\b$1\b/$2/g"
}
convert PRUnichar char16_t
1000 lines
37 KiB
C++
1000 lines
37 KiB
C++
/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#include "nsClipboard.h"
|
|
#include <ole2.h>
|
|
#include <shlobj.h>
|
|
#include <intshcut.h>
|
|
|
|
// shellapi.h is needed to build with WIN32_LEAN_AND_MEAN
|
|
#include <shellapi.h>
|
|
|
|
#include "nsCOMPtr.h"
|
|
#include "nsDataObj.h"
|
|
#include "nsIClipboardOwner.h"
|
|
#include "nsString.h"
|
|
#include "nsNativeCharsetUtils.h"
|
|
#include "nsIFormatConverter.h"
|
|
#include "nsITransferable.h"
|
|
#include "nsCOMPtr.h"
|
|
#include "nsXPCOM.h"
|
|
#include "nsISupportsPrimitives.h"
|
|
#include "nsXPIDLString.h"
|
|
#include "nsReadableUtils.h"
|
|
#include "nsUnicharUtils.h"
|
|
#include "nsPrimitiveHelpers.h"
|
|
#include "nsImageClipboard.h"
|
|
#include "nsIWidget.h"
|
|
#include "nsIComponentManager.h"
|
|
#include "nsWidgetsCID.h"
|
|
#include "nsCRT.h"
|
|
#include "nsNetUtil.h"
|
|
#include "nsEscape.h"
|
|
#include "nsIObserverService.h"
|
|
|
|
#ifdef PR_LOGGING
|
|
PRLogModuleInfo* gWin32ClipboardLog = nullptr;
|
|
#endif
|
|
|
|
// oddly, this isn't in the MSVC headers anywhere.
|
|
UINT nsClipboard::CF_HTML = ::RegisterClipboardFormatW(L"HTML Format");
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
//
|
|
// nsClipboard constructor
|
|
//
|
|
//-------------------------------------------------------------------------
|
|
nsClipboard::nsClipboard() : nsBaseClipboard()
|
|
{
|
|
#ifdef PR_LOGGING
|
|
if (!gWin32ClipboardLog) {
|
|
gWin32ClipboardLog = PR_NewLogModule("nsClipboard");
|
|
}
|
|
#endif
|
|
|
|
mIgnoreEmptyNotification = false;
|
|
mWindow = nullptr;
|
|
|
|
// Register for a shutdown notification so that we can flush data
|
|
// to the OS clipboard.
|
|
nsCOMPtr<nsIObserverService> observerService =
|
|
do_GetService("@mozilla.org/observer-service;1");
|
|
if (observerService)
|
|
observerService->AddObserver(this, NS_XPCOM_SHUTDOWN_OBSERVER_ID, PR_FALSE);
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
// nsClipboard destructor
|
|
//-------------------------------------------------------------------------
|
|
nsClipboard::~nsClipboard()
|
|
{
|
|
|
|
}
|
|
|
|
NS_IMPL_ISUPPORTS_INHERITED1(nsClipboard, nsBaseClipboard, nsIObserver)
|
|
|
|
NS_IMETHODIMP
|
|
nsClipboard::Observe(nsISupports *aSubject, const char *aTopic,
|
|
const char16_t *aData)
|
|
{
|
|
// This will be called on shutdown.
|
|
::OleFlushClipboard();
|
|
::CloseClipboard();
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
UINT nsClipboard::GetFormat(const char* aMimeStr)
|
|
{
|
|
UINT format;
|
|
|
|
if (strcmp(aMimeStr, kTextMime) == 0)
|
|
format = CF_TEXT;
|
|
else if (strcmp(aMimeStr, kUnicodeMime) == 0)
|
|
format = CF_UNICODETEXT;
|
|
else if (strcmp(aMimeStr, kJPEGImageMime) == 0 ||
|
|
strcmp(aMimeStr, kJPGImageMime) == 0 ||
|
|
strcmp(aMimeStr, kPNGImageMime) == 0)
|
|
format = CF_DIBV5;
|
|
else if (strcmp(aMimeStr, kFileMime) == 0 ||
|
|
strcmp(aMimeStr, kFilePromiseMime) == 0)
|
|
format = CF_HDROP;
|
|
else if (strcmp(aMimeStr, kNativeHTMLMime) == 0)
|
|
format = CF_HTML;
|
|
else
|
|
format = ::RegisterClipboardFormatW(NS_ConvertASCIItoUTF16(aMimeStr).get());
|
|
|
|
return format;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
nsresult nsClipboard::CreateNativeDataObject(nsITransferable * aTransferable, IDataObject ** aDataObj, nsIURI * uri)
|
|
{
|
|
if (nullptr == aTransferable) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
// Create our native DataObject that implements
|
|
// the OLE IDataObject interface
|
|
nsDataObj * dataObj = new nsDataObj(uri);
|
|
|
|
if (!dataObj)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
dataObj->AddRef();
|
|
|
|
// Now set it up with all the right data flavors & enums
|
|
nsresult res = SetupNativeDataObject(aTransferable, dataObj);
|
|
if (NS_OK == res) {
|
|
*aDataObj = dataObj;
|
|
} else {
|
|
delete dataObj;
|
|
}
|
|
return res;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
nsresult nsClipboard::SetupNativeDataObject(nsITransferable * aTransferable, IDataObject * aDataObj)
|
|
{
|
|
if (nullptr == aTransferable || nullptr == aDataObj) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
nsDataObj * dObj = static_cast<nsDataObj *>(aDataObj);
|
|
|
|
// Now give the Transferable to the DataObject
|
|
// for getting the data out of it
|
|
dObj->SetTransferable(aTransferable);
|
|
|
|
// Get the transferable list of data flavors
|
|
nsCOMPtr<nsISupportsArray> dfList;
|
|
aTransferable->FlavorsTransferableCanExport(getter_AddRefs(dfList));
|
|
|
|
// Walk through flavors that contain data and register them
|
|
// into the DataObj as supported flavors
|
|
uint32_t i;
|
|
uint32_t cnt;
|
|
dfList->Count(&cnt);
|
|
for (i=0;i<cnt;i++) {
|
|
nsCOMPtr<nsISupports> genericFlavor;
|
|
dfList->GetElementAt ( i, getter_AddRefs(genericFlavor) );
|
|
nsCOMPtr<nsISupportsCString> currentFlavor ( do_QueryInterface(genericFlavor) );
|
|
if ( currentFlavor ) {
|
|
nsXPIDLCString flavorStr;
|
|
currentFlavor->ToString(getter_Copies(flavorStr));
|
|
UINT format = GetFormat(flavorStr);
|
|
|
|
// Now tell the native IDataObject about both our mime type and
|
|
// the native data format
|
|
FORMATETC fe;
|
|
SET_FORMATETC(fe, format, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL);
|
|
dObj->AddDataFlavor(flavorStr, &fe);
|
|
|
|
// Do various things internal to the implementation, like map one
|
|
// flavor to another or add additional flavors based on what's required
|
|
// for the win32 impl.
|
|
if ( strcmp(flavorStr, kUnicodeMime) == 0 ) {
|
|
// if we find text/unicode, also advertise text/plain (which we will convert
|
|
// on our own in nsDataObj::GetText().
|
|
FORMATETC textFE;
|
|
SET_FORMATETC(textFE, CF_TEXT, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL);
|
|
dObj->AddDataFlavor(kTextMime, &textFE);
|
|
}
|
|
else if ( strcmp(flavorStr, kHTMLMime) == 0 ) {
|
|
// if we find text/html, also advertise win32's html flavor (which we will convert
|
|
// on our own in nsDataObj::GetText().
|
|
FORMATETC htmlFE;
|
|
SET_FORMATETC(htmlFE, CF_HTML, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL);
|
|
dObj->AddDataFlavor(kHTMLMime, &htmlFE);
|
|
}
|
|
else if ( strcmp(flavorStr, kURLMime) == 0 ) {
|
|
// if we're a url, in addition to also being text, we need to register
|
|
// the "file" flavors so that the win32 shell knows to create an internet
|
|
// shortcut when it sees one of these beasts.
|
|
FORMATETC shortcutFE;
|
|
SET_FORMATETC(shortcutFE, ::RegisterClipboardFormat(CFSTR_FILEDESCRIPTORA), 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL)
|
|
dObj->AddDataFlavor(kURLMime, &shortcutFE);
|
|
SET_FORMATETC(shortcutFE, ::RegisterClipboardFormat(CFSTR_FILEDESCRIPTORW), 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL)
|
|
dObj->AddDataFlavor(kURLMime, &shortcutFE);
|
|
SET_FORMATETC(shortcutFE, ::RegisterClipboardFormat(CFSTR_FILECONTENTS), 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL)
|
|
dObj->AddDataFlavor(kURLMime, &shortcutFE);
|
|
SET_FORMATETC(shortcutFE, ::RegisterClipboardFormat(CFSTR_INETURLA), 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL)
|
|
dObj->AddDataFlavor(kURLMime, &shortcutFE);
|
|
SET_FORMATETC(shortcutFE, ::RegisterClipboardFormat(CFSTR_INETURLW), 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL)
|
|
dObj->AddDataFlavor(kURLMime, &shortcutFE);
|
|
}
|
|
else if ( strcmp(flavorStr, kPNGImageMime) == 0 || strcmp(flavorStr, kJPEGImageMime) == 0 ||
|
|
strcmp(flavorStr, kJPGImageMime) == 0 || strcmp(flavorStr, kGIFImageMime) == 0 ||
|
|
strcmp(flavorStr, kNativeImageMime) == 0 ) {
|
|
// if we're an image, register the native bitmap flavor
|
|
FORMATETC imageFE;
|
|
// Add DIBv5
|
|
SET_FORMATETC(imageFE, CF_DIBV5, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL)
|
|
dObj->AddDataFlavor(flavorStr, &imageFE);
|
|
// Add DIBv3
|
|
SET_FORMATETC(imageFE, CF_DIB, 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL)
|
|
dObj->AddDataFlavor(flavorStr, &imageFE);
|
|
}
|
|
else if ( strcmp(flavorStr, kFilePromiseMime) == 0 ) {
|
|
// if we're a file promise flavor, also register the
|
|
// CFSTR_PREFERREDDROPEFFECT format. The data object
|
|
// returns a value of DROPEFFECTS_MOVE to the drop target
|
|
// when it asks for the value of this format. This causes
|
|
// the file to be moved from the temporary location instead
|
|
// of being copied. The right thing to do here is to call
|
|
// SetData() on the data object and set the value of this format
|
|
// to DROPEFFECTS_MOVE on this particular data object. But,
|
|
// since all the other clipboard formats follow the model of setting
|
|
// data on the data object only when the drop object calls GetData(),
|
|
// I am leaving this format's value hard coded in the data object.
|
|
// We can change this if other consumers of this format get added to this
|
|
// codebase and they need different values.
|
|
FORMATETC shortcutFE;
|
|
SET_FORMATETC(shortcutFE, ::RegisterClipboardFormat(CFSTR_PREFERREDDROPEFFECT), 0, DVASPECT_CONTENT, -1, TYMED_HGLOBAL)
|
|
dObj->AddDataFlavor(kFilePromiseMime, &shortcutFE);
|
|
}
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
NS_IMETHODIMP nsClipboard::SetNativeClipboardData ( int32_t aWhichClipboard )
|
|
{
|
|
if ( aWhichClipboard != kGlobalClipboard )
|
|
return NS_ERROR_FAILURE;
|
|
|
|
mIgnoreEmptyNotification = true;
|
|
|
|
// make sure we have a good transferable
|
|
if (nullptr == mTransferable) {
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
IDataObject * dataObj;
|
|
if ( NS_SUCCEEDED(CreateNativeDataObject(mTransferable, &dataObj, nullptr)) ) { // this add refs dataObj
|
|
::OleSetClipboard(dataObj);
|
|
dataObj->Release();
|
|
} else {
|
|
// Clear the native clipboard
|
|
::OleSetClipboard(nullptr);
|
|
}
|
|
|
|
mIgnoreEmptyNotification = false;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
nsresult nsClipboard::GetGlobalData(HGLOBAL aHGBL, void ** aData, uint32_t * aLen)
|
|
{
|
|
// Allocate a new memory buffer and copy the data from global memory.
|
|
// Recall that win98 allocates to nearest DWORD boundary. As a safety
|
|
// precaution, allocate an extra 2 bytes (but don't report them!) and
|
|
// null them out to ensure that all of our strlen calls will succeed.
|
|
nsresult result = NS_ERROR_FAILURE;
|
|
if (aHGBL != nullptr) {
|
|
LPSTR lpStr = (LPSTR) GlobalLock(aHGBL);
|
|
DWORD allocSize = GlobalSize(aHGBL);
|
|
char* data = static_cast<char*>(nsMemory::Alloc(allocSize + sizeof(char16_t)));
|
|
if ( data ) {
|
|
memcpy ( data, lpStr, allocSize );
|
|
data[allocSize] = data[allocSize + 1] = '\0'; // null terminate for safety
|
|
|
|
GlobalUnlock(aHGBL);
|
|
*aData = data;
|
|
*aLen = allocSize;
|
|
|
|
result = NS_OK;
|
|
}
|
|
} else {
|
|
#ifdef MOZ_METRO
|
|
return result;
|
|
#endif
|
|
// We really shouldn't ever get here
|
|
// but just in case
|
|
*aData = nullptr;
|
|
*aLen = 0;
|
|
LPVOID lpMsgBuf;
|
|
|
|
FormatMessageW(
|
|
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
|
|
nullptr,
|
|
GetLastError(),
|
|
MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
|
|
(LPWSTR) &lpMsgBuf,
|
|
0,
|
|
nullptr
|
|
);
|
|
|
|
// Display the string.
|
|
MessageBoxW( nullptr, (LPCWSTR) lpMsgBuf, L"GetLastError",
|
|
MB_OK | MB_ICONINFORMATION );
|
|
|
|
// Free the buffer.
|
|
LocalFree( lpMsgBuf );
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
nsresult nsClipboard::GetNativeDataOffClipboard(nsIWidget * aWidget, UINT /*aIndex*/, UINT aFormat, void ** aData, uint32_t * aLen)
|
|
{
|
|
HGLOBAL hglb;
|
|
nsresult result = NS_ERROR_FAILURE;
|
|
|
|
HWND nativeWin = nullptr;
|
|
if (::OpenClipboard(nativeWin)) {
|
|
hglb = ::GetClipboardData(aFormat);
|
|
result = GetGlobalData(hglb, aData, aLen);
|
|
::CloseClipboard();
|
|
}
|
|
return result;
|
|
}
|
|
|
|
static void DisplayErrCode(HRESULT hres)
|
|
{
|
|
#if defined(DEBUG_rods) || defined(DEBUG_pinkerton)
|
|
if (hres == E_INVALIDARG) {
|
|
PR_LOG(gWin32ClipboardLog, PR_LOG_ALWAYS, ("E_INVALIDARG\n"));
|
|
} else
|
|
if (hres == E_UNEXPECTED) {
|
|
PR_LOG(gWin32ClipboardLog, PR_LOG_ALWAYS, ("E_UNEXPECTED\n"));
|
|
} else
|
|
if (hres == E_OUTOFMEMORY) {
|
|
PR_LOG(gWin32ClipboardLog, PR_LOG_ALWAYS, ("E_OUTOFMEMORY\n"));
|
|
} else
|
|
if (hres == DV_E_LINDEX ) {
|
|
PR_LOG(gWin32ClipboardLog, PR_LOG_ALWAYS, ("DV_E_LINDEX\n"));
|
|
} else
|
|
if (hres == DV_E_FORMATETC) {
|
|
PR_LOG(gWin32ClipboardLog, PR_LOG_ALWAYS, ("DV_E_FORMATETC\n"));
|
|
} else
|
|
if (hres == DV_E_TYMED) {
|
|
PR_LOG(gWin32ClipboardLog, PR_LOG_ALWAYS, ("DV_E_TYMED\n"));
|
|
} else
|
|
if (hres == DV_E_DVASPECT) {
|
|
PR_LOG(gWin32ClipboardLog, PR_LOG_ALWAYS, ("DV_E_DVASPECT\n"));
|
|
} else
|
|
if (hres == OLE_E_NOTRUNNING) {
|
|
PR_LOG(gWin32ClipboardLog, PR_LOG_ALWAYS, ("OLE_E_NOTRUNNING\n"));
|
|
} else
|
|
if (hres == STG_E_MEDIUMFULL) {
|
|
PR_LOG(gWin32ClipboardLog, PR_LOG_ALWAYS, ("STG_E_MEDIUMFULL\n"));
|
|
} else
|
|
if (hres == DV_E_CLIPFORMAT) {
|
|
PR_LOG(gWin32ClipboardLog, PR_LOG_ALWAYS, ("DV_E_CLIPFORMAT\n"));
|
|
} else
|
|
if (hres == S_OK) {
|
|
PR_LOG(gWin32ClipboardLog, PR_LOG_ALWAYS, ("S_OK\n"));
|
|
} else {
|
|
PR_LOG(gWin32ClipboardLog, PR_LOG_ALWAYS,
|
|
("****** DisplayErrCode 0x%X\n", hres));
|
|
}
|
|
#endif
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
static HRESULT FillSTGMedium(IDataObject * aDataObject, UINT aFormat, LPFORMATETC pFE, LPSTGMEDIUM pSTM, DWORD aTymed)
|
|
{
|
|
SET_FORMATETC(*pFE, aFormat, 0, DVASPECT_CONTENT, -1, aTymed);
|
|
|
|
// Starting by querying for the data to see if we can get it as from global memory
|
|
HRESULT hres = S_FALSE;
|
|
hres = aDataObject->QueryGetData(pFE);
|
|
DisplayErrCode(hres);
|
|
if (S_OK == hres) {
|
|
hres = aDataObject->GetData(pFE, pSTM);
|
|
DisplayErrCode(hres);
|
|
}
|
|
return hres;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
// If aFormat is CF_DIBV5, aMIMEImageFormat must be a type for which we have
|
|
// an image encoder (e.g. image/png).
|
|
// For other values of aFormat, it is OK to pass null for aMIMEImageFormat.
|
|
nsresult nsClipboard::GetNativeDataOffClipboard(IDataObject * aDataObject, UINT aIndex, UINT aFormat, const char * aMIMEImageFormat, void ** aData, uint32_t * aLen)
|
|
{
|
|
nsresult result = NS_ERROR_FAILURE;
|
|
*aData = nullptr;
|
|
*aLen = 0;
|
|
|
|
if ( !aDataObject )
|
|
return result;
|
|
|
|
UINT format = aFormat;
|
|
HRESULT hres = S_FALSE;
|
|
|
|
// XXX at the moment we only support global memory transfers
|
|
// It is here where we will add support for native images
|
|
// and IStream
|
|
FORMATETC fe;
|
|
STGMEDIUM stm;
|
|
hres = FillSTGMedium(aDataObject, format, &fe, &stm, TYMED_HGLOBAL);
|
|
|
|
// Currently this is only handling TYMED_HGLOBAL data
|
|
// For Text, Dibs, Files, and generic data (like HTML)
|
|
if (S_OK == hres) {
|
|
static CLIPFORMAT fileDescriptorFlavorA = ::RegisterClipboardFormat( CFSTR_FILEDESCRIPTORA );
|
|
static CLIPFORMAT fileDescriptorFlavorW = ::RegisterClipboardFormat( CFSTR_FILEDESCRIPTORW );
|
|
static CLIPFORMAT fileFlavor = ::RegisterClipboardFormat( CFSTR_FILECONTENTS );
|
|
static CLIPFORMAT preferredDropEffect = ::RegisterClipboardFormat(CFSTR_PREFERREDDROPEFFECT);
|
|
|
|
switch (stm.tymed) {
|
|
case TYMED_HGLOBAL:
|
|
{
|
|
switch (fe.cfFormat) {
|
|
case CF_TEXT:
|
|
{
|
|
// Get the data out of the global data handle. The size we return
|
|
// should not include the null because the other platforms don't
|
|
// use nulls, so just return the length we get back from strlen(),
|
|
// since we know CF_TEXT is null terminated. Recall that GetGlobalData()
|
|
// returns the size of the allocated buffer, not the size of the data
|
|
// (on 98, these are not the same) so we can't use that.
|
|
uint32_t allocLen = 0;
|
|
if ( NS_SUCCEEDED(GetGlobalData(stm.hGlobal, aData, &allocLen)) ) {
|
|
*aLen = strlen ( reinterpret_cast<char*>(*aData) );
|
|
result = NS_OK;
|
|
}
|
|
} break;
|
|
|
|
case CF_UNICODETEXT:
|
|
{
|
|
// Get the data out of the global data handle. The size we return
|
|
// should not include the null because the other platforms don't
|
|
// use nulls, so just return the length we get back from strlen(),
|
|
// since we know CF_UNICODETEXT is null terminated. Recall that GetGlobalData()
|
|
// returns the size of the allocated buffer, not the size of the data
|
|
// (on 98, these are not the same) so we can't use that.
|
|
uint32_t allocLen = 0;
|
|
if ( NS_SUCCEEDED(GetGlobalData(stm.hGlobal, aData, &allocLen)) ) {
|
|
*aLen = NS_strlen(reinterpret_cast<char16_t*>(*aData)) * 2;
|
|
result = NS_OK;
|
|
}
|
|
} break;
|
|
|
|
case CF_DIBV5:
|
|
if (aMIMEImageFormat)
|
|
{
|
|
uint32_t allocLen = 0;
|
|
unsigned char * clipboardData;
|
|
if (NS_SUCCEEDED(GetGlobalData(stm.hGlobal, (void **)&clipboardData, &allocLen)))
|
|
{
|
|
nsImageFromClipboard converter;
|
|
nsIInputStream * inputStream;
|
|
converter.GetEncodedImageStream(clipboardData, aMIMEImageFormat, &inputStream); // addrefs for us, don't release
|
|
if ( inputStream ) {
|
|
*aData = inputStream;
|
|
*aLen = sizeof(nsIInputStream*);
|
|
result = NS_OK;
|
|
}
|
|
}
|
|
} break;
|
|
|
|
case CF_HDROP :
|
|
{
|
|
// in the case of a file drop, multiple files are stashed within a
|
|
// single data object. In order to match mozilla's D&D apis, we
|
|
// just pull out the file at the requested index, pretending as
|
|
// if there really are multiple drag items.
|
|
HDROP dropFiles = (HDROP) GlobalLock(stm.hGlobal);
|
|
|
|
UINT numFiles = ::DragQueryFileW(dropFiles, 0xFFFFFFFF, nullptr, 0);
|
|
NS_ASSERTION ( numFiles > 0, "File drop flavor, but no files...hmmmm" );
|
|
NS_ASSERTION ( aIndex < numFiles, "Asked for a file index out of range of list" );
|
|
if (numFiles > 0) {
|
|
UINT fileNameLen = ::DragQueryFileW(dropFiles, aIndex, nullptr, 0);
|
|
wchar_t* buffer = reinterpret_cast<wchar_t*>(nsMemory::Alloc((fileNameLen + 1) * sizeof(wchar_t)));
|
|
if ( buffer ) {
|
|
::DragQueryFileW(dropFiles, aIndex, buffer, fileNameLen + 1);
|
|
*aData = buffer;
|
|
*aLen = fileNameLen * sizeof(char16_t);
|
|
result = NS_OK;
|
|
}
|
|
else
|
|
result = NS_ERROR_OUT_OF_MEMORY;
|
|
}
|
|
GlobalUnlock (stm.hGlobal) ;
|
|
|
|
} break;
|
|
|
|
default: {
|
|
if ( fe.cfFormat == fileDescriptorFlavorA || fe.cfFormat == fileDescriptorFlavorW || fe.cfFormat == fileFlavor ) {
|
|
NS_WARNING ( "Mozilla doesn't yet understand how to read this type of file flavor" );
|
|
}
|
|
else
|
|
{
|
|
// Get the data out of the global data handle. The size we return
|
|
// should not include the null because the other platforms don't
|
|
// use nulls, so just return the length we get back from strlen(),
|
|
// since we know CF_UNICODETEXT is null terminated. Recall that GetGlobalData()
|
|
// returns the size of the allocated buffer, not the size of the data
|
|
// (on 98, these are not the same) so we can't use that.
|
|
//
|
|
// NOTE: we are assuming that anything that falls into this default case
|
|
// is unicode. As we start to get more kinds of binary data, this
|
|
// may become an incorrect assumption. Stay tuned.
|
|
uint32_t allocLen = 0;
|
|
if ( NS_SUCCEEDED(GetGlobalData(stm.hGlobal, aData, &allocLen)) ) {
|
|
if ( fe.cfFormat == CF_HTML ) {
|
|
// CF_HTML is actually UTF8, not unicode, so disregard the assumption
|
|
// above. We have to check the header for the actual length, and we'll
|
|
// do that in FindPlatformHTML(). For now, return the allocLen. This
|
|
// case is mostly to ensure we don't try to call strlen on the buffer.
|
|
*aLen = allocLen;
|
|
} else if (fe.cfFormat == preferredDropEffect) {
|
|
// As per the MSDN doc entitled: "Shell Clipboard Formats"
|
|
// CFSTR_PREFERREDDROPEFFECT should return a DWORD
|
|
// Reference: http://msdn.microsoft.com/en-us/library/bb776902(v=vs.85).aspx
|
|
NS_ASSERTION(allocLen == sizeof(DWORD),
|
|
"CFSTR_PREFERREDDROPEFFECT should return a DWORD");
|
|
*aLen = allocLen;
|
|
} else {
|
|
*aLen = NS_strlen(reinterpret_cast<char16_t*>(*aData)) *
|
|
sizeof(char16_t);
|
|
}
|
|
result = NS_OK;
|
|
}
|
|
}
|
|
} break;
|
|
} // switch
|
|
} break;
|
|
|
|
case TYMED_GDI:
|
|
{
|
|
#ifdef DEBUG
|
|
PR_LOG(gWin32ClipboardLog, PR_LOG_ALWAYS,
|
|
("*********************** TYMED_GDI\n"));
|
|
#endif
|
|
} break;
|
|
|
|
default:
|
|
break;
|
|
} //switch
|
|
|
|
ReleaseStgMedium(&stm);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
nsresult nsClipboard::GetDataFromDataObject(IDataObject * aDataObject,
|
|
UINT anIndex,
|
|
nsIWidget * aWindow,
|
|
nsITransferable * aTransferable)
|
|
{
|
|
// make sure we have a good transferable
|
|
if ( !aTransferable )
|
|
return NS_ERROR_INVALID_ARG;
|
|
|
|
nsresult res = NS_ERROR_FAILURE;
|
|
|
|
// get flavor list that includes all flavors that can be written (including ones
|
|
// obtained through conversion)
|
|
nsCOMPtr<nsISupportsArray> flavorList;
|
|
res = aTransferable->FlavorsTransferableCanImport ( getter_AddRefs(flavorList) );
|
|
if ( NS_FAILED(res) )
|
|
return NS_ERROR_FAILURE;
|
|
|
|
// Walk through flavors and see which flavor is on the clipboard them on the native clipboard,
|
|
uint32_t i;
|
|
uint32_t cnt;
|
|
flavorList->Count(&cnt);
|
|
for (i=0;i<cnt;i++) {
|
|
nsCOMPtr<nsISupports> genericFlavor;
|
|
flavorList->GetElementAt ( i, getter_AddRefs(genericFlavor) );
|
|
nsCOMPtr<nsISupportsCString> currentFlavor ( do_QueryInterface(genericFlavor) );
|
|
if ( currentFlavor ) {
|
|
nsXPIDLCString flavorStr;
|
|
currentFlavor->ToString(getter_Copies(flavorStr));
|
|
UINT format = GetFormat(flavorStr);
|
|
|
|
// Try to get the data using the desired flavor. This might fail, but all is
|
|
// not lost.
|
|
void* data = nullptr;
|
|
uint32_t dataLen = 0;
|
|
bool dataFound = false;
|
|
if (nullptr != aDataObject) {
|
|
if ( NS_SUCCEEDED(GetNativeDataOffClipboard(aDataObject, anIndex, format, flavorStr, &data, &dataLen)) )
|
|
dataFound = true;
|
|
}
|
|
else if (nullptr != aWindow) {
|
|
if ( NS_SUCCEEDED(GetNativeDataOffClipboard(aWindow, anIndex, format, &data, &dataLen)) )
|
|
dataFound = true;
|
|
}
|
|
|
|
// This is our second chance to try to find some data, having not found it
|
|
// when directly asking for the flavor. Let's try digging around in other
|
|
// flavors to help satisfy our craving for data.
|
|
if ( !dataFound ) {
|
|
if ( strcmp(flavorStr, kUnicodeMime) == 0 )
|
|
dataFound = FindUnicodeFromPlainText ( aDataObject, anIndex, &data, &dataLen );
|
|
else if ( strcmp(flavorStr, kURLMime) == 0 ) {
|
|
// drags from other windows apps expose the native
|
|
// CFSTR_INETURL{A,W} flavor
|
|
dataFound = FindURLFromNativeURL ( aDataObject, anIndex, &data, &dataLen );
|
|
if ( !dataFound )
|
|
dataFound = FindURLFromLocalFile ( aDataObject, anIndex, &data, &dataLen );
|
|
}
|
|
} // if we try one last ditch effort to find our data
|
|
|
|
// Hopefully by this point we've found it and can go about our business
|
|
if ( dataFound ) {
|
|
nsCOMPtr<nsISupports> genericDataWrapper;
|
|
if ( strcmp(flavorStr, kFileMime) == 0 ) {
|
|
// we have a file path in |data|. Create an nsLocalFile object.
|
|
nsDependentString filepath(reinterpret_cast<char16_t*>(data));
|
|
nsCOMPtr<nsIFile> file;
|
|
if ( NS_SUCCEEDED(NS_NewLocalFile(filepath, false, getter_AddRefs(file))) )
|
|
genericDataWrapper = do_QueryInterface(file);
|
|
nsMemory::Free(data);
|
|
}
|
|
else if ( strcmp(flavorStr, kNativeHTMLMime) == 0) {
|
|
// the editor folks want CF_HTML exactly as it's on the clipboard, no conversions,
|
|
// no fancy stuff. Pull it off the clipboard, stuff it into a wrapper and hand
|
|
// it back to them.
|
|
if ( FindPlatformHTML(aDataObject, anIndex, &data, &dataLen) )
|
|
nsPrimitiveHelpers::CreatePrimitiveForData ( flavorStr, data, dataLen, getter_AddRefs(genericDataWrapper) );
|
|
else
|
|
{
|
|
nsMemory::Free(data);
|
|
continue; // something wrong with this flavor, keep looking for other data
|
|
}
|
|
nsMemory::Free(data);
|
|
}
|
|
else if ( strcmp(flavorStr, kJPEGImageMime) == 0 ||
|
|
strcmp(flavorStr, kJPGImageMime) == 0 ||
|
|
strcmp(flavorStr, kPNGImageMime) == 0) {
|
|
nsIInputStream * imageStream = reinterpret_cast<nsIInputStream*>(data);
|
|
genericDataWrapper = do_QueryInterface(imageStream);
|
|
NS_IF_RELEASE(imageStream);
|
|
}
|
|
else {
|
|
// we probably have some form of text. The DOM only wants LF, so convert from Win32 line
|
|
// endings to DOM line endings.
|
|
int32_t signedLen = static_cast<int32_t>(dataLen);
|
|
nsLinebreakHelpers::ConvertPlatformToDOMLinebreaks ( flavorStr, &data, &signedLen );
|
|
dataLen = signedLen;
|
|
|
|
nsPrimitiveHelpers::CreatePrimitiveForData ( flavorStr, data, dataLen, getter_AddRefs(genericDataWrapper) );
|
|
nsMemory::Free(data);
|
|
}
|
|
|
|
NS_ASSERTION ( genericDataWrapper, "About to put null data into the transferable" );
|
|
aTransferable->SetTransferData(flavorStr, genericDataWrapper, dataLen);
|
|
res = NS_OK;
|
|
|
|
// we found one, get out of the loop
|
|
break;
|
|
}
|
|
|
|
}
|
|
} // foreach flavor
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// FindPlatformHTML
|
|
//
|
|
// Someone asked for the OS CF_HTML flavor. We give it back to them exactly as-is.
|
|
//
|
|
bool
|
|
nsClipboard :: FindPlatformHTML ( IDataObject* inDataObject, UINT inIndex, void** outData, uint32_t* outDataLen )
|
|
{
|
|
// Reference: MSDN doc entitled "HTML Clipboard Format"
|
|
// http://msdn.microsoft.com/en-us/library/aa767917(VS.85).aspx#unknown_854
|
|
// CF_HTML is UTF8, not unicode. We also can't rely on it being null-terminated
|
|
// so we have to check the CF_HTML header for the correct length.
|
|
// The length we return is the bytecount from the beginning of the selected data to the end
|
|
// of the selected data, without the null termination. Because it's UTF8, we're guaranteed
|
|
// the header is ASCII.
|
|
|
|
if (!outData || !*outData) {
|
|
return false;
|
|
}
|
|
|
|
char version[8] = { 0 };
|
|
int32_t startOfData = 0;
|
|
int32_t endOfData = 0;
|
|
int numFound = sscanf((char*)*outData, "Version:%7s\nStartHTML:%d\nEndHTML:%d",
|
|
version, &startOfData, &endOfData);
|
|
|
|
if (numFound != 3 || startOfData < -1 || endOfData < -1) {
|
|
return false;
|
|
}
|
|
|
|
// Fixup the start and end markers if they have no context (set to -1)
|
|
if (startOfData == -1) {
|
|
startOfData = 0;
|
|
}
|
|
if (endOfData == -1) {
|
|
endOfData = *outDataLen;
|
|
}
|
|
|
|
// Make sure we were passed sane values within our buffer size.
|
|
// (Note that we've handled all cases of negative endOfData above, so we can
|
|
// safely cast it to be unsigned here.)
|
|
if (!endOfData || startOfData >= endOfData ||
|
|
static_cast<uint32_t>(endOfData) > *outDataLen) {
|
|
return false;
|
|
}
|
|
|
|
// We want to return the buffer not offset by startOfData because it will be
|
|
// parsed out later (probably by nsHTMLEditor::ParseCFHTML) when it is still
|
|
// in CF_HTML format.
|
|
*outDataLen = endOfData;
|
|
return true;
|
|
}
|
|
|
|
|
|
//
|
|
// FindUnicodeFromPlainText
|
|
//
|
|
// we are looking for text/unicode and we failed to find it on the clipboard first,
|
|
// try again with text/plain. If that is present, convert it to unicode.
|
|
//
|
|
bool
|
|
nsClipboard :: FindUnicodeFromPlainText ( IDataObject* inDataObject, UINT inIndex, void** outData, uint32_t* outDataLen )
|
|
{
|
|
bool dataFound = false;
|
|
|
|
// we are looking for text/unicode and we failed to find it on the clipboard first,
|
|
// try again with text/plain. If that is present, convert it to unicode.
|
|
nsresult loadResult = GetNativeDataOffClipboard(inDataObject, inIndex, GetFormat(kTextMime), nullptr, outData, outDataLen);
|
|
if ( NS_SUCCEEDED(loadResult) && *outData ) {
|
|
const char* castedText = reinterpret_cast<char*>(*outData);
|
|
char16_t* convertedText = nullptr;
|
|
int32_t convertedTextLen = 0;
|
|
nsPrimitiveHelpers::ConvertPlatformPlainTextToUnicode ( castedText, *outDataLen,
|
|
&convertedText, &convertedTextLen );
|
|
if ( convertedText ) {
|
|
// out with the old, in with the new
|
|
nsMemory::Free(*outData);
|
|
*outData = convertedText;
|
|
*outDataLen = convertedTextLen * sizeof(char16_t);
|
|
dataFound = true;
|
|
}
|
|
} // if plain text data on clipboard
|
|
|
|
return dataFound;
|
|
|
|
} // FindUnicodeFromPlainText
|
|
|
|
|
|
//
|
|
// FindURLFromLocalFile
|
|
//
|
|
// we are looking for a URL and couldn't find it, try again with looking for
|
|
// a local file. If we have one, it may either be a normal file or an internet shortcut.
|
|
// In both cases, however, we can get a URL (it will be a file:// url in the
|
|
// local file case).
|
|
//
|
|
bool
|
|
nsClipboard :: FindURLFromLocalFile ( IDataObject* inDataObject, UINT inIndex, void** outData, uint32_t* outDataLen )
|
|
{
|
|
bool dataFound = false;
|
|
|
|
nsresult loadResult = GetNativeDataOffClipboard(inDataObject, inIndex, GetFormat(kFileMime), nullptr, outData, outDataLen);
|
|
if ( NS_SUCCEEDED(loadResult) && *outData ) {
|
|
// we have a file path in |data|. Is it an internet shortcut or a normal file?
|
|
const nsDependentString filepath(static_cast<char16_t*>(*outData));
|
|
nsCOMPtr<nsIFile> file;
|
|
nsresult rv = NS_NewLocalFile(filepath, true, getter_AddRefs(file));
|
|
if (NS_FAILED(rv)) {
|
|
nsMemory::Free(*outData);
|
|
return dataFound;
|
|
}
|
|
|
|
if ( IsInternetShortcut(filepath) ) {
|
|
nsMemory::Free(*outData);
|
|
nsAutoCString url;
|
|
ResolveShortcut( file, url );
|
|
if ( !url.IsEmpty() ) {
|
|
// convert it to unicode and pass it out
|
|
nsDependentString urlString(UTF8ToNewUnicode(url));
|
|
// the internal mozilla URL format, text/x-moz-url, contains
|
|
// URL\ntitle. We can guess the title from the file's name.
|
|
nsAutoString title;
|
|
file->GetLeafName(title);
|
|
// We rely on IsInternetShortcut check that file has a .url extension.
|
|
title.SetLength(title.Length() - 4);
|
|
if (title.IsEmpty())
|
|
title = urlString;
|
|
*outData = ToNewUnicode(urlString + NS_LITERAL_STRING("\n") + title);
|
|
*outDataLen = NS_strlen(static_cast<char16_t*>(*outData)) * sizeof(char16_t);
|
|
|
|
dataFound = true;
|
|
}
|
|
}
|
|
else {
|
|
// we have a normal file, use some Necko objects to get our file path
|
|
nsAutoCString urlSpec;
|
|
NS_GetURLSpecFromFile(file, urlSpec);
|
|
|
|
// convert it to unicode and pass it out
|
|
nsMemory::Free(*outData);
|
|
*outData = UTF8ToNewUnicode(urlSpec);
|
|
*outDataLen = NS_strlen(static_cast<char16_t*>(*outData)) * sizeof(char16_t);
|
|
dataFound = true;
|
|
} // else regular file
|
|
}
|
|
|
|
return dataFound;
|
|
} // FindURLFromLocalFile
|
|
|
|
//
|
|
// FindURLFromNativeURL
|
|
//
|
|
// we are looking for a URL and couldn't find it using our internal
|
|
// URL flavor, so look for it using the native URL flavor,
|
|
// CF_INETURLSTRW (We don't handle CF_INETURLSTRA currently)
|
|
//
|
|
bool
|
|
nsClipboard :: FindURLFromNativeURL ( IDataObject* inDataObject, UINT inIndex, void** outData, uint32_t* outDataLen )
|
|
{
|
|
bool dataFound = false;
|
|
|
|
void* tempOutData = nullptr;
|
|
uint32_t tempDataLen = 0;
|
|
|
|
nsresult loadResult = GetNativeDataOffClipboard(inDataObject, inIndex, ::RegisterClipboardFormat(CFSTR_INETURLW), nullptr, &tempOutData, &tempDataLen);
|
|
if ( NS_SUCCEEDED(loadResult) && tempOutData ) {
|
|
nsDependentString urlString(static_cast<char16_t*>(tempOutData));
|
|
// the internal mozilla URL format, text/x-moz-url, contains
|
|
// URL\ntitle. Since we don't actually have a title here,
|
|
// just repeat the URL to fake it.
|
|
*outData = ToNewUnicode(urlString + NS_LITERAL_STRING("\n") + urlString);
|
|
*outDataLen = NS_strlen(static_cast<char16_t*>(*outData)) * sizeof(char16_t);
|
|
nsMemory::Free(tempOutData);
|
|
dataFound = true;
|
|
}
|
|
else {
|
|
loadResult = GetNativeDataOffClipboard(inDataObject, inIndex, ::RegisterClipboardFormat(CFSTR_INETURLA), nullptr, &tempOutData, &tempDataLen);
|
|
if ( NS_SUCCEEDED(loadResult) && tempOutData ) {
|
|
// CFSTR_INETURLA is (currently) equal to CFSTR_SHELLURL which is equal to CF_TEXT
|
|
// which is by definition ANSI encoded.
|
|
nsCString urlUnescapedA;
|
|
bool unescaped = NS_UnescapeURL(static_cast<char*>(tempOutData), tempDataLen, esc_OnlyNonASCII | esc_SkipControl, urlUnescapedA);
|
|
|
|
nsString urlString;
|
|
if (unescaped)
|
|
NS_CopyNativeToUnicode(urlUnescapedA, urlString);
|
|
else
|
|
NS_CopyNativeToUnicode(nsDependentCString(static_cast<char*>(tempOutData), tempDataLen), urlString);
|
|
|
|
// the internal mozilla URL format, text/x-moz-url, contains
|
|
// URL\ntitle. Since we don't actually have a title here,
|
|
// just repeat the URL to fake it.
|
|
*outData = ToNewUnicode(urlString + NS_LITERAL_STRING("\n") + urlString);
|
|
*outDataLen = NS_strlen(static_cast<char16_t*>(*outData)) * sizeof(char16_t);
|
|
nsMemory::Free(tempOutData);
|
|
dataFound = true;
|
|
}
|
|
}
|
|
|
|
return dataFound;
|
|
} // FindURLFromNativeURL
|
|
|
|
//
|
|
// ResolveShortcut
|
|
//
|
|
void
|
|
nsClipboard :: ResolveShortcut ( nsIFile* aFile, nsACString& outURL )
|
|
{
|
|
nsCOMPtr<nsIFileProtocolHandler> fph;
|
|
nsresult rv = NS_GetFileProtocolHandler(getter_AddRefs(fph));
|
|
if (NS_FAILED(rv))
|
|
return;
|
|
|
|
nsCOMPtr<nsIURI> uri;
|
|
rv = fph->ReadURLFile(aFile, getter_AddRefs(uri));
|
|
if (NS_FAILED(rv))
|
|
return;
|
|
|
|
uri->GetSpec(outURL);
|
|
} // ResolveShortcut
|
|
|
|
|
|
//
|
|
// IsInternetShortcut
|
|
//
|
|
// A file is an Internet Shortcut if it ends with .URL
|
|
//
|
|
bool
|
|
nsClipboard :: IsInternetShortcut ( const nsAString& inFileName )
|
|
{
|
|
return StringEndsWith(inFileName, NS_LITERAL_STRING(".url"), nsCaseInsensitiveStringComparator());
|
|
} // IsInternetShortcut
|
|
|
|
|
|
//-------------------------------------------------------------------------
|
|
NS_IMETHODIMP
|
|
nsClipboard::GetNativeClipboardData ( nsITransferable * aTransferable, int32_t aWhichClipboard )
|
|
{
|
|
// make sure we have a good transferable
|
|
if ( !aTransferable || aWhichClipboard != kGlobalClipboard )
|
|
return NS_ERROR_FAILURE;
|
|
|
|
nsresult res;
|
|
|
|
// This makes sure we can use the OLE functionality for the clipboard
|
|
IDataObject * dataObj;
|
|
if (S_OK == ::OleGetClipboard(&dataObj)) {
|
|
// Use OLE IDataObject for clipboard operations
|
|
res = GetDataFromDataObject(dataObj, 0, nullptr, aTransferable);
|
|
dataObj->Release();
|
|
}
|
|
else {
|
|
// do it the old manual way
|
|
res = GetDataFromDataObject(nullptr, 0, mWindow, aTransferable);
|
|
}
|
|
return res;
|
|
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsClipboard::EmptyClipboard(int32_t aWhichClipboard)
|
|
{
|
|
// Some programs such as ZoneAlarm monitor clipboard usage and then open the
|
|
// clipboard to scan it. If we i) empty and then ii) set data, then the
|
|
// 'set data' can sometimes fail with access denied becacuse another program
|
|
// has the clipboard open. So to avoid this race condition for OpenClipboard
|
|
// we do not empty the clipboard when we're setting it.
|
|
if (aWhichClipboard == kGlobalClipboard && !mEmptyingForSetData) {
|
|
OleSetClipboard(nullptr);
|
|
}
|
|
return nsBaseClipboard::EmptyClipboard(aWhichClipboard);
|
|
}
|
|
|
|
//-------------------------------------------------------------------------
|
|
NS_IMETHODIMP nsClipboard::HasDataMatchingFlavors(const char** aFlavorList,
|
|
uint32_t aLength,
|
|
int32_t aWhichClipboard,
|
|
bool *_retval)
|
|
{
|
|
*_retval = false;
|
|
if (aWhichClipboard != kGlobalClipboard || !aFlavorList)
|
|
return NS_OK;
|
|
|
|
for (uint32_t i = 0;i < aLength; ++i) {
|
|
#ifdef DEBUG
|
|
if (strcmp(aFlavorList[i], kTextMime) == 0)
|
|
NS_WARNING ( "DO NOT USE THE text/plain DATA FLAVOR ANY MORE. USE text/unicode INSTEAD" );
|
|
#endif
|
|
|
|
UINT format = GetFormat(aFlavorList[i]);
|
|
if (IsClipboardFormatAvailable(format)) {
|
|
*_retval = true;
|
|
break;
|
|
}
|
|
else {
|
|
// We haven't found the exact flavor the client asked for, but maybe we can
|
|
// still find it from something else that's on the clipboard...
|
|
if (strcmp(aFlavorList[i], kUnicodeMime) == 0) {
|
|
// client asked for unicode and it wasn't present, check if we have CF_TEXT.
|
|
// We'll handle the actual data substitution in the data object.
|
|
if (IsClipboardFormatAvailable(GetFormat(kTextMime)))
|
|
*_retval = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|