Tiré de GTK+ Reference Manual
acryline 2007 Boosteur de petits projets

Presse-Papier

Presse-Papier — Mettre des données dans le presse-papier.

Synopsis


#include <gtk/gtk.h>

GtkClipboard;
void (*GtkClipboardReceivedFunc) (GtkClipboard *clipboard,
	 GtkSelectionData *selection_data,
	 gpointer data);
void (*GtkClipboardTextReceivedFunc) (GtkClipboard *clipboard,
	 const gchar *text,
	 gpointer data);
void (*GtkClipboardImageReceivedFunc) (GtkClipboard *clipboard,
	 GdkPixbuf *pixbuf,
	 gpointer data);
void (*GtkClipboardTargetsReceivedFunc) (GtkClipboard *clipboard,
	 GdkAtom *atoms,
	 gint n_atoms,
	 gpointer data);
void (*GtkClipboardRichTextReceivedFunc) (GtkClipboard *clipboard,
	 GdkAtom format,
	 const guint8 *text,
	 gsize length,
	 gpointer data);
void (*GtkClipboardGetFunc) (GtkClipboard *clipboard,
	 GtkSelectionData *selection_data,
	 guint info,
	 gpointer user_data_or_owner);
void (*GtkClipboardClearFunc) (GtkClipboard *clipboard,
	 gpointer user_data_or_owner);
GtkClipboard* gtk_clipboard_get (GdkAtom selection);
GtkClipboard* gtk_clipboard_get_for_display (GdkDisplay *display,
	 GdkAtom selection);
GdkDisplay* gtk_clipboard_get_display (GtkClipboard *clipboard);
gboolean	gtk_clipboard_set_with_data (GtkClipboard *clipboard,
	 const GtkTargetEntry *targets,
	 guint n_targets,
	 GtkClipboardGetFunc get_func,
	 GtkClipboardClearFunc clear_func,
	 gpointer user_data);
gboolean gtk_clipboard_set_with_owner (GtkClipboard *clipboard,
	 const GtkTargetEntry *targets,
	 guint n_targets,
	 GtkClipboardGetFunc get_func,
	 GtkClipboardClearFunc clear_func,
	 GObject *owner);
GObject* gtk_clipboard_get_owner (GtkClipboard *clipboard);
void gtk_clipboard_clear (GtkClipboard *clipboard);
void gtk_clipboard_set_text (GtkClipboard *clipboard,
	 const gchar *text,
	 gint len);
void gtk_clipboard_set_image (GtkClipboard *clipboard,
	 GdkPixbuf *pixbuf);
void gtk_clipboard_request_contents (GtkClipboard *clipboard,
	 GdkAtom target,
	 GtkClipboardReceivedFunc callback,
	 gpointer user_data);
void gtk_clipboard_request_text (GtkClipboard *clipboard,
	 GtkClipboardTextReceivedFunc callback,
	 gpointer user_data);
void gtk_clipboard_request_image (GtkClipboard *clipboard,
	 GtkClipboardImageReceivedFunc callback,
	 gpointer user_data);
void gtk_clipboard_request_targets (GtkClipboard *clipboard,
	 GtkClipboardTargetsReceivedFunc callback,
	 gpointer user_data);
void gtk_clipboard_request_rich_text (GtkClipboard *clipboard,
	 GtkTextBuffer *buffer,
	 GtkClipboardRichTextReceivedFunc callback,
	 gpointer user_data);
GtkSelectionData* gtk_clipboard_wait_for_contents (GtkClipboard *clipboard,
	 GdkAtom target);
gchar* gtk_clipboard_wait_for_text (GtkClipboard *clipboard);
GdkPixbuf* gtk_clipboard_wait_for_image (GtkClipboard *clipboard);
guint8* gtk_clipboard_wait_for_rich_text (GtkClipboard *clipboard,
	 GtkTextBuffer *buffer,
	 GdkAtom *format,
	 gsize *length);
gboolean gtk_clipboard_wait_is_text_available
	(GtkClipboard *clipboard);
gboolean gtk_clipboard_wait_is_image_available
	(GtkClipboard *clipboard);
