nsClipboard::~nsClipboard()
{
// We have to clear clipboard before gdk_display_close() call.
// See bug 531580 for details.
if (mGlobalTransferable) {
gtk_clipboard_clear(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD));
}
if (mSelectionTransferable) {
gtk_clipboard_clear(gtk_clipboard_get(GDK_SELECTION_PRIMARY));
}
}
/* \brief Set the contents of the system clipboard.
* \par Function Description
* Set the system clipboard to contain the gschem objects listed in \a
* object_list.
*
* \param [in,out] w_current The current GSCHEM_TOPLEVEL.
* \param [in] object_list The objects to put in the clipboard.
*
* \return TRUE if the clipboard is successfully set.
*/
gboolean
x_clipboard_set (GSCHEM_TOPLEVEL *w_current, const GList *object_list)
{
GtkClipboard *cb = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
GtkTargetEntry target = { MIME_TYPE_SCHEMATIC, 0,
CLIP_TYPE_SCHEMATIC };
TOPLEVEL *toplevel = w_current->toplevel;
gboolean result;
/* Clear the clipboard buffer */
if (w_current->clipboard_buffer)
gtk_clipboard_clear (cb);
/* Copy the objects to the clipboard buffer */
w_current->clipboard_buffer =
o_glist_copy_all (toplevel, object_list, w_current->clipboard_buffer);
/* Advertise that the data is available */
result = gtk_clipboard_set_with_data (cb, &target, 1,
clip_get, clip_clear, w_current);
/* Hint that the data can be stored to be accessed after the program
* has quit. */
gtk_clipboard_set_can_store (cb, NULL, 0);
return result;
}
EditorTest()
: m_clipboard(gtk_clipboard_get(GDK_SELECTION_CLIPBOARD))
, m_canExecuteEditingCommand(false)
, m_triesCount(0)
{
gtk_clipboard_clear(m_clipboard);
}
void EditorClient::respondToChangedSelection()
{
WebKitWebViewPrivate* priv = m_webView->priv;
Frame* targetFrame = core(m_webView)->focusController()->focusedOrMainFrame();
if (!targetFrame)
return;
if (targetFrame->editor()->ignoreCompositionSelectionChange())
return;
GtkClipboard* clipboard = gtk_widget_get_clipboard(GTK_WIDGET(m_webView), GDK_SELECTION_PRIMARY);
if (targetFrame->selection()->isRange()) {
GtkTargetList* targetList = webkit_web_view_get_copy_target_list(m_webView);
gint targetCount;
GtkTargetEntry* targets = gtk_target_table_new_from_list(targetList, &targetCount);
gtk_clipboard_set_with_owner(clipboard, targets, targetCount,
clipboard_get_contents_cb, clipboard_clear_contents_cb, G_OBJECT(m_webView));
gtk_target_table_free(targets, targetCount);
} else if (gtk_clipboard_get_owner(clipboard) == G_OBJECT(m_webView))
gtk_clipboard_clear(clipboard);
if (!targetFrame->editor()->hasComposition())
return;
unsigned start;
unsigned end;
if (!targetFrame->editor()->getCompositionSelection(start, end)) {
// gtk_im_context_reset() clears the composition for us.
gtk_im_context_reset(priv->imContext);
targetFrame->editor()->confirmCompositionWithoutDisturbingSelection();
}
}
void PasteboardHelper::writeClipboardContents(GtkClipboard* clipboard, SmartPasteInclusion includeSmartPaste, GClosure* callback)
{
DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
GtkTargetList* list = targetListForDataObject(dataObject, includeSmartPaste);
int numberOfTargets;
GtkTargetEntry* table = gtk_target_table_new_from_list(list, &numberOfTargets);
if (numberOfTargets > 0 && table) {
settingClipboardDataObject = dataObject;
if (gtk_clipboard_set_with_data(clipboard, table, numberOfTargets, getClipboardContentsCallback, clearClipboardContentsCallback, callback ? g_closure_ref(callback) : nullptr))
gtk_clipboard_set_can_store(clipboard, nullptr, 0);
else {
// When gtk_clipboard_set_with_data fails the callbacks are ignored, so we need to release the reference we were passing to clearClipboardContentsCallback.
if (callback)
g_closure_unref(callback);
}
settingClipboardDataObject = nullptr;
} else
gtk_clipboard_clear(clipboard);
if (table)
gtk_target_table_free(table, numberOfTargets);
gtk_target_list_unref(list);
}
void
nautilus_clipboard_clear_if_colliding_uris (GtkWidget *widget,
const GList *item_uris,
GdkAtom copied_files_atom)
{
GtkSelectionData *data;
GList *clipboard_item_uris, *l;
gboolean collision;
collision = FALSE;
data = gtk_clipboard_wait_for_contents (nautilus_clipboard_get (widget),
copied_files_atom);
if (data == NULL) {
return;
}
clipboard_item_uris = nautilus_clipboard_get_uri_list_from_selection_data (data, NULL,
copied_files_atom);
for (l = (GList *) item_uris; l; l = l->next) {
if (g_list_find_custom ((GList *) item_uris, l->data,
(GCompareFunc) g_strcmp0)) {
collision = TRUE;
break;
}
}
if (collision) {
gtk_clipboard_clear (nautilus_clipboard_get (widget));
}
if (clipboard_item_uris) {
g_list_free_full (clipboard_item_uris, g_free);
}
}
static void load_status_cb(WebKitWebView* webView, GParamSpec* spec, gpointer data)
{
CopyAndPasteFixture* fixture = (CopyAndPasteFixture*)data;
WebKitLoadStatus status = webkit_web_view_get_load_status(webView);
if (status != WEBKIT_LOAD_FINISHED)
return;
GtkClipboard* clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
gtk_clipboard_clear(clipboard);
webkit_web_view_copy_clipboard(webView);
gchar* text = gtk_clipboard_wait_for_text(clipboard);
g_assert(text || !fixture->info->expectedContent);
g_assert(!text || !strcmp(text, fixture->info->expectedContent));
g_free(text);
// Verify that the markup starts with the proper content-type meta tag prefix.
GtkSelectionData* selectionData = gtk_clipboard_wait_for_contents(clipboard, gdk_atom_intern("text/html", FALSE));
if (selectionData) {
static const char* markupPrefix = "<meta http-equiv=\"content-type\" content=\"text/html; charset=utf-8\">";
char* markup = g_strndup((const char*) gtk_selection_data_get_data(selectionData),
gtk_selection_data_get_length(selectionData));
g_assert(strlen(markupPrefix) <= strlen(markup));
g_assert(!strncmp(markupPrefix, markup, strlen(markupPrefix)));
g_free(markup);
}
g_assert(!gtk_clipboard_wait_is_uris_available(clipboard));
g_assert(!gtk_clipboard_wait_is_image_available(clipboard));
g_main_loop_quit(fixture->loop);
}
void PasteboardHelperGtk::writeClipboardContents(GtkClipboard* clipboard, gpointer data)
{
DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
GtkTargetList* list = targetListForDataObject(dataObject);
int numberOfTargets;
GtkTargetEntry* table = gtk_target_table_new_from_list(list, &numberOfTargets);
if (numberOfTargets > 0 && table) {
settingClipboardDataObject = dataObject;
settingClipboardData = data;
// Protect the web view from being destroyed before one of the clipboard callbacks
// is called. Balanced in both getClipboardContentsCallback and
// clearClipboardContentsCallback.
WebKitWebView* webView = static_cast<WebKitWebView*>(data);
g_object_ref(webView);
gboolean succeeded = gtk_clipboard_set_with_data(clipboard, table, numberOfTargets,
getClipboardContentsCallback,
clearClipboardContentsCallback, data);
if (!succeeded)
g_object_unref(webView);
settingClipboardDataObject = 0;
settingClipboardData = 0;
} else
gtk_clipboard_clear(clipboard);
if (table)
gtk_target_table_free(table, numberOfTargets);
gtk_target_list_unref(list);
}
void entries_vis_deinit (void){
if (isThereAClip && grg_prefs_clip_clear_on_quit
&& !grg_prefs_clip_clear_on_close)
gtk_clipboard_clear (clip);
del_needle ();
}
//!
//! @brief To be written
//!
G_MODULE_EXPORT gboolean gw_kanjipadwindow_candidatearea_button_press_event_cb (GtkWidget *widget, GdkEventButton *event, gpointer data)
{
//Declarations
GwKanjipadWindow *window;
GwKanjipadWindowPrivate *priv;
GwKanjipadWindowClass *klass;
int j;
gint char_height;
GtkClipboard *clipboard;
char *string_utf;
//Initializations
window = GW_KANJIPADWINDOW (gtk_widget_get_ancestor (GTK_WIDGET (data), GW_TYPE_KANJIPADWINDOW));
if (window == NULL) return FALSE;
priv = window->priv;
klass = GW_KANJIPADWINDOW_CLASS (G_OBJECT_GET_CLASS (window));
clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
static const GtkTargetEntry targets[] = {
{ "STRING", 0, 0 },
{ "TEXT", 0, 0 },
{ "COMPOUND_TEXT", 0, 0 },
{ "UTF8_STRING", 0, 0 }
};
_kanjipadwindow_erase_candidate_selection (window);
_kanjipadwindow_get_candidate_character_size (window, NULL, &char_height);
j = event->y / (char_height + 6);
if (j < priv->total_candidates)
{
gw_kanjipadwindow_draw_candidates (window);
strncpy(priv->kselected, priv->kanji_candidates[j], 2);
_kanjipadwindow_draw_candidate_character (window, j, 1);
if (!gtk_clipboard_set_with_owner (clipboard, targets, G_N_ELEMENTS (targets),
_kanjipadwindow_primary_candidates_get, _kanjipadwindow_primary_candidates_clear, G_OBJECT (widget)))
_kanjipadwindow_primary_candidates_clear (clipboard, widget);
}
else
{
priv->kselected[0] = 0;
priv->kselected[1] = 0;
if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (widget))
gtk_clipboard_clear (clipboard);
}
gtk_widget_queue_draw (widget);
string_utf = _kanjipadwindow_utf8_for_char (priv->kselected);
g_signal_emit (G_OBJECT (window), klass->signalid[GW_KANJIPADWINDOW_CLASS_SIGNALID_KANJI_SELECTED], 0, string_utf);
g_free (string_utf);
//Cleanup so the user can draw the next character
gw_kanjipadwindow_clear_drawingarea (window);
return TRUE;
}
void iscreenshot_save_to_clipboard(GtkWidget *widget,GdkPixbuf *pixbuf)
{
GtkClipboard *clip;
clip=gtk_clipboard_get(gdk_atom_intern_static_string("CLIPBOARD"));
gtk_clipboard_clear(clip);
gtk_clipboard_set_image(clip,pixbuf);
gtk_main_quit();
}
void remmina_rdp_cliprdr_detach_owner(RemminaProtocolWidget* gp)
{
/* When closing a rdp connection, we should check if gp is a clipboard owner.
* If it’s an owner, detach it from the clipboard */
TRACE_CALL(__func__);
rfContext* rfi = GET_PLUGIN_DATA(gp);
GtkClipboard* gtkClipboard;
gtkClipboard = gtk_widget_get_clipboard(rfi->drawing_area, GDK_SELECTION_CLIPBOARD);
if (gtkClipboard && gtk_clipboard_get_owner(gtkClipboard) == (GObject*)gp) {
gtk_clipboard_clear(gtkClipboard);
}
}
//TODO: multiple copy, single cut.
// or single copy, single cut.
void
fileops_paste (GFile* dest_dir)
{
if (copied_files_atom == GDK_NONE)
copied_files_atom = gdk_atom_intern ("x-special/gnome-copied-files", FALSE);
//TODO: we may not own the clipboard now
//cut : move files
//use clipboard_info or clipboard_info_tmp
FileOpsClipboardInfo* real_info = NULL;
//cleanup tmp clipboard info
g_debug ("free tmp clipboard info");
__clear_clipboard_info (&clipboard_info_tmp);
if (__request_clipboard_contents (&clipboard_info_tmp))
real_info = &clipboard_info_tmp;
if (real_info == NULL || real_info->num == 0)
return;
if (real_info->cut)
{
fileops_move (real_info->file_list, real_info->num, dest_dir, true);
//post messages event paste cancelled or failed.
JSObjectRef json = json_array_create();
for (int i = 0; i < real_info->num; i++)
{
json_array_insert_nobject (json, i, real_info->file_list[i],
g_object_ref, g_object_unref);
g_debug ("send file: %d : %s", i, g_file_get_uri (real_info->file_list[i]));
}
js_post_message ("cut_completed", json);
gtk_clipboard_clear (gtk_clipboard_get (GDK_SELECTION_CLIPBOARD));
g_debug ("free tmp clipboard info");
__clear_clipboard_info (&clipboard_info_tmp);
//though maybe we're not the clipboard owner, we still
//free clipboard_info here to avoid possible memory leak
g_debug ("free clipboard info");
__clear_clipboard_info (&clipboard_info);
}
else
{
//copy can be done multiple times. so we should not free real_info;
fileops_copy (real_info->file_list, real_info->num, dest_dir);
}
}
/* As icon_set_selected(), but doesn't automatically unselect incompatible
* icons.
*/
static void icon_set_selected_int(Icon *icon, gboolean selected)
{
static GtkClipboard *primary;
g_return_if_fail(icon != NULL);
if (icon->selected == selected)
return;
if (!primary)
primary = gtk_clipboard_get(gdk_atom_intern("PRIMARY", FALSE));
if (selected)
{
icon_selection = g_list_prepend(icon_selection, icon);
if (!have_primary)
{
GtkTargetEntry target_table[] =
{
{"text/uri-list", 0, TARGET_URI_LIST},
{"UTF8", 0, TARGET_STRING},
{"COMPOUND_TEXT", 0, TARGET_STRING},
{"STRING", 0, TARGET_STRING},
};
/* Grab selection */
have_primary = gtk_clipboard_set_with_data(primary,
target_table,
sizeof(target_table) / sizeof(*target_table),
selection_get, lose_selection, NULL);
}
}
else
{
icon_selection = g_list_remove(icon_selection, icon);
if (have_primary && !icon_selection)
{
have_primary = FALSE;
gtk_clipboard_clear(primary);
}
}
icon->selected = selected;
g_signal_emit_by_name(icon, "redraw");
}
void ClipboardGtk::declareAndWriteDragImage(Element* element, const KURL& url, const String& label, Frame*)
{
CachedImage* cachedImage = getCachedImage(element);
if (!cachedImage || !cachedImage->isLoaded())
return;
GdkPixbuf* pixbuf = cachedImage->image()->getGdkPixbuf();
if (!pixbuf)
return;
GtkClipboard* imageClipboard = gtk_clipboard_get(gdk_atom_intern_static_string("WebKitClipboardImage"));
gtk_clipboard_clear(imageClipboard);
gtk_clipboard_set_image(imageClipboard, pixbuf);
g_object_unref(pixbuf);
writeURL(url, label, 0);
}
static void clipboard_release(SpiceMainChannel *main, guint selection,
gpointer user_data)
{
g_return_if_fail(SPICE_IS_GTK_SESSION(user_data));
SpiceGtkSession *self = user_data;
SpiceGtkSessionPrivate *s = self->priv;
GtkClipboard* clipboard = get_clipboard_from_selection(s, selection);
if (!clipboard)
return;
s->nclip_targets[selection] = 0;
if (!s->clipboard_by_guest[selection])
return;
gtk_clipboard_clear(clipboard);
s->clipboard_by_guest[selection] = FALSE;
}
static int
karea_button_press_event (GtkWidget *w, GdkEventButton *event)
{
int j;
gint char_height;
GtkClipboard *clipboard = gtk_clipboard_get (GDK_SELECTION_PRIMARY);
static const GtkTargetEntry targets[] = {
{ "STRING", 0, 0 },
{ "TEXT", 0, 0 },
{ "COMPOUND_TEXT", 0, 0 },
{ "UTF8_STRING", 0, 0 }
};
karea_erase_selection (w);
karea_get_char_size (w, NULL, &char_height);
j = event->y / (char_height + 6);
if (j < num_guesses)
{
kselected = kanjiguess[j];
karea_draw_character (w, j, 1);
if (!gtk_clipboard_set_with_owner (clipboard, targets, G_N_ELEMENTS (targets),
karea_primary_get, karea_primary_clear, G_OBJECT (w)))
karea_primary_clear (clipboard, w);
}
else
{
kselected.d[0] = 0;
kselected.d[1] = 0;
if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (w))
gtk_clipboard_clear (clipboard);
}
update_sensitivity ();
gtk_widget_queue_draw (w);
return TRUE;
}
static void load_status_cb(WebKitWebView* webView, GParamSpec* spec, gpointer data)
{
CopyAndPasteFixture* fixture = (CopyAndPasteFixture*)data;
WebKitLoadStatus status = webkit_web_view_get_load_status(webView);
if (status != WEBKIT_LOAD_FINISHED)
return;
GtkClipboard* clipboard = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
gtk_clipboard_clear(clipboard);
webkit_web_view_copy_clipboard(webView);
gchar* text = gtk_clipboard_wait_for_text(clipboard);
g_assert(text || !fixture->info->expectedContent);
g_assert(!text || !strcmp(text, fixture->info->expectedContent));
g_free(text);
g_assert(!gtk_clipboard_wait_is_uris_available(clipboard));
g_assert(!gtk_clipboard_wait_is_image_available(clipboard));
g_main_loop_quit(fixture->loop);
}
/**
* gimp_clipboard_set_buffer:
* @gimp: pointer to #Gimp
* @buffer: a #GimpBuffer, or %NULL.
*
* Offers the buffer in %GDK_SELECTION_CLIPBOARD.
**/
void
gimp_clipboard_set_buffer (Gimp *gimp,
GimpBuffer *buffer)
{
GimpClipboard *gimp_clip;
GtkClipboard *clipboard;
g_return_if_fail (GIMP_IS_GIMP (gimp));
g_return_if_fail (buffer == NULL || GIMP_IS_BUFFER (buffer));
clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (),
GDK_SELECTION_CLIPBOARD);
if (! clipboard)
return;
gimp_clip = gimp_clipboard_get (gimp);
gimp_clipboard_clear (gimp_clip);
if (buffer)
{
gimp_clip->buffer = g_object_ref (buffer);
gtk_clipboard_set_with_owner (clipboard,
gimp_clip->target_entries,
gimp_clip->n_target_entries,
(GtkClipboardGetFunc) gimp_clipboard_send_buffer,
(GtkClipboardClearFunc) NULL,
G_OBJECT (gimp));
/* mark the first entry (image/png) as suitable for storing */
gtk_clipboard_set_can_store (clipboard, gimp_clip->target_entries, 1);
}
else if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (gimp))
{
gtk_clipboard_clear (clipboard);
}
}
static void channel_destroy(SpiceSession *session, SpiceChannel *channel,
gpointer user_data)
{
g_return_if_fail(SPICE_IS_GTK_SESSION(user_data));
SpiceGtkSession *self = user_data;
SpiceGtkSessionPrivate *s = self->priv;
guint i;
if (SPICE_IS_MAIN_CHANNEL(channel) && SPICE_MAIN_CHANNEL(channel) == s->main) {
s->main = NULL;
for (i = 0; i < CLIPBOARD_LAST; ++i) {
if (s->clipboard_by_guest[i]) {
GtkClipboard *cb = get_clipboard_from_selection(s, i);
if (cb)
gtk_clipboard_clear(cb);
s->clipboard_by_guest[i] = FALSE;
}
s->clip_grabbed[i] = FALSE;
s->nclip_targets[i] = 0;
}
}
}
/**
* gimp_clipboard_set_svg:
* @gimp: pointer to #Gimp
* @svg: a string containing the SVG data, or %NULL
*
* Offers SVG data in %GDK_SELECTION_CLIPBOARD.
**/
void
gimp_clipboard_set_svg (Gimp *gimp,
const gchar *svg)
{
GimpClipboard *gimp_clip;
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)
return;
gimp_clip = gimp_clipboard_get (gimp);
gimp_clipboard_clear (gimp_clip);
if (svg)
{
gimp_clip->svg = g_strdup (svg);
gtk_clipboard_set_with_owner (clipboard,
gimp_clip->svg_target_entries,
gimp_clip->n_svg_target_entries,
(GtkClipboardGetFunc) gimp_clipboard_send_svg,
(GtkClipboardClearFunc) NULL,
G_OBJECT (gimp));
/* mark the first entry (image/svg) as suitable for storing */
gtk_clipboard_set_can_store (clipboard, gimp_clip->svg_target_entries, 1);
}
else if (gtk_clipboard_get_owner (clipboard) == G_OBJECT (gimp))
{
gtk_clipboard_clear (clipboard);
}
}
void PasteboardHelper::writeClipboardContents(GtkClipboard* clipboard, GClosure* callback)
{
DataObjectGtk* dataObject = DataObjectGtk::forClipboard(clipboard);
GtkTargetList* list = targetListForDataObject(dataObject);
int numberOfTargets;
GtkTargetEntry* table = gtk_target_table_new_from_list(list, &numberOfTargets);
if (numberOfTargets > 0 && table) {
settingClipboardDataObject = dataObject;
gtk_clipboard_set_with_data(clipboard, table, numberOfTargets,
getClipboardContentsCallback, clearClipboardContentsCallback, callback);
gtk_clipboard_set_can_store(clipboard, 0, 0);
settingClipboardDataObject = 0;
} else
gtk_clipboard_clear(clipboard);
if (table)
gtk_target_table_free(table, numberOfTargets);
gtk_target_list_unref(list);
}
void
clear_clipboard (void) {
gtk_clipboard_clear (clip);
}
void Pasteboard::clear()
{
GtkClipboard* clipboard = gtk_clipboard_get_for_display(gdk_display_get_default(), GDK_SELECTION_CLIPBOARD);
gtk_clipboard_clear(clipboard);
}
static void
xfdesktop_clipboard_manager_contents_received (GtkClipboard *clipboard,
GtkSelectionData *selection_data,
gpointer user_data)
{
XfdesktopClipboardPasteRequest *request = user_data;
XfdesktopClipboardManager *manager = XFDESKTOP_CLIPBOARD_MANAGER (request->manager);
GtkWindow *parent = GTK_WINDOW(gtk_widget_get_toplevel(request->widget));
gboolean path_copy = TRUE;
GList *path_list = NULL;
GList *dest_file_list = NULL;
GList *l = NULL;
gchar *data;
/* check whether the retrieval worked */
if (G_LIKELY (gtk_selection_data_get_length(selection_data) > 0))
{
/* be sure the selection data is zero-terminated */
data = (gchar *) gtk_selection_data_get_data(selection_data);
data[gtk_selection_data_get_length(selection_data)] = '\0';
/* check whether to copy or move */
if (g_ascii_strncasecmp (data, "copy\n", 5) == 0)
{
path_copy = TRUE;
data += 5;
}
else if (g_ascii_strncasecmp (data, "cut\n", 4) == 0)
{
path_copy = FALSE;
data += 4;
}
/* determine the path list stored with the selection */
path_list = xfdesktop_file_utils_file_list_from_string (data);
}
/* perform the action if possible */
if (G_LIKELY (path_list != NULL))
{
for (l = path_list; l; l = l->next) {
gchar *dest_basename = g_file_get_basename(l->data);
if(dest_basename && *dest_basename != '\0') {
/* If we copy a file, we need to use the new absolute filename
* as the destination. If we move, we need to use the destination
* directory. */
if(path_copy) {
GFile *dest_file = g_file_get_child(request->target_file, dest_basename);
dest_file_list = g_list_prepend(dest_file_list, dest_file);
} else {
dest_file_list = g_list_prepend(dest_file_list, request->target_file);
}
}
g_free(dest_basename);
}
dest_file_list = g_list_reverse(dest_file_list);
if (G_LIKELY (path_copy))
{
xfdesktop_file_utils_transfer_files(GDK_ACTION_COPY,
path_list,
dest_file_list,
gtk_widget_get_screen(GTK_WIDGET(parent)));
} else {
xfdesktop_file_utils_transfer_files(GDK_ACTION_MOVE,
path_list,
dest_file_list,
gtk_widget_get_screen(GTK_WIDGET(parent)));
}
/* clear the clipboard if it contained "cutted data"
* (gtk_clipboard_clear takes care of not clearing
* the selection if we don't own it)
*/
if (G_UNLIKELY (!path_copy))
gtk_clipboard_clear (manager->clipboard);
/* check the contents of the clipboard again
* if either the Xserver or our GTK+ version
* doesn't support the XFixes extension.
*/
if (!gdk_display_supports_selection_notification (gtk_clipboard_get_display (manager->clipboard)))
{
xfdesktop_clipboard_manager_owner_changed (manager->clipboard, NULL, manager);
}
}
/* free the request */
if (G_LIKELY (request->widget != NULL))
g_object_remove_weak_pointer (G_OBJECT (request->widget), (gpointer) &request->widget);
if (G_LIKELY (request->new_files_closure != NULL))
g_closure_unref (request->new_files_closure);
g_object_unref (G_OBJECT (request->manager));
g_list_free(dest_file_list);
g_list_free(path_list);
}
void Pasteboard::clear()
{
gtk_clipboard_clear(gtk_clipboard_get_for_display(gdk_display_get_default(), GDK_SELECTION_CLIPBOARD));
}
void GtkClipboard_::clear()
{
gtk_clipboard_clear (GTK_CLIPBOARD(instance));
}
static VALUE
rg_clear(VALUE self)
{
gtk_clipboard_clear(_SELF(self));
return self;
}
/**
\author Peter G. Baum
**/
int gnoclClipboardCmd (
ClientData data,
Tcl_Interp *interp,
int objc,
Tcl_Obj * const objv[] )
{
GnoclOption options[] =
{
{ "-primary", GNOCL_BOOL, NULL },
{ NULL }
};
const int usePrimaryIdx = 0;
static const char *cmd[] = { "hasText", "setText", "getText", "clear",
NULL
};
enum optIdx { HasTextIdx, SetTextIdx, GetTextIdx, ClearIdx };
int idx;
int optNum;
GtkClipboard *clip;
int usePrimary = 0;
if ( objc < 2 )
{
Tcl_WrongNumArgs ( interp, 1, objv, "option" );
return TCL_ERROR;
}
if ( Tcl_GetIndexFromObj ( interp, objv[1], cmd, "option", TCL_EXACT,
&idx ) != TCL_OK )
return TCL_ERROR;
if ( idx == SetTextIdx )
{
optNum = 2;
if ( objc < 3 )
{
Tcl_WrongNumArgs ( interp, 1, objv, "text ?option value?" );
return TCL_ERROR;
}
}
else
{
optNum = 1;
if ( objc < 2 )
{
Tcl_WrongNumArgs ( interp, 1, objv, NULL );
return TCL_ERROR;
}
}
if ( gnoclParseOptions ( interp, objc - optNum, objv + optNum, options )
!= TCL_OK )
return TCL_ERROR;
if ( options[usePrimaryIdx].status == GNOCL_STATUS_CHANGED )
usePrimary = options[usePrimaryIdx].val.b;
clip = gtk_clipboard_get ( usePrimary ? gdk_atom_intern ( "PRIMARY", 1 )
: GDK_NONE );
switch ( idx )
{
case HasTextIdx:
{
int ret = gtk_clipboard_wait_is_text_available ( clip );
Tcl_SetObjResult ( interp, Tcl_NewBooleanObj ( ret ) );
}
break;
case SetTextIdx:
gtk_clipboard_set_text ( clip, Tcl_GetString ( objv[2] ), -1 );
break;
case GetTextIdx:
{
char *txt = gtk_clipboard_wait_for_text ( clip );
if ( txt )
{
Tcl_SetObjResult ( interp, Tcl_NewStringObj ( txt, -1 ) );
g_free ( txt );
}
/* FIXME? else error? */
}
break;
case ClearIdx:
gtk_clipboard_clear ( clip );
break;
}
return TCL_OK;
}
