Home | History | Annotate | Download | only in clipboard 
      1 // Copyright (c) 2012 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 // This file implements the ScopedClipboardWriter class. Documentation on its
      6 // purpose can be found in our header. Documentation on the format of the
      7 // parameters for each clipboard target can be found in clipboard.h.
      8 
      9 #include "ui/base/clipboard/scoped_clipboard_writer.h"
     10 
     11 #include "base/pickle.h"
     12 #include "base/strings/utf_string_conversions.h"
     13 #include "ui/gfx/size.h"
     14 
     15 namespace ui {
     16 
     17 ScopedClipboardWriter::ScopedClipboardWriter(Clipboard* clipboard,
     18                                              Clipboard::Buffer buffer)
     19     : clipboard_(clipboard),
     20       buffer_(buffer) {
     21 }
     22 
     23 ScopedClipboardWriter::~ScopedClipboardWriter() {
     24   if (!objects_.empty() && clipboard_)
     25     clipboard_->WriteObjects(buffer_, objects_);
     26 }
     27 
     28 void ScopedClipboardWriter::WriteText(const string16& text) {
     29   WriteTextOrURL(text, false);
     30 }
     31 
     32 void ScopedClipboardWriter::WriteURL(const string16& text) {
     33   WriteTextOrURL(text, true);
     34 }
     35 
     36 void ScopedClipboardWriter::WriteHTML(const string16& markup,
     37                                       const std::string& source_url) {
     38   std::string utf8_markup = UTF16ToUTF8(markup);
     39 
     40   Clipboard::ObjectMapParams parameters;
     41   parameters.push_back(
     42       Clipboard::ObjectMapParam(utf8_markup.begin(),
     43                                 utf8_markup.end()));
     44   if (!source_url.empty()) {
     45     parameters.push_back(Clipboard::ObjectMapParam(source_url.begin(),
     46                                                    source_url.end()));
     47   }
     48 
     49   objects_[Clipboard::CBF_HTML] = parameters;
     50 }
     51 
     52 void ScopedClipboardWriter::WriteRTF(const std::string& rtf_data) {
     53   Clipboard::ObjectMapParams parameters;
     54   parameters.push_back(Clipboard::ObjectMapParam(rtf_data.begin(),
     55                                                  rtf_data.end()));
     56   objects_[Clipboard::CBF_RTF] = parameters;
     57 }
     58 
     59 void ScopedClipboardWriter::WriteBookmark(const string16& bookmark_title,
     60                                           const std::string& url) {
     61   if (bookmark_title.empty() || url.empty())
     62     return;
     63 
     64   std::string utf8_markup = UTF16ToUTF8(bookmark_title);
     65 
     66   Clipboard::ObjectMapParams parameters;
     67   parameters.push_back(Clipboard::ObjectMapParam(utf8_markup.begin(),
     68                                                  utf8_markup.end()));
     69   parameters.push_back(Clipboard::ObjectMapParam(url.begin(), url.end()));
     70   objects_[Clipboard::CBF_BOOKMARK] = parameters;
     71 }
     72 
     73 void ScopedClipboardWriter::WriteHyperlink(const string16& anchor_text,
     74                                            const std::string& url) {
     75   if (anchor_text.empty() || url.empty())
     76     return;
     77 
     78   // Construct the hyperlink.
     79   std::string html("<a href=\"");
     80   html.append(url);
     81   html.append("\">");
     82   html.append(UTF16ToUTF8(anchor_text));
     83   html.append("</a>");
     84   WriteHTML(UTF8ToUTF16(html), std::string());
     85 }
     86 
     87 void ScopedClipboardWriter::WriteWebSmartPaste() {
     88   objects_[Clipboard::CBF_WEBKIT] = Clipboard::ObjectMapParams();
     89 }
     90 
     91 void ScopedClipboardWriter::WriteBitmapFromPixels(const void* pixels,
     92                                                   const gfx::Size& size) {
     93   Clipboard::ObjectMapParam pixels_parameter, size_parameter;
     94   const char* pixels_data = static_cast<const char*>(pixels);
     95   size_t pixels_length = 4 * size.width() * size.height();
     96   for (size_t i = 0; i < pixels_length; i++)
     97     pixels_parameter.push_back(pixels_data[i]);
     98 
     99   const char* size_data = reinterpret_cast<const char*>(&size);
    100   size_t size_length = sizeof(gfx::Size);
    101   for (size_t i = 0; i < size_length; i++)
    102     size_parameter.push_back(size_data[i]);
    103 
    104   Clipboard::ObjectMapParams parameters;
    105   parameters.push_back(pixels_parameter);
    106   parameters.push_back(size_parameter);
    107   objects_[Clipboard::CBF_BITMAP] = parameters;
    108 }
    109 
    110 void ScopedClipboardWriter::WritePickledData(
    111     const Pickle& pickle, const Clipboard::FormatType& format) {
    112   std::string format_string = format.Serialize();
    113   Clipboard::ObjectMapParam format_parameter(format_string.begin(),
    114                                              format_string.end());
    115   Clipboard::ObjectMapParam data_parameter;
    116 
    117   data_parameter.resize(pickle.size());
    118   memcpy(const_cast<char*>(&data_parameter.front()),
    119          pickle.data(), pickle.size());
    120 
    121   Clipboard::ObjectMapParams parameters;
    122   parameters.push_back(format_parameter);
    123   parameters.push_back(data_parameter);
    124   objects_[Clipboard::CBF_DATA] = parameters;
    125 }
    126 
    127 void ScopedClipboardWriter::Reset() {
    128   url_text_.clear();
    129   objects_.clear();
    130 }
    131 
    132 void ScopedClipboardWriter::WriteTextOrURL(const string16& text, bool is_url) {
    133   std::string utf8_text = UTF16ToUTF8(text);
    134 
    135   Clipboard::ObjectMapParams parameters;
    136   parameters.push_back(Clipboard::ObjectMapParam(utf8_text.begin(),
    137                                                  utf8_text.end()));
    138   objects_[Clipboard::CBF_TEXT] = parameters;
    139 
    140   if (is_url) {
    141     url_text_ = utf8_text;
    142   } else {
    143     url_text_.clear();
    144   }
    145 }
    146 
    147 }  // namespace ui
    148