gtk/gdk/win32/gdkclipboard-win32.c

/* GDK - The GIMP Drawing Kit
 * Copyright (C) 2017 Red Hat, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
 */

#include "config.h"

#include "gdkclipboardprivate.h"
#include "gdkclipboard-win32.h"

#include "gdkintl.h"
#include "gdkprivate-win32.h"
#include "gdkhdataoutputstream-win32.h"
#include "gdk/gdk-private.h"

#include <string.h>

typedef struct _GdkWin32ClipboardClass GdkWin32ClipboardClass;

typedef struct _RetrievalInfo RetrievalInfo;

struct _GdkWin32Clipboard
{
  GdkClipboard parent;

  /* Taken from the OS, the OS increments it every time
   * clipboard data changes.
   * -1 means that clipboard data that we claim to
   * have access to is actually just an empty set that
   * we made up. Thus any real data from the OS will
   * override anything we make up.
   */
  gint64      sequence_number;
};

struct _GdkWin32ClipboardClass
{
  GdkClipboardClass parent_class;
};

G_DEFINE_TYPE (GdkWin32Clipboard, gdk_win32_clipboard, GDK_TYPE_CLIPBOARD)

static GdkContentFormats *
gdk_win32_clipboard_request_contentformats (GdkWin32Clipboard *cb)
{
  BOOL success;
  UINT *w32_formats = NULL;
  UINT w32_formats_len = 0;
  UINT w32_formats_allocated;
  gsize i;
  GArray *formatpairs;
  GdkWin32Clipdrop *clipdrop = _gdk_win32_clipdrop_get ();
  DWORD error_code;

  SetLastError (0);
  success = clipdrop->GetUpdatedClipboardFormats (NULL, 0, &w32_formats_allocated);
  error_code = GetLastError ();

  if (!success && error_code != ERROR_INSUFFICIENT_BUFFER)
    {
      g_warning ("Initial call to GetUpdatedClipboardFormats() failed with error %lu", error_code);
      return NULL;
    }

  w32_formats = g_new0 (UINT, w32_formats_allocated);

  SetLastError (0);
  success = clipdrop->GetUpdatedClipboardFormats (w32_formats, w32_formats_allocated, &w32_formats_len);
  error_code = GetLastError ();

  if (!success)
    {
      g_warning ("Second call to GetUpdatedClipboardFormats() failed with error %lu", error_code);
      g_free (w32_formats);
      return NULL;
    }

  formatpairs = g_array_sized_new (FALSE,
                                   FALSE,
                                   sizeof (GdkWin32ContentFormatPair),
                                   MIN (w32_formats_len, w32_formats_allocated));

  for (i = 0; i < MIN (w32_formats_len, w32_formats_allocated); i++)
    _gdk_win32_add_w32format_to_pairs (w32_formats[i], formatpairs, NULL);

  g_free (w32_formats);

  GDK_NOTE (DND, {
      g_print ("... ");
      for (i = 0; i < formatpairs->len; i++)
        {
          const char *mime_type = (const char *) g_array_index (formatpairs, GdkWin32ContentFormatPair, i).contentformat;

          g_print ("%s", mime_type);
          if (i < formatpairs->len - 1)
            g_print (", ");
        }
      g_print ("\n");
    });

  if (formatpairs->len > 0)
    {
      GdkContentFormatsBuilder *builder = gdk_content_formats_builder_new ();

      for (i = 0; i < formatpairs->len; i++)
        gdk_content_formats_builder_add_mime_type (builder, g_array_index (formatpairs, GdkWin32ContentFormatPair, i).contentformat);

      g_array_free (formatpairs, TRUE);

      return gdk_content_formats_builder_free_to_formats (builder);
    }
  else
    {
      g_array_free (formatpairs, TRUE);

      return NULL;
    }
}

void
gdk_win32_clipboard_claim_remote (GdkWin32Clipboard *cb)
{
  GdkContentFormats *formats;

  /* Claim empty first, in case the format request fails */
  formats = gdk_content_formats_new (NULL, 0);
  gdk_clipboard_claim_remote (GDK_CLIPBOARD (cb), formats);
  gdk_content_formats_unref (formats);
  cb->sequence_number = -1;

  formats = gdk_win32_clipboard_request_contentformats (cb);
  gdk_clipboard_claim_remote (GDK_CLIPBOARD (cb), formats);
  gdk_content_formats_unref (formats);
  cb->sequence_number = GetClipboardSequenceNumber ();
}

static void
gdk_win32_clipboard_finalize (GObject *object)
{
  G_OBJECT_CLASS (gdk_win32_clipboard_parent_class)->finalize (object);
}