gboolean gtk_clipboard_wait_is_rich_text_available
	(GtkClipboard *clipboard,
	 GtkTextBuffer *buffer);
gboolean gtk_clipboard_wait_for_targets (GtkClipboard *clipboard,
	 GdkAtom **targets,
	 gint *n_targets);
gboolean gtk_clipboard_wait_is_target_available
	(GtkClipboard *clipboard,
	 GdkAtom target);
void gtk_clipboard_set_can_store (GtkClipboard *clipboard,
	 const GtkTargetEntry *targets,
	 gint n_targets);
void gtk_clipboard_store (GtkClipboard *clipboard);

Hiérarchie de l'Objet 

GObject
+----GtkClipboard

Signaux

"owner-change" : Première exécution

Description

L'objet GtkClipboard représente un presse-papier de données partagées entre les différents processus ou entre les différents widgets dans un processus.Chaque presse-papier est identifié par un nom encodé comme un  GdkAtom. (La conversion vers et depuis les chaînes peut se faire avec  gdk_atom_intern() et gdk_atom_name().) Le presse-papier par défaut correspond à l'atome (identifiant) "CLIPBOARD"; un autre presse-papier communément utilisé est le presse-papier  "PRIMARY" , lequel, dans X, contient traditionnellement le texte sélectionné en cours.

Le support ayant un nombre de formats différents dans le presse-papier au même moment, le mécanisme du presse-papier permets de fournir des callbacks à la place des données actuelles. Quand vous définissez le contenu d'un presse-papier, vous pouvez soit envoyer les données directement (via des fonctions comme gtk_clipboard_set_text()), ou vous pouvez fournir un callback qui sera ppelé plus tard quand les données seront nécessaires (via gtk_clipboard_set_with_data() ou gtk_clipboard_set_with_owner().) Fournir un callback permet aussi d'éviter d'avoir à faire des copies de données quand on en a besoin.

gtk_clipboard_set_with_data() et gtk_clipboard_set_with_owner()sont presque semblables; le choix entre les deux dépend de la  commodité dans certaines situations particulières. La première fonction est plus utile quand vous voulez avoir un groupe de données avec des callbacks pour les convertir en différents types variés de données que vous annoncez. Quand la clear_func que vous fournissez est appelée, vous libérez simplement le groupe de données. La deuxième fonction est plus utile quand le contenu du presse-papier reflète l'état interne de GObject (Comme par exemple, pour le presse-papier PRIMARY , quand un widget d'entrée apporte un contenu de presse-papier, ce contenu est un texte  à l'intérieur d'un région sélectionnée). Si le contenu change, le widget d'entrée peut appeler  gtk_clipboard_set_with_owner()pour mettre à jour le timestamp de la propriété du presse-papier, sans avoir à se soucier d'appeler clear_func.

Prendre les données du presse-papier est essentiellement asynchrone. Si le contenu du presse-papier est fourni à l'interieur du même processus, alors un appel direct de  fonction  sera fait pour rechercher les données, mais s' il est fourni par un autre processus , alors les données nécessitent d'être recherchées depuis l'autre processus, ce qui peut prendre du temps. Pour éviter de bloquer l'interface utilisateur, l'appel de la sélection,  gtk_clipboard_request_contents() utilise un  callback qui sera appelé quand le contenu sera reçu (ou quand la demande échouera.) Si vous ne  voulez pas apporter et utiliser un callback séparé vous pouvez aussi utiliser gtk_clipboard_wait_for_contents().  Ce qui provoque l'exécution de la boucle principale de GLib  récursivement pour attendre le contenu.  Cela peut simplifier le code, mais vous  devez savoir que d'autre callbacks dans votre programme peuvent être appélées pendant que cette boucle principale récursive tourne.

A côté des fonctions qui reçoivent le contenu du presse-papier comme de gros morceaux aléatoires de données, il y a aussi des fonctions qui le reçoivent en tant que texte, gtk_clipboard_request_text() et gtk_clipboard_wait_for_text(). Ces fonctions prennent en compte les formats qui sont annoncés  par le fournisseur d'accès du presse-papier, demandant le presse-papier dans le meilleur format disponible et convertissant le résultat dans l'encodage UTF-8.(La forme standard représentant les chaînes dans GTK+).

