Changeset 58470 in webkit

Timestamp:

Apr 28, 2010 9:13:23 PM (14 years ago)

Author:

Martin Robinson

Message:

2010-04-28 Martin Robinson <Martin Robinson>

Reviewed by Gustavo Noronha.

[GTK] Enable DOM clipboard and drag-and-drop access
​https://bugs.webkit.org/show_bug.cgi?id=30623

Make ClipboardGtk a "live" DataTransfer object, able to modify
the clipboard when setData(...) is called.

• platform/gtk/Skipped: Uncomment tests that are now passing.

2010-04-28 Martin Robinson <Martin Robinson>

Reviewed by Gustavo Noronha.

[GTK] Enable DOM clipboard and drag-and-drop access
​https://bugs.webkit.org/show_bug.cgi?id=30623

Make ClipboardGtk a "live" DataTransfer object, able to modify
the clipboard when setData(...) is called.

• platform/gtk/ClipboardGtk.cpp: (WebCore::Editor::newGeneralClipboard): Pass the GtkClipboard into the factory method. (WebCore::ClipboardGtk::ClipboardGtk): Create two separate constructors, one for DnD data and one for clipboard data. (WebCore::dataObjectTypeFromHTMLClipboardType): Added. (WebCore::ClipboardGtk::clearData): Clear the member DataObject, optionally write the clipboard. (WebCore::ClipboardGtk::clearAllData): Ditto. (WebCore::joinURIList): Added. (WebCore::ClipboardGtk::getData): Get the data from the clipboard, if possible. (WebCore::ClipboardGtk::setData): Write data to the DataObject and maybe the clipboard. (WebCore::ClipboardGtk::types): Read the clipboard/DataObject to find applicable types. (WebCore::ClipboardGtk::files): Read the clipboard/DataObject to find the files. (WebCore::ClipboardGtk::writeURL): Write to the DataObject and maybe the clipboard. (WebCore::ClipboardGtk::writeRange): Ditto. (WebCore::ClipboardGtk::writePlainText): Ditto. (WebCore::ClipboardGtk::hasData): Query the clipboard/DataObject.
• platform/gtk/ClipboardGtk.h: (WebCore::ClipboardGtk::create): Added one factory for pasteboard-backed DataObjects and one for DnD-backed objects.
• platform/gtk/DataObjectGtk.cpp: (WebCore::replaceNonBreakingSpaceWithSpace): Added this helper function to clean &nbsp; from plain text. (WebCore::DataObjectGtk::markup): Actually return the range if it's set. (WebCore::DataObjectGtk::setText): Clean &nbsp; from plain text. (WebCore::DataObjectGtk::clearText): Added. (WebCore::DataObjectGtk::clearMarkup): Added.
• platform/gtk/DataObjectGtk.h: (WebCore::DataObjectGtk::clearURIList): Added. (WebCore::DataObjectGtk::clearImage): Added.
• platform/gtk/PasteboardHelper.cpp: (WebCore::PasteboardHelper::initializeTargetList): Added target ID's for URI list and Netscape URL targets. (WebCore::urisToKURLVector): Added. (WebCore::PasteboardHelper::getClipboardContents): Added. (WebCore::PasteboardHelper::fillSelectionData): Added logic for URI lists and Netscape URLs. (WebCore::PasteboardHelper::targetListForDataObject): Ditto.
• platform/gtk/PasteboardHelper.h: Added default argument to writeClipboardContents and new method.

Location:

trunk

Files:

• LayoutTests/ChangeLog (modified) (1 diff)
• LayoutTests/platform/gtk/Skipped (modified) (2 diffs)
• WebCore/ChangeLog (modified) (1 diff)
• WebCore/platform/gtk/ClipboardGtk.cpp (modified) (4 diffs)
• WebCore/platform/gtk/ClipboardGtk.h (modified) (3 diffs)
• WebCore/platform/gtk/DataObjectGtk.cpp (modified) (4 diffs)
• WebCore/platform/gtk/DataObjectGtk.h (modified) (2 diffs)
• WebCore/platform/gtk/PasteboardHelper.cpp (modified) (5 diffs)
• WebCore/platform/gtk/PasteboardHelper.h (modified) (1 diff)

trunk/LayoutTests/ChangeLog

