static void copy_tokencode(gpointer user_data)
{
GdkDisplay *disp = gdk_display_get_default();
GtkClipboard *clip;
char *str = user_data;
/* CLIPBOARD - Control-V in most applications */
clip = gtk_clipboard_get_for_display(disp, GDK_SELECTION_CLIPBOARD);
gtk_clipboard_set_text(clip, str, -1);
/* PRIMARY - middle-click in xterm */
clip = gtk_clipboard_get_for_display(disp, GDK_SELECTION_PRIMARY);
gtk_clipboard_set_text(clip, str, -1);
}
void Pasteboard::writePlainText(const String& text)
{
GtkClipboard* clipboard = gtk_clipboard_get_for_display(gdk_display_get_default(), GDK_SELECTION_CLIPBOARD);
DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
dataObject->setText(text);
PasteboardHelper::defaultPasteboardHelper()->writeClipboardContents(clipboard);
}
static void
take_xconsole_ownership(GtkWidget *widget, gpointer data)
{
char *name, hostname[255];
GdkAtom atom;
GtkClipboard *clipboard;
const GtkTargetEntry targets[] = {
{"UTF8_STRING", 0, 0},
{"COMPOUND_TEXT", 0, 0},
{"TEXT", 0, 0},
{"STRING", 0, 0},
};
memset(hostname, '\0', sizeof(hostname));
gethostname(hostname, sizeof(hostname) - 1);
name = g_strdup_printf("MIT_CONSOLE_%s", hostname);
atom = gdk_atom_intern(name, FALSE);
clipboard = gtk_clipboard_get_for_display(gtk_widget_get_display(widget),
atom);
g_free(name);
gtk_clipboard_set_with_owner(clipboard,
targets,
G_N_ELEMENTS(targets),
clipboard_get,
(GtkClipboardClearFunc)gtk_main_quit,
G_OBJECT(widget));
}
static void
take_xconsole_ownership(GtkWidget *widget, gpointer data)
{
char *name, hostname[255];
GdkAtom atom;
GtkClipboard *clipboard;
GtkTargetList *target_list;
GtkTargetEntry *targets;
int n_targets;
target_list = gtk_target_list_new(NULL, 0);
gtk_target_list_add_text_targets(target_list, 0);
targets = gtk_target_table_new_from_list (target_list, &n_targets);
gtk_target_list_unref(target_list);
memset(hostname, '\0', sizeof(hostname));
gethostname(hostname, sizeof(hostname) - 1);
name = g_strdup_printf("MIT_CONSOLE_%s", hostname);
atom = gdk_atom_intern(name, FALSE);
clipboard = gtk_clipboard_get_for_display(gtk_widget_get_display(widget),
atom);
g_free(name);
gtk_clipboard_set_with_owner(clipboard,
targets,
n_targets,
clipboard_get,
(GtkClipboardClearFunc)gtk_main_quit,
G_OBJECT(widget));
}
void Pasteboard::writeImage(Node* node, const KURL&, const String& title)
{
ASSERT(node);
if (!(node->renderer() && node->renderer()->isImage()))
return;
RenderImage* renderer = toRenderImage(node->renderer());
CachedImage* cachedImage = renderer->cachedImage();
if (!cachedImage || cachedImage->errorOccurred())
return;
Image* image = cachedImage->imageForRenderer(renderer);
ASSERT(image);
GtkClipboard* clipboard = gtk_clipboard_get_for_display(gdk_display_get_default(), GDK_SELECTION_CLIPBOARD);
DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
KURL url = getURLForImageNode(node);
if (!url.isEmpty()) {
dataObject->setURL(url, title);
dataObject->setMarkup(createMarkup(static_cast<Element*>(node), IncludeNode, 0, ResolveAllURLs));
}
GRefPtr<GdkPixbuf> pixbuf = adoptGRef(image->getGdkPixbuf());
dataObject->setImage(pixbuf.get());
PasteboardHelper::defaultPasteboardHelper()->writeClipboardContents(clipboard);
}
/**
* xfdesktop_clipboard_manager_get_for_display:
* @display : a #GdkDisplay.
*
* Determines the #XfdesktopClipboardManager that is used to manage
* the clipboard on the given @display.
*
* The caller is responsible for freeing the returned object
* using g_object_unref() when it's no longer needed.
*
* Return value: the #XfdesktopClipboardManager for @display.
**/
XfdesktopClipboardManager*
xfdesktop_clipboard_manager_get_for_display (GdkDisplay *display)
{
XfdesktopClipboardManager *manager;
GtkClipboard *clipboard;
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
/* generate the quark on-demand */
if (G_UNLIKELY (xfdesktop_clipboard_manager_quark == 0))
xfdesktop_clipboard_manager_quark = g_quark_from_static_string ("xfdesktop-clipboard-manager");
/* figure out the clipboard for the given display */
clipboard = gtk_clipboard_get_for_display (display, GDK_SELECTION_CLIPBOARD);
/* check if a clipboard manager exists */
manager = g_object_get_qdata (G_OBJECT (clipboard), xfdesktop_clipboard_manager_quark);
if (G_LIKELY (manager != NULL))
{
g_object_ref (G_OBJECT (manager));
return manager;
}
/* allocate a new manager */
manager = g_object_new (XFDESKTOP_TYPE_CLIPBOARD_MANAGER, NULL);
manager->clipboard = g_object_ref (G_OBJECT (clipboard));
g_object_set_qdata (G_OBJECT (clipboard), xfdesktop_clipboard_manager_quark, manager);
/* listen for the "owner-change" signal on the clipboard */
g_signal_connect (G_OBJECT (manager->clipboard), "owner-change",
G_CALLBACK (xfdesktop_clipboard_manager_owner_changed), manager);
return manager;
}
static gboolean clipboard_callback(GtkWidget *widget, GdkEvent *event,
gpointer data)
{
GdkDisplay *disp = gdk_display_get_default();
GtkClipboard *clip;
/* CLIPBOARD - Control-V in most applications */
clip = gtk_clipboard_get_for_display(disp, GDK_SELECTION_CLIPBOARD);
gtk_clipboard_set_text(clip, tokencode_str, -1);
/* PRIMARY - middle-click in xterm */
clip = gtk_clipboard_get_for_display(disp, GDK_SELECTION_PRIMARY);
gtk_clipboard_set_text(clip, tokencode_str, -1);
return FALSE;
}
static void fm_path_entry_paste_and_go(GtkMenuItem *menuitem, GtkEntry *entry)
{
GtkClipboard* clipboard = gtk_clipboard_get_for_display(
gtk_widget_get_display (GTK_WIDGET (menuitem)),GDK_SELECTION_CLIPBOARD);
gchar* full_path = gtk_clipboard_wait_for_text(clipboard);
if (full_path)
{
FmPathEntryPrivate *priv = FM_PATH_ENTRY_GET_PRIVATE(entry);
if(priv->path)
fm_path_unref(priv->path);
/* special handling for home dir */
if(full_path[0] == '~' && full_path[1] == G_DIR_SEPARATOR)
priv->path = fm_path_new_relative(fm_path_get_home(), full_path + 2);
else if(full_path[0] == '~' && full_path[1] == 0)
priv->path = fm_path_ref(fm_path_get_home());
else
priv->path = fm_path_new_for_str(full_path);
gchar * disp_name = fm_path_display_name(priv->path, FALSE);
gtk_entry_set_text(entry, disp_name);
g_free(disp_name);
gtk_editable_set_position(GTK_EDITABLE(entry), -1);
g_free(full_path);
fm_path_entry_activate(FM_PATH_ENTRY(entry));
}
}
gint main ( gint argc, gchar* argv[] )
{
gtk_init( &argc, &argv );
GtkWidget *window = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_title( GTK_WINDOW(window), "Clipboard Demonstration" );
g_object_set( window, "window-position", GTK_WIN_POS_CENTER, "border-width", 10, NULL );
gtk_window_set_default_size( GTK_WINDOW(window), 350, 70 );
g_signal_connect ( GTK_WIDGET(window), "destroy", G_CALLBACK(gtk_main_quit), NULL);
GtkWidget *entry = gtk_entry_new();
gtk_container_add( GTK_CONTAINER(window), entry );
gtk_widget_show_all( GTK_WIDGET( window ) );
GdkDisplay *display = gtk_widget_get_display( window );
GtkClipboard *clipboard = gtk_clipboard_get_for_display( display, GDK_SELECTION_CLIPBOARD );
gchar *text = gtk_clipboard_wait_for_text( clipboard );
if ( !text ) {
text = g_strdup("");
}
gtk_entry_set_text( GTK_ENTRY(entry), text );
g_signal_connect( entry, "changed", G_CALLBACK(entry_text_changes), (gpointer)clipboard);
gtk_main();
g_free( text );
return 0;
}
static void
pgd_selections_copy (GtkButton *button,
PgdSelectionsDemo *demo)
{
GtkClipboard *clipboard = gtk_clipboard_get_for_display(gdk_display_get_default(),
GDK_SELECTION_CLIPBOARD);
gtk_clipboard_set_text (clipboard, demo->selected_text, -1);
}
gboolean fm_clipboard_cut_or_copy_files(GtkWidget* src_widget, FmPathList* files, gboolean _is_cut)
{
GdkDisplay* dpy = src_widget ? gtk_widget_get_display(src_widget) : gdk_display_get_default();
GtkClipboard* clip = gtk_clipboard_get_for_display(dpy, GDK_SELECTION_CLIPBOARD);
gboolean ret = gtk_clipboard_set_with_data(clip, targets, G_N_ELEMENTS(targets),
get_data, clear_data, fm_list_ref(files));
is_cut = _is_cut;
return ret;
}
static void
screenshot_save_to_clipboard (void)
{
GtkClipboard *clipboard;
clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (),
GDK_SELECTION_CLIPBOARD);
gtk_clipboard_set_image (clipboard, screenshot);
}
static void
screenshot_save_to_clipboard (ScreenshotApplication *self)
{
GtkClipboard *clipboard;
clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (),
GDK_SELECTION_CLIPBOARD);
gtk_clipboard_set_image (clipboard, self->priv->screenshot);
}
static gboolean
clipboard_cut_or_copy_files (GtkWidget* src_widget, clipboard_data_context_t *ctx)
{
GdkDisplay *display = src_widget ? gtk_widget_get_display (src_widget) : gdk_display_get_default();
GtkClipboard *clipboard = gtk_clipboard_get_for_display (display, GDK_SELECTION_CLIPBOARD);
gboolean ret;
ret = gtk_clipboard_set_with_data (clipboard, targets, G_N_ELEMENTS(targets),
clipboard_get_clipboard_data, clipboard_free, ctx);
return ret;
}
void Pasteboard::writePlainText(const String& text, SmartReplaceOption smartReplaceOption)
{
GtkClipboard* clipboard = gtk_clipboard_get_for_display(gdk_display_get_default(), GDK_SELECTION_CLIPBOARD);
DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
dataObject->clearAll();
dataObject->setText(text);
PasteboardHelper::defaultPasteboardHelper()->writeClipboardContents(clipboard,
(smartReplaceOption == CanSmartReplace) ? PasteboardHelper::IncludeSmartPaste : PasteboardHelper::DoNotIncludeSmartPaste);
}
static void
grain_stat_copy(GtkWidget *dialog)
{
GtkClipboard *clipboard;
GdkDisplay *display;
gchar *text = (gchar*)g_object_get_data(G_OBJECT(dialog), "report");
display = gtk_widget_get_display(dialog);
clipboard = gtk_clipboard_get_for_display(display, GDK_SELECTION_CLIPBOARD);
gtk_clipboard_set_text(clipboard, text, -1);
}
static void
xdg_open_selection (GtkWidget *terminal)
{
GdkDisplay *display;
GtkClipboard *clipboard;
vte_terminal_copy_primary (VTE_TERMINAL (terminal));
display = gtk_widget_get_display (terminal);
clipboard = gtk_clipboard_get_for_display (display, GDK_SELECTION_PRIMARY);
gtk_clipboard_request_text (clipboard, xdg_open_selection_cb, NULL);
}
void
psppire_data_editor_clip_paste (PsppireDataEditor *de)
{
GdkDisplay *display = gtk_widget_get_display ( GTK_WIDGET (de));
GtkClipboard *clipboard =
gtk_clipboard_get_for_display (display, GDK_SELECTION_CLIPBOARD);
gtk_clipboard_request_contents (clipboard,
gdk_atom_intern ("UTF8_STRING", TRUE),
data_sheet_contents_received_callback,
de);
}
/**
* gimp_clipboard_set_text:
* @gimp: pointer to #Gimp
* @text: a %NULL-terminated string in UTF-8 encoding
*
* Offers @text in %GDK_SELECTION_CLIPBOARD and %GDK_SELECTION_PRIMARY.
**/
void
gimp_clipboard_set_text (Gimp *gimp,
const gchar *text)
{
GtkClipboard *clipboard;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (text != NULL);
gimp_clipboard_clear (gimp_clipboard_get (gimp));
clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (),
GDK_SELECTION_CLIPBOARD);
if (clipboard)
gtk_clipboard_set_text (clipboard, text, -1);
clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (),
GDK_SELECTION_PRIMARY);
if (clipboard)
gtk_clipboard_set_text (clipboard, text, -1);
}
static void
curvature_copy(CurvatureControls *controls)
{
GtkClipboard *clipboard;
GdkDisplay *display;
gchar *text = curvature_make_report(controls);
display = gtk_widget_get_display(controls->dialog);
clipboard = gtk_clipboard_get_for_display(display, GDK_SELECTION_CLIPBOARD);
gtk_clipboard_set_text(clipboard, text, -1);
g_free(text);
}
int
clipboard_is_clipboard_data_available ()
{
GdkDisplay *display = mainwin ? gtk_widget_get_display (mainwin) : gdk_display_get_default();
GtkClipboard *clipboard = gtk_clipboard_get_for_display (display, GDK_SELECTION_CLIPBOARD);
clipboard_check_atoms ();
for (int i = 0; i < N_CLIPBOARD_TARGETS; i++) {
if (gtk_clipboard_wait_is_target_available (clipboard, target_atom[i])) {
return 1;
}
}
return 0;
}
/**
* gimp_clipboard_get_svg:
* @gimp: pointer to #Gimp
* @svg_length: returns the size of the SVG stream in bytes
*
* Retrieves SVG data from %GDK_SELECTION_CLIPBOARD or from the global
* SVG buffer of @gimp.
*
* The returned data needs to be freed when it's no longer needed.
*
* Return value: a reference to a #GimpBuffer or %NULL if there's no
* image data
**/
gchar *
gimp_clipboard_get_svg (Gimp *gimp,
gsize *svg_length)
{
GimpClipboard *gimp_clip;
GtkClipboard *clipboard;
GdkAtom atom;
gchar *svg = NULL;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (svg_length != NULL, NULL);
clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (),
GDK_SELECTION_CLIPBOARD);
if (clipboard &&
gtk_clipboard_get_owner (clipboard) != G_OBJECT (gimp) &&
(atom = gimp_clipboard_wait_for_svg (gimp)) != GDK_NONE)
{
GtkSelectionData *data;
gimp_set_busy (gimp);
data = gtk_clipboard_wait_for_contents (clipboard, atom);
if (data)
{
const guchar *stream;
stream = gimp_selection_data_get_stream (data, svg_length);
if (stream)
svg = g_memdup (stream, *svg_length);
gtk_selection_data_free (data);
}
gimp_unset_busy (gimp);
}
gimp_clip = gimp_clipboard_get (gimp);
if (! svg && gimp_clip->svg)
{
svg = g_strdup (gimp_clip->svg);
*svg_length = strlen (svg);
}
return svg;
}
void
gimp_clipboard_exit (Gimp *gimp)
{
GtkClipboard *clipboard;
g_return_if_fail (GIMP_IS_GIMP (gimp));
clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (),
GDK_SELECTION_CLIPBOARD);
if (clipboard && gtk_clipboard_get_owner (clipboard) == G_OBJECT (gimp))
gtk_clipboard_store (clipboard);
g_object_set_data (G_OBJECT (gimp), GIMP_CLIPBOARD_KEY, NULL);
}
void Pasteboard::writeImage(Node* node, const KURL&, const String&)
{
GtkClipboard* clipboard = gtk_clipboard_get_for_display(gdk_display_get_default(), GDK_SELECTION_CLIPBOARD);
ASSERT(node && node->renderer() && node->renderer()->isImage());
RenderImage* renderer = static_cast<RenderImage*>(node->renderer());
CachedImage* cachedImage = static_cast<CachedImage*>(renderer->cachedImage());
ASSERT(cachedImage);
Image* image = cachedImage->image();
ASSERT(image);
GdkPixbuf* pixbuf = image->getGdkPixbuf();
gtk_clipboard_set_image(clipboard, pixbuf);
g_object_unref(pixbuf);
}
static void
gwy_graph_window_copy_to_clipboard(GwyGraphWindow *graph_window)
{
GtkClipboard *clipboard;
GdkDisplay *display;
GdkPixbuf *pixbuf;
GdkAtom atom;
display = gtk_widget_get_display(GTK_WIDGET(graph_window));
atom = gdk_atom_intern("CLIPBOARD", FALSE);
clipboard = gtk_clipboard_get_for_display(display, atom);
pixbuf = gwy_graph_export_pixmap(GWY_GRAPH(graph_window->graph),
FALSE, TRUE, TRUE);
gtk_clipboard_set_image(clipboard, pixbuf);
g_object_unref(pixbuf);
}
/**
* gimp_clipboard_get_buffer:
* @gimp: pointer to #Gimp
*
* Retrieves either image data from %GDK_SELECTION_CLIPBOARD or from
* the global cut buffer of @gimp.
*
* The returned #GimpBuffer needs to be unref'ed when it's no longer
* needed.
*
* Return value: a reference to a #GimpBuffer or %NULL if there's no
* image data
**/
GimpBuffer *
gimp_clipboard_get_buffer (Gimp *gimp)
{
GimpClipboard *gimp_clip;
GtkClipboard *clipboard;
GdkAtom atom;
GimpBuffer *buffer = NULL;
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (),
GDK_SELECTION_CLIPBOARD);
if (clipboard &&
gtk_clipboard_get_owner (clipboard) != G_OBJECT (gimp) &&
(atom = gimp_clipboard_wait_for_buffer (gimp)) != GDK_NONE)
{
GtkSelectionData *data;
gimp_set_busy (gimp);
data = gtk_clipboard_wait_for_contents (clipboard, atom);
if (data)
{
GdkPixbuf *pixbuf = gtk_selection_data_get_pixbuf (data);
gtk_selection_data_free (data);
if (pixbuf)
{
buffer = gimp_buffer_new_from_pixbuf (pixbuf, _("Clipboard"));
g_object_unref (pixbuf);
}
}
gimp_unset_busy (gimp);
}
gimp_clip = gimp_clipboard_get (gimp);
if (! buffer && gimp_clip->buffer)
buffer = g_object_ref (gimp_clip->buffer);
return buffer;
}
static void
lsv_copy_activated(GSimpleAction * action,
GVariant * parameter,
gpointer user_data)
{
LibBalsaSourceViewerInfo *lsvi =
g_object_get_data(G_OBJECT(user_data), "lsvi");
GtkTextView *text = GTK_TEXT_VIEW(lsvi->text);
GtkTextBuffer *buffer = gtk_text_view_get_buffer(text);
GdkDisplay *display;
GtkClipboard *clipboard;
display = gtk_widget_get_display(GTK_WIDGET(text));
clipboard = gtk_clipboard_get_for_display(display, GDK_NONE);
gtk_text_buffer_copy_clipboard(buffer, clipboard);
}
void Pasteboard::writeImage(Node* node, const KURL&, const String&)
{
GtkClipboard* clipboard = gtk_clipboard_get_for_display(gdk_display_get_default(), GDK_SELECTION_CLIPBOARD);
ASSERT(node && node->renderer() && node->renderer()->isImage());
RenderImage* renderer = toRenderImage(node->renderer());
CachedImage* cachedImage = renderer->cachedImage();
if (!cachedImage || cachedImage->errorOccurred())
return;
Image* image = cachedImage->image();
ASSERT(image);
PlatformRefPtr<GdkPixbuf> pixbuf = adoptPlatformRef(image->getGdkPixbuf());
DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
dataObject->setImage(pixbuf.get());
m_helper->writeClipboardContents(clipboard);
}
static GdkAtom *
gimp_clipboard_wait_for_targets (Gimp *gimp,
gint *n_targets)
{
GtkClipboard *clipboard;
clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (),
GDK_SELECTION_CLIPBOARD);
if (clipboard)
{
GtkSelectionData *data;
GdkAtom atom = gdk_atom_intern_static_string ("TARGETS");
data = gtk_clipboard_wait_for_contents (clipboard, atom);
if (data)
{
GdkAtom *targets;
gboolean success;
success = gtk_selection_data_get_targets (data, &targets, n_targets);
gtk_selection_data_free (data);
if (success)
{
if (gimp->be_verbose)
{
gint i;
for (i = 0; i < *n_targets; i++)
g_printerr ("clipboard: offered type: %s\n",
gdk_atom_name (targets[i]));
g_printerr ("\n");
}
return targets;
}
}
}
return NULL;
}
static void
screenshot_dialog_response_cb (GtkDialog *d,
gint response_id,
ScreenshotDialog *dialog)
{
char *uri;
if (response_id == GTK_RESPONSE_HELP)
{
display_help (GTK_WINDOW (d));
}
else if (response_id == GTK_RESPONSE_OK)
{
uri = screenshot_dialog_get_uri (dialog);
if (temporary_file == NULL)
{
save_immediately = TRUE;
screenshot_dialog_set_busy (dialog, TRUE);
}
else
{
/* we've saved the temporary file, lets try to copy it to the
* correct location.
*/
try_to_save (dialog, uri);
}
g_free (uri);
}
else if (response_id == SCREENSHOT_RESPONSE_COPY)
{
GtkClipboard *clipboard;
GdkPixbuf *screenshot;
clipboard = gtk_clipboard_get_for_display (gtk_widget_get_display (GTK_WIDGET (d)),
GDK_SELECTION_CLIPBOARD);
screenshot = screenshot_dialog_get_screenshot (dialog);
gtk_clipboard_set_image (clipboard, screenshot);
}
else /* dialog was canceled */
{
gtk_widget_destroy (GTK_WIDGET (d));
gtk_main_quit ();
}
}
