Changeset 151091 in webkit


Ignore:
Timestamp:
Jun 2, 2013 9:53:33 PM (11 years ago)
Author:
commit-queue@webkit.org
Message:

[Qt] Move Qt port off legacy clipboard
​https://bugs.webkit.org/show_bug.cgi?id=116416

Patch by Arunprasad Rajkumar <​arurajku@cisco.com> on 2013-06-02
Reviewed by Darin Adler.

Source/WebCore:

No change in behavior, no new tests added.

  • Target.pri: Removed ClipboardQt.h and EditorQt.cpp from compilation.
  • dom/Clipboard.h:
  • editing/qt/EditorQt.cpp: Removed.
  • page/qt/EventHandlerQt.cpp: Use Clipboard::createForDragAndDrop().

(WebCore::EventHandler::createDraggingClipboard):

  • platform/Pasteboard.h:

(WebCore::Pasteboard::clipboardData): Expose writable QMimeData* to outside, so that it is accessible
from DragClientQt.cpp and WebDragClientQt.cpp.
(WebCore::Pasteboard::invalidateWritableData):
(WebCore::Pasteboard::isForDragAndDrop):
(WebCore::Pasteboard::isForCopyAndPaste):

  • platform/qt/ClipboardQt.cpp:

(WebCore::Clipboard::createDragImage):
(WebCore::Clipboard::declareAndWriteDragImage):

  • platform/qt/ClipboardQt.h: Removed.
  • platform/qt/PasteboardQt.cpp: Moved required methods from ClipboardQt.cpp.

(WebCore::isTextMimeType):
(WebCore::isHtmlMimeType):
(WebCore::Pasteboard::create):
(WebCore::Pasteboard::createForCopyAndPaste):
(WebCore::Pasteboard::createPrivate):
(WebCore::Pasteboard::createForDragAndDrop):
(WebCore::Pasteboard::Pasteboard):
(WebCore::Pasteboard::~Pasteboard):
(WebCore::Pasteboard::generalPasteboard):
(WebCore::Pasteboard::isSelectionMode):
(WebCore::Pasteboard::setSelectionMode):
(WebCore::Pasteboard::readData):
(WebCore::Pasteboard::hasData):
(WebCore::Pasteboard::clear):
(WebCore::Pasteboard::readString):
(WebCore::Pasteboard::writeString):
(WebCore::Pasteboard::types):
(WebCore::Pasteboard::readFilenames):
(WebCore::Pasteboard::setDragImage):
(WebCore::Pasteboard::writePasteboard):

Source/WebKit/qt:

  • WebCoreSupport/DragClientQt.cpp:

(WebCore::DragClientQt::startDrag):

Source/WebKit2:

  • WebProcess/WebCoreSupport/qt/WebDragClientQt.cpp:

(WebKit::WebDragClient::startDrag):

