Un Plug encapsule un interface utilisateur fourni par une application pour qu'il puisse être inséré dans l'interface d'une autre application. Le signal "embedded" avertit l'application connectée qu'elle a été insérée dans l'interface utilisateur de l'autre application.

On crée un Plug par la fonction suivante :

  plug = gtk.Plug(socket_id)

... qui crée un nouveau Plug et l'insère dans le Socket identifié par socket_id. Si socket_id vaut OL, le plug est laissé "déconnecté" et pourra, plus tard, être connecté dans unSocket en utilisant la méthode add_id() du Socket.

La méthode de Plug :

  id = plug.get_id()

... retourne l'identifiant de la fenêtre d'un Plug, qui peut être utilisé pour l'insérer dans un Socket en utilisant la méthode add_id() du Socket.

Le programme exemple plug.py illustre l'utilisation d'un Plug :

     1   #!/usr/bin/python
     2   # -*- coding:utf-8 -*-
     3   import pygtk
     4   pygtk.require('2.0')
     5   import gtk,sys
     6   
     7   Wid = 0L
     8   if len(sys.argv) == 2:
     9       Wid = long(sys.argv[1])
    10   
    11   plug = gtk.Plug(Wid)
    12   print "Id de Plug=", plug.get_id()
    13   
    14   def embed_event(widget):
    15       print "Je (", widget, ") viens juste d'être inséré !"
    16   
    17   plug.connect("embedded", embed_event)
    18   
    19   entry = gtk.Entry()
    20   entry.set_text("salut")
    21   def entry_point(widget):
    22       print "Vous avez modifié mon texte en '%s'" % widget.get_text()
    23   
    24   entry.connect("changed", entry_point)
    25   plug.connect("destroy", lambda w: gtk.main_quit())
    26   
    27   plug.add(entry)
    28   plug.show_all()
    29   
    30   
    31   gtk.main()

Ce programme se lance ainsi :

  plug.py [windowID]

... où le paramètre windowID est l'identifiant d'un Socket où connecter le Plug.

Un Socket fournit le widget pour insérer, de manière transparente, un Plug d'une autre application dans votre interface graphique. Une application crée un Socket et transmet l'identifiant de fenêtre de ce widget à une autre application, qui, alors, crée un Plug en utilisant cet identifiant de fenêtre comme paramètre. Tout widget contenu dans le Plug apparaîtra dans la fenêtre de la première application.

L'ID (identifiant) de fenêtre du Socket s'obtient en utilisant la méthode de Socket get_id(). Avant d'utiliser cette méthode, le Socket doit être réalisé et ajouté à son parent.

Quand GTK+ est prévenu que la fenêtre insérée a été détruite, il détruira aussi le Socket. Il faut toujours être préparé à ce que vos sockets soient détruits à n'importe quel moment quand la boucle principale s'exécute. Détruire un Socket entraîne aussi la destruction du Plug inséré.

La communication entre un Socket et un Plug suit le protocole XEmbed. Ce protocole a été inplémenté dans d'autres toolkits, par ex. Qt, ce qui permet le même niveau d'intégration lorsque l'on incorpore un widget Qt dans GTK ou vice-versa.

Création d'un nouveau Socket vide :

  socket = gtk.Socket()

Le Socket doit être placé dans une fenêtre de premier niveau avant d'invoquer la méthode add_id() :

  socket.add_id(window_id)

... qui ajoute un client XEMBED, tel un Plug, au Socket. Le client peut être dans le même processus ou un processus différent.

Pour insérer un Plug dans un Socket, on peut soit créer le Plug par :

  plug = gtk.Plug(0L)

... et ensuite, transmettre à la méthode add_id() du Socket le nombre renvoyé par la méthode get_id() du Plug :

  socket.add_id(plug)

soit utiliser la méthode get_id() du Socket :

    window_id = socket.get_id()

... pour obtenir l'ID de fenêtre du socket et ensuite créer le plug par :

  plug = gtk.Plug(window_id)

Le Socket doit avoir été déjà ajouté à une fenêtre de niveau supérieur avant cet appel.

Le programme exemple socket.py illustre l'utilisatin d'un Socket :

     1   #!/usr/bin/python
     2   # -*- coding:utf-8 -*-
     3   import string
     4   
     5   import pygtk
     6   pygtk.require('2.0')
     7   import gtk,sys
     8   
     9   window = gtk.Window()
    10   window.show()
    11   
    12   socket = gtk.Socket()
    13   socket.show()
    14   window.add(socket)
    15   
    16   print "ID du Socket = ", socket.get_id()
    17   window.connect("destroy", lambda w: gtk.main_quit())
    18   
    19   def plugged_event(widget):
    20       print "Je (", widget, ") viens juste d'avoir un plug inséré !"
    21   
    22   socket.connect("plug-added", plugged_event)
    23   
    24   if len(sys.argv) == 2:
    25       socket.add_id(long(sys.argv[1]))
    26   
    27   gtk.main()

Pour tester l'exemple, vous pouvez lancer d'abord plug.py

  $ python plug.py
  Id de Plug= 39845891

... et copier l'ID résultant comme premier argument à socket.py :

  $ python socket.py 39845891
  Socket ID= 48234523
  ID du Socket =  44040231
  Je ( <gtk.Plug object (GtkPlug) at 0x404057ac> ) viens juste d'être inséré !
  Je ( <gtk.Socket object (GtkSocket) at 0x4040a9b4> ) viens juste d'avoir un plug inséré !

Ou vous pouvez lancer socket.py :

  $ python socket.py
  ID du Socket =  39845927

et ensuite lancer plug.py, en recopiant L'ID de fenêtre :

  $ python plug.py
  39845927
  Je ( <gtk.Socket object (GtkSocket) at 0x4040a9b4> ) viens juste d'avoir un plug inséré !
  Id de Plug= 44040195