@@ +1 @@
+2010-04-28  Martin Robinson  <mrobinson@webkit.org>
+
+        Reviewed by Gustavo Noronha.
+
+        [GTK] Enable DOM clipboard and drag-and-drop access
+        https://bugs.webkit.org/show_bug.cgi?id=30623
+
+        Make ClipboardGtk a "live" DataTransfer object, able to modify
+        the clipboard when setData(...) is called.
+
+        * platform/gtk/Skipped: Uncomment tests that are now passing.
+
 2010-04-28  Evan Martin  <evan@chromium.org>
 

trunk/LayoutTests/platform/gtk/Skipped

@@ -741 +741 @@
 editing/deleting/type-delete-after-quote-2.html
 editing/execCommand/4128080-2.html
-editing/execCommand/copy-without-selection.html
 editing/execCommand/createLink.html
 editing/execCommand/delete-image-in-anchor.html
@@ -774 +773 @@
 editing/pasteboard/4744008.html
 editing/pasteboard/5368833.html
-editing/pasteboard/5665299.html
 editing/pasteboard/5780697-2.html
 editing/pasteboard/copy-in-password-field.html
-editing/pasteboard/copy-paste-float.html
 editing/pasteboard/drag-image-in-about-blank-frame.html
 editing/pasteboard/file-input-files-access.html
 editing/pasteboard/get-data-text-plain-drop.html
-editing/pasteboard/get-data-text-plain-paste.html
-editing/pasteboard/onpaste-text-html.html
-editing/pasteboard/paste-blockquote-before-blockquote.html
-editing/pasteboard/paste-double-nested-blockquote-before-blockquote.html
 editing/pasteboard/paste-into-anchor-text.html
 editing/pasteboard/paste-plaintext-user-select-none.html

trunk/WebCore/ChangeLog

@@ +1 @@
+2010-04-28  Martin Robinson  <mrobinson@webkit.org>
+
+        Reviewed by Gustavo Noronha.
+
+        [GTK] Enable DOM clipboard and drag-and-drop access
+        https://bugs.webkit.org/show_bug.cgi?id=30623
+
+        Make ClipboardGtk a "live" DataTransfer object, able to modify
+        the clipboard when setData(...) is called.
+
+        * platform/gtk/ClipboardGtk.cpp:
+        (WebCore::Editor::newGeneralClipboard): Pass the GtkClipboard into the factory method.
+        (WebCore::ClipboardGtk::ClipboardGtk): Create two separate constructors, one for DnD data and one for clipboard data.
+        (WebCore::dataObjectTypeFromHTMLClipboardType): Added.
+        (WebCore::ClipboardGtk::clearData): Clear the member DataObject, optionally write the clipboard.
+        (WebCore::ClipboardGtk::clearAllData): Ditto.
+        (WebCore::joinURIList): Added.
+        (WebCore::ClipboardGtk::getData): Get the data from the clipboard, if possible.
+        (WebCore::ClipboardGtk::setData): Write data to the DataObject and maybe the clipboard.
+        (WebCore::ClipboardGtk::types): Read the clipboard/DataObject to find applicable types.
+        (WebCore::ClipboardGtk::files): Read the clipboard/DataObject to find the files.
+        (WebCore::ClipboardGtk::writeURL): Write to the DataObject and maybe the clipboard.
+        (WebCore::ClipboardGtk::writeRange): Ditto.
+        (WebCore::ClipboardGtk::writePlainText): Ditto.
+        (WebCore::ClipboardGtk::hasData): Query the clipboard/DataObject.
+        * platform/gtk/ClipboardGtk.h: 
+        (WebCore::ClipboardGtk::create): Added one factory for pasteboard-backed DataObjects and one for DnD-backed objects.
+        * platform/gtk/DataObjectGtk.cpp:
+        (WebCore::replaceNonBreakingSpaceWithSpace): Added this helper function to clean &nbsp; from plain text.
+        (WebCore::DataObjectGtk::markup): Actually return the range if it's set.
+        (WebCore::DataObjectGtk::setText): Clean &nbsp; from plain text.
+        (WebCore::DataObjectGtk::clearText): Added.
+        (WebCore::DataObjectGtk::clearMarkup): Added.
+        * platform/gtk/DataObjectGtk.h:
+        (WebCore::DataObjectGtk::clearURIList): Added.
+        (WebCore::DataObjectGtk::clearImage): Added.
+        * platform/gtk/PasteboardHelper.cpp:
+        (WebCore::PasteboardHelper::initializeTargetList): Added target ID's for URI list and Netscape URL targets.
+        (WebCore::urisToKURLVector): Added.
+        (WebCore::PasteboardHelper::getClipboardContents): Added.
+        (WebCore::PasteboardHelper::fillSelectionData): Added logic for URI lists and Netscape URLs.
+        (WebCore::PasteboardHelper::targetListForDataObject): Ditto.
+        * platform/gtk/PasteboardHelper.h: Added default argument to writeClipboardContents and new method.
+
 2010-04-28  Martin Robinson  <mrobinson@webkit.org>
 