Details

GtkClipboard


typedef struct _GtkClipboard GtkClipboard;

GtkClipboardReceivedFunc ()


void (*GtkClipboardReceivedFunc) (GtkClipboard *clipboard,
	 GtkSelectionData *selection_data,
	 gpointer data);

Fonction à appeler à la réception des résultats de  gtk_clipboard_request_contents() , ou quand la requête échoue.

clipboard : Le GtkClipboard
selection_data : Un GtkSelectionData contenant les données reçues. Si la recherche de données échoue, alors le champs longuer de selection_data sera négatif.
data : Données utilisateur fournies à  gtk_clipboard_request_contents().

GtkClipboardTextReceivedFunc ()


void (*GtkClipboardTextReceivedFunc) (GtkClipboard *clipboard,
	const gchar *text,
	 gpointer data);

Fonction à appeler à la réception des résultats de gtk_clipboard_request_text(), ou quand la requête échoue.
clipboard :  Le  GtkClipboard
text : Le texte reçu, en tant que chaîne au format d'encodage  UTF-8, ou  NULL  si la recherche de données échoue.
data : the user_data supplied to gtk_clipboard_request_text().

GtkClipboardImageReceivedFunc ()


void (*GtkClipboardImageReceivedFunc) (GtkClipboard *clipboard,
	 GdkPixbuf *pixbuf,
	 gpointer data);

Fonction à appeler à la réception des résultats de gtk_clipboard_request_image() , ou quand la requêteéchoue.
clipboard : Le GtkClipboard
pixbuf : L'image reçue
data : le user_data fourni à  gtk_clipboard_request_image().

Depuis 2.6

GtkClipboardTargetsReceivedFunc ()


void (*GtkClipboardTargetsReceivedFunc) (GtkClipboard *clipboard,
	 GdkAtom *atoms,
	 gint n_atoms,
	 gpointer data);

Fonction àappeler à la réception des résultats de gtk_clipboard_request_targets() , ou quand la requête échoue.

clipboard : Le GtkClipboard
atoms : Cibles (targets)  supportées, comme un tableau de  GdkAtom, ou NULL si la recherche de données échoue.
n_atoms : La taille du tableau d'atomes
data : le user_data fourni à  gtk_clipboard_request_targets().

Depuis 2.4

GtkClipboardRichTextReceivedFunc ()


void (*GtkClipboardRichTextReceivedFunc) (GtkClipboard *clipboard,
	 GdkAtom format,
	 const guint8 *text,
	 gsize length,
	 gpointer data);

clipboard :
format :
text :
length :
data :

GtkClipboardGetFunc ()


void (*GtkClipboardGetFunc) (GtkClipboard *clipboard,
	 GtkSelectionData *selection_data,
	 guint info,
	 gpointer user_data_or_owner);

Fonction qui sera appelée pour fournir le contenu de la sélection. Si des types multiples de données sont annoncés, le type demandé peut être déterminé à partir du paramètre info  ou en contrôlant le champ cible de  selection_data. Si les données peuvent être convertie avec succès alors elles devraient être placées dans l'objet  selection_data en appelant gtk_selection_data_set() (ou les fonctions apparentées comme  gtk_selection_data_set_text()). S'il n'y a pas de données définies, celui qui a fait la requête sera informé que sa tentative  d'obtenir des données a échoué.

clipboard : Le GtkClipboard
selection_data : Un argument GtkSelectionData dans lequel les données demandées doivent être placées.
info : Le champ d'information correspondant à la cible demandée depuis un tableau de GtkTargetEntry passé à gtk_clipboard_set_with_data() ou gtk_clipboard_set_with_owner().
user_data_or_owner : Argument  user_data passé à  gtk_clipboard_set_with_data(), ou l'argument owner passé à gtk_clipboard_set_with_owner()

GtkClipboardClearFunc ()


void (*GtkClipboardClearFunc) (GtkClipboard *clipboard,
	 gpointer user_data_or_owner);

