Table of Contents
      From time to time, it may be useful to be able to embed a widget from
      another application within your application. gtkmm allows you to do
      this with the Gtk::Socket and
      Gtk::Plug classes. It is not anticipated that very
      many applications will need this functionality, but in the rare case that
      you need to display a widget that is running in a completely different
      process, these classes can be very helpful.
    
      The communication between a Socket and a
      Plug follows the XEmbed protocol. This protocol has
      also been implemented in other toolkits (e.g. Qt), which allows the same
      level of integration when embedding a Qt widget in GTK+ or vice versa.
    
      The way that Sockets and
      Plugs work together is through their window ids.
      Both a Socket and a Plug
      have IDs that can be retrieved with their get_id()
      member functions. The use of these IDs will be explained below in the section called “Connecting Plugs and Sockets”.
    
        A Socket is a special kind of container widget that
        provides the ability to embed widgets from one process into another
        process in a way that is transparent to the user.
      
        A Plug is a special kind of Window that can be
        plugged into a Socket. Besides the normal
        properties and methods of Gtk::Window, a
        Plug provides a constructor that takes the ID of
        a Socket, which will automatically embed the
        Plug into the Socket that
        matches that ID.
      
        Since a Plug is just a special type of
        Gtk::Window class, you can add containers or
        widgets to it like you would to any other window.
      
        After a Socket or Plug
        object is realized, you can obtain its ID with its
        get_id() function. This ID can then be shared with
        other processes so that other processes know how to connect to
        each other.
      
There are two basic strategies that can be used:
              Create a Socket object in one process and
              pass the ID of that Socket to another
              process so that it can create a Plug object
              by specifying the given Socket ID in its
              constructor. There is no way to assign a
              Plug to a particular
              Socket after creation, so you must pass the
              Socket ID to the
              Plug's constructor.
            
              Create a Plug independantly from any
              particular Socket and pass the ID of the
              Plug to other processes that need to use
              it. The ID of the Plug can be associated
              with a particular Socket object using the
              Socket::add_id() function. This is the
              approach used in the example below.