app/os_exchange_data_provider_gtk.cc

   1 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "app/os_exchange_data_provider_gtk.h"
   6
   7 #include <algorithm>
   8
   9 #include "app/gtk_dnd_util.h"
  10 #include "base/file_path.h"
  11 #include "base/utf_string_conversions.h"
  12 #include "net/base/net_util.h"
  13
  14 OSExchangeDataProviderGtk::OSExchangeDataProviderGtk(
  15     int known_formats,
  16     const std::set<GdkAtom>& known_custom_formats)
  17     : known_formats_(known_formats),
  18       known_custom_formats_(known_custom_formats),
  19       formats_(0),
  20       drag_image_(NULL) {
  21 }
  22
  23 OSExchangeDataProviderGtk::OSExchangeDataProviderGtk()
  24     : known_formats_(0),
  25       formats_(0),
  26       drag_image_(NULL) {
  27 }
  28
  29 OSExchangeDataProviderGtk::~OSExchangeDataProviderGtk() {
  30   if (drag_image_)
  31     g_object_unref(drag_image_);
  32 }
  33
  34 bool OSExchangeDataProviderGtk::HasDataForAllFormats(
  35     int formats,
  36     const std::set<GdkAtom>& custom_formats) const {
  37   if ((formats_ & formats) != formats)
  38     return false;
  39   for (std::set<GdkAtom>::iterator i = custom_formats.begin();
  40        i != custom_formats.end(); ++i) {
  41     if (pickle_data_.find(*i) == pickle_data_.end())
  42       return false;
  43   }
  44   return true;
  45 }
  46
  47 GtkTargetList* OSExchangeDataProviderGtk::GetTargetList() const {
  48   GtkTargetList* targets = gtk_target_list_new(NULL, 0);
  49
  50   if ((formats_ & OSExchangeData::STRING) != 0)
  51     gtk_target_list_add_text_targets(targets, OSExchangeData::STRING);
  52
  53   if ((formats_ & OSExchangeData::URL) != 0) {
  54     gtk_target_list_add_uri_targets(targets, OSExchangeData::URL);
  55     gtk_target_list_add(
  56         targets,
  57         gtk_dnd_util::GetAtomForTarget(gtk_dnd_util::CHROME_NAMED_URL),
  58         0,
  59         OSExchangeData::URL);
  60   }
  61
  62   if ((formats_ & OSExchangeData::FILE_NAME) != 0)
  63     gtk_target_list_add_uri_targets(targets, OSExchangeData::FILE_NAME);
  64
  65   for (PickleData::const_iterator i = pickle_data_.begin();
  66        i != pickle_data_.end(); ++i) {
  67     gtk_target_list_add(targets, i->first, 0, OSExchangeData::PICKLED_DATA);
  68   }
  69
  70   return targets;
  71 }
  72
  73 void OSExchangeDataProviderGtk::WriteFormatToSelection(
  74     int format,
  75     GtkSelectionData* selection) const {
  76   if ((format & OSExchangeData::STRING) != 0) {
  77     gtk_selection_data_set_text(
  78         selection,
  79         reinterpret_cast<const gchar*>(string_.c_str()),
  80         -1);
  81   }
  82
  83   if ((format & OSExchangeData::URL) != 0) {
  84     // TODO: this should be pulled out of TabContentsDragSource into a common
  85     // place.
  86     Pickle pickle;
  87     pickle.WriteString(UTF16ToUTF8(title_));
  88     pickle.WriteString(url_.spec());
  89     gtk_selection_data_set(
  90         selection,
  91         gtk_dnd_util::GetAtomForTarget(gtk_dnd_util::CHROME_NAMED_URL),
  92         8,
  93         reinterpret_cast<const guchar*>(pickle.data()),
  94         pickle.size());
  95
  96     gchar* uri_array[2];
  97     uri_array[0] = strdup(url_.spec().c_str());
  98     uri_array[1] = NULL;
  99     gtk_selection_data_set_uris(selection, uri_array);
 100     free(uri_array[0]);
 101   }
 102
 103   if ((format & OSExchangeData::FILE_NAME) != 0) {
 104     gchar* uri_array[2];
 105     uri_array[0] =
 106         strdup(net::FilePathToFileURL(FilePath(filename_)).spec().c_str());
 107     uri_array[1] = NULL;
 108     gtk_selection_data_set_uris(selection, uri_array);
 109     free(uri_array[0]);
 110   }
 111
 112   if ((format & OSExchangeData::PICKLED_DATA) != 0) {
 113     for (PickleData::const_iterator i = pickle_data_.begin();
 114          i != pickle_data_.end(); ++i) {
 115       const Pickle& data = i->second;
 116       gtk_selection_data_set(
 117           selection,
 118           i->first,
 119           8,
 120           reinterpret_cast<const guchar*>(data.data()),
 121           data.size());
 122     }
 123   }
 124 }
 125
 126 void OSExchangeDataProviderGtk::SetString(const std::wstring& data) {
 127   string_ = WideToUTF16Hack(data);
 128   formats_ |= OSExchangeData::STRING;
 129 }
 130
 131 void OSExchangeDataProviderGtk::SetURL(const GURL& url,
 132                                        const std::wstring& title) {
 133   url_ = url;
 134   title_ = WideToUTF16Hack(title);
 135   formats_ |= OSExchangeData::URL;
 136 }
 137
 138 void OSExchangeDataProviderGtk::SetFilename(const std::wstring& full_path) {
 139   filename_ = WideToUTF8(full_path);
 140   formats_ |= OSExchangeData::FILE_NAME;
 141 }
 142
 143 void OSExchangeDataProviderGtk::SetPickledData(GdkAtom format,
 144                                                const Pickle& data) {
 145   pickle_data_[format] = data;
 146   formats_ |= OSExchangeData::PICKLED_DATA;
 147 }
 148
 149 bool OSExchangeDataProviderGtk::GetString(std::wstring* data) const {
 150   if ((formats_ & OSExchangeData::STRING) == 0)
 151     return false;
 152   *data = UTF16ToWideHack(string_);
 153   return true;
 154 }
 155
 156 bool OSExchangeDataProviderGtk::GetURLAndTitle(GURL* url,
 157                                                std::wstring* title) const {
 158   if ((formats_ & OSExchangeData::URL) == 0) {
 159     title->clear();
 160     return GetPlainTextURL(url);
 161   }
 162
 163   if (!url_.is_valid())
 164     return false;
 165
 166   *url = url_;
 167   *title = UTF16ToWideHack(title_);
 168   return true;
 169 }
 170
 171 bool OSExchangeDataProviderGtk::GetFilename(std::wstring* full_path) const {
 172   if ((formats_ & OSExchangeData::FILE_NAME) == 0)
 173     return false;
 174   *full_path = UTF8ToWide(filename_);
 175   return true;
 176 }
 177
 178 bool OSExchangeDataProviderGtk::GetPickledData(GdkAtom format,
 179                                                Pickle* data) const {
 180   PickleData::const_iterator i = pickle_data_.find(format);
 181   if (i == pickle_data_.end())
 182     return false;
 183
 184   *data = i->second;
 185   return true;
 186 }
 187
 188 bool OSExchangeDataProviderGtk::HasString() const {
 189   return (known_formats_ & OSExchangeData::STRING) != 0 ||
 190          (formats_ & OSExchangeData::STRING) != 0;
 191 }
 192
 193 bool OSExchangeDataProviderGtk::HasURL() const {
 194   if ((known_formats_ & OSExchangeData::URL) != 0 ||
 195       (formats_ & OSExchangeData::URL) != 0) {
 196     return true;
 197   }
 198   // No URL, see if we have plain text that can be parsed as a URL.
 199   return GetPlainTextURL(NULL);
 200 }
 201
 202 bool OSExchangeDataProviderGtk::HasFile() const {
 203   return (known_formats_ & OSExchangeData::FILE_NAME) != 0 ||
 204          (formats_ & OSExchangeData::FILE_NAME) != 0;
 205   }
 206
 207 bool OSExchangeDataProviderGtk::HasCustomFormat(GdkAtom format) const {
 208   return known_custom_formats_.find(format) != known_custom_formats_.end() ||
 209          pickle_data_.find(format) != pickle_data_.end();
 210 }
 211
 212 bool OSExchangeDataProviderGtk::GetPlainTextURL(GURL* url) const {
 213   if ((formats_ & OSExchangeData::STRING) == 0)
 214     return false;
 215
 216   GURL test_url(string_);
 217   if (!test_url.is_valid())
 218     return false;
 219
 220   if (url)
 221     *url = test_url;
 222   return true;
 223 }
 224
 225 void OSExchangeDataProviderGtk::SetDragImage(GdkPixbuf* drag_image,
 226                                              const gfx::Point& cursor_offset) {
 227   if (drag_image_)
 228     g_object_unref(drag_image_);
 229   g_object_ref(drag_image);
 230   drag_image_ = drag_image;
 231   cursor_offset_ = cursor_offset;
 232 }
 233
 234 ///////////////////////////////////////////////////////////////////////////////
 235 // OSExchangeData, public:
 236
 237 // static
 238 OSExchangeData::Provider* OSExchangeData::CreateProvider() {
 239   return new OSExchangeDataProviderGtk();
 240 }
 241
 242 GdkAtom OSExchangeData::RegisterCustomFormat(const std::string& type) {
 243   return gdk_atom_intern(type.c_str(), false);
 244 }