Part 2 of removing PlatformString.h, remove PlatformString.h
[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 <QGuiApplication>
52 #include <QClipboard>
53 #include <QImage>
54 #include <QList>
55 #include <QMimeData>
56 #include <QStringList>
57 #include <QTextCodec>
58 #include <QUrl>
59 #include <qdebug.h>
60
61 #define methodDebug() qDebug("ClipboardQt: %s", __FUNCTION__)
62
63 namespace WebCore {
64
65 static bool isTextMimeType(const String& type)
66 {
67     return type == "text/plain" || type.startsWith("text/plain;");
68 }
69
70 static bool isHtmlMimeType(const String& type)
71 {
72     return type == "text/html" || type.startsWith("text/html;");
73 }
74
75 PassRefPtr<Clipboard> Clipboard::create(ClipboardAccessPolicy policy, DragData* dragData, Frame* frame)
76 {
77     return ClipboardQt::create(policy, dragData->platformData(), frame);
78 }
79
80 ClipboardQt::ClipboardQt(ClipboardAccessPolicy policy, const QMimeData* readableClipboard, Frame* frame)
81     : Clipboard(policy, DragAndDrop)
82     , m_readableData(readableClipboard)
83     , m_writableData(0)
84     , m_frame(frame)
85 {
86     Q_ASSERT(policy == ClipboardReadable || policy == ClipboardTypesReadable);
87 }
88
89 ClipboardQt::ClipboardQt(ClipboardAccessPolicy policy, ClipboardType clipboardType, Frame* frame)
90     : Clipboard(policy, clipboardType)
91     , m_readableData(0)
92     , m_writableData(0)
93     , m_frame(frame)
94 {
95     Q_ASSERT(policy == ClipboardReadable || policy == ClipboardWritable || policy == ClipboardNumb);
96
97 #ifndef QT_NO_CLIPBOARD
98     if (policy != ClipboardWritable) {
99         Q_ASSERT(isForCopyAndPaste());
100         m_readableData = QGuiApplication::clipboard()->mimeData();
101     }
102 #endif
103 }
104
105 ClipboardQt::~ClipboardQt()
106 {
107     if (m_writableData && isForCopyAndPaste())
108         m_writableData = 0;
109     else
110         delete m_writableData;
111     m_readableData = 0;
112 }
113
114 void ClipboardQt::clearData(const String& type)
115 {
116     if (policy() != ClipboardWritable)
117         return;
118
119     if (m_writableData) {
120         m_writableData->removeFormat(type);
121         if (m_writableData->formats().isEmpty()) {
122             if (isForDragAndDrop())
123                 delete m_writableData;
124             m_writableData = 0;
125         }
126     }
127 #ifndef QT_NO_CLIPBOARD
128     if (isForCopyAndPaste())
129         QGuiApplication::clipboard()->setMimeData(m_writableData);
130 #endif
131 }
132
133 void ClipboardQt::clearAllData()
134 {
135     if (policy() != ClipboardWritable)
136         return;
137
138 #ifndef QT_NO_CLIPBOARD
139     if (isForCopyAndPaste())
140         QGuiApplication::clipboard()->setMimeData(0);
141     else
142 #endif
143         delete m_writableData;
144     m_writableData = 0;
145 }
146
147 String ClipboardQt::getData(const String& type) const
148 {
149
150     if (policy() != ClipboardReadable)
151         return String();
152
153     if (isHtmlMimeType(type) && m_readableData->hasHtml())
154         return m_readableData->html();
155
156     if (isTextMimeType(type) && m_readableData->hasText())
157         return m_readableData->text();
158
159     ASSERT(m_readableData);
160     QByteArray rawData = m_readableData->data(type);
161     QString data = QTextCodec::codecForName("UTF-16")->toUnicode(rawData);
162     return data;
163 }
164
165 bool ClipboardQt::setData(const String& type, const String& data)
166 {
167     if (policy() != ClipboardWritable)
168         return false;
169
170     if (!m_writableData)
171         m_writableData = new QMimeData;
172
173     if (isTextMimeType(type))
174         m_writableData->setText(QString(data));
175     else if (isHtmlMimeType(type))
176         m_writableData->setHtml(QString(data));
177     else {
178         QByteArray array(reinterpret_cast<const char*>(data.characters()), data.length() * 2);
179         m_writableData->setData(QString(type), array);
180     }
181
182     return true;
183 }
184
185 // extensions beyond IE's API
186 HashSet<String> ClipboardQt::types() const
187 {
188     if (policy() != ClipboardReadable && policy() != ClipboardTypesReadable)
189         return HashSet<String>();
190
191     ASSERT(m_readableData);
192     HashSet<String> result;
193     QStringList formats = m_readableData->formats();
194     for (int i = 0; i < formats.count(); ++i)
195         result.add(formats.at(i));
196     return result;
197 }
198
199 PassRefPtr<FileList> ClipboardQt::files() const
200 {
201     if (policy() != ClipboardReadable || !m_readableData->hasUrls())
202         return FileList::create();
203
204     RefPtr<FileList> fileList = FileList::create();
205     QList<QUrl> urls = m_readableData->urls();
206
207     for (int i = 0; i < urls.size(); i++) {
208         QUrl url = urls[i];
209         if (url.scheme() != QLatin1String("file"))
210             continue;
211         fileList->append(File::create(url.toLocalFile(), File::AllContentTypes));
212     }
213
214     return fileList.release();
215 }
216
217 void ClipboardQt::setDragImage(CachedImage* image, const IntPoint& point)
218 {
219     setDragImage(image, 0, point);
220 }
221
222 void ClipboardQt::setDragImageElement(Node* node, const IntPoint& point)
223 {
224     setDragImage(0, node, point);
225 }
226
227 void ClipboardQt::setDragImage(CachedImage* image, Node *node, const IntPoint &loc)
228 {
229     if (policy() != ClipboardImageWritable && policy() != ClipboardWritable)
230         return;
231
232     if (m_dragImage)
233         m_dragImage->removeClient(this);
234     m_dragImage = image;
235     if (m_dragImage)
236         m_dragImage->addClient(this);
237
238     m_dragLoc = loc;
239     m_dragImageElement = node;
240 }
241
242 DragImageRef ClipboardQt::createDragImage(IntPoint& dragLoc) const
243 {
244     if (!m_dragImage)
245         return 0;
246     dragLoc = m_dragLoc;
247     return new QImage(*m_dragImage->image()->nativeImageForCurrentFrame());
248 }
249
250
251 static CachedImage* getCachedImage(Element* element)
252 {
253     // Attempt to pull CachedImage from element
254     ASSERT(element);
255     RenderObject* renderer = element->renderer();
256     if (!renderer || !renderer->isImage())
257         return 0;
258
259     RenderImage* image = toRenderImage(renderer);
260     if (image->cachedImage() && !image->cachedImage()->errorOccurred())
261         return image->cachedImage();
262
263     return 0;
264 }
265
266 void ClipboardQt::declareAndWriteDragImage(Element* element, const KURL& url, const String& title, Frame* frame)
267 {
268     ASSERT(frame);
269
270     // WebCore::writeURL(m_writableDataObject.get(), url, title, true, false);
271     if (!m_writableData)
272         m_writableData = new QMimeData;
273
274     CachedImage* cachedImage = getCachedImage(element);
275     if (!cachedImage || !cachedImage->imageForRenderer(element->renderer()) || !cachedImage->isLoaded())
276         return;
277     QImage* image = cachedImage->imageForRenderer(element->renderer())->nativeImageForCurrentFrame();
278     if (image)
279         m_writableData->setImageData(*image);
280
281     QList<QUrl> urls;
282     urls.append(url);
283
284     m_writableData->setText(title);
285     m_writableData->setUrls(urls);
286     m_writableData->setHtml(createMarkup(element, IncludeNode, 0, ResolveAllURLs));
287 #ifndef QT_NO_CLIPBOARD
288     if (isForCopyAndPaste())
289         QGuiApplication::clipboard()->setMimeData(m_writableData);
290 #endif
291 }
292
293 void ClipboardQt::writeURL(const KURL& url, const String& title, Frame* frame)
294 {
295     ASSERT(frame);
296
297     QList<QUrl> urls;
298     urls.append(frame->document()->completeURL(url.string()));
299     if (!m_writableData)
300         m_writableData = new QMimeData;
301     m_writableData->setUrls(urls);
302     m_writableData->setText(title);
303 #ifndef QT_NO_CLIPBOARD
304     if (isForCopyAndPaste())
305         QGuiApplication::clipboard()->setMimeData(m_writableData);
306 #endif
307 }
308
309 void ClipboardQt::writeRange(Range* range, Frame* frame)
310 {
311     ASSERT(range);
312     ASSERT(frame);
313
314     if (!m_writableData)
315         m_writableData = new QMimeData;
316     QString text = frame->editor()->selectedText();
317     text.replace(QChar(0xa0), QLatin1Char(' '));
318     m_writableData->setText(text);
319     m_writableData->setHtml(createMarkup(range, 0, AnnotateForInterchange, false, ResolveNonLocalURLs));
320 #ifndef QT_NO_CLIPBOARD
321     if (isForCopyAndPaste())
322         QGuiApplication::clipboard()->setMimeData(m_writableData);
323 #endif
324 }
325
326 void ClipboardQt::writePlainText(const String& str)
327 {
328     if (!m_writableData)
329         m_writableData = new QMimeData;
330     QString text = str;
331     text.replace(QChar(0xa0), QLatin1Char(' '));
332     m_writableData->setText(text);
333 #ifndef QT_NO_CLIPBOARD
334     if (isForCopyAndPaste())
335         QGuiApplication::clipboard()->setMimeData(m_writableData);
336 #endif
337 }
338
339 bool ClipboardQt::hasData()
340 {
341     const QMimeData *data = m_readableData ? m_readableData : m_writableData;
342     if (!data)
343         return false;
344     return data->formats().count() > 0;
345 }
346
347 #if ENABLE(DATA_TRANSFER_ITEMS)
348 PassRefPtr<DataTransferItemList> ClipboardQt::items()
349 {
350
351     if (!m_frame && !m_frame->document())
352         return 0;
353
354     RefPtr<DataTransferItemListQt> items = DataTransferItemListQt::create(this, m_frame->document()->scriptExecutionContext());
355
356     if (!m_readableData)
357         return items;
358
359     if (isForCopyAndPaste() && policy() == ClipboardReadable) {
360         const QStringList types = m_readableData->formats();
361         for (int i = 0; i < types.count(); ++i)
362             items->addPasteboardItem(types.at(i));
363     }
364     return items;
365 }
366 #endif
367
368 }