trunk/WebCore/platform/gtk/ClipboardGtk.cpp

@@ -25 +25 @@
 #include "Image.h"
 #include "NotImplemented.h"
+#include "Pasteboard.h"
+#include "PasteboardHelper.h"
 #include "RenderImage.h"
 #include "StringHash.h"
@@ -33 +35 @@
 namespace WebCore {
 
+enum ClipboardType {
+    ClipboardTypeText,
+    ClipboardTypeMarkup,
+    ClipboardTypeURIList,
+    ClipboardTypeURL,
+    ClipboardTypeImage,
+    ClipboardTypeUnknown
+};
+
 PassRefPtr<Clipboard> Editor::newGeneralClipboard(ClipboardAccessPolicy policy)
 {
-    return ClipboardGtk::create(policy, false);
-}
-
-ClipboardGtk::ClipboardGtk(ClipboardAccessPolicy policy, bool forDragging)
+    return ClipboardGtk::create(policy, gtk_clipboard_get_for_display(gdk_display_get_default(), GDK_SELECTION_CLIPBOARD), false);
+}
+
+ClipboardGtk::ClipboardGtk(ClipboardAccessPolicy policy, GtkClipboard* clipboard)
+    : Clipboard(policy, false)
+    , m_dataObject(DataObjectGtk::forClipboard(clipboard))
+    , m_clipboard(clipboard)
+    , m_helper(Pasteboard::generalPasteboard()->helper())
+{
+}
+
+ClipboardGtk::ClipboardGtk(ClipboardAccessPolicy policy, PassRefPtr<DataObjectGtk> dataObject, bool forDragging)
     : Clipboard(policy, forDragging)
+    , m_dataObject(dataObject)
+    , m_clipboard(0)
+    , m_helper(Pasteboard::generalPasteboard()->helper())
 {
 }
@@ -47 +69 @@
 }
 
