Data store should be readable in dragstart/copy/cut events
[WebKit-https.git] / Source / WebCore / platform / qt / ClipboardQt.cpp
1 /*
2  * Copyright (C) 2007 Apple Inc.  All rights reserved.
3  * Copyright (C) 2006, 2007 Apple Inc.  All rights reserved.
4  * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
5  * Copyright (C) 2010 Sencha, Inc. All rights reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  *
16  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
17  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
20  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
21  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
22  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
23  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
24  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27  */
28
29 #include "config.h"
30 #include "ClipboardQt.h"
31
32 #include "CachedImage.h"
33 #include "DataTransferItemListQt.h"
34 #include "Document.h"
35 #include "DragData.h"
36 #include "Element.h"
37 #include "FileList.h"
38 #include "Frame.h"
39 #include "HTMLNames.h"
40 #include "HTMLParserIdioms.h"
41 #include "Image.h"
42 #include "IntPoint.h"
43 #include "KURL.h"
44 #include "NotImplemented.h"
45 #include "Range.h"
46 #include "RenderImage.h"
47 #include "markup.h"
48 #include <wtf/text/StringHash.h>
49 #include <wtf/text/WTFString.h>
50
51 #include <QClipboard>
52 #include <QGuiApplication>
53 #include <QList>
54 #include <QMimeData>
55 #include <QStringList>
56 #include <QTextCodec>
57 #include <QUrl>
58 #include <qdebug.h>
59
60 #define methodDebug() qDebug("ClipboardQt: %s", __FUNCTION__)
61
62 namespace WebCore {
63
64 static bool isTextMimeType(const String& type)
65 {
66     return type == "text/plain" || type.startsWith("text/plain;");
67 }
68
69 static bool isHtmlMimeType(const String& type)
70 {
71     return type == "text/html" || type.startsWith("text/html;");
72 }
73
74 PassRefPtr<Clipboard> Clipboard::create(ClipboardAccessPolicy policy, DragData* dragData, Frame* frame)
75 {
76     return ClipboardQt::create(policy, dragData->platformData(), frame);
77 }
78
79 ClipboardQt::ClipboardQt(ClipboardAccessPolicy policy, const QMimeData* readableClipboard, Frame* frame)
80     : Clipboard(policy, DragAndDrop)
81     , m_readableData(readableClipboard)
82     , m_writableData(0)
83     , m_frame(frame)
84 {
85     Q_ASSERT(policy == ClipboardReadable || policy == ClipboardTypesReadable);
86 }
87
88 ClipboardQt::ClipboardQt(ClipboardAccessPolicy policy, ClipboardType clipboardType, Frame* frame)
89     : Clipboard(policy, clipboardType)
90     , m_readableData(0)
91     , m_writableData(0)
92     , m_frame(frame)
93 {
94     Q_ASSERT(policy == ClipboardReadable || policy == ClipboardWritable || policy == ClipboardNumb);
95
96 #ifndef QT_NO_CLIPBOARD
97     if (policy != ClipboardWritable) {
98         Q_ASSERT(isForCopyAndPaste());
99         m_readableData = QGuiApplication::clipboard()->mimeData();
100     }
101 #endif
102 }
103
104 ClipboardQt::~ClipboardQt()
105 {
106     if (m_writableData && isForCopyAndPaste())
107         m_writableData = 0;
108     else
109         delete m_writableData;
110     m_readableData = 0;
111 }
112
113 void ClipboardQt::clearData(const String& type)
114 {
115     if (!canWriteData())
116         return;
117
118     if (m_writableData) {
119         m_writableData->removeFormat(type);
120         if (m_writableData->formats().isEmpty()) {
121             if (isForDragAndDrop())
122                 delete m_writableData;
123             m_writableData = 0;
124         }
125     }
126 #ifndef QT_NO_CLIPBOARD
127     if (isForCopyAndPaste())
128         QGuiApplication::clipboard()->setMimeData(m_writableData);
129 #endif
130 }
131
132 void ClipboardQt::clearAllData()
133 {
134     if (!canWriteData())
135         return;
136
137 #ifndef QT_NO_CLIPBOARD
138     if (isForCopyAndPaste())
139         QGuiApplication::clipboard()->setMimeData(0);
140     else
141 #endif
142         delete m_writableData;
143     m_writableData = 0;
144 }
145
146 String ClipboardQt::getData(const String& type) const
147 {
148
149     if (!canReadData())
150         return String();
151
152     if (isHtmlMimeType(type) && m_readableData->hasHtml())
153         return m_readableData->html();
154
155     if (isTextMimeType(type) && m_readableData->hasText())
156         return m_readableData->text();
157
158     ASSERT(m_readableData);
159     QByteArray rawData = m_readableData->data(type);
160     QString data = QTextCodec::codecForName("UTF-16")->toUnicode(rawData);
161     return data;
162 }
163
164 bool ClipboardQt::setData(const String& type, const String& data)
165 {
166     if (!canWriteData())
167         return false;
168
169     if (!m_writableData)
170         m_writableData = new QMimeData;
171
172     if (isTextMimeType(type))
173         m_writableData->setText(QString(data));
174     else if (isHtmlMimeType(type))
175         m_writableData->setHtml(QString(data));
176     else {
177         QByteArray array(reinterpret_cast<const char*>(data.characters()), data.length() * 2);
178         m_writableData->setData(QString(type), array);
179     }
180
181     return true;
182 }
183
184 // extensions beyond IE's API
185 ListHashSet<String> ClipboardQt::types() const
186 {
187     if (!canReadTypes())
188         return ListHashSet<String>();
189
190     ASSERT(m_readableData);
191     ListHashSet<String> result;
192     QStringList formats = m_readableData->formats();
193     for (int i = 0; i < formats.count(); ++i)
194         result.add(formats.at(i));
195     return result;
196 }
197
198 PassRefPtr<FileList> ClipboardQt::files() const
199 {
200     if (!canReadData() || !m_readableData->hasUrls())
201         return FileList::create();
202
203     RefPtr<FileList> fileList = FileList::create();
204     QList<QUrl> urls = m_readableData->urls();
205
206     for (int i = 0; i < urls.size(); i++) {
207         QUrl url = urls[i];
208         if (url.scheme() != QLatin1String("file"))
209             continue;
210         fileList->append(File::create(url.toLocalFile(), File::AllContentTypes));
211     }
212
213     return fileList.release();
214 }
215
216 void ClipboardQt::setDragImage(CachedImage* image, const IntPoint& point)
217 {
218     setDragImage(image, 0, point);
219 }
220
221 void ClipboardQt::setDragImageElement(Node* node, const IntPoint& point)
222 {
223     setDragImage(0, node, point);
224 }
225
226 void ClipboardQt::setDragImage(CachedImage* image, Node *node, const IntPoint &loc)
227 {
228     if (!canSetDragImage())
229         return;
230
231     if (m_dragImage)
232         m_dragImage->removeClient(this);
233     m_dragImage = image;
234     if (m_dragImage)
235         m_dragImage->addClient(this);
236
237     m_dragLoc = loc;
238     m_dragImageElement = node;
239 }
240
241 DragImageRef ClipboardQt::createDragImage(IntPoint& dragLoc) const
242 {
243     dragLoc = m_dragLoc;
244
245     if (m_dragImage)
246         return m_dragImage->image()->nativeImageForCurrentFrame();
247     if (m_dragImageElement && m_frame)
248         return m_frame->nodeImage(m_dragImageElement.get());
249
250     return 0;
251 }
252
253
254 static CachedImage* getCachedImage(Element* element)
255 {
256     // Attempt to pull CachedImage from element
257     ASSERT(element);
258     RenderObject* renderer = element->renderer();
259     if (!renderer || !renderer->isImage())
260         return 0;
261
262     RenderImage* image = toRenderImage(renderer);
263     if (image->cachedImage() && !image->cachedImage()->errorOccurred())
264         return image->cachedImage();
265
266     return 0;
267 }
268
269 void ClipboardQt::declareAndWriteDragImage(Element* element, const KURL& url, const String& title, Frame* frame)
270 {
271     ASSERT(frame);
272
273     // WebCore::writeURL(m_writableDataObject.get(), url, title, true, false);
274     if (!m_writableData)
275         m_writableData = new QMimeData;
276
277     CachedImage* cachedImage = getCachedImage(element);
278     if (!cachedImage || !cachedImage->imageForRenderer(element->renderer()) || !cachedImage->isLoaded())
279         return;
280     QPixmap* pixmap = cachedImage->imageForRenderer(element->renderer())->nativeImageForCurrentFrame();
281     if (pixmap)
282         m_writableData->setImageData(*pixmap);
283
284     QList<QUrl> urls;
285     urls.append(url);
286
287     m_writableData->setText(title);
288     m_writableData->setUrls(urls);
289     m_writableData->setHtml(createMarkup(element, IncludeNode, 0, ResolveAllURLs));
290 #ifndef QT_NO_CLIPBOARD
291     if (isForCopyAndPaste())
292         QGuiApplication::clipboard()->setMimeData(m_writableData);
293 #endif
294 }
295
296 void ClipboardQt::writeURL(const KURL& url, const String& title, Frame* frame)
297 {
298     ASSERT(frame);
299
300     QList<QUrl> urls;
301     urls.append(frame->document()->completeURL(url.string()));
302     if (!m_writableData)
303         m_writableData = new QMimeData;
304     m_writableData->setUrls(urls);
305     m_writableData->setText(title);
306 #ifndef QT_NO_CLIPBOARD
307     if (isForCopyAndPaste())
308         QGuiApplication::clipboard()->setMimeData(m_writableData);
309 #endif
310 }
311
312 void ClipboardQt::writeRange(Range* range, Frame* frame)
313 {
314     ASSERT(range);
315     ASSERT(frame);
316
317     if (!m_writableData)
318         m_writableData = new QMimeData;
319     QString text = frame->editor()->selectedText();
320     text.replace(QChar(0xa0), QLatin1Char(' '));
321     m_writableData->setText(text);
322     m_writableData->setHtml(createMarkup(range, 0, AnnotateForInterchange, false, ResolveNonLocalURLs));
323 #ifndef QT_NO_CLIPBOARD
324     if (isForCopyAndPaste())
325         QGuiApplication::clipboard()->setMimeData(m_writableData);
326 #endif
327 }
328
329 void ClipboardQt::writePlainText(const String& str)
330 {
331     if (!m_writableData)
332         m_writableData = new QMimeData;
333     QString text = str;
334     text.replace(QChar(0xa0), QLatin1Char(' '));
335     m_writableData->setText(text);
336 #ifndef QT_NO_CLIPBOARD
337     if (isForCopyAndPaste())
338         QGuiApplication::clipboard()->setMimeData(m_writableData);
339 #endif
340 }
341
342 bool ClipboardQt::hasData()
343 {
344     const QMimeData *data = m_readableData ? m_readableData : m_writableData;
345     if (!data)
346         return false;
347     return data->formats().count() > 0;
348 }
349
350 #if ENABLE(DATA_TRANSFER_ITEMS)
351 PassRefPtr<DataTransferItemList> ClipboardQt::items()
352 {
353
354     if (!m_frame && !m_frame->document())
355         return 0;
356
357     RefPtr<DataTransferItemListQt> items = DataTransferItemListQt::create(this, m_frame->document()->scriptExecutionContext());
358
359     if (!m_readableData)
360         return items;
361
362     if (isForCopyAndPaste() && canReadData()) {
363         const QStringList types = m_readableData->formats();
364         for (int i = 0; i < types.count(); ++i)
365             items->addPasteboardItem(types.at(i));
366     }
367     return items;
368 }
369 #endif
370
371 }