Location:
trunk/Source
Files:
2 deleted
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r151088 r151091  
     12013-06-02  Arunprasad Rajkumar  <arurajku@cisco.com>
     2
     3        [Qt] Move Qt port off legacy clipboard
     4        https://bugs.webkit.org/show_bug.cgi?id=116416
     5
     6        Reviewed by Darin Adler.
     7
     8        No change in behavior, no new tests added.
     9
     10        * Target.pri: Removed ClipboardQt.h and EditorQt.cpp from compilation.
     11        * dom/Clipboard.h:
     12        * editing/qt/EditorQt.cpp: Removed.
     13        * page/qt/EventHandlerQt.cpp: Use Clipboard::createForDragAndDrop().
     14        (WebCore::EventHandler::createDraggingClipboard):
     15        * platform/Pasteboard.h:
     16        (WebCore::Pasteboard::clipboardData): Expose writable QMimeData* to outside, so that it is accessible
     17        from DragClientQt.cpp and WebDragClientQt.cpp.
     18        (WebCore::Pasteboard::invalidateWritableData):
     19        (WebCore::Pasteboard::isForDragAndDrop):
     20        (WebCore::Pasteboard::isForCopyAndPaste):
     21        * platform/qt/ClipboardQt.cpp:
     22        (WebCore::Clipboard::createDragImage):
     23        (WebCore::Clipboard::declareAndWriteDragImage):
     24        * platform/qt/ClipboardQt.h: Removed.
     25        * platform/qt/PasteboardQt.cpp: Moved required methods from ClipboardQt.cpp.
     26        (WebCore::isTextMimeType):
     27        (WebCore::isHtmlMimeType):
     28        (WebCore::Pasteboard::create):
     29        (WebCore::Pasteboard::createForCopyAndPaste):
     30        (WebCore::Pasteboard::createPrivate):
     31        (WebCore::Pasteboard::createForDragAndDrop):
     32        (WebCore::Pasteboard::Pasteboard):
     33        (WebCore::Pasteboard::~Pasteboard):
     34        (WebCore::Pasteboard::generalPasteboard):
     35        (WebCore::Pasteboard::isSelectionMode):
     36        (WebCore::Pasteboard::setSelectionMode):
     37        (WebCore::Pasteboard::readData):
     38        (WebCore::Pasteboard::hasData):
     39        (WebCore::Pasteboard::clear):
     40        (WebCore::Pasteboard::readString):
     41        (WebCore::Pasteboard::writeString):
     42        (WebCore::Pasteboard::types):
     43        (WebCore::Pasteboard::readFilenames):
     44        (WebCore::Pasteboard::setDragImage):
     45        (WebCore::Pasteboard::writePasteboard):
     46
    1472013-06-02  Brady Eidson  <beidson@apple.com>
    248

  • trunk/Source/WebCore/Target.pri

    r150971 r151091  
    23432343    platform/PopupMenu.h \
    23442344    platform/ReferrerPolicy.h \
    2345     platform/qt/ClipboardQt.h \
    23462345    platform/qt/QWebPageClient.h \
    23472346    platform/qt/QStyleFacade.h \
    … …  
    29032902    platform/network/qt/QtMIMETypeSniffer.cpp \
    29042903    platform/network/qt/QNetworkReplyHandler.cpp \
    2905     editing/qt/EditorQt.cpp \
    29062904    platform/Cursor.cpp \
    29072905    platform/ContextMenu.cpp \

  • trunk/Source/WebCore/dom/Clipboard.h

    r150926 r151091  
    3535// Specifically, the class currently named Pasteboard. The legacy style instead
    3636// uses this as an abstract base class.
    37 #define WTF_USE_LEGACY_STYLE_ABSTRACT_CLIPBOARD_CLASS (PLATFORM(IOS) || PLATFORM(QT))
     37#define WTF_USE_LEGACY_STYLE_ABSTRACT_CLIPBOARD_CLASS PLATFORM(IOS)
    3838
    3939#if USE(LEGACY_STYLE_ABSTRACT_CLIPBOARD_CLASS)

  • trunk/Source/WebCore/page/qt/EventHandlerQt.cpp

    r145913 r151091  
    2929#include "EventHandler.h"
    3030
    31 #include "ClipboardQt.h"
     31#include "Clipboard.h"
    3232#include "Cursor.h"
    3333#include "Document.h"
    … …  
    9797PassRefPtr<Clipboard> EventHandler::createDraggingClipboard() const
    9898{
    99     return ClipboardQt::create(ClipboardWritable, m_frame, Clipboard::DragAndDrop);
     99    return Clipboard::createForDragAndDrop();
    100100}
    101101

  • trunk/Source/WebCore/platform/Pasteboard.h

    r150772 r151091  
    3838#endif
    3939
     40#if PLATFORM(QT)
     41#include <QMimeData>
     42#endif
     43
    4044#if PLATFORM(WIN)
    4145#include "COMPtr.h"
    … …  
    103107    static PassOwnPtr<Pasteboard> create(GtkClipboard*);
    104108    PassRefPtr<DataObjectGtk> dataObject() const;
     109#endif
     110
     111#if PLATFORM(QT)
     112    static PassOwnPtr<Pasteboard> create(const QMimeData* readableClipboard = 0, bool isForDragAndDrop = false);
     113    QMimeData* clipboardData() const { return m_writableData; }
     114    void invalidateWritableData() const { m_writableData = 0; }
     115    bool isForDragAndDrop() const { return m_isForDragAndDrop; }
     116    bool isForCopyAndPaste() const { return !m_isForDragAndDrop; }
    105117#endif
    106118
    … …  
    166178#endif
    167179
    168 #if PLATFORM(GTK)
     180#if PLATFORM(GTK) || PLATFORM(QT)
    169181    ~Pasteboard();
    170182#endif
    … …  
    176188    Pasteboard(PassRefPtr<DataObjectGtk>);
    177189    Pasteboard(GtkClipboard*);
     190#endif
     191
     192#if PLATFORM(QT)
     193    Pasteboard(const QMimeData* , bool);
    178194#endif
    179195
    … …  
    206222
    207223#if PLATFORM(QT)
     224    const QMimeData* readData() const;
     225
    208226    bool m_selectionMode;
     227    const QMimeData* m_readableData;
     228    mutable QMimeData* m_writableData;
     229    bool m_isForDragAndDrop;
    209230#endif
    210231

  • trunk/Source/WebCore/platform/qt/ClipboardQt.cpp

    r150373 r151091  
    44 * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
    55 * Copyright (C) 2010 Sencha, Inc. All rights reserved.
     6 * Copyright (C) 2013 Cisco Systems, Inc. All rights reserved.
    67 *
    78 * Redistribution and use in source and binary forms, with or without
    … …  
    2829
    2930#include "config.h"
    30 #include "ClipboardQt.h"
     31#include "Clipboard.h"
    3132
    3233#include "CachedImage.h"
    33 #include "DataTransferItemListQt.h"
    3434#include "Document.h"
    35 #include "DragData.h"
    3635#include "Editor.h"
    3736#include "Element.h"
    38 #include "FileList.h"
    3937#include "Frame.h"
    40 #include "HTMLNames.h"
    41 #include "HTMLParserIdioms.h"
    4238#include "Image.h"
    43 #include "IntPoint.h"
    44 #include "KURL.h"
    45 #include "NotImplemented.h"
    46 #include "Range.h"
    47 #include "RenderImage.h"
    48 #include "markup.h"
    49 #include <wtf/text/StringHash.h>
    50 #include <wtf/text/WTFString.h>
    51 
    52 #include <QClipboard>
    53 #include <QGuiApplication>
    54 #include <QList>
    55 #include <QMimeData>
    56 #include <QStringList>
    57 #include <QTextCodec>
    58 #include <QUrl>
     39#include "Pasteboard.h"
    5940
    6041namespace WebCore {
    6142
    62 static bool isTextMimeType(const String& type)
     43DragImageRef Clipboard::createDragImage(IntPoint& location) const
    6344{
    64     return type == "text/plain" || type.startsWith("text/plain;");
     45    location = m_dragLoc;
     46
     47    if (m_dragImage)
     48        return createDragImageFromImage(m_dragImage->image());
     49
     50    if (m_dragImageElement) {
     51        Document* document = m_dragImageElement->document();
     52        if (Frame* frame = document->frame())
     53            return frame->nodeImage(m_dragImageElement.get());
     54    }
     55
     56    return 0; // We do not have enough information to create a drag image, use the default icon.
    6557}
    6658
    67 static bool isHtmlMimeType(const String& type)
     59void Clipboard::declareAndWriteDragImage(Element* element, const KURL& url, const String& label, Frame* frame)
    6860{
    69     return type == "text/html" || type.startsWith("text/html;");
     61    m_pasteboard->writeImage(element->toNode(), url, label);
    7062}
    7163
    72 PassRefPtr<Clipboard> Clipboard::create(ClipboardAccessPolicy policy, DragData* dragData, Frame* frame)
    73 {
    74     return ClipboardQt::create(policy, dragData->platformData(), frame);
    7564}
    76 
    77 ClipboardQt::ClipboardQt(ClipboardAccessPolicy policy, const QMimeData* readableClipboard, Frame* frame)
    78     : Clipboard(policy, DragAndDrop)
    79     , m_readableData(readableClipboard)
    80     , m_writableData(0)
    81     , m_frame(frame)
    82 {
    83     Q_ASSERT(policy == ClipboardReadable || policy == ClipboardTypesReadable);
    84 }
    85 
    86 ClipboardQt::ClipboardQt(ClipboardAccessPolicy policy, ClipboardType clipboardType, Frame* frame)
    87     : Clipboard(policy, clipboardType)
    88     , m_readableData(0)
    89     , m_writableData(0)
    90     , m_frame(frame)
    91 {
    92     Q_ASSERT(policy == ClipboardReadable || policy == ClipboardWritable || policy == ClipboardNumb);
    93 
    94 #ifndef QT_NO_CLIPBOARD
    95     if (policy != ClipboardWritable) {
    96         Q_ASSERT(isForCopyAndPaste());
    97         m_readableData = QGuiApplication::clipboard()->mimeData();
    98     }
    99 #endif
    100 }
    101 
    102 ClipboardQt::~ClipboardQt()
    103 {
    104     if (m_writableData && isForCopyAndPaste())
    105         m_writableData = 0;
    106     else
    107         delete m_writableData;
    108     m_readableData = 0;
    109 }
    110 
    111 void ClipboardQt::clearData(const String& type)
    112 {
    113     if (!canWriteData())
    114         return;
    115 
    116     if (m_writableData) {
    117         m_writableData->removeFormat(type);
    118         if (m_writableData->formats().isEmpty()) {
    119             if (isForDragAndDrop())
    120                 delete m_writableData;
    121             m_writableData = 0;
    122         }
    123     }
    124 #ifndef QT_NO_CLIPBOARD
    125     if (isForCopyAndPaste())
    126         QGuiApplication::clipboard()->setMimeData(m_writableData);
    127 #endif
    128 }
    129 
    130 void ClipboardQt::clearData()
    131 {
    132     if (!canWriteData())
    133         return;
    134 
    135 #ifndef QT_NO_CLIPBOARD
    136     if (isForCopyAndPaste())
    137         QGuiApplication::clipboard()->setMimeData(0);
    138     else
    139 #endif
    140         delete m_writableData;
    141     m_writableData = 0;
    142 }
    143 
    144 String ClipboardQt::getData(const String& type) const
    145 {
    146     const QMimeData* data = readData();
    147     if (!canReadData() || !data)
    148         return String();
    149 
    150     if (isHtmlMimeType(type) && data->hasHtml())
    151         return data->html();
    152 
    153     if (isTextMimeType(type) && data->hasText())
    154         return data->text();
    155 
    156     QByteArray rawData = data->data(type);
    157     QString stringData = QTextCodec::codecForName("UTF-16")->toUnicode(rawData);
    158     return stringData;
    159 }
    160 
    161 bool ClipboardQt::setData(const String& type, const String& data)
    162 {
    163     if (!canWriteData())
    164         return false;
    165 
    166     if (!m_writableData)
    167         m_writableData = new QMimeData;
    168 
    169     if (isTextMimeType(type))
    170         m_writableData->setText(QString(data));
    171     else if (isHtmlMimeType(type))
    172         m_writableData->setHtml(QString(data));
    173     else {
    174         QByteArray array(reinterpret_cast<const char*>(data.characters()), data.length() * 2);
    175         m_writableData->setData(QString(type), array);
    176     }
    177 
    178     return true;
    179 }
    180 
    181 // extensions beyond IE's API
    182 ListHashSet<String> ClipboardQt::types() const
    183 {
    184     const QMimeData* data = readData();
    185     if (!canReadTypes() || !data)
    186         return ListHashSet<String>();
    187 
    188     ListHashSet<String> result;
    189     QStringList formats = data->formats();
    190     for (int i = 0; i < formats.count(); ++i)
    191         result.add(formats.at(i));
    192     return result;
    193 }
    194 
    195 PassRefPtr<FileList> ClipboardQt::files() const
    196 {
    197     const QMimeData* data = readData();
    198     if (!canReadData() || !data || !data->hasUrls())
    199         return FileList::create();
    200 
    201     RefPtr<FileList> fileList = FileList::create();
    202     QList<QUrl> urls = data->urls();
    203 
    204     for (int i = 0; i < urls.size(); i++) {
    205         QUrl url = urls[i];
    206         if (url.scheme() != QLatin1String("file"))
    207             continue;
    208         fileList->append(File::create(url.toLocalFile(), File::AllContentTypes));
    209     }
    210 
    211     return fileList.release();
    212 }
    213 
    214 void ClipboardQt::setDragImage(CachedImage* image, const IntPoint& point)
    215 {
    216     setDragImage(image, 0, point);
    217 }
    218 
    219 void ClipboardQt::setDragImageElement(Node* node, const IntPoint& point)
    220 {
    221     setDragImage(0, node, point);
    222 }
    223 
    224 void ClipboardQt::setDragImage(CachedImage* image, Node *node, const IntPoint &loc)
    225 {
    226     if (!canSetDragImage())
    227         return;
    228 
    229     if (m_dragImage)
    230         m_dragImage->removeClient(this);
    231     m_dragImage = image;
    232     if (m_dragImage)
    233         m_dragImage->addClient(this);
    234 
    235     m_dragLoc = loc;
    236     m_dragImageElement = node;
    237 }
    238 
    239 DragImageRef ClipboardQt::createDragImage(IntPoint& dragLoc) const
    240 {
    241     dragLoc = m_dragLoc;
    242 
    243     if (m_dragImage)
    244         return m_dragImage->image()->nativeImageForCurrentFrame();
    245     if (m_dragImageElement && m_frame)
    246         return m_frame->nodeImage(m_dragImageElement.get());
    247 
    248     return 0;
    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     QPixmap* pixmap = cachedImage->imageForRenderer(element->renderer())->nativeImageForCurrentFrame();
    278     if (pixmap)
    279         m_writableData->setImageData(*pixmap);
    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().selectedTextForClipboard();
    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 const QMimeData* ClipboardQt::readData() const
    340 {
    341     ASSERT(!(m_readableData && m_writableData));
    342     ASSERT(m_readableData || m_writableData || canWriteData());
    343     return m_readableData ? m_readableData : m_writableData;
    344 }
    345 
    346 bool ClipboardQt::hasData()
    347 {
    348     const QMimeData *data = readData();
    349     if (!data)
    350         return false;
    351     return data->formats().count() > 0;
    352 }
    353 
    354 #if ENABLE(DATA_TRANSFER_ITEMS)
    355 PassRefPtr<DataTransferItemList> ClipboardQt::items()
    356 {
    357     if (!m_frame && !m_frame->document())
    358         return 0;
    359 
    360     RefPtr<DataTransferItemListQt> items = DataTransferItemListQt::create(this, m_frame->document()->scriptExecutionContext());
    361 
    362     const QMimeData* readableData = readData();
    363     if (readableData && isForCopyAndPaste() && canReadData()) {
    364         const QStringList types = readableData->formats();
    365         for (int i = 0; i < types.count(); ++i)
    366             items->addPasteboardItem(types.at(i));
    367     }
    368     return items;
    369 }
    370 #endif
    371 
    372 }

  • trunk/Source/WebCore/platform/qt/PasteboardQt.cpp

    r150140 r151091  
    33 * Copyright (C) 2006, 2007 Apple Inc.  All rights reserved.
    44 * Copyright (C) 2008 Nokia Corporation and/or its subsidiary(-ies)
     5 * Copyright (C) 2013 Cisco Systems, Inc. All rights reserved.
    56 *
    67 * Redistribution and use in source and binary forms, with or without
    … …  
    3031
    3132#include "CachedImage.h"
    32 #include "ClipboardQt.h"
    3333#include "DocumentFragment.h"
     34#include "DragData.h"
    3435#include "Editor.h"
    3536#include "Frame.h"
    3637#include "Image.h"
     38#include "NotImplemented.h"
    3739#include "RenderImage.h"
    3840#include "markup.h"
    … …  
    4143#include <qguiapplication.h>
    4244#include <qmimedata.h>
     45#include <qtextcodec.h>
    4346#include <qurl.h>
    4447
    … …  
    4750namespace WebCore {
    4851
    49 Pasteboard::Pasteboard()
     52static bool isTextMimeType(const String& type)
     53{
     54    return type == "text/plain" || type.startsWith("text/plain;");
     55}
     56
     57static bool isHtmlMimeType(const String& type)
     58{
     59    return type == "text/html" || type.startsWith("text/html;");
     60}
     61
     62PassOwnPtr<Pasteboard> Pasteboard::create(const QMimeData* readableClipboard, bool isForDragAndDrop)
     63{
     64    return adoptPtr(new Pasteboard(readableClipboard, isForDragAndDrop));
     65}
     66
     67PassOwnPtr<Pasteboard> Pasteboard::createForCopyAndPaste()
     68{
     69#ifndef QT_NO_CLIPBOARD
     70    return create(QGuiApplication::clipboard()->mimeData());
     71#else
     72    return create();
     73#endif
     74}
     75
     76PassOwnPtr<Pasteboard> Pasteboard::createPrivate()
     77{
     78    return create();
     79}
     80
     81PassOwnPtr<Pasteboard> Pasteboard::createForDragAndDrop()
     82{
     83    return create(0, true);
     84}
     85
     86PassOwnPtr<Pasteboard> Pasteboard::createForDragAndDrop(const DragData& dragData)
     87{
     88    return create(dragData.platformData(), true);
     89}
     90
     91Pasteboard::Pasteboard(const QMimeData* readableClipboard, bool isForDragAndDrop)
    5092    : m_selectionMode(false)
    51 {
     93    , m_readableData(readableClipboard)
     94    , m_writableData(0)
     95    , m_isForDragAndDrop(isForDragAndDrop)
     96{
     97}
     98
     99Pasteboard::~Pasteboard()
     100{
     101    if (m_writableData && isForCopyAndPaste())
     102        m_writableData = 0;
     103    else
     104        delete m_writableData;
     105    m_readableData = 0;
    52106}
    53107
    … …  
    56110    static Pasteboard* pasteboard = 0;
    57111    if (!pasteboard)
    58         pasteboard = new Pasteboard();
     112        pasteboard = new Pasteboard(0, false);
    59113    return pasteboard;
    60114}
    … …  
    177231}
    178232
    179 void Pasteboard::writeClipboard(Clipboard* clipboard)
    180 {
    181 #ifndef QT_NO_CLIPBOARD
    182     QGuiApplication::clipboard()->setMimeData(static_cast<ClipboardQt*>(clipboard)->clipboardData());
    183 #endif
    184 }
    185 
    186 /* This function is called from Editor::tryDHTMLCopy before actually set the clipboard
    187  * It introduce a race condition with klipper, which will try to grab the clipboard
    188  * It's not required to clear it anyway, since QClipboard take care about replacing the clipboard
    189  */
     233bool Pasteboard::isSelectionMode() const
     234{
     235    return m_selectionMode;
     236}
     237
     238void Pasteboard::setSelectionMode(bool selectionMode)
     239{
     240    m_selectionMode = selectionMode;
     241}
     242
     243const QMimeData* Pasteboard::readData() const
     244{
     245    ASSERT(!(m_readableData && m_writableData));
     246    ASSERT(m_readableData || m_writableData);
     247    return m_readableData ? m_readableData : m_writableData;
     248}
     249
     250bool Pasteboard::hasData()
     251{
     252    const QMimeData *data = readData();
     253    if (!data)
     254        return false;
     255    return data->formats().count() > 0;
     256}
     257
     258void Pasteboard::clear(const String& type)
     259{
     260    if (m_writableData) {
     261        m_writableData->removeFormat(type);
     262        if (m_writableData->formats().isEmpty()) {
     263            if (isForDragAndDrop())
     264                delete m_writableData;
     265            m_writableData = 0;
     266        }
     267    }
     268#ifndef QT_NO_CLIPBOARD
     269    if (isForCopyAndPaste())
     270        QGuiApplication::clipboard()->setMimeData(m_writableData);
     271#endif
     272}
     273
    190274void Pasteboard::clear()
    191275{
    192 }
    193 
    194 bool Pasteboard::isSelectionMode() const
    195 {
    196     return m_selectionMode;
    197 }
    198 
    199 void Pasteboard::setSelectionMode(bool selectionMode)
    200 {
    201     m_selectionMode = selectionMode;
    202 }
    203 
    204 }
     276#ifndef QT_NO_CLIPBOARD
     277    if (isForCopyAndPaste())
     278        QGuiApplication::clipboard()->setMimeData(0);
     279    else
     280#endif
     281    delete m_writableData;
     282    m_writableData = 0;
     283}
     284
     285String Pasteboard::readString(const String& type)
     286{
     287    const QMimeData* data = readData();
     288    if (!data)
     289        return String();
     290
     291    if (isHtmlMimeType(type) && data->hasHtml())
     292        return data->html();
     293
     294    if (isTextMimeType(type) && data->hasText())
     295        return data->text();
     296
     297    QByteArray rawData = data->data(type);
     298    QString stringData = QTextCodec::codecForName("UTF-16")->toUnicode(rawData);
     299    return stringData;
     300}
     301
     302bool Pasteboard::writeString(const String& type, const String& data)
     303{
     304    if (!m_writableData)
     305        m_writableData = new QMimeData;
     306
     307    if (isTextMimeType(type))
     308        m_writableData->setText(QString(data));
     309    else if (isHtmlMimeType(type))
     310        m_writableData->setHtml(QString(data));
     311    else {
     312        QByteArray array(reinterpret_cast<const char*>(data.characters()), data.length() * 2);
     313        m_writableData->setData(QString(type), array);
     314    }
     315
     316    return true;
     317}
     318
     319// extensions beyond IE's API
     320ListHashSet<String> Pasteboard::types()
     321{
     322    const QMimeData* data = readData();
     323    if (!data)
     324        return ListHashSet<String>();
     325
     326    ListHashSet<String> result;
     327    QStringList formats = data->formats();
     328    for (int i = 0; i < formats.count(); ++i)
     329        result.add(formats.at(i));
     330    return result;
     331}
     332
     333Vector<String> Pasteboard::readFilenames()
     334{
     335    const QMimeData* data = readData();
     336    if (!data)
     337        return Vector<String>();
     338
     339    Vector<String> fileList;
     340    QList<QUrl> urls = data->urls();
     341
     342    for (int i = 0; i < urls.size(); i++) {
     343        QUrl url = urls[i];
     344        if (url.scheme() != QLatin1String("file"))
     345            continue;
     346        fileList.append(url.toLocalFile());
     347    }
     348
     349    return fileList;
     350}
     351
     352void Pasteboard::setDragImage(DragImageRef, const IntPoint& hotSpot)
     353{
     354    notImplemented();
     355}
     356
     357void Pasteboard::writePasteboard(const Pasteboard& sourcePasteboard)
     358{
     359#ifndef QT_NO_CLIPBOARD
     360    QGuiApplication::clipboard()->setMimeData(sourcePasteboard.clipboardData());
     361#endif
     362}
     363
     364}

  • trunk/Source/WebKit/qt/ChangeLog

    r150895 r151091  
     12013-06-02  Arunprasad Rajkumar  <arurajku@cisco.com>
     2
     3        [Qt] Move Qt port off legacy clipboard
     4        https://bugs.webkit.org/show_bug.cgi?id=116416
     5
     6        Reviewed by Darin Adler.
     7
     8        * WebCoreSupport/DragClientQt.cpp:
     9        (WebCore::DragClientQt::startDrag):
     10
    1112013-05-29  Liang Qi  <liang.qi@digia.com>
    212

  • trunk/Source/WebKit/qt/WebCoreSupport/DragClientQt.cpp

    r148545 r151091  
    2828
    2929#include "ChromeClient.h"
    30 #include "ClipboardQt.h"
     30#include "Clipboard.h"
    3131#include "DragController.h"
    3232#include "EventHandler.h"
    3333#include "Frame.h"
    3434#include "Page.h"
     35#include "Pasteboard.h"
    3536#include "PlatformMouseEvent.h"
    3637
    … …  
    9394{
    9495#ifndef QT_NO_DRAGANDDROP
    95     QMimeData* clipboardData = static_cast<ClipboardQt*>(clipboard)->clipboardData();
    96     static_cast<ClipboardQt*>(clipboard)->invalidateWritableData();
     96    QMimeData* clipboardData = clipboard->pasteboard().clipboardData();
     97    clipboard->pasteboard().invalidateWritableData();
    9798    QObject* view = m_chromeClient->platformPageClient()->ownerWidget();
    9899    if (view) {

  • trunk/Source/WebKit2/ChangeLog

    r151081 r151091  
     12013-06-02  Arunprasad Rajkumar  <arurajku@cisco.com>
     2
     3        [Qt] Move Qt port off legacy clipboard
     4        https://bugs.webkit.org/show_bug.cgi?id=116416
     5
     6        Reviewed by Darin Adler.
     7
     8        * WebProcess/WebCoreSupport/qt/WebDragClientQt.cpp:
     9        (WebKit::WebDragClient::startDrag):
     10
    1112013-06-02  Sergio Correia  <sergio.correia@openbossa.org>
    212

  • trunk/Source/WebKit2/WebProcess/WebCoreSupport/qt/WebDragClientQt.cpp

    r130636 r151091  
    2727#include "WebDragClient.h"
    2828
    29 #include "ClipboardQt.h"
     29#include "Clipboard.h"
    3030#include "DragData.h"
    3131#include "GraphicsContext.h"
     32#include "Pasteboard.h"
    3233#include "ShareableBitmap.h"
    3334#include "WebCoreArgumentCoders.h"
    … …  
    5354void WebDragClient::startDrag(DragImageRef dragImage, const IntPoint& clientPosition, const IntPoint& globalPosition, Clipboard* clipboard, Frame*, bool)
    5455{
    55     QMimeData* clipboardData = static_cast<ClipboardQt*>(clipboard)->clipboardData();
     56    QMimeData* clipboardData = clipboard->pasteboard().clipboardData();
    5657    DragOperation dragOperationMask = clipboard->sourceOperation();
    57     static_cast<ClipboardQt*>(clipboard)->invalidateWritableData();
     58    clipboard->pasteboard().invalidateWritableData();
    5859    DragData dragData(clipboardData, clientPosition, globalPosition, dragOperationMask);
    5960
Note: See TracChangeset for help on using the changeset viewer.