Fonction appelée quand le contenu du presse-papier a changé ou a été effacé. Une fois cette fonction appelée, l'argument  user_data_or_owner  ne sera plus réutilisé.
clipboard : Le  GtkClipboard
user_data_or_owner : Argument  user_data passé à  gtk_clipboard_set_with_data(), ou argument  owner passé à gtk_clipboard_set_with_owner()

gtk_clipboard_get ()


GtkClipboard* gtk_clipboard_get (GdkAtom selection);

Retourbe l'objet presse-papier pour la sélection donnée. Voir gtk_clipboard_get_for_display() pour plus de détails.
selection : un GdkAtom qui identifie le presse-papier utilisé.
Retourne : L'objet presse-papier approprié . Si aucun presse-papier n'existe, un nouveau sera créé. Une fois que l'objet presse-papier est créé, il est persistant et, tant qu'il appartient à GTK+, il ne doit pas être libéréou déréférencé. 

gtk_clipboard_get_for_display ()


GtkClipboard* gtk_clipboard_get_for_display (GdkDisplay *display,
	 GdkAtom selection);

Retourne l'objet presse-papier pour la sélection donnée. Les items de menu couper/copier/Coller et les raccourcis clavier doivent utiliser le presse-papier par défaut, retourné en passant  GDK_SELECTION_CLIPBOARD dans selection. (GDK_NONE est supporté comme synonyme de  GDK_SELECTION_CLIPBOARD pour des raisons de compatibilité backwards.) L'objet ou le texte de sélection courante  doivent être passés dans l'identifiant du presse-papier par  GDK_SELECTION_PRIMARY. Les items de menu couper /copier/ coller conceptuellement  copient le contenu du presse-papier  GDK_SELECTION_PRIMARY dans le presse papier par défaut c'est à dire qu'ils copient la sélection de ce que l'utilisateur voit comme le presse-papier. (?)

(Passer GDK_NONE revient au même que d'utiliser gdk_atom_intern ("CLIPBOARD", FALSE). Voir http://www.freedesktop.org/Standards/clipboards-spec pour avoir plus d'information au sujet des sélections  "CLIPBOARD" vs. "PRIMARY" sous le système X window.  Sur  Win32 le presse-papier  GDK_SELECTION_PRIMARY est essenciellement ignoré.)

Il est possible d'avoir un nom de presse-papier arbitraire; si vous créez un nouveau presse-papier, vous devrez ajouter un préfixe au nom de la sélection avec un  underscore (parce que l' ICCCM ( Manuel Inter-Client Communication Conventions) demande que les atomes non standards aient un underscore en préfixe), et appelez le comme vous le désirez. Par exemple, si votre application nommée "Foo"  a un presse-papier pour un but particulier, vous pouvez l'appeler  "_FOO_PRESSE_PAPIER_SPECIAL".

display : L'affichage pour lequel le presse-papier doit être recherché ou créé.
selection : Un GdkAtom  qui identifie le presse-papier à utiliser.
Retourne : L'objet presse-papier approprié. Si aucun presse-papier n'existe, un nouveau presse-papier est créé. Un fois que le presse-papier a été créé, il est persistant, tant qu'il appartient à GTK+, il ne doit pas être libéré ou déréférencé.

Depuis  2.2

gtk_clipboard_get_display ()


GdkDisplay* gtk_clipboard_get_display (GtkClipboard *clipboard);

Pour obtenir le GdkDisplay associé à  clipboard

clipboard : Un GtkClipboard
Returns : Le GdkDisplay associé à  clipboard

Depuis 2.2

gtk_clipboard_set_with_data ()


gboolean gtk_clipboard_set_with_data (GtkClipboard *clipboard, 
	const GtkTargetEntry *targets,
	 guint n_targets,
	 GtkClipboardGetFunc get_func, 
	GtkClipboardClearFunc clear_func,
	 gpointer user_data);

Virtuellement définit le contenu d'un presse-papier spécifique en fournissant une liste de formats supportés pour les données du presse-papier et une fonction à appeler pour obtenir les données actuelles quand elles sont demandées.