-void ClipboardGtk::clearData(const String&)
-{
-    notImplemented();
-}
+static ClipboardType dataObjectTypeFromHTMLClipboardType(const String& rawType)
+{
+    String type(rawType.stripWhiteSpace());
+
+    // Two special cases for IE compatibility
+    if (type == "Text")
+        return ClipboardTypeText;
+    if (type == "URL")
+        return ClipboardTypeURL;
+
+    // From the Mac port: Ignore any trailing charset - JS strings are
+    // Unicode, which encapsulates the charset issue.
+    if (type == "text/plain" || type.startsWith("text/plain;"))
+        return ClipboardTypeText;
+    if (type == "text/html" || type.startsWith("text/html;"))
+        return ClipboardTypeMarkup;
+    if (type == "Files" || type == "text/uri-list" || type.startsWith("text/uri-list;"))
+        return ClipboardTypeURIList;
+
+    // Not a known type, so just default to using the text portion.
+    return ClipboardTypeUnknown;
+}
+
+void ClipboardGtk::clearData(const String& typeString)
+{
+    if (policy() != ClipboardWritable)
+        return;
+
+    ClipboardType type = dataObjectTypeFromHTMLClipboardType(typeString);
+    switch (type) {
+    case ClipboardTypeURIList:
+    case ClipboardTypeURL:
+        m_dataObject->clearURIList();
+        break;
+    case ClipboardTypeMarkup:
+        m_dataObject->clearMarkup();
+        break;
+    case ClipboardTypeText:
+        m_dataObject->clearText();
+        break;
+    case ClipboardTypeUnknown:
+    default:
+        m_dataObject->clear();
+    }
+
+    if (m_clipboard)
+        m_helper->writeClipboardContents(m_clipboard);
+}
+
 
 void ClipboardGtk::clearAllData()
 {
-    notImplemented();
-}
-
-String ClipboardGtk::getData(const String&, bool &success) const
-{
-    notImplemented();
-    success = false;
+    if (policy() != ClipboardWritable)
+        return;
+
+    m_dataObject->clear();
+
+    if (m_clipboard)
+        m_helper->writeClipboardContents(m_clipboard);
+}
+
+static String joinURIList(Vector<KURL> uriList)
+{
+    if (uriList.isEmpty())
+        return String();
+
+    String joined(uriList[0].string());
+    for (size_t i = 1; i < uriList.size(); i++) {
+        joined.append("\r\n");
+        joined.append(uriList[i].string());
+    }
+
+    return joined;
+}
+
+String ClipboardGtk::getData(const String& typeString, bool& success) const
+{
+    success = false; // Pessimism.
+    if (policy() != ClipboardReadable || !m_dataObject)
+        return String();
+
+    if (m_clipboard)
+        m_helper->getClipboardContents(m_clipboard);
+
+    ClipboardType type = dataObjectTypeFromHTMLClipboardType(typeString);
+    if (type == ClipboardTypeURIList) {
+        if (!m_dataObject->hasURIList())
+            return String();
+        success = true;
+        return joinURIList(m_dataObject->uriList());
+    }
+
+    if (type == ClipboardTypeURL) {
+        if (!m_dataObject->hasURL())
+            return String();
+        success = true;
+        return m_dataObject->url();
+    }
+
+    if (type == ClipboardTypeMarkup) {
+        if (!m_dataObject->hasMarkup())
+            return String();
+        success = true;
+        return m_dataObject->markup();
+    }
+
+    if (type == ClipboardTypeText) {
+        if (!m_dataObject->hasText())
+                return String();
+        success = true;
+        return m_dataObject->text();
+    }
+
     return String();
 }
 