static gboolean
gdk_win32_clipboard_claim (GdkClipboard       *clipboard,
                           GdkContentFormats  *formats,
                           gboolean            local,
                           GdkContentProvider *content)
{
  if (local)
    _gdk_win32_advertise_clipboard_contentformats (NULL, content ? formats : NULL);

  return GDK_CLIPBOARD_CLASS (gdk_win32_clipboard_parent_class)->claim (clipboard, formats, local, content);
}

static void
gdk_win32_clipboard_store_async (GdkClipboard        *clipboard,
                                 int                  io_priority,
                                 GCancellable        *cancellable,
                                 GAsyncReadyCallback  callback,
                                 gpointer             user_data)
{
  GdkContentProvider *content;
  GdkContentFormats *formats;
  GTask *store_task;

  store_task = g_task_new (clipboard, cancellable, callback, user_data);
  g_task_set_priority (store_task, io_priority);
  g_task_set_source_tag (store_task, gdk_win32_clipboard_store_async);

  content = gdk_clipboard_get_content (clipboard);

  if (content == NULL)
    {
      GDK_NOTE (CLIPBOARD, g_printerr ("storing empty clipboard: SUCCESS!\n"));
      g_task_return_boolean (store_task, TRUE);
      g_clear_object (&store_task);
      return;
    }

  formats = gdk_content_provider_ref_storable_formats (content);
  formats = gdk_content_formats_union_serialize_mime_types (formats);

  if (!_gdk_win32_store_clipboard_contentformats (clipboard, store_task, formats))
    {
      GDK_NOTE (CLIPBOARD, g_printerr ("clipdrop says there's nothing to store: SUCCESS!\n"));
      g_task_return_boolean (store_task, TRUE);
      g_clear_object (&store_task);

      return;
    }
}

static gboolean
gdk_win32_clipboard_store_finish (GdkClipboard  *clipboard,
                                  GAsyncResult  *result,
                                  GError       **error)
{
  g_return_val_if_fail (g_task_is_valid (result, clipboard), FALSE);
  g_return_val_if_fail (g_task_get_source_tag (G_TASK (result)) == gdk_win32_clipboard_store_async, FALSE);

  return g_task_propagate_boolean (G_TASK (result), error);
}

static void
gdk_win32_clipboard_read_async (GdkClipboard        *clipboard,
                                GdkContentFormats   *contentformats,
                                int                  io_priority,
                                GCancellable        *cancellable,
                                GAsyncReadyCallback  callback,
                                gpointer             user_data)
{
  GTask *task;

  task = g_task_new (clipboard, cancellable, callback, user_data);
  g_task_set_priority (task, io_priority);
  g_task_set_source_tag (task, gdk_win32_clipboard_read_async);

  _gdk_win32_retrieve_clipboard_contentformats (task, contentformats);

  return;
}

static GInputStream *
gdk_win32_clipboard_read_finish (GdkClipboard  *clipboard,
                                 const char   **out_mime_type,
                                 GAsyncResult  *result,
                                 GError       **error)
{
  GTask *task;
  GInputStream *stream;

  g_return_val_if_fail (g_task_is_valid (result, G_OBJECT (clipboard)), NULL);
  task = G_TASK (result);
  g_return_val_if_fail (g_task_get_source_tag (task) == gdk_win32_clipboard_read_async, NULL);

  stream = g_task_propagate_pointer (task, error);

  if (stream == NULL)
    return stream;

  if (out_mime_type)
    *out_mime_type = g_object_get_data (G_OBJECT (stream), "gdk-clipboard-stream-contenttype");

  return stream;
}

static void
gdk_win32_clipboard_class_init (GdkWin32ClipboardClass *class)
{
  GObjectClass *object_class = G_OBJECT_CLASS (class);
  GdkClipboardClass *clipboard_class = GDK_CLIPBOARD_CLASS (class);

  object_class->finalize = gdk_win32_clipboard_finalize;

  clipboard_class->claim = gdk_win32_clipboard_claim;
  clipboard_class->store_async = gdk_win32_clipboard_store_async;
  clipboard_class->store_finish = gdk_win32_clipboard_store_finish;
  clipboard_class->read_async = gdk_win32_clipboard_read_async;
  clipboard_class->read_finish = gdk_win32_clipboard_read_finish;
}

static void
gdk_win32_clipboard_init (GdkWin32Clipboard *cb)
{
  cb->sequence_number = -1;
}

GdkClipboard *
gdk_win32_clipboard_new (GdkDisplay  *display)
{
  GdkWin32Clipboard *cb;

  cb = g_object_new (GDK_TYPE_WIN32_CLIPBOARD,
                     "display", display,
                     NULL);

  gdk_win32_clipboard_claim_remote (cb);

  return GDK_CLIPBOARD (cb);
}