clipboard : Un GtkClipboard
targets : Tableau contenant les informations concernant les formes disponibles pour les données du presse-papier.
n_targets : Nombre d'éléments dans targets
get_func : Fonction à appeler pour obtenir les données actuelles du presse-papier.
clear_func : Quand le contenu du presse-papier est redéfinit, cette fonction sera appelée, et  get_func ne sera pas appelée plus tard.
user_data : Données utilisateyr à passer à  get_func et clear_func.
Returns : TRUE si la définition des données du presse-papier réussit. Si la définition des données du presse-papier échoue la fonction callback fournie  sera ignorée.

gtk_clipboard_set_with_owner ()


gboolean gtk_clipboard_set_with_owner (GtkClipboard *clipboard,
	const GtkTargetEntry *targets,
	 guint n_targets,
	 GtkClipboardGetFunc get_func,
	 GtkClipboardClearFunc clear_func, 
	GObject *owner);

Virtuellement définit le contenu d'un presse-papier spécifique en fournissant une liste de formats supportés pour les données du presse-papier et une fonction à appeler pour obtenir les données actuelles quand elles sont demandées.

La différence entre cette fonction et gtk_clipboard_set_with_data() est qu'à la place du pointeur sur  user_data , un GObject est passé.

clipboard : Un GtkClipboard
targets : Tableau contenant les informations concernant les formes disponibles pour les données du presse-papier.
n_targets : Nombre d'éléments dans targets
get_func : Fonction à appeler pour obtenir les données actuelles du presse-papier.
clear_func : Quand le contenu du presse-papier est redéfinit, cette fonction sera appelée, et  get_func ne sera pas appelée plus tard.
owner : Un objet qui est propriétaire des données. Cette objet sera passé à la fonction callbacks quand elle est appelée.
Returns : TRUE si la définition des données du presse-papier réussit. Si la définition des données du presse-papier échoue la fonction callback fournie  sera ignorée.

gtk_clipboard_get_owner ()


GObject* gtk_clipboard_get_owner (GtkClipboard *clipboard);

Si les fonctions callbacks du contenu du presse-papier ont été définies avec gtk_clipboard_set_with_owner(), et  gtk_clipboard_set_with_data() ou gtk_clipboard_clear() n'ont pas été appelées ultérieurement, retourne le propriétaire définit par  gtk_clipboard_set_with_owner().

clipboard : Un GtkClipboard
Retourne : Le propriétaire du presse-papier, s'il y en a un; autrement  NULL.

gtk_clipboard_clear ()


void gtk_clipboard_clear (GtkClipboard *clipboard);

Efface le contenu du presse-papier. Générallement elle peut être appelée seulement entre le moment où vous appelez  gtk_clipboard_set_with_owner() ou gtk_clipboard_set_with_data(), et le moment où  clear_func que vous avez fournit est appelée. Autrement, le prese-papier peut appartenir à quelqu'un d'autre.

clipboard : Un GtkClipboard

gtk_clipboard_set_text ()


void gtk_clipboard_set_text (GtkClipboard *clipboard,
	 const gchar *text,gint len);

Définit le contenu du presse-papier à une chaîne UTF-8 donnée. GTK+ fera une copie du texte et se chargera de la réponse aux demandes concernant le texte et  la convertion du texte au format demandé.

clipboard : Un objet GtkClipboard 
text : Une chaîne  UTF-8 .
len : Taille de text, en bytes, ou -1, dans ce cas la taille sera déterminée par  strlen().

gtk_clipboard_set_image ()


void gtk_clipboard_set_image (GtkClipboard *clipboard,
	 GdkPixbuf *pixbuf);

Définit le contenu du presse-papier pour un  GdkPixbuf donné. GTK+se chargera de la réponse aux demandes concernant  l'image, et  la convertion du texte au format demandé.

clipboard : Un objet GtkClipboard 
pixbuf : Un GdkPixbuf

Depuis 2.6

gtk_clipboard_request_contents ()


void gtk_clipboard_request_contents (GtkClipboard *clipboard,
	 GdkAtom target,
	 GtkClipboardReceivedFunc callback,
	 gpointer user_data);

Demande le contenu du presse-papier comme cible donnée. Quand les résultats de la réponse sont reçus plus tard la fonction callback fournie sera appelée.