-bool ClipboardGtk::setData(const String&, const String&)
-{
-    notImplemented();
-    return false;
+bool ClipboardGtk::setData(const String& typeString, const String& data)
+{
+    if (policy() != ClipboardWritable)
+        return false;
+
+    bool success = false;
+    ClipboardType type = dataObjectTypeFromHTMLClipboardType(typeString);
+    if (type == ClipboardTypeURIList || type == ClipboardTypeURL) {
+        Vector<KURL> uriList;
+        gchar** uris = g_uri_list_extract_uris(data.utf8().data());
+        if (uris) {
+            gchar** currentURI = uris;
+            while (*currentURI) {
+                uriList.append(KURL(KURL(), *currentURI));
+                currentURI++;
+            }
+            g_strfreev(uris);
+            m_dataObject->setURIList(uriList);
+            success = true;
+        }
+    } else if (type == ClipboardTypeMarkup) {
+        m_dataObject->setMarkup(data);
+        success = true;
+    } else if (type == ClipboardTypeText) {
+        m_dataObject->setText(data);
+        success = true;
+    }
+
+    if (success && m_clipboard)
+        m_helper->writeClipboardContents(m_clipboard);
+
+    return success;
 }
 
 HashSet<String> ClipboardGtk::types() const
 {
-    notImplemented();
-    return HashSet<String>();
+    if (policy() != ClipboardReadable && policy() != ClipboardTypesReadable)
+        return HashSet<String>();
+
+    if (m_clipboard)
+        m_helper->getClipboardContents(m_clipboard);
+
+    HashSet<String> types;
+    if (m_dataObject->hasText()) {
+        types.add("text/plain");
+        types.add("Text");
+    }
+
+    if (m_dataObject->hasMarkup())
+        types.add("text/html");
+
+    if (m_dataObject->hasURIList()) {
+        types.add("text/uri-list");
+        types.add("URL");
+        types.add("Files");
+    }
+
+    return types;
 }
 
 PassRefPtr<FileList> ClipboardGtk::files() const
 {
-    notImplemented();
-    return 0;
+    if (policy() != ClipboardReadable)
+        return FileList::create();
+
+    if (m_clipboard)
+        m_helper->getClipboardContents(m_clipboard);
+
+    RefPtr<FileList> fileList = FileList::create();
+    Vector<String> fileVector(m_dataObject->files());
+
+    for (size_t i = 0; i < fileVector.size(); i++)
+        fileList->append(File::create(fileVector[i]));
+
+    return fileList.release();
 }
 
@@ -152 +332 @@
 void ClipboardGtk::writeURL(const KURL& url, const String& label, Frame*)
 {
-    GtkClipboard* textClipboard = gtk_clipboard_get(gdk_atom_intern_static_string("WebKitClipboardText"));
-    GtkClipboard* urlClipboard = gtk_clipboard_get(gdk_atom_intern_static_string("WebKitClipboardUrl"));
-    GtkClipboard* urlLabelClipboard = gtk_clipboard_get(gdk_atom_intern_static_string("WebKitClipboardUrlLabel"));
-
-    gtk_clipboard_clear(textClipboard);
-    gtk_clipboard_clear(urlClipboard);
-    gtk_clipboard_clear(urlLabelClipboard);
-
-    gtk_clipboard_set_text(textClipboard, url.string().utf8().data(), -1);
-    gtk_clipboard_set_text(urlClipboard, url.string().utf8().data(), -1);
-    gtk_clipboard_set_text(urlLabelClipboard, label.utf8().data(), -1);
+    String actualLabel(label);
+    if (actualLabel.isEmpty())
+        actualLabel = url;
+
+    m_dataObject->setText(url.string());
+
+    Vector<UChar> markup;
+    append(markup, "<a href=\"");
+    append(markup, url.string());
+    append(markup, "\">");
+    append(markup, label);
+    append(markup, "</a>");
+    m_dataObject->setMarkup(String::adopt(markup));
+
+    Vector<KURL> uriList;
+    uriList.append(url);
+    m_dataObject->setURIList(uriList);
+
+    if (m_clipboard)
+        m_helper->writeClipboardContents(m_clipboard);
 }
 
 void ClipboardGtk::writeRange(Range* range, Frame* frame)
 {
-    GtkClipboard* textClipboard = gtk_clipboard_get(gdk_atom_intern_static_string("WebKitClipboardText"));
-    GtkClipboard* htmlClipboard = gtk_clipboard_get(gdk_atom_intern_static_string("WebKitClipboardHtml"));
-
-    gtk_clipboard_clear(textClipboard);
-    gtk_clipboard_clear(htmlClipboard);
-
-    gtk_clipboard_set_text(textClipboard, frame->selectedText().utf8().data(), -1);
-    gtk_clipboard_set_text(htmlClipboard, createMarkup(range, 0, AnnotateForInterchange).utf8().data(), -1);
+    ASSERT(range);
+
+    m_dataObject->setText(frame->selectedText());
+    m_dataObject->setMarkup(createMarkup(range, 0, AnnotateForInterchange));
+
+    if (m_clipboard)
+        m_helper->writeClipboardContents(m_clipboard);
 }
 
 void ClipboardGtk::writePlainText(const String& text)
 {
-    GtkClipboard* textClipboard = gtk_clipboard_get(gdk_atom_intern_static_string("WebKitClipboardText"));
-    
-    gtk_clipboard_clear(textClipboard);
-    
-    gtk_clipboard_set_text(textClipboard, text.utf8().data(), -1);
-}
-    
+    m_dataObject->setText(text);
+
+    if (m_clipboard)
+        m_helper->writeClipboardContents(m_clipboard);
+}
+
 bool ClipboardGtk::hasData()
 {
-    notImplemented();
-    return false;
-}
-
-}
+    if (m_clipboard)
+        m_helper->getClipboardContents(m_clipboard);
+
+    return m_dataObject->hasText() || m_dataObject->hasMarkup()
+        || m_dataObject->hasURIList() || m_dataObject->hasImage();
+}
+
+}

trunk/WebCore/platform/gtk/ClipboardGtk.h

@@ -29 +29 @@
 
 #include "Clipboard.h"
