* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
-#include <config.h>
+#include "config.h"
#include <stdarg.h>
#include <string.h>
#include "gdk.h"
MULTIPLE,
TARGETS,
TIMESTAMP,
+ SAVE_TARGETS,
LAST_ATOM
};
/* Local Functions */
static void gtk_selection_init (void);
-static gint gtk_selection_incr_timeout (GtkIncrInfo *info);
-static gint gtk_selection_retrieval_timeout (GtkRetrievalInfo *info);
+static gboolean gtk_selection_incr_timeout (GtkIncrInfo *info);
+static gboolean gtk_selection_retrieval_timeout (GtkRetrievalInfo *info);
static void gtk_selection_retrieval_report (GtkRetrievalInfo *info,
GdkAtom type,
gint format,
gtk_target_list_new (const GtkTargetEntry *targets,
guint ntargets)
{
- GtkTargetList *result = g_new (GtkTargetList, 1);
+ GtkTargetList *result = g_slice_new (GtkTargetList);
result->list = NULL;
result->ref_count = 1;
while (tmp_list)
{
GtkTargetPair *pair = tmp_list->data;
- g_free (pair);
+ g_slice_free (GtkTargetPair, pair);
tmp_list = tmp_list->next;
}
g_list_free (list->list);
- g_free (list);
+ g_slice_free (GtkTargetList, list);
}
}
g_return_if_fail (list != NULL);
- pair = g_new (GtkTargetPair, 1);
+ pair = g_slice_new (GtkTargetPair);
pair->target = target;
pair->flags = flags;
pair->info = info;
gtk_target_list_add (list, text_atom, 0, info);
gtk_target_list_add (list, GDK_TARGET_STRING, 0, info);
gtk_target_list_add (list, text_plain_utf8_atom, 0, info);
- gtk_target_list_add (list, text_plain_locale_atom, 0, info);
+ if (!g_get_charset (NULL))
+ gtk_target_list_add (list, text_plain_locale_atom, 0, info);
gtk_target_list_add (list, text_plain_atom, 0, info);
}
for (i=ntargets-1; i >= 0; i--)
{
- GtkTargetPair *pair = g_new (GtkTargetPair, 1);
+ GtkTargetPair *pair = g_slice_new (GtkTargetPair);
pair->target = gdk_atom_intern (targets[i].target, FALSE);
pair->flags = targets[i].flags;
pair->info = targets[i].info;
if (pair->target == target)
{
- g_free (pair);
+ g_slice_free (GtkTargetPair, pair);
list->list = g_list_remove_link (list->list, tmp_list);
g_list_free_1 (tmp_list);
* gtk_target_list_find:
* @list: a #GtkTargetList
* @target: an interned atom representing the target to search for
- * @info: a pointer to the location to store application info for target
- *
+ * @info: a pointer to the location to store application info for target,
+ * or %NULL
+ *
* Looks up a given target in a #GtkTargetList.
- *
+ *
* Return value: %TRUE if the target was found, otherwise %FALSE
**/
gboolean
GdkAtom target,
guint *info)
{
- GList *tmp_list = list->list;
+ GList *tmp_list;
+
+ g_return_val_if_fail (list != NULL, FALSE);
+
+ tmp_list = list->list;
while (tmp_list)
{
GtkTargetPair *pair = tmp_list->data;
if (pair->target == target)
{
- *info = pair->info;
+ if (info)
+ *info = pair->info;
+
return TRUE;
}
+
tmp_list = tmp_list->next;
}
current_selections = g_list_remove_link (current_selections,
tmp_list);
g_list_free (tmp_list);
- g_free (selection_info);
+ g_slice_free (GtkSelectionInfo, selection_info);
}
}
else
{
if (selection_info == NULL)
{
- selection_info = g_new (GtkSelectionInfo, 1);
+ selection_info = g_slice_new (GtkSelectionInfo);
selection_info->selection = selection;
selection_info->widget = widget;
selection_info->time = time;
tmp_list = tmp_list->next;
}
- sellist = g_new (GtkSelectionTargetList, 1);
+ sellist = g_slice_new (GtkSelectionTargetList);
sellist->selection = selection;
sellist->list = gtk_target_list_new (NULL, 0);
gtk_target_list_unref (sellist->list);
- g_free (sellist);
+ g_slice_free (GtkSelectionTargetList, sellist);
tmp_list = tmp_list->next;
}
{
lists = g_list_delete_link (lists, tmp_list);
gtk_target_list_unref (sellist->list);
- g_free (sellist);
+ g_slice_free (GtkSelectionTargetList, sellist);
break;
}
GList *tmp_list;
GList *next;
GtkSelectionInfo *selection_info;
-
+
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+
/* Remove pending requests/incrs for this widget */
tmp_list = current_retrievals;
current_selections = g_list_remove_link (current_selections,
tmp_list);
g_list_free (tmp_list);
- g_free (selection_info);
+ g_slice_free (GtkSelectionInfo, selection_info);
}
tmp_list = next;
In emergency, you could use #GDK_CURRENT_TIME
*
* Requests the contents of a selection. When received,
- * a "selection_received" signal will be generated.
+ * a "selection-received" signal will be generated.
*
* Return value: %TRUE if requested succeeded. %FALSE if we could not process
* request. (e.g., there was already a request in process for
tmp_list = tmp_list->next;
}
- info = g_new (GtkRetrievalInfo, 1);
+ info = g_slice_new (GtkRetrievalInfo);
info->widget = widget;
info->selection = selection;
if (owner_window != NULL)
{
GtkWidget *owner_widget;
+ gpointer owner_widget_ptr;
GtkSelectionData selection_data;
selection_data.selection = selection;
selection_data.length = -1;
selection_data.display = display;
- gdk_window_get_user_data (owner_window, (gpointer *)&owner_widget);
+ gdk_window_get_user_data (owner_window, &owner_widget_ptr);
+ owner_widget = owner_widget_ptr;
if (owner_widget != NULL)
{
time_);
g_free (selection_data.data);
+ selection_data.data = NULL;
+ selection_data.length = -1;
- g_free (info);
+ g_slice_free (GtkRetrievalInfo, info);
return TRUE;
}
}
current_retrievals = g_list_append (current_retrievals, info);
gdk_selection_convert (widget->window, selection, target, time_);
- g_timeout_add (1000, (GSourceFunc) gtk_selection_retrieval_timeout, info);
+ gdk_threads_add_timeout (1000,
+ (GSourceFunc) gtk_selection_retrieval_timeout, info);
return TRUE;
}
+/**
+ * gtk_selection_data_get_selection:
+ * @selection_data: a pointer to a #GtkSelectionData structure.
+ *
+ * Retrieves the selection #GdkAtom of the selection data.
+ *
+ * Returns: the selection #GdkAtom of the selection data.
+ *
+ * Since: 2.16
+ **/
+GdkAtom
+gtk_selection_data_get_selection (GtkSelectionData *selection_data)
+{
+ g_return_val_if_fail (selection_data != NULL, 0);
+
+ return selection_data->selection;
+}
+
+/**
+ * gtk_selection_data_get_target:
+ * @selection_data: a pointer to a #GtkSelectionData structure.
+ *
+ * Retrieves the target of the selection.
+ *
+ * Returns: the target of the selection.
+ *
+ * Since: 2.14
+ **/
+GdkAtom
+gtk_selection_data_get_target (GtkSelectionData *selection_data)
+{
+ g_return_val_if_fail (selection_data != NULL, 0);
+
+ return selection_data->target;
+}
+
+/**
+ * gtk_selection_data_get_data_type:
+ * @selection_data: a pointer to a #GtkSelectionData structure.
+ *
+ * Retrieves the data type of the selection.
+ *
+ * Returns: the data type of the selection.
+ *
+ * Since: 2.14
+ **/
+GdkAtom
+gtk_selection_data_get_data_type (GtkSelectionData *selection_data)
+{
+ g_return_val_if_fail (selection_data != NULL, 0);
+
+ return selection_data->type;
+}
+
+/**
+ * gtk_selection_data_get_format:
+ * @selection_data: a pointer to a #GtkSelectionData structure.
+ *
+ * Retrieves the format of the selection.
+ *
+ * Returns: the format of the selection.
+ *
+ * Since: 2.14
+ **/
+gint
+gtk_selection_data_get_format (GtkSelectionData *selection_data)
+{
+ g_return_val_if_fail (selection_data != NULL, 0);
+
+ return selection_data->format;
+}
+
+/**
+ * gtk_selection_data_get_data:
+ * @selection_data: a pointer to a #GtkSelectionData structure.
+ *
+ * Retrieves the raw data of the selection.
+ *
+ * Returns: the raw data of the selection.
+ *
+ * Since: 2.14
+ **/
+const guchar*
+gtk_selection_data_get_data (GtkSelectionData *selection_data)
+{
+ g_return_val_if_fail (selection_data != NULL, NULL);
+
+ return selection_data->data;
+}
+
+/**
+ * gtk_selection_data_get_length:
+ * @selection_data: a pointer to a #GtkSelectionData structure.
+ *
+ * Retrieves the length of the raw data of the selection.
+ *
+ * Returns: the length of the data of the selection.
+ *
+ * Since: 2.14
+ */
+gint
+gtk_selection_data_get_length (GtkSelectionData *selection_data)
+{
+ g_return_val_if_fail (selection_data != NULL, -1);
+
+ return selection_data->length;
+}
+
+/**
+ * gtk_selection_data_get_display:
+ * @selection_data: a pointer to a #GtkSelectionData structure.
+ *
+ * Retrieves the display of the selection.
+ *
+ * Returns: the display of the selection.
+ *
+ * Since: 2.14
+ **/
+GdkDisplay *
+gtk_selection_data_get_display (GtkSelectionData *selection_data)
+{
+ g_return_val_if_fail (selection_data != NULL, NULL);
+
+ return selection_data->display;
+}
/**
* gtk_selection_data_set:
const guchar *data,
gint length)
{
- if (selection_data->data)
- g_free (selection_data->data);
+ g_return_if_fail (selection_data != NULL);
+
+ g_free (selection_data->data);
selection_data->type = type;
selection_data->format = format;
if (length < 0)
selection_data->data = NULL;
else
- selection_data->data = g_strdup("");
+ selection_data->data = (guchar *) g_strdup ("");
}
selection_data->length = length;
{
gtk_selection_data_set (selection_data,
GDK_SELECTION_TYPE_STRING,
- 8, latin1, strlen (latin1));
+ 8, (guchar *) latin1, strlen (latin1));
g_free (latin1);
return TRUE;
{
GString *result = g_string_sized_new (len);
const gchar *p = str;
+ const gchar *end = str + len;
- while (1)
+ while (p < end)
{
if (*p == '\n')
g_string_append_c (result, '\r');
{
g_string_append_c (result, *p);
p++;
- if (*p != '\n')
+ if (p == end || *p != '\n')
g_string_append_c (result, '\n');
+ if (p == end)
+ break;
}
- if (*p == '\0')
- break;
-
g_string_append_c (result, *p);
p++;
}
if (!result)
{
- g_warning ("Error converting from UTF-8 to %s: %s",
- charset, error->message);
+ g_warning ("Error converting from %s to %s: %s",
+ "UTF-8", charset, error->message);
g_error_free (error);
return FALSE;
gtk_selection_data_set (selection_data,
selection_data->target,
- 8, result, strlen (result));
+ 8, (guchar *) result, strlen (result));
g_free (result);
return TRUE;
}
-static gchar *
+static guchar *
selection_get_text_plain (GtkSelectionData *selection_data)
{
const gchar *charset = NULL;
gsize len;
GError *error = NULL;
- str = g_strdup (selection_data->data);
+ str = g_strdup ((const gchar *) selection_data->data);
len = selection_data->length;
if (selection_data->type == text_plain_atom)
{
gchar *tmp = str;
str = g_convert_with_fallback (tmp, len,
- charset, "UTF-8",
+ "UTF-8", charset,
NULL, NULL, &len, &error);
g_free (tmp);
if (!str)
{
- g_warning ("Error converting from %s to UTF-8: %s",
- charset, error->message);
+ g_warning ("Error converting from %s to %s: %s",
+ charset, "UTF-8", error->message);
g_error_free (error);
return NULL;
}
else if (!g_utf8_validate (str, -1, NULL))
{
- g_warning ("Error converting from text/plain;charset=utf-8 to UTF-8");
+ g_warning ("Error converting from %s to %s: %s",
+ "text/plain;charset=utf-8", "UTF-8", "invalid UTF-8");
g_free (str);
return NULL;
result = normalize_to_lf (str, len);
g_free (str);
- return result;
+ return (guchar *) result;
}
/**
const gchar *str,
gint len)
{
+ g_return_val_if_fail (selection_data != NULL, FALSE);
+
if (len < 0)
len = strlen (str);
{
guchar *result = NULL;
+ g_return_val_if_fail (selection_data != NULL, NULL);
+
init_atoms ();
if (selection_data->length >= 0 &&
selection_data->length,
&list);
if (count > 0)
- result = list[0];
+ result = (guchar *) list[0];
for (i = 1; i < count; i++)
g_free (list[i]);
gchar *str, *type;
gsize len;
+ g_return_val_if_fail (selection_data != NULL, FALSE);
+ g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), FALSE);
+
formats = gdk_pixbuf_get_formats ();
for (f = formats; f; f = f->next)
GdkPixbufLoader *loader;
GdkPixbuf *result = NULL;
+ g_return_val_if_fail (selection_data != NULL, NULL);
+
if (selection_data->length > 0)
{
loader = gdk_pixbuf_loader_new ();
/**
* gtk_selection_data_set_uris:
* @selection_data: a #GtkSelectionData
- * @uris: a %NULL-terminated array of strings hilding URIs
+ * @uris: a %NULL-terminated array of strings holding URIs
*
* Sets the contents of the selection from a list of URIs.
* The string is converted to the form determined by
gtk_selection_data_set_uris (GtkSelectionData *selection_data,
gchar **uris)
{
+ g_return_val_if_fail (selection_data != NULL, FALSE);
+ g_return_val_if_fail (uris != NULL, FALSE);
+
init_atoms ();
if (selection_data->target == text_uri_list_atom)
{
gchar **result = NULL;
+ g_return_val_if_fail (selection_data != NULL, NULL);
+
init_atoms ();
if (selection_data->length >= 0 &&
selection_data->type == text_uri_list_atom)
{
gchar **list;
- gint i;
gint count = gdk_text_property_to_utf8_list_for_display (selection_data->display,
utf8_atom,
selection_data->format,
GdkAtom **targets,
gint *n_atoms)
{
+ g_return_val_if_fail (selection_data != NULL, FALSE);
+
+ /* As usual, java gets it wrong and sets the type to TARGETS, not ATOM
+ */
if (selection_data->length >= 0 &&
selection_data->format == 32 &&
- selection_data->type == GDK_SELECTION_TYPE_ATOM)
+ (selection_data->type == GDK_SELECTION_TYPE_ATOM ||
+ selection_data->type == gtk_selection_atoms[TARGETS]))
{
if (targets)
*targets = g_memdup (selection_data->data, selection_data->length);
**/
gboolean
gtk_targets_include_text (GdkAtom *targets,
- gint n_targets)
+ gint n_targets)
{
gint i;
gboolean result = FALSE;
+ g_return_val_if_fail (targets != NULL || n_targets == 0, FALSE);
+
/* Keep in sync with gtk_target_list_add_text_targets()
*/
gint i, j;
gboolean result = FALSE;
+ g_return_val_if_fail (targets != NULL || n_targets == 0, FALSE);
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), FALSE);
init_atoms ();
gint n_targets;
gboolean result = FALSE;
+ g_return_val_if_fail (selection_data != NULL, FALSE);
+
init_atoms ();
if (gtk_selection_data_get_targets (selection_data, &targets, &n_targets))
gint n_targets;
gboolean result = FALSE;
+ g_return_val_if_fail (selection_data != NULL, FALSE);
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), FALSE);
init_atoms ();
gint i;
gboolean result = FALSE;
+ g_return_val_if_fail (targets != NULL || n_targets == 0, FALSE);
+
list = gtk_target_list_new (NULL, 0);
gtk_target_list_add_image_targets (list, 0, writable);
for (i = 0; i < n_targets && !result; i++)
gint n_targets;
gboolean result = FALSE;
+ g_return_val_if_fail (selection_data != NULL, FALSE);
+
init_atoms ();
if (gtk_selection_data_get_targets (selection_data, &targets, &n_targets))
gint i;
gboolean result = FALSE;
+ g_return_val_if_fail (targets != NULL || n_targets == 0, FALSE);
+
/* Keep in sync with gtk_target_list_add_uri_targets()
*/
* provide a list or URIs.
*
* Return value: %TRUE if @selection_data holds a list of targets,
- * and a suitable target for text is included, otherwise %FALSE.
+ * and a suitable target for URI lists is included, otherwise %FALSE.
*
* Since: 2.10
**/
gint n_targets;
gboolean result = FALSE;
+ g_return_val_if_fail (selection_data != NULL, FALSE);
+
init_atoms ();
if (gtk_selection_data_get_targets (selection_data, &targets, &n_targets))
gtk_selection_atoms[MULTIPLE] = gdk_atom_intern_static_string ("MULTIPLE");
gtk_selection_atoms[TIMESTAMP] = gdk_atom_intern_static_string ("TIMESTAMP");
gtk_selection_atoms[TARGETS] = gdk_atom_intern_static_string ("TARGETS");
+ gtk_selection_atoms[SAVE_TARGETS] = gdk_atom_intern_static_string ("SAVE_TARGETS");
initialize = FALSE;
}
* @widget: a #GtkWidget
* @event: the event
*
- * The default handler for the GtkWidget::selection_clear_event
+ * The default handler for the #GtkWidget::selection-clear-event
* signal.
*
* Return value: %TRUE if the event was handled, otherwise false
* Since: 2.2
*
* Deprecated: 2.4: Instead of calling this function, chain up from
- * your selection_clear_event handler. Calling this function
+ * your selection-clear-event handler. Calling this function
* from any other context is illegal.
**/
gboolean
{
current_selections = g_list_remove_link (current_selections, tmp_list);
g_list_free (tmp_list);
- g_free (selection_info);
+ g_slice_free (GtkSelectionInfo, selection_info);
}
return TRUE;
if (tmp_list == NULL)
return FALSE;
- info = g_new (GtkIncrInfo, 1);
+ info = g_slice_new (GtkIncrInfo);
g_object_ref (widget);
GDK_NONE,
event->time);
g_free (mult_atoms);
- g_free (info);
+ g_slice_free (GtkIncrInfo, info);
+ gdk_error_trap_pop ();
return TRUE;
}
gdk_error_trap_pop ();
info->conversions[i].target = ((GdkAtom *)mult_atoms)[2*i];
info->conversions[i].property = ((GdkAtom *)mult_atoms)[2*i+1];
}
+
+ g_free (mult_atoms);
}
}
else /* only a single conversion */
#endif
gtk_selection_invoke_handler (widget, &data, event->time);
-
if (data.length < 0)
{
info->conversions[i].property = GDK_NONE;
gdk_window_get_events (info->requestor) |
GDK_PROPERTY_CHANGE_MASK);
current_incrs = g_list_append (current_incrs, info);
- g_timeout_add (1000, (GSourceFunc) gtk_selection_incr_timeout, info);
+ gdk_threads_add_timeout (1000, (GSourceFunc) gtk_selection_incr_timeout, info);
}
/* If it was a MULTIPLE request, set the property to indicate which
if (info->num_incrs == 0)
{
g_free (info->conversions);
- g_free (info);
+ g_slice_free (GtkIncrInfo, info);
}
g_object_unref (widget);
GList *tmp_list;
gboolean retval;
- GDK_THREADS_ENTER ();
-
/* Determine if retrieval has finished by checking if it still in
list of pending retrievals */
/* FIXME: we should check if requestor window is still in use,
and if not, remove it? */
- g_free (info);
+ g_slice_free (GtkIncrInfo, info);
retval = FALSE; /* remove timeout */
}
retval = TRUE; /* timeout will happen again */
}
- GDK_THREADS_LEAVE ();
-
return retval;
}
/*************************************************************
* _gtk_selection_notify:
- * Handler for "selection_notify_event" signals on windows
+ * Handler for "selection-notify-event" signals on windows
* where a retrieval is currently in process. The selection
* owner has responded to our conversion request.
* arguments:
/*************************************************************
* _gtk_selection_property_notify:
- * Handler for "property_notify_event" signals on windows
+ * Handler for "property-notify-event" signals on windows
* where a retrieval is currently in process. The selection
* owner has added more data.
* arguments:
* results:
*************************************************************/
-static gint
+static gboolean
gtk_selection_retrieval_timeout (GtkRetrievalInfo *info)
{
GList *tmp_list;
gboolean retval;
- GDK_THREADS_ENTER ();
-
/* Determine if retrieval has finished by checking if it still in
list of pending retrievals */
}
g_free (info->buffer);
- g_free (info);
+ g_slice_free (GtkRetrievalInfo, info);
retval = FALSE; /* remove timeout */
}
retval = TRUE; /* timeout will happen again */
}
- GDK_THREADS_LEAVE ();
-
return retval;
}
/*************************************************************
* gtk_selection_retrieval_report:
- * Emits a "selection_received" signal.
+ * Emits a "selection-received" signal.
* arguments:
* info: information about the retrieval that completed
* buffer: buffer containing data (NULL => errror)
data.display = gtk_widget_get_display (info->widget);
g_signal_emit_by_name (info->widget,
- "selection_received",
+ "selection-received",
&data, time);
}
g_return_if_fail (widget != NULL);
target_list = gtk_selection_target_list_get (widget, data->selection);
- if (target_list &&
+ if (data->target != gtk_selection_atoms[SAVE_TARGETS] &&
+ target_list &&
gtk_target_list_find (target_list, data->target, &info))
{
g_signal_emit_by_name (widget,
- "selection_get",
+ "selection-get",
data,
info, time);
}
tmp_list = tmp_list->next;
}
}
+ else if (data->target == gtk_selection_atoms[SAVE_TARGETS])
+ {
+ gtk_selection_data_set (data,
+ gdk_atom_intern_static_string ("NULL"),
+ 32, "", 0);
+ }
else
{
data->length = -1;
g_return_val_if_fail (data != NULL, NULL);
- new_data = g_new (GtkSelectionData, 1);
+ new_data = g_slice_new (GtkSelectionData);
*new_data = *data;
if (data->data)
{
g_return_if_fail (data != NULL);
- if (data->data)
- g_free (data->data);
+ g_free (data->data);
- g_free (data);
+ g_slice_free (GtkSelectionData, data);
}
GType