clipboard : Un GtkClipboard
target : Un atome représentant la forme dans laquelle le propriétaire du presse-papier doit convertir la sélection.
callback : Une fonction à appeler quand les résultats eont reçus (ou la récupération échoue). Si la récupération échoue le champs de la taille de selection_data sera négatif.
user_data : Données utilisateur à passer à  callback

gtk_clipboard_request_text ()


void gtk_clipboard_request_text (GtkClipboard *clipboard,
	 GtkClipboardTextReceivedFunc callback,
	 gpointer user_data);

Demande le contenu du presse-papier en tant que texte.  Quand le texte est reçu plus tard, il sera converti en UTF-8 si nécessaire, et callback sera appelée.

Le paramètre text  du callback contiendra le texte résultant si le requête réussit, ou  NULL si elle échoue. Cela peut arriver pour des raison variée, en particulier si le presse-papier était vide ou si le contenu du presse-papier ne peut pas être converti dans la forme du texte. 

clipboard : Un GtkClipboard
callback : Une fonction à appeler quand le texte est reçu, ou si la récupération échoue. (elle est toujours appelée d'une façon ou d'une aute).
user_data : Données utilisateur à passer à  callback.

gtk_clipboard_request_image ()


void gtk_clipboard_request_image (GtkClipboard *clipboard,
	 GtkClipboardImageReceivedFunc callback,
	 gpointer user_data);

Demande le contenu du presse-papier en tant qu'image. Quand l'image est reçue plus tard, elle sera convertie en  GdkPixbuf, et  callback sera appelée.

Le paramètre pixbuf de  callback contiendra le  GdkPixbuf  résultant si la requête réussit, ou NULLsi elle échoue. Cela peut arriver pour des raison variées, en particulier si le presse-papier était vide ou si le contenu du presse-papier ne peut pas être convertit en image.

clipboard : Un GtkClipboard
callback : Une fonction appelée quand l'image est reçue, ou si la récupération échoue. (Elle sera toujours appelée d'une façon ou d'une autre).
user_data : Données utilisateur à passer à callback.

Depuis 2.6

gtk_clipboard_request_targets ()


void gtk_clipboard_request_targets (GtkClipboard *clipboard,
	 GtkClipboardTargetsReceivedFunc callback,
	 gpointer user_data);

Demande le contenu du presse-papier en tant que liste de cibles supportées. Quand la liste est reçue plus tard, callback sera appelée.

Le paramètre targets de callback contiendra les cibles résultantes si la requête réussit, ou  NULL  si elle échoue. 

clipboard : Un GtkClipboard
callback : Une fonction à appeler quand les cibles sont reçues, ou quand la récupération échoue. (Elle  sera toujours appelée d'une façon ou l'autre).
user_data : Données utilisateur à passer à callback.

Depuis 2.4

gtk_clipboard_request_rich_text ()


void gtk_clipboard_request_rich_text (GtkClipboard *clipboard,
	 GtkTextBuffer *buffer,
	 GtkClipboardRichTextReceivedFunc callback,
	 gpointer user_data);

Demande le contenu du presse-papier en tant que  texte au format rich text. Quand le  rich text est reçu plus tard,  callback wsera appelée.

Le paramètre text de callback contiendra le rich text résultant si la requête réussit, ou NULL si elle échoue. Le paramètre length contiendra la taille de text. Cette fonction peut échouer pour différentes raison, en particulier si le presse-papier est vide ou si le contenu du presse-papier ne peut pas être converti au format rich text.

clipboard : Un GtkClipboard
buffer : Un GtkTextBuffer
callback : Une fonction à appeler quand le texte est reçu, ou quand la réupération échoue. (Elle sera appelée d'une façon ou d'une autre).
user_data : Données utilisateur à passer à  callback.

Depuis 2.10

gtk_clipboard_wait_for_contents ()


GtkSelectionData* gtk_clipboard_wait_for_contents (GtkClipboard *clipboard,
	 GdkAtom target);

Demande le contenu du presse-paspier en tant que cible donnée. Cette fonction attend que les données soient reçues en utilisant une boucle principale, aussi les événements, le timeouts, etc, peuvent être distribués pendant l'attente.