+#include "DataObjectGtk.h"
+
+typedef struct _GtkClipboard GtkClipboard;
 
 namespace WebCore {
     class CachedImage;
+    class PasteboardHelper;
 
     // State available during IE's events for drag and drop and copy/paste
@@ -37 +41 @@
     class ClipboardGtk : public Clipboard {
     public:
+        static PassRefPtr<ClipboardGtk> create(ClipboardAccessPolicy policy, GtkClipboard* clipboard, bool isForDragging)
+        {
+            return adoptRef(new ClipboardGtk(policy, clipboard));
+        }
+
         static PassRefPtr<ClipboardGtk> create(ClipboardAccessPolicy policy, bool isForDragging)
         {
-            return adoptRef(new ClipboardGtk(policy, isForDragging));
+            return adoptRef(new ClipboardGtk(policy, DataObjectGtk::create(), isForDragging));
         }
         virtual ~ClipboardGtk();
@@ -66 +75 @@
 
     private:
-        ClipboardGtk(ClipboardAccessPolicy, bool);
+        ClipboardGtk(ClipboardAccessPolicy, GtkClipboard*);
+        ClipboardGtk(ClipboardAccessPolicy, PassRefPtr<DataObjectGtk>, bool);
+
+        RefPtr<DataObjectGtk> m_dataObject;
+        GtkClipboard* m_clipboard;
+        PasteboardHelper* m_helper;
     };
 }

trunk/WebCore/platform/gtk/DataObjectGtk.cpp

@@ -25 +25 @@
 namespace WebCore {
 
+static void replaceNonBreakingSpaceWithSpace(String& str)
+{
+    static const UChar NonBreakingSpaceCharacter = 0xA0;
+    static const UChar SpaceCharacter = ' ';
+    str.replace(NonBreakingSpaceCharacter, SpaceCharacter);
+}
+
 String DataObjectGtk::text()
 {
@@ -35 +42 @@
 {
     if (m_range)
-        createMarkup(m_range.get(), 0, AnnotateForInterchange);
+        return createMarkup(m_range.get(), 0, AnnotateForInterchange);
     return m_markup;
 }
@@ -43 +50 @@
     m_range = 0;
     m_text = newText;
+    replaceNonBreakingSpaceWithSpace(m_text);
 }
 
@@ -49 +57 @@
     m_range = 0;
     m_markup = newMarkup;
+}
+
+void DataObjectGtk::clearText()
+{
+    m_range = 0;
+    m_text = "";
+}
+
+void DataObjectGtk::clearMarkup()
+{
+    m_range = 0;
+    m_markup = "";
 }
 

trunk/WebCore/platform/gtk/DataObjectGtk.h

@@ -51 +51 @@
     bool hasURIList() { return !m_uriList.isEmpty(); }
     bool hasImage() { return m_image; }
+    void clearURIList() { m_uriList.clear(); }
+    void clearImage() { m_image = 0; }
     GdkDragContext* dragContext() { return m_dragContext.get(); }
 
@@ -62 +64 @@
     String urlLabel();
     void clear();
+    void clearText();
+    void clearMarkup();
 
     static DataObjectGtk* forClipboard(GtkClipboard*);

trunk/WebCore/platform/gtk/PasteboardHelper.cpp

@@ -27 +27 @@
 #include "Page.h"
 #include "Pasteboard.h"
+#include "TextResourceDecoder.h"
 #include <gtk/gtk.h>
 #include <wtf/gobject/GOwnPtr.h>
@@ -33 +34 @@
 
 static GdkAtom gdkMarkupAtom = gdk_atom_intern("text/html", FALSE);
+static GdkAtom netscapeURLAtom = gdk_atom_intern("_NETSCAPE_URL", FALSE);
+static GdkAtom uriListAtom = gdk_atom_intern("text/uri-list", FALSE);
 
 PasteboardHelper::PasteboardHelper()
@@ -49 +52 @@
     gtk_target_list_add_text_targets(m_targetList, getIdForTargetType(TargetTypeText));
     gtk_target_list_add(m_targetList, gdkMarkupAtom, 0, getIdForTargetType(TargetTypeMarkup));
+    gtk_target_list_add_uri_targets(m_targetList, getIdForTargetType(TargetTypeURIList));
+    gtk_target_list_add(m_targetList, netscapeURLAtom, 0, getIdForTargetType(TargetTypeNetscapeURL));
 }
 
@@ -85 +90 @@
 }
 
