widget/gtk/AsyncGtkClipboardRequest.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=4 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this
   5  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "AsyncGtkClipboardRequest.h"
   8
   9 namespace mozilla {
  10
  11 AsyncGtkClipboardRequest::AsyncGtkClipboardRequest(ClipboardDataType aDataType,
  12                                                    int32_t aWhichClipboard,
  13                                                    const char* aMimeType) {
  14   GtkClipboard* clipboard =
  15       gtk_clipboard_get(GetSelectionAtom(aWhichClipboard));
  16   mRequest = MakeUnique<Request>(aDataType);
  17
  18   switch (aDataType) {
  19     case ClipboardDataType::Data:
  20       MOZ_CLIPBOARD_LOG("  getting DATA MIME %s\n", aMimeType);
  21       gtk_clipboard_request_contents(clipboard,
  22                                      gdk_atom_intern(aMimeType, FALSE),
  23                                      OnDataReceived, mRequest.get());
  24       break;
  25     case ClipboardDataType::Text:
  26       MOZ_CLIPBOARD_LOG("  getting TEXT\n");
  27       gtk_clipboard_request_text(clipboard, OnTextReceived, mRequest.get());
  28       break;
  29     case ClipboardDataType::Targets:
  30       MOZ_CLIPBOARD_LOG("  getting TARGETS\n");
  31       gtk_clipboard_request_contents(clipboard,
  32                                      gdk_atom_intern("TARGETS", FALSE),
  33                                      OnDataReceived, mRequest.get());
  34       break;
  35   }
  36 }
  37
  38 void AsyncGtkClipboardRequest::OnDataReceived(GtkClipboard* clipboard,
  39                                               GtkSelectionData* selection_data,
  40                                               gpointer data) {
  41   auto whichClipboard = GetGeckoClipboardType(clipboard);
  42   MOZ_CLIPBOARD_LOG("OnDataReceived(%s) callback\n",
  43                     whichClipboard == Some(nsClipboard::kSelectionClipboard)
  44                         ? "primary"
  45                         : "clipboard");
  46   static_cast<Request*>(data)->Complete(selection_data);
  47 }
  48
  49 void AsyncGtkClipboardRequest::OnTextReceived(GtkClipboard* clipboard,
  50                                               const gchar* text,
  51                                               gpointer data) {
  52   auto whichClipboard = GetGeckoClipboardType(clipboard);
  53   MOZ_CLIPBOARD_LOG("OnTextReceived(%s) callback\n",
  54                     whichClipboard == Some(nsClipboard::kSelectionClipboard)
  55                         ? "primary"
  56                         : "clipboard");
  57   static_cast<Request*>(data)->Complete(text);
  58 }
  59
  60 void AsyncGtkClipboardRequest::Request::Complete(const void* aData) {
  61   MOZ_CLIPBOARD_LOG("Request::Complete(), aData = %p, timedOut = %d\n", aData,
  62                     mTimedOut);
  63
  64   if (mTimedOut) {
  65     delete this;
  66     return;
  67   }
  68
  69   mData.emplace();
  70
  71   gint dataLength = 0;
  72   if (mDataType == ClipboardDataType::Targets ||
  73       mDataType == ClipboardDataType::Data) {
  74     dataLength = gtk_selection_data_get_length((GtkSelectionData*)aData);
  75   } else {
  76     dataLength = aData ? strlen((const char*)aData) : 0;
  77   }
  78
  79   // Negative size means no data or data error.
  80   if (dataLength <= 0) {
  81     MOZ_CLIPBOARD_LOG("    zero dataLength, quit.\n");
  82     return;
  83   }
  84
  85   switch (mDataType) {
  86     case ClipboardDataType::Targets: {
  87       MOZ_CLIPBOARD_LOG("    getting %d bytes of clipboard targets.\n",
  88                         dataLength);
  89       gint n_targets = 0;
  90       GdkAtom* targets = nullptr;
  91       if (!gtk_selection_data_get_targets((GtkSelectionData*)aData, &targets,
  92                                           &n_targets) ||
  93           !n_targets) {
  94         // We failed to get targets
  95         return;
  96       }
  97       mData->SetTargets(
  98           ClipboardTargets{GUniquePtr<GdkAtom>(targets), uint32_t(n_targets)});
  99       break;
 100     }
 101     case ClipboardDataType::Text: {
 102       MOZ_CLIPBOARD_LOG("    getting %d bytes of text.\n", dataLength);
 103       mData->SetText(Span(static_cast<const char*>(aData), dataLength));
 104       MOZ_CLIPBOARD_LOG("    done, mClipboardData = %p\n",
 105                         mData->AsSpan().data());
 106       break;
 107     }
 108     case ClipboardDataType::Data: {
 109       MOZ_CLIPBOARD_LOG("    getting %d bytes of data.\n", dataLength);
 110       mData->SetData(Span(gtk_selection_data_get_data((GtkSelectionData*)aData),
 111                           dataLength));
 112       MOZ_CLIPBOARD_LOG("    done, mClipboardData = %p\n",
 113                         mData->AsSpan().data());
 114       break;
 115     }
 116   }
 117 }
 118
 119 AsyncGtkClipboardRequest::~AsyncGtkClipboardRequest() {
 120   if (mRequest && mRequest->mData.isNothing()) {
 121     mRequest->mTimedOut = true;
 122     Unused << mRequest.release();
 123   }
 124 }
 125
 126 }  // namespace mozilla