clipboard : Un GtkClipboard
target : Un atome représentant la forme dans laquelle le propriétaire du presse-papier doit convertir la sélection.
Retourne : Un objet  GtkSelectionData nouvellement alloué ou NULL si la récupération pour la cible donnée échoue. Si elle n'est pas NULL, cette valeur doit être libérée avec gtk_selection_data_free() quand vous avez terminé avec elle.

gtk_clipboard_wait_for_text ()


gchar* gtk_clipboard_wait_for_text (GtkClipboard *clipboard);

Demande le contenu du presse-papier en tant que texte et convertit le résultat au format UTF-8 si nécessaire. Cette fonction attend que les données soient reçues en utilisant une bloucle principale, ainsi les événements, les timeouts, etc, peuvent être distribués pendant l'attente.

clipboard : Un GtkClipboard
Retourne : Une chaîne UTF-8 nouvellement allouée qui doit être libérée avec g_free(), ou NULL si la récupération des données délectionnées échoue.  (Cela peut arriver pour différentes raison, en particulier si le presse-papier est vde ou si le contenu du presse-papier ne peut pas être converti dans la forme texte.)

gtk_clipboard_wait_for_image ()


GdkPixbuf* gtk_clipboard_wait_for_image (GtkClipboard *clipboard);

Demande le contenu du presse-papier en tant qu'image et convertit le résultat en GdkPixbuf. Cette fonction attend que les données soient reçues en utilisant une bloucle principale, ainsi les événements, les timeouts, etc, peuvent être distribués pendant l'attente.

clipboard : Un GtkClipboard
Retourne: Un objet  GdkPixbuf nouvellement alloué qui doit être libérée avec g_object_unref(), ou NULL si la récupération des données délectionnées échoue.  (Cela peut arriver pour différentes raison, en particulier si le presse-papier est vde ou si le contenu du presse-papier ne peut pas être converti en  image.)

Depuis 2.6

gtk_clipboard_wait_for_rich_text ()


guint8* gtk_clipboard_wait_for_rich_text (GtkClipboard *clipboard,
	 GtkTextBuffer *buffer,
	 GdkAtom *format,
	 gsize *length);

Demande le contenu du presse-papier en tant que rich text. Cette fonction attend que les données soient reçues en utilisant une bloucle principale, ainsi les événements, les timeouts, etc, peuvent être distribués pendant l'attente.

clipboard : Un GtkClipboard
buffer : Un GtkTextBuffer
format : Retourne la localisation pour le format des données retournées.
length : Retourne la localisation pour la taille des données retournées.
Retourne: Un bloc binaire de données nouvellement  qui doit être libérée avec g_free(), ou NULL si la récupération des données délectionnées échoue.  (Cecla peut arriver pour différentes raison, en particulier si le presse-papier est vde ou si le contenu du presse-papier ne peut pas être converti dans la forme texte.)

Depuis 2.10

gtk_clipboard_wait_is_text_available ()


gboolean gtk_clipboard_wait_is_text_available (GtkClipboard *clipboard);

Teste pour savoir s'il y a du texte à coller disponible. Cela se fait en demandant l'atome  TARGETS et en contrôlant s'il contient une des cible texte supportée. Cette fonction attend que les données soient reçue en utilisant un boucle principale   , ainsi les événements, les timeouts, etc, peuvent être distribués pendant l'attente.

Cette fonction est un peu plus rapide que l'appel de gtk_clipboard_wait_for_text() elle n'a pas besoin de rechercher le texte courant.

clipboard : Un GtkClipboard
Retourne : TRUE s'il y a du texte disponible, FALSE autrement

gtk_clipboard_wait_is_image_available ()


gboolean gtk_clipboard_wait_is_image_available (GtkClipboard *clipboard);

Teste pour savoir s'il y a une image à coller disponible.Cela se fait en demandant l'atome  TARGETS et en contrôlant s'il contient une  image cible supportée. Cette fonction attend que les données soient reçue en utilisant un boucle principale   , ainsi les événements, les timeouts, etc, peuvent être distribués pendant l'attente.

Cette fonction est un peu plus rapide que l'appel de  gtk_clipboard_wait_for_image() elle n'a pas besoin de rechercher les données de l'image courante.