+static Vector<KURL> urisToKURLVector(gchar** uris)
+{
+    ASSERT(uris);
+
+    Vector<KURL> uriList;
+    for (int i = 0; *(uris + i); i++)
+        uriList.append(KURL(KURL(), *(uris + i)));
+
+    return uriList;
+}
+
+void PasteboardHelper::getClipboardContents(GtkClipboard* clipboard)
+{
+    DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
+    ASSERT(dataObject);
+
+    if (gtk_clipboard_wait_is_text_available(clipboard)) {
+        GOwnPtr<gchar> textData(gtk_clipboard_wait_for_text(clipboard));
+        if (textData)
+            dataObject->setText(String::fromUTF8(textData.get()));
+    }
+
+    if (gtk_clipboard_wait_is_target_available(clipboard, gdkMarkupAtom)) {
+       if (GtkSelectionData* data = gtk_clipboard_wait_for_contents(clipboard, gdkMarkupAtom)) {
+          RefPtr<TextResourceDecoder> decoder(TextResourceDecoder::create("text/plain", "UTF-8", true));
+          String markup(decoder->decode(reinterpret_cast<char*>(data->data), data->length));
+          markup += decoder->flush();
+          dataObject->setMarkup(markup);
+          gtk_selection_data_free(data);
+       }
+    }
+
+    if (gtk_clipboard_wait_is_target_available(clipboard, uriListAtom)) {
+        if (GtkSelectionData* data = gtk_clipboard_wait_for_contents(clipboard, uriListAtom)) {
+            gchar** uris = gtk_selection_data_get_uris(data);
+            if (uris) {
+                dataObject->setURIList(urisToKURLVector(uris));
+                g_strfreev(uris);
+            }
+            gtk_selection_data_free(data);
+        }
+    }
+}
+
 void PasteboardHelper::fillSelectionData(GtkSelectionData* selectionData, guint info, DataObjectGtk* dataObject)
 {
     if (info == getIdForTargetType(TargetTypeText))
         gtk_selection_data_set_text(selectionData, dataObject->text().utf8().data(), -1);
+
     else if (info == getIdForTargetType(TargetTypeMarkup)) {
         GOwnPtr<gchar> markup(g_strdup(dataObject->markup().utf8().data()));
         gtk_selection_data_set(selectionData, selectionData->target, 8,
-                               reinterpret_cast<const guchar*>(markup.get()),
-                               strlen(markup.get()));
+            reinterpret_cast<const guchar*>(markup.get()), strlen(markup.get()));
+
+    } else if (info == getIdForTargetType(TargetTypeURIList)) {
+        Vector<KURL> uriList(dataObject->uriList());
+        gchar** uris = g_new0(gchar*, uriList.size() + 1);
+        for (size_t i = 0; i < uriList.size(); i++)
+            uris[i] = g_strdup(uriList[i].string().utf8().data());
+
+        gtk_selection_data_set_uris(selectionData, uris);
+        g_strfreev(uris);
+
+    } else if (info == getIdForTargetType(TargetTypeNetscapeURL) && dataObject->hasURL()) {
+        String url(dataObject->url());
+        String result(url);
+        result.append("\n");
+
+        if (dataObject->hasText())
+            result.append(dataObject->text());
+        else
+            result.append(url);
+
+        GOwnPtr<gchar> resultData(g_strdup(result.utf8().data()));
+        gtk_selection_data_set(selectionData, selectionData->target, 8,
+            reinterpret_cast<const guchar*>(resultData.get()), strlen(resultData.get()));
     }
 }
@@ -106 +178 @@
     if (dataObject->hasMarkup())
         gtk_target_list_add(list, gdkMarkupAtom, 0, getIdForTargetType(TargetTypeMarkup));
+
+    if (dataObject->hasURIList()) {
+        gtk_target_list_add_uri_targets(list, getIdForTargetType(TargetTypeURIList));
+        gtk_target_list_add(list, netscapeURLAtom, 0, getIdForTargetType(TargetTypeNetscapeURL));
+    }
 
     return list;

trunk/WebCore/platform/gtk/PasteboardHelper.h

@@ -51 +51 @@
     GtkTargetList* targetList() const;
     void fillSelectionData(GtkSelectionData*, guint, DataObjectGtk*);
-    void writeClipboardContents(GtkClipboard*, GClosure*);
+    void writeClipboardContents(GtkClipboard*, GClosure* closure = 0);
+    void getClipboardContents(GtkClipboard*);
 
     enum PasteboardTargetType { TargetTypeText, TargetTypeMarkup, TargetTypeURIList, TargetTypeNetscapeURL, TargetTypeImage, TargetTypeUnknown };