自学教程：C++ GTK_SOCKET函数代码示例

static voidgtk_xtbin_realize (GtkWidget *widget){  GtkXtBin     *xtbin;  GtkAllocation allocation = { 0, 0, 200, 200 };#if GTK_CHECK_VERSION(2, 18, 0)  GtkAllocation widget_allocation;#endif#ifdef DEBUG_XTBIN  printf("gtk_xtbin_realize()/n");#endif  g_return_if_fail (GTK_IS_XTBIN (widget));  xtbin = GTK_XTBIN (widget);  /* caculate the allocation before realize */#if GTK_CHECK_VERSION(2, 24, 0)  allocation.width = gdk_window_get_width(xtbin->parent_window);  allocation.height = gdk_window_get_height(xtbin->parent_window);#else  gint  x, y, w, h, d; /* geometry of window */  gdk_window_get_geometry(xtbin->parent_window, &x, &y, &w, &h, &d);  allocation.width = w;  allocation.height = h;#endif  gtk_widget_size_allocate (widget, &allocation);#ifdef DEBUG_XTBIN  printf("initial allocation %d %d %d %d/n", x, y, w, h);#endif#if GTK_CHECK_VERSION(2, 18, 0)  gtk_widget_get_allocation(widget, &widget_allocation);  xtbin->width = widget_allocation.width;  xtbin->height = widget_allocation.height;#else  xtbin->width = widget->allocation.width;  xtbin->height = widget->allocation.height;#endif  /* use GtkSocket's realize */  (*GTK_WIDGET_CLASS(parent_class)->realize)(widget);  /* create the Xt client widget */  xt_client_create(&(xtbin->xtclient),        gtk_socket_get_id(GTK_SOCKET(xtbin)),        xtbin->height,        xtbin->width);  xtbin->xtwindow = XtWindow(xtbin->xtclient.child_widget);  gdk_flush();  /* now that we have created the xt client, add it to the socket. */  gtk_socket_add_id(GTK_SOCKET(widget), xtbin->xtwindow);}

GdkWindow *awn_ua_alignment_add_id (AwnUAAlignment *self,GdkNativeWindow native_window){  GdkWindow * plugwin;  AwnUAAlignmentPrivate *priv;  priv =  AWN_UA_ALIGNMENT_GET_PRIVATE (self);   gtk_socket_add_id (GTK_SOCKET(priv->socket), native_window);  plugwin = gtk_socket_get_plug_window (GTK_SOCKET(priv->socket));  g_signal_connect (priv->socket,"plug-removed",                    G_CALLBACK(awn_ua_alignment_plug_removed),self);  gtk_widget_realize (priv->socket);  gtk_widget_show_all (priv->socket);  return plugwin;}

/***f* socket/gnoclSocketCmd * AUTHOR *	PGB * SOURCE */int gnoclSocketCmd ( ClientData data, Tcl_Interp *interp,					 int objc, Tcl_Obj * const objv[] ){	int       ret;	GtkSocket *socket;	if ( gnoclParseOptions ( interp, objc, objv, socketOptions ) != TCL_OK )	{		gnoclClearOptions ( socketOptions );		return TCL_ERROR;	}	socket = GTK_SOCKET ( gtk_socket_new() );	gtk_widget_show ( GTK_WIDGET ( socket ) );	ret = gnoclSetOptions ( interp, socketOptions, G_OBJECT ( socket ), -1 );	if ( ret == TCL_OK )		ret = configure ( interp, socket, socketOptions );	gnoclClearOptions ( socketOptions );	if ( ret != TCL_OK )	{		gtk_widget_destroy ( GTK_WIDGET ( socket ) );		return TCL_ERROR;	}	return gnoclRegisterWidget ( interp, GTK_WIDGET ( socket ), socketFunc );}

voidsetup_new_socket_for_plug(struct Gtkabber *gtkabber){	struct ContainerData *cd;	static int __id;	{		cd = malloc( sizeof *cd );		if (cd == NULL)		{			fprintf( stderr, "Can't malloc() *cd/n" );			exit( EXIT_FAILURE );		}		memset( cd, '/0', sizeof *cd );	}	cd->id = ++__id;	cd->socket = gtk_socket_new();	new_tab_page( gtkabber, GTK_WIDGET(cd->socket) );	cd->xwin_id = gtk_socket_get_id( GTK_SOCKET( cd->socket ) );	gtkabber->toplevel.next_socket_id = cd->xwin_id;	gtkabber->socket_list = g_list_append( gtkabber->socket_list,			(gpointer)cd );}

UzblInstance::UzblInstance(const char* u, const char* mainfifo, GtkNotebook* n, GtkTreeRowReference* r){    //id = ID++;    url = g_strdup(u);    title = g_strdup("...");            /*sprintf(fifopath, "/tmp/uzbl_fifo_%s", fifo);    sprintf(sockpath, "/tmp/uzbl_socket_%s", fifo);*/        row = r;    notebook = n;    children = NULL;        socket = GTK_SOCKET(gtk_socket_new());    //gtk_widget_set_can_focus(GTK_WIDGET(socket), false);    gtk_notebook_append_page(notebook, GTK_WIDGET(socket), NULL);    //gtk_widget_show_all(GTK_WIDGET(notebook));    gtk_widget_show(GTK_WIDGET(socket));    int rn = rand();    sprintf(name, "%d", rn &0x7FFFFFFF);    char cmd[1024];    sprintf(cmd, "uzbl-browser tab %d %s %s /"%s/"",                 gtk_socket_get_id(socket), name, mainfifo, u);        printf("%s/n", cmd);    g_spawn_command_line_async(cmd, NULL);}

nsresult nsPluginNativeWindowGtk2::CallSetWindow(nsCOMPtr<nsIPluginInstance> &aPluginInstance){  if(aPluginInstance) {    nsresult rv;    PRBool val = PR_FALSE;    if(!mGtkSocket) {      if (CanGetValueFromPlugin(aPluginInstance))        rv = aPluginInstance->GetValue               ((nsPluginInstanceVariable)NPPVpluginNeedsXEmbed, &val);    }#ifdef DEBUG    printf("nsPluginNativeWindowGtk2: NPPVpluginNeedsXEmbed=%d/n", val);#endif    if(val) {      CreateXEmbedWindow();    }    if(mGtkSocket) {      // Make sure to resize and re-place the window if required      SetAllocation();      window = (nsPluginPort *)gtk_socket_get_id(GTK_SOCKET(mGtkSocket));    }#ifdef DEBUG    printf("nsPluginNativeWindowGtk2: call SetWindow with xid=%p/n", (void *)window);#endif    aPluginInstance->SetWindow(this);  }  else if (mPluginInstance)    mPluginInstance->SetWindow(nsnull);  SetPluginInstance(aPluginInstance);  return NS_OK;}

NetscapePluginX11::NetscapePluginX11(NetscapePlugin& plugin, Display* display, uint64_t windowID)    : m_plugin(plugin)    , m_pluginDisplay(display)    , m_windowID(windowID){    // It seems flash needs the socket to be in the same process,    // I guess it uses gdk_window_lookup(), so we create a new socket here    // containing a plug with the UI process socket embedded.    m_platformPluginWidget = gtk_plug_new(static_cast<Window>(windowID));    // Hide the GtkPlug on delete-event since we assume the widget is valid while the plugin is active.    // platformDestroy() will be called anyway right after the delete-event.    g_signal_connect(m_platformPluginWidget, "delete-event", G_CALLBACK(gtk_widget_hide_on_delete), nullptr);    GtkWidget* socket = gtk_socket_new();    // Do not show the plug widget until the socket is connected.    g_signal_connect_swapped(socket, "plug-added", G_CALLBACK(gtk_widget_show), m_platformPluginWidget);    g_signal_connect(socket, "plug-removed", G_CALLBACK(socketPlugRemovedCallback), nullptr);    gtk_container_add(GTK_CONTAINER(m_platformPluginWidget), socket);    gtk_widget_show(socket);    Display* hostDisplay = x11HostDisplay();    m_npWindowID = gtk_socket_get_id(GTK_SOCKET(socket));    GdkWindow* window = gtk_widget_get_window(socket);    m_setWindowCallbackStruct.display = GDK_WINDOW_XDISPLAY(window);    m_setWindowCallbackStruct.visual = GDK_VISUAL_XVISUAL(gdk_window_get_visual(window));    m_setWindowCallbackStruct.depth = gdk_visual_get_depth(gdk_window_get_visual(window));    m_setWindowCallbackStruct.colormap = XCreateColormap(hostDisplay, GDK_ROOT_WINDOW(), m_setWindowCallbackStruct.visual, AllocNone);    XFlush(hostDisplay);}

static voidegg_tray_manager_handle_dock_request (EggTrayManager       *manager,				      XClientMessageEvent  *xevent){  GtkWidget *socket;  Window *window;    socket = gtk_socket_new ();    /* We need to set the child window here   * so that the client can call _get functions   * in the signal handler   */  window = g_new (Window, 1);  *window = xevent->data.l[2];        g_object_set_data_full (G_OBJECT (socket),			  "egg-tray-child-window",			  window, g_free);  g_signal_emit (manager, manager_signals[TRAY_ICON_ADDED], 0,		 socket);  /* Add the socket only if it's been attached */  if (GTK_IS_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (socket))))    {      g_signal_connect (socket, "plug_removed",			G_CALLBACK (egg_tray_manager_plug_removed), manager);            gtk_socket_add_id (GTK_SOCKET (socket), xevent->data.l[2]);      g_hash_table_insert (manager->socket_table, GINT_TO_POINTER (xevent->data.l[2]), socket);    }  else    gtk_widget_destroy (socket);}

nsresult nsPluginNativeWindowGtk2::CreateXEmbedWindow() {  if(!mGtkSocket) {    GdkWindow *win = gdk_window_lookup((XID)window);    mGtkSocket = gtk_socket_new();    //attach the socket to the container widget    gtk_widget_set_parent_window(mGtkSocket, win);    // Make sure to handle the plug_removed signal.  If we don't the    // socket will automatically be destroyed when the plug is    // removed, which means we're destroying it more than once.    // SYNTAX ERROR.    g_signal_connect(mGtkSocket, "plug_removed",                     G_CALLBACK(plug_removed_cb), NULL);    gpointer user_data = NULL;    gdk_window_get_user_data(win, &user_data);    GtkContainer *container = GTK_CONTAINER(user_data);    gtk_container_add(container, mGtkSocket);    gtk_widget_realize(mGtkSocket);    // Resize before we show    SetAllocation();    gtk_widget_show(mGtkSocket);    gdk_flush();    window = (nsPluginPort *)gtk_socket_get_id(GTK_SOCKET(mGtkSocket));  }  return NS_OK;}

static voidna_tray_manager_handle_dock_request (NaTrayManager       *manager,				     XClientMessageEvent *xevent){  Window icon_window = xevent->data.l[2];  GtkWidget *child;  if (g_hash_table_lookup (manager->socket_table,                           GINT_TO_POINTER (icon_window)))    {      /* We already got this notification earlier, ignore this one */      return;    }  child = na_tray_child_new (manager->screen, icon_window);  if (child == NULL) /* already gone or other error */    return;  g_signal_emit (manager, manager_signals[TRAY_ICON_ADDED], 0,		 child);  /* If the child wasn't attached, then destroy it */  if (!GTK_IS_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (child))))    {      gtk_widget_destroy (child);      return;    }  g_signal_connect (child, "plug_removed",		    G_CALLBACK (na_tray_manager_plug_removed), manager);  gtk_socket_add_id (GTK_SOCKET (child), icon_window);  if (!GTK_SOCKET (child)->plug_window)    {      /* Embedding failed, we won't get a plug-removed signal */      g_signal_emit (manager, manager_signals[TRAY_ICON_REMOVED], 0, child);      gtk_widget_destroy (child);      return;    }  g_hash_table_insert (manager->socket_table,                       GINT_TO_POINTER (icon_window), child);  gtk_widget_show (child);}

nsresult nsPluginNativeWindowGtk2::CreateXEmbedWindow() {  NS_ASSERTION(!mSocketWidget,"Already created a socket widget!");  GdkWindow *parent_win = gdk_window_lookup((XID)window);  mSocketWidget = gtk_socket_new();  //attach the socket to the container widget  gtk_widget_set_parent_window(mSocketWidget, parent_win);  // Make sure to handle the plug_removed signal.  If we don't the  // socket will automatically be destroyed when the plug is  // removed, which means we're destroying it more than once.  // SYNTAX ERROR.  g_signal_connect(mSocketWidget, "plug_removed",                   G_CALLBACK(plug_removed_cb), NULL);  g_signal_connect(mSocketWidget, "unrealize",                   G_CALLBACK(socket_unrealize_cb), NULL);  g_signal_connect(mSocketWidget, "destroy",                   G_CALLBACK(gtk_widget_destroyed), &mSocketWidget);  gpointer user_data = NULL;  gdk_window_get_user_data(parent_win, &user_data);  GtkContainer *container = GTK_CONTAINER(user_data);  gtk_container_add(container, mSocketWidget);  gtk_widget_realize(mSocketWidget);  // The GtkSocket has a visible window, but the plugin's XEmbed plug will  // cover this window.  Normally GtkSockets let the X server paint their  // background and this would happen immediately (before the plug is  // created).  Setting the background to None prevents the server from  // painting this window, avoiding flicker.  gdk_window_set_back_pixmap(mSocketWidget->window, NULL, FALSE);  // Resize before we show  SetAllocation();  gtk_widget_show(mSocketWidget);  gdk_flush();  window = (void*)gtk_socket_get_id(GTK_SOCKET(mSocketWidget));  // Fill out the ws_info structure.  // (The windowless case is done in nsObjectFrame.cpp.)  GdkWindow *gdkWindow = gdk_window_lookup((XID)window);  if(!gdkWindow)    return NS_ERROR_FAILURE;  mWsInfo.display = GDK_WINDOW_XDISPLAY(gdkWindow);  mWsInfo.colormap = GDK_COLORMAP_XCOLORMAP(gdk_drawable_get_colormap(gdkWindow));  GdkVisual* gdkVisual = gdk_drawable_get_visual(gdkWindow);  mWsInfo.visual = GDK_VISUAL_XVISUAL(gdkVisual);  mWsInfo.depth = gdkVisual->depth;  return NS_OK;}

nsresult nsPluginNativeWindowGtk2::CallSetWindow(nsRefPtr<nsNPAPIPluginInstance> &aPluginInstance){  if (aPluginInstance) {    if (type == NPWindowTypeWindow) {      if (!mSocketWidget) {        nsresult rv;        PRBool needXEmbed = PR_FALSE;        rv = aPluginInstance->GetValueFromPlugin(NPPVpluginNeedsXEmbed, &needXEmbed);        // If the call returned an error code make sure we still use our default value.        if (NS_FAILED(rv)) {          needXEmbed = PR_FALSE;        }#ifdef DEBUG        printf("nsPluginNativeWindowGtk2: NPPVpluginNeedsXEmbed=%d/n", needXEmbed);#endif        if (needXEmbed) {          rv = CreateXEmbedWindow();        }        else {          rv = CreateXtWindow();        }        if (NS_FAILED(rv)) {          return NS_ERROR_FAILURE;        }      }      if (!mSocketWidget) {        return NS_ERROR_FAILURE;      }      // Make sure to resize and re-place the window if required.      // Need to reset "window" each time as nsObjectFrame::DidReflow sets it      // to the ancestor window.      if (GTK_IS_XTBIN(mSocketWidget)) {        gtk_xtbin_resize(mSocketWidget, width, height);        // Point the NPWindow structures window to the actual X window        window = (void*)GTK_XTBIN(mSocketWidget)->xtwindow;      }      else { // XEmbed        SetAllocation();        window = (void*)gtk_socket_get_id(GTK_SOCKET(mSocketWidget));      }#ifdef DEBUG      printf("nsPluginNativeWindowGtk2: call SetWindow with xid=%p/n", (void *)window);#endif    } // NPWindowTypeWindow    aPluginInstance->SetWindow(this);  }  else if (mPluginInstance)    mPluginInstance->SetWindow(nsnull);  SetPluginInstance(aPluginInstance);  return NS_OK;}

void MCNativeLayerX11::doAttach(){    if (m_socket == NULL)    {        // Create a new GTK socket to deal with the XEMBED protocol        GtkSocket *t_socket;		t_socket = GTK_SOCKET(gtk_socket_new());                // Create a new GTK window to hold the socket        MCRectangle t_rect;        t_rect = m_object->getrect();        m_child_window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_POPUP));        gtk_widget_set_parent_window(GTK_WIDGET(m_child_window), getStackGdkWindow());        gtk_widget_realize(GTK_WIDGET(m_child_window));        gdk_window_reparent(gtk_widget_get_window(GTK_WIDGET(m_child_window)), getStackGdkWindow(), t_rect.x, t_rect.y);                // Add the socket to the window        gtk_container_add(GTK_CONTAINER(m_child_window), GTK_WIDGET(t_socket));                // The socket needs to be realised before going any further or any        // operations on it will fail.        gtk_widget_realize(GTK_WIDGET(t_socket));                // Show the socket (we'll control visibility at the window level)        gtk_widget_show(GTK_WIDGET(t_socket));                // Create an empty region to act as an input mask while in edit mode        m_input_shape = gdk_region_new();		// Retain a reference to the socket		m_socket = GTK_SOCKET(g_object_ref(G_OBJECT(t_socket)));    }        // Attach the X11 window to this socket    if (gtk_socket_get_plug_window(m_socket) == NULL)        gtk_socket_add_id(m_socket, m_widget_xid);    //fprintf(stderr, "XID: %u/n", gtk_socket_get_id(m_socket));        // Act as if there were a re-layer to put the widget in the right place    doRelayer();    doSetViewportGeometry(m_viewport_rect);    doSetGeometry(m_rect);    doSetVisible(ShouldShowLayer());}

nsresult nsPluginNativeWindowGtk2::CallSetWindow(nsCOMPtr<nsIPluginInstance> &aPluginInstance){  if(aPluginInstance) {    if (type == nsPluginWindowType_Window) {      nsresult rv;      if(!mSocketWidget) {        PRBool needXEmbed = PR_FALSE;        if (CanGetValueFromPlugin(aPluginInstance)) {          rv = aPluginInstance->GetValue            ((nsPluginInstanceVariable)NPPVpluginNeedsXEmbed, &needXEmbed);#ifdef DEBUG          printf("nsPluginNativeWindowGtk2: NPPVpluginNeedsXEmbed=%d/n", needXEmbed);#endif        }        nsresult rv;        if(needXEmbed) {#ifdef MOZ_COMPOSITED_PLUGINS          rv = CreateXCompositedWindow();#else          rv = CreateXEmbedWindow();#endif        }        else {          rv = CreateXtWindow();        }        if(NS_FAILED(rv))          return NS_ERROR_FAILURE;      }      if(!mSocketWidget)        return NS_ERROR_FAILURE;      // Make sure to resize and re-place the window if required.      // Need to reset "window" each time as nsObjectFrame::DidReflow sets it      // to the ancestor window.      if(GTK_IS_XTBIN(mSocketWidget)) {        gtk_xtbin_resize(mSocketWidget, width, height);        // Point the NPWindow structures window to the actual X window        window = (nsPluginPort *)GTK_XTBIN(mSocketWidget)->xtwindow;      }      else { // XEmbed        SetAllocation();        window = (nsPluginPort *)gtk_socket_get_id(GTK_SOCKET(mSocketWidget));      }#ifdef DEBUG      printf("nsPluginNativeWindowGtk2: call SetWindow with xid=%p/n", (void *)window);#endif    } // nsPluginWindowType_Window    aPluginInstance->SetWindow(this);  }  else if (mPluginInstance)    mPluginInstance->SetWindow(nsnull);  SetPluginInstance(aPluginInstance);  return NS_OK;}

int main(int argc, char **argv){  GtkWidget *window, *button, *textview, *vbox;  GtkWidget *socket, *plug, *socket_box;  unsigned long     kb_xid;  gtk_init (&argc, &argv);  install_signal_handlers();  kb_xid = launch_keyboard();  if (!kb_xid)    {      perror ("### 'matchbox-keyboard --xid', failed to return valid window ID. ### ");      exit(-1);    }  /* Window */  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);  gtk_window_set_default_size (GTK_WINDOW (window), 640, 480);  gtk_container_set_border_width (GTK_CONTAINER (window), 10);  g_signal_connect (G_OBJECT (window), "destroy",		    G_CALLBACK (widget_destroy), NULL);  /* Container and textview */  vbox = gtk_vbox_new(FALSE, 5);  gtk_container_add (GTK_CONTAINER (window), vbox);    textview = gtk_text_view_new();  gtk_box_pack_start (GTK_BOX(vbox), textview, TRUE, TRUE, 2);  /* Socket ( XEMBED ) stuff */  socket_box = gtk_event_box_new ();  gtk_widget_show (socket_box);    socket = gtk_socket_new ();  gtk_container_add (GTK_CONTAINER (socket_box), socket);  gtk_box_pack_start (GTK_BOX (vbox), GTK_WIDGET(socket_box), TRUE, TRUE, 0);  gtk_socket_add_id(GTK_SOCKET(socket), kb_xid);   /* FIXME: handle "plug-added" & "plug-removed" signals for socket */  gtk_widget_show_all (window);  gtk_main ();  return 0;}

static gintluaH_socket_newindex(lua_State *L, luapdf_token_t token){    widget_t *w = luaH_checkwidget(L, 1);    if (token == L_TK_ID) {        gint id = luaL_checkint(L, 2);        gtk_socket_add_id(GTK_SOCKET(w->widget), (GdkNativeWindow) id);    }    return 0;}

static gintluaH_socket_index(lua_State *L, luapdf_token_t token){    widget_t *w = luaH_checkwidget(L, 1);    switch(token)    {      LUAPDF_WIDGET_INDEX_COMMON      /* push integer methods */      PI_CASE(ID,      (int) gtk_socket_get_id(GTK_SOCKET(w->widget)))      /* push boolean methods */      PB_CASE(PLUGGED, gtk_socket_get_plug_window(GTK_SOCKET(w->widget))!=NULL)      default:        break;    }    return 0;}

static voidgtk_socket_finalize (GObject *object){  GtkSocket *socket = GTK_SOCKET (object);  GtkSocketPrivate *priv = socket->priv;  g_object_unref (priv->accel_group);  G_OBJECT_CLASS (gtk_socket_parent_class)->finalize (object);}

static void add_menubar(MacMenu* mmb, WnckWindow* mbarwin){  Window mbar = wnck_window_get_xid(mbarwin);  GtkWidget* sck = gtk_socket_new();  g_signal_connect(sck, "destroy", G_CALLBACK(socket_destroyed), mmb);  gtk_notebook_append_page(mmb->notebook, GTK_WIDGET(sck), NULL);  gtk_socket_steal(GTK_SOCKET(sck), mbar);  gtk_widget_show_all(sck);  g_hash_table_insert(mmb->mbars_scks, (gpointer) mbar, sck);}

static voidgtk_socket_finalize (GObject *object){  GtkSocket *socket = GTK_SOCKET (object);    g_object_unref (socket->accel_group);  socket->accel_group = NULL;  G_OBJECT_CLASS (gtk_socket_parent_class)->finalize (object);}

/* If we are faking transparency with a window-relative background, force a * redraw of the icon. This should be called if the background changes or if * the child is shifted with respect to the background. */voidna_tray_child_force_redraw (NaTrayChild *child){  GtkWidget *widget = GTK_WIDGET (child);  if (gtk_widget_get_mapped (widget) && child->parent_relative_bg)    {#if 1      /* Sending an ExposeEvent might cause redraw problems if the       * icon is expecting the server to clear-to-background before       * the redraw. It should be ok for GtkStatusIcon or EggTrayIcon.       */      Display *xdisplay = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (widget));      XEvent xev;      GdkWindow *plug_window;      GtkAllocation allocation;      plug_window = gtk_socket_get_plug_window (GTK_SOCKET (child));      gtk_widget_get_allocation (widget, &allocation);      xev.xexpose.type = Expose;#if GTK_CHECK_VERSION (3, 0, 0)      xev.xexpose.window = GDK_WINDOW_XID (plug_window);#else      xev.xexpose.window = GDK_WINDOW_XWINDOW (plug_window);#endif      xev.xexpose.x = 0;      xev.xexpose.y = 0;      xev.xexpose.width = allocation.width;      xev.xexpose.height = allocation.height;      xev.xexpose.count = 0;      gdk_error_trap_push ();      XSendEvent (GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (widget)),                  xev.xexpose.window,                  False, ExposureMask,                  &xev);      /* We have to sync to reliably catch errors from the XSendEvent(),       * since that is asynchronous.       */      XSync (xdisplay, False);#if GTK_CHECK_VERSION (3, 0, 0)      gdk_error_trap_pop_ignored ();#else      gdk_error_trap_pop ();#endif#else      /* Hiding and showing is the safe way to do it, but can result in more       * flickering.       */      gdk_window_hide (widget->window);      gdk_window_show (widget->window);#endif    }}

voidadd_local_active_child (GtkWidget *window){  Socket *socket;  socket = create_socket ();  gtk_box_pack_start (GTK_BOX (box), socket->box, TRUE, TRUE, 0);  gtk_widget_show (socket->box);  create_child_plug (gtk_socket_get_id (GTK_SOCKET (socket->socket)), TRUE);}

static char * get_display_string(visualizer_t * v)  {  char * ret;  GdkDisplay * dpy;  /* Get the display string */  gtk_widget_realize(v->normal_window.socket);  gtk_widget_realize(v->fullscreen_window.socket);  dpy = gdk_display_get_default();    //  ret = bg_sprintf("%s:%08lx:%08lx", gdk_display_get_name(dpy),  //                   GDK_WINDOW_XID(v->normal_window.window->window),  //                   GDK_WINDOW_XID(v->fullscreen_window.window->window));  ret =    bg_sprintf("%s:%08lx:%08lx", gdk_display_get_name(dpy),               (long unsigned int)gtk_socket_get_id(GTK_SOCKET(v->normal_window.socket)),               (long unsigned int)gtk_socket_get_id(GTK_SOCKET(v->fullscreen_window.socket)));    return ret;  }

intclip_GTK_SOCKETGETID(ClipMachine * cm){	C_widget *csocket = _fetch_cw_arg(cm);	CHECKCWID(csocket,GTK_IS_SOCKET);	_clip_retni(cm, gtk_socket_get_id(GTK_SOCKET(csocket->widget)));	return 0;err:	return 1;}

voidadd_local_passive_child (GtkWidget *window){  Socket *socket;  Window xid;  socket = create_socket ();  gtk_box_pack_start (GTK_BOX (box), socket->box, TRUE, TRUE, 0);  gtk_widget_show (socket->box);  xid = create_child_plug (0, TRUE);  gtk_socket_add_id (GTK_SOCKET (socket->socket), xid);}

/* [gtk thread] */static gboolean do_create_display_hook(gpointer data){   const ARGS_CREATE *args = _al_gtk_lock_args(data);   ALLEGRO_DISPLAY *display = (ALLEGRO_DISPLAY *)args->display;   ALLEGRO_DISPLAY_XGLX *d = args->display;   const int w = args->w;   const int h = args->h;   GtkWidget *window;   GtkWidget *vbox;   GtkWidget *socket;   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);   d->gtk->gtkwindow = window;   gtk_window_set_default_size(GTK_WINDOW(window), w, h);   g_signal_connect(G_OBJECT(window), "delete-event",      G_CALLBACK(xgtk_quit_callback), display);   g_signal_connect(G_OBJECT(window), "configure-event",      G_CALLBACK(xgtk_handle_configure_event), display);   vbox = gtk_vbox_new(FALSE, 0);   gtk_container_add(GTK_CONTAINER(window), vbox);   socket = gtk_socket_new();   d->gtk->gtksocket = socket;   gtk_box_pack_end(GTK_BOX(vbox), socket, TRUE, TRUE, 0);   gtk_socket_add_id(GTK_SOCKET(socket), d->window);   ALLEGRO_DEBUG("gtk_socket_add_id: window = %ld/n", d->window);   gtk_window_set_title(GTK_WINDOW(window), args->title);   gtk_widget_show_all(window);   if (display->flags & ALLEGRO_RESIZABLE) {      /* Allow socket widget to be resized smaller than initial size. */      gtk_widget_set_size_request(socket, -1, -1);      gtk_window_set_resizable(GTK_WINDOW(window), true);   }   else {      gtk_window_set_resizable(GTK_WINDOW(window), false);   }   if (display->flags & ALLEGRO_FULLSCREEN_WINDOW) {      gtk_window_fullscreen(GTK_WINDOW(window));   }   d->overridable_vt = &xgtk_override_vt;   return _al_gtk_release_args(data);}

/* FIXME: should we schedule the event or not?static gbooleanschedule_send_client_event (gpointer data){  GdkEvent *event = (GdkEvent*) data;  gdk_event_send_client_message (event, GDK_WINDOW_XID (event->client.window));  gdk_event_free (event);  return FALSE;}*/static void on_size_alloc (AwnAppletProxy *proxy, GtkAllocation *alloc){  AwnAppletProxyPrivate *priv;  GtkWidget *parent;  GtkAllocation parent_alloc;  GdkWindow *plug_win;  g_return_if_fail (AWN_IS_APPLET_PROXY (proxy));  priv = proxy->priv;  parent = gtk_widget_get_parent (GTK_WIDGET (proxy));  gtk_widget_get_allocation (parent, &parent_alloc);  gint pos_x = alloc->x;  gint pos_y = alloc->y;  gint rel_x = pos_x - parent_alloc.x;  gint rel_y = pos_y - parent_alloc.y;  gint parent_w = parent_alloc.width;  gint parent_h = parent_alloc.height;  if (pos_x == priv->old_x && pos_y == priv->old_y      && parent_w == priv->old_w && parent_h == priv->old_h) return;  priv->old_x = pos_x;  priv->old_y = pos_y;  priv->old_w = parent_w;  priv->old_h = parent_h;  /* Only directly access the struct member if we have to. */  plug_win = gtk_socket_get_plug_window (GTK_SOCKET (proxy));  if (plug_win)  {    GdkAtom msg_type = gdk_atom_intern("_AWN_APPLET_POS_CHANGE", FALSE);    GdkEvent *event = gdk_event_new (GDK_CLIENT_EVENT);    event->client.window = g_object_ref (plug_win);    event->client.data_format = 32;    event->client.message_type = msg_type;    // first two longs are our relative [x, y]    event->client.data.l[0] = rel_x;    event->client.data.l[1] = rel_y;    // other two longs are our parent's [w, h]    event->client.data.l[2] = parent_w;    event->client.data.l[3] = parent_h;    gdk_event_send_client_message (event, GDK_WINDOW_XID (plug_win));    gdk_event_free (event);    /* g_idle_add (schedule_send_client_event, event); */  }}

static voidcinnamon_tray_icon_constructed (GObject *object){  GdkWindow *icon_app_window;  CinnamonTrayIcon *icon = CINNAMON_TRAY_ICON (object);  CinnamonEmbeddedWindow *window;  GdkDisplay *display;  Window plug_xid;  Atom _NET_WM_PID, type;  int result, format;  gulong nitems, bytes_after, *val = NULL;  /* We do all this now rather than computing it on the fly later,   * because Cinnamon may want to see their values from a   * tray-icon-removed signal handler, at which point the plug has   * already been removed from the socket.   */  g_object_get (object, "window", &window, NULL);  g_return_if_fail (window != NULL);  icon->priv->socket = NA_TRAY_CHILD (gtk_bin_get_child (GTK_BIN (window)));  g_object_unref (window);  icon->priv->title = na_tray_child_get_title (icon->priv->socket);  na_tray_child_get_wm_class (icon->priv->socket, NULL, &icon->priv->wm_class);  icon_app_window = gtk_socket_get_plug_window (GTK_SOCKET (icon->priv->socket));  if (icon_app_window == NULL)    {      g_warning ("cinnamon tray: icon app window is gone");      return;    }  plug_xid = GDK_WINDOW_XID (icon_app_window);  display = gtk_widget_get_display (GTK_WIDGET (icon->priv->socket));  gdk_error_trap_push ();  _NET_WM_PID = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_PID");  result = XGetWindowProperty (GDK_DISPLAY_XDISPLAY (display), plug_xid,                               _NET_WM_PID, 0, G_MAXLONG, False, XA_CARDINAL,                               &type, &format, &nitems,                               &bytes_after, (guchar **)&val);  if (!gdk_error_trap_pop () &&      result == Success &&      type == XA_CARDINAL &&      nitems == 1)    icon->priv->pid = *val;  if (val)    XFree (val);}

voidnew_tab_page(struct Gtkabber *gtkabber, GtkWidget *socket){	gtk_widget_show( socket );	gtk_notebook_append_page( GTK_NOTEBOOK(gtkabber->toplevel.notebook),			socket, NULL );	gtk_notebook_set_current_page( GTK_NOTEBOOK(gtkabber->toplevel.notebook), -1 );	gtk_notebook_set_tab_reorderable (GTK_NOTEBOOK(				gtkabber->toplevel.notebook), socket, TRUE);	printf("%d/n", gtk_socket_get_id( GTK_SOCKET( socket ) ) );	fflush(stdout);}