clipboard : Un GtkClipboard
Retourne : TRUE s'il y a une image disponible, FALSE autrement.

Depuis 2.6

gtk_clipboard_wait_is_rich_text_available ()


gboolean gtk_clipboard_wait_is_rich_text_available (GtkClipboard *clipboard,
	 GtkTextBuffer *buffer);

Teste pour savoir s'il y a un rich text à coller disponible. Cela se fait en demandant l'atome  TARGETS et en contrôlant s'il contient un rich text cible supporté. Cette fonction attend que les données soient reçue en utilisant un boucle principale   , ainsi les événements, les timeouts, etc, peuvent être distribués pendant l'attente.

Cette fonction est un peu plus rapide que l'appel de gtk_clipboard_wait_for_rich_text() elle n'a pas besoin de rechercher le texte courant.

clipboard : Un GtkClipboard
buffer : Un GtkTextBuffer
Retourne : TRUE s'il y a un rich text disponible  FALSE autrement

Depuis 2.10

gtk_clipboard_wait_for_targets ()


gboolean gtk_clipboard_wait_for_targets (GtkClipboard *clipboard,
	 GdkAtom **targets,
	 gint *n_targets);

Retourne une liste de cibles qui sont présentes dans le presse-papier, ou  NULL  s'il n'y a aucune cible disponible.La liste retournée doit être libérée avec g_free(). Cette fonction attends que les données soient reçues en utilisant un boucle principale   , ainsi les événements, les timeouts, etc, peuvent être distribués pendant l'attente.

clipboard : Un GtkClipboard
targets : Endroit où placer le tableau de cibles. Ce qui a été placé ici doit être libéré avec g_free().
n_targets : Endroit  où placer le nombre d'items dans targets.
Retourne : TRUE si des cibles sont présente dans le presse-papier, autrement  FALSE.

Depuis 2.4

gtk_clipboard_wait_is_target_available ()


gboolean gtk_clipboard_wait_is_target_available (GtkClipboard *clipboard,
	 GdkAtom target);

Contrôle si le presse-papier supporte le passage de données d'un type donné. Cette fonction peut être utilisée pour déterminer si  un item de menu "Coller"  doit être insensible ou non.

Si vous voulez voir s'il y a du texte disponible dans le presse papier, utilisez  gtk_clipboard_wait_is_text_available() à la place.

clipboard : Un GtkClipboard
target : Un GdkAtom indiquant la cible à chercher
Retourne : TRUE si la cible est disponible, FALSE autrement

Depuis 2.6

gtk_clipboard_set_can_store ()


void gtk_clipboard_set_can_store (GtkClipboard *clipboard,
	 const GtkTargetEntry *targets,
	 gint n_targets);

Conseille que les données du presse-papier peuvent être placée quelque part quand l'application se termine ou quand  gtk_clipboard_store() est appélée.

Cette valeur est redéfinie quand le propriétaire du presse-papier changer. L'endroit où les données du presse-papier sont placées dépendent de la plateforme, voir  gdk_display_store_clipboard() pour plus d'informations.

clipboard : Un GtkClipboard
targets : Tableau contenant les information au sujet des formes qui doivent être stockées ou  NULL  qui indique que toutes les formes doivent être stockées.
n_targets : nombre d'éléments dans targets

Depuis 2.6

gtk_clipboard_store ()


void gtk_clipboard_store (GtkClipboard *clipboard);

Stocke les données courantes du presse-papier quelque part ainsi elles existeront encore après la fermeture de l'application.

clipboard : Un GtkClipboard

Depuis 2.6

Signal Details

The "owner-change" signal

void user_function (GtkClipboard *clipboard,
	 GdkEvent *event,
	 gpointer user_data) : première exécution

clipboard : L'objet qui reçoit le signal
event :
user_data : Données utilisateur  définies quand le handler du signal a été connecté.

Voir Aussi

GtkSelection

GtkClipboard fournit une enveloppe de haut niveau autour de la routine de bas niveau qui fonctionne avec les sélection X. Il est aussi possible de manipuler directement les délection X, It is also possibly to directly manipulate the X selections, bien qu'il soit rarement nécessaire de procéder ainsi.