static void
egg_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);
}
static void
gtk_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);
}
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 gint
luaH_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;
}
void
add_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);
}
int
clip_GTK_SOCKETADDID(ClipMachine * cm)
{
C_widget *csocket = _fetch_cw_arg(cm);
GdkNativeWindow id = _clip_parni(cm, 2);
CHECKCWID(csocket,GTK_IS_SOCKET);
CHECKARG(2, NUMERIC_t);
gtk_socket_add_id(GTK_SOCKET(csocket->widget), id);
return 0;
err:
return 1;
}
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/staticFuncs/configure
* AUTHOR
* PGB
* SOURCE
*/
static int configure ( Tcl_Interp *interp, GtkSocket *socket,
GnoclOption options[] )
{
if ( options[plugIDIdx].status == GNOCL_STATUS_CHANGED )
{
long xid;
if ( Tcl_GetLongFromObj ( interp, options[plugIDIdx].val.obj, &xid )
!= TCL_OK )
return TCL_ERROR;
gtk_socket_add_id ( socket, xid );
}
return TCL_OK;
}
static void
realize_cb (GtkWidget *socket, gpointer user_data)
{
GtkWidget *plug, *w;
g_warning ("Realize");
plug = gtk_plug_new (0);
w = gtk_button_new_with_label ("Baa");
gtk_widget_show_all (w);
gtk_widget_show (plug);
gtk_container_add (GTK_CONTAINER (plug), w);
GTK_PLUG (plug)->socket_window = GTK_WIDGET (socket)->window;
gtk_socket_add_id (GTK_SOCKET (socket),
gtk_plug_get_id (GTK_PLUG (plug)));
gdk_window_show (GTK_WIDGET (plug)->window);
}
static void
na_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);
}
static gboolean
child_read_watch (GIOChannel *channel, GIOCondition cond, gpointer data)
{
GIOStatus status;
GError *error = NULL;
char *line;
gsize term;
int xid;
status = g_io_channel_read_line (channel, &line, NULL, &term, &error);
switch (status)
{
case G_IO_STATUS_NORMAL:
line[term] = '\0';
xid = strtol (line, NULL, 0);
if (xid == 0)
{
fprintf (stderr, "Invalid window id '%s'\n", line);
}
else
{
Socket *socket = create_socket ();
gtk_box_pack_start (GTK_BOX (box), socket->box, TRUE, TRUE, 0);
gtk_widget_show (socket->box);
gtk_socket_add_id (GTK_SOCKET (socket->socket), xid);
}
g_free (line);
return TRUE;
case G_IO_STATUS_AGAIN:
return TRUE;
case G_IO_STATUS_EOF:
n_children--;
return FALSE;
case G_IO_STATUS_ERROR:
fprintf (stderr, "Error reading fd from child: %s\n", error->message);
exit (1);
return FALSE;
default:
g_assert_not_reached ();
return FALSE;
}
}
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());
}
void
notebook_swallow_childs (void)
{
guint i, n_tabs;
n_tabs = g_slist_length (options.notebook_data.tabs);
/* wait until all children are register */
while (tabs[0].xid != n_tabs)
usleep (1000);
for (i = 1; i <= n_tabs; i++)
{
GtkWidget *s =
GTK_WIDGET (g_object_get_data
(G_OBJECT (gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook), i - 1)), "socket"));
if (tabs[i].pid != -1)
gtk_socket_add_id (GTK_SOCKET (s), tabs[i].xid);
}
}
static gboolean
remmina_plugin_nx_start_session (RemminaProtocolWidget *gp)
{
RemminaPluginNxData *gpdata;
RemminaFile *remminafile;
RemminaNXSession *nx;
const gchar *type, *app;
gchar *s1, *s2;
gint port;
gint ret;
gboolean is_empty_list;
gint event_type = 0;
const gchar *cs;
gint i;
gpdata = (RemminaPluginNxData*) g_object_get_data (G_OBJECT (gp), "plugin-data");
remminafile = remmina_plugin_nx_service->protocol_plugin_get_file (gp);
nx = gpdata->nx;
/* Connect */
remmina_nx_session_set_encryption (nx,
remmina_plugin_nx_service->file_get_int (remminafile, "disableencryption", FALSE) ? 0 : 1);
remmina_nx_session_set_localport (nx, remmina_plugin_nx_service->pref_get_sshtunnel_port ());
remmina_nx_session_set_log_callback (nx, remmina_plugin_nx_service->log_printf);
s2 = remmina_plugin_nx_service->protocol_plugin_start_direct_tunnel (gp, 22, FALSE);
if (s2 == NULL)
{
return FALSE;
}
remmina_plugin_nx_service->get_server_port (s2, 22, &s1, &port);
g_free (s2);
if (!remmina_nx_session_open (nx, s1, port,
remmina_plugin_nx_service->file_get_string (remminafile, "nx_privatekey"),
remmina_plugin_nx_ssh_auth_callback, gp))
{
g_free (s1);
return FALSE;
}
g_free (s1);
/* Login */
s1 = g_strdup (remmina_plugin_nx_service->file_get_string (remminafile, "username"));
THREADS_ENTER
s2 = remmina_plugin_nx_service->file_get_secret (remminafile, "password");
THREADS_LEAVE
if (s1 && s2)
{
ret = remmina_nx_session_login (nx, s1, s2);
}
else
{
g_free (s1);
g_free (s2);
THREADS_ENTER
ret = remmina_plugin_nx_service->protocol_plugin_init_authuserpwd (gp, FALSE);
THREADS_LEAVE
if (ret != GTK_RESPONSE_OK) return FALSE;
s1 = remmina_plugin_nx_service->protocol_plugin_init_get_username (gp);
s2 = remmina_plugin_nx_service->protocol_plugin_init_get_password (gp);
ret = remmina_nx_session_login (nx, s1, s2);
}
g_free (s1);
g_free (s2);
if (!ret) return FALSE;
THREADS_ENTER
remmina_plugin_nx_service->protocol_plugin_init_save_cred (gp);
THREADS_LEAVE
/* Prepare the session type and application */
cs = remmina_plugin_nx_service->file_get_string (remminafile, "exec");
if (!cs || g_strcmp0 (cs, "GNOME") == 0)
{
type = "unix-gnome";
app = NULL;
}
else if (g_strcmp0 (cs, "KDE") == 0)
{
type = "unix-kde";
app = NULL;
}
else if (g_strcmp0 (cs, "Xfce") == 0)
{
/* NX does not know Xfce. So we simply launch the Xfce startup program. */
type = "unix-application";
app = "startxfce4";
}
else if (g_strcmp0 (cs, "Shadow") == 0)
{
type = "shadow";
app = NULL;
}
else
{
type = "unix-application";
app = cs;
}
/* List sessions */
gpdata->attach_session = (g_strcmp0 (type, "shadow") == 0);
while (1)
{
remmina_nx_session_add_parameter (nx, "type", type);
if (!gpdata->attach_session)
{
remmina_nx_session_add_parameter (nx, "user", remmina_plugin_nx_service->file_get_string (remminafile, "username"));
remmina_nx_session_add_parameter (nx, "status", "suspended,running");
}
if (!remmina_nx_session_list (nx))
{
return FALSE;
}
is_empty_list = !remmina_nx_session_iter_first (nx, &gpdata->iter);
if (is_empty_list && !gpdata->manager_started && !gpdata->attach_session)
{
event_type = REMMINA_NX_EVENT_START;
}
else
{
remmina_nx_session_manager_start (gp);
event_type = remmina_plugin_nx_wait_signal (gpdata);
if (event_type == REMMINA_NX_EVENT_CANCEL)
{
return FALSE;
}
if (event_type == REMMINA_NX_EVENT_TERMINATE)
{
if (!is_empty_list)
{
s1 = remmina_nx_session_iter_get (nx, &gpdata->iter, REMMINA_NX_SESSION_COLUMN_ID);
remmina_nx_session_add_parameter (nx, "sessionid", s1);
g_free (s1);
if (!remmina_nx_session_terminate (nx))
{
remmina_nx_session_manager_start (gp);
remmina_plugin_nx_wait_signal (gpdata);
}
}
continue;
}
}
break;
}
/* Start, Restore or Attach, based on the setting and existing session */
remmina_nx_session_add_parameter (nx, "type", type);
i = remmina_plugin_nx_service->file_get_int (remminafile, "quality", 0);
remmina_nx_session_add_parameter (nx, "link",
i > 2 ? "lan" :
i == 2 ? "adsl" :
i == 1 ? "isdn" : "modem");
remmina_nx_session_add_parameter (nx, "geometry", "%ix%i",
remmina_plugin_nx_service->file_get_int (remminafile, "resolution_width", 0),
remmina_plugin_nx_service->file_get_int (remminafile, "resolution_height", 0));
remmina_nx_session_add_parameter (nx, "keyboard", remmina_kbtype);
remmina_nx_session_add_parameter (nx, "client", "linux");
remmina_nx_session_add_parameter (nx, "media", "0");
remmina_nx_session_add_parameter (nx, "clipboard",
remmina_plugin_nx_service->file_get_int (remminafile, "disableclipboard", FALSE) ? "none" : "both");
switch (event_type)
{
case REMMINA_NX_EVENT_START:
if (app) remmina_nx_session_add_parameter (nx, "application", app);
remmina_nx_session_add_parameter (nx, "session", remmina_plugin_nx_service->file_get_string (remminafile, "name"));
remmina_nx_session_add_parameter (nx, "screeninfo", "%ix%ix24+render",
remmina_plugin_nx_service->file_get_int (remminafile, "resolution_width", 0),
remmina_plugin_nx_service->file_get_int (remminafile, "resolution_height", 0));
if (!remmina_nx_session_start (nx)) return FALSE;
break;
case REMMINA_NX_EVENT_ATTACH:
s1 = remmina_nx_session_iter_get (nx, &gpdata->iter, REMMINA_NX_SESSION_COLUMN_ID);
remmina_nx_session_add_parameter (nx, "id", s1);
g_free (s1);
s1 = remmina_nx_session_iter_get (nx, &gpdata->iter, REMMINA_NX_SESSION_COLUMN_DISPLAY);
remmina_nx_session_add_parameter (nx, "display", s1);
g_free (s1);
if (!remmina_nx_session_attach (nx)) return FALSE;
break;
case REMMINA_NX_EVENT_RESTORE:
s1 = remmina_nx_session_iter_get (nx, &gpdata->iter, REMMINA_NX_SESSION_COLUMN_ID);
remmina_nx_session_add_parameter (nx, "id", s1);
g_free (s1);
remmina_nx_session_add_parameter (nx, "session", remmina_plugin_nx_service->file_get_string (remminafile, "name"));
if (!remmina_nx_session_restore (nx)) return FALSE;
break;
default:
return FALSE;
}
if (!remmina_nx_session_tunnel_open (nx)) return FALSE;
if (!remmina_plugin_nx_start_create_notify (gp)) return FALSE;
/* nxproxy */
if (!remmina_nx_session_invoke_proxy (nx, -1, remmina_plugin_nx_on_proxy_exit, gp)) return FALSE;
/* get the window id of the remote nxagent */
if (!remmina_plugin_nx_monitor_create_notify (gp, "nxagent")) return FALSE;
/* embed it */
THREADS_ENTER
gtk_socket_add_id (GTK_SOCKET (gpdata->socket), gpdata->window_id);
THREADS_LEAVE
return TRUE;
}
static void
na_tray_manager_handle_dock_request (NaTrayManager *manager,
XClientMessageEvent *xevent)
{
GtkWidget *socket;
Window *window;
GtkRequisition req;
if (g_hash_table_lookup (manager->socket_table, GINT_TO_POINTER (xevent->data.l[2])))
{
/* We already got this notification earlier, ignore this one */
return;
}
socket = gtk_socket_new ();
gtk_widget_set_app_paintable (socket, TRUE);
//FIXME: need to find a theme where this (and expose event) is needed
gtk_widget_set_double_buffered (socket, FALSE);
g_signal_connect (socket, "realize",
G_CALLBACK (na_tray_manager_make_socket_transparent), NULL);
g_signal_connect (socket, "expose_event",
G_CALLBACK (na_tray_manager_socket_exposed), NULL);
g_signal_connect_after (socket, "style_set",
G_CALLBACK (na_tray_manager_socket_style_set), NULL);
/* 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),
"na-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 (na_tray_manager_plug_removed), manager);
gtk_socket_add_id (GTK_SOCKET (socket), *window);
g_hash_table_insert (manager->socket_table, GINT_TO_POINTER (*window), socket);
/*
* Make sure the icons have a meaningfull size ...
*/
req.width = req.height = 1;
gtk_widget_size_request (socket, &req);
/*
if ((req.width < 16) || (req.height < 16))
{
gint nw = MAX (24, req.width);
gint nh = MAX (24, req.height);
g_warning (_("tray icon has requested a size of (%i x %i), resizing to (%i x %i)"),
req.width, req.height, nw, nh);
gtk_widget_set_size_request(icon, nw, nh);
}
*/
gtk_widget_show(socket);
}
else
gtk_widget_destroy (socket);
}
/* phone_embed */
static void _phone_embed(GtkWidget * widget, unsigned long window)
{
gtk_socket_add_id(GTK_SOCKET(widget), window);
}
static void
egg_tray_manager_handle_dock_request(EggTrayManager *manager,
XClientMessageEvent *xevent)
{
GtkWidget *socket;
Window *window;
ENTER;
socket = gtk_socket_new ();
gtk_widget_set_app_paintable (socket, TRUE);
gtk_widget_set_double_buffered (socket, FALSE);
gtk_widget_add_events (socket, GDK_EXPOSURE_MASK);
g_signal_connect (socket, "realize",
G_CALLBACK (egg_tray_manager_make_socket_transparent), NULL);
g_signal_connect (socket, "expose_event",
G_CALLBACK (egg_tray_manager_socket_exposed), NULL);
g_signal_connect_after (socket, "style_set",
G_CALLBACK (egg_tray_manager_socket_style_set), NULL);
gtk_widget_show (socket);
/* 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];
DBG("plug window %lx\n", *window);
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)))) {
GtkRequisition req;
XWindowAttributes wa;
DBG("socket has window. going on\n");
gtk_socket_add_id(GTK_SOCKET (socket), xevent->data.l[2]);
g_signal_connect(socket, "plug_removed",
G_CALLBACK(egg_tray_manager_plug_removed), manager);
gdk_error_trap_push();
XGetWindowAttributes(GDK_DISPLAY(), *window, &wa);
if (gdk_error_trap_pop()) {
ERR("can't embed window %lx\n", xevent->data.l[2]);
goto error;
}
g_hash_table_insert(manager->socket_table,
GINT_TO_POINTER(xevent->data.l[2]), socket);
req.width = req.height = 1;
gtk_widget_size_request(socket, &req);
RET();
}
error:
DBG("socket has NO window. destroy it\n");
g_signal_emit(manager, manager_signals[TRAY_ICON_REMOVED], 0,
socket);
gtk_widget_destroy(socket);
RET();
}
