/***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 );
}
GtkWidget *
notebook_create_widget (GtkWidget * dlg)
{
GtkWidget *w;
GSList *tab;
/* get shared memory */
tabs = get_tabs (options.common_data.key, TRUE);
if (!tabs)
exit (-1);
/* create widget */
w = notebook = gtk_notebook_new ();
gtk_notebook_set_tab_pos (GTK_NOTEBOOK (w), options.notebook_data.pos);
gtk_container_set_border_width (GTK_CONTAINER (w), 5);
/* add tabs */
for (tab = options.notebook_data.tabs; tab; tab = tab->next)
{
GtkWidget *a, *s;
a = gtk_alignment_new (0.5, 0.5, 1, 1);
gtk_alignment_set_padding (GTK_ALIGNMENT (a),
options.notebook_data.borders, options.notebook_data.borders,
options.notebook_data.borders, options.notebook_data.borders);
s = gtk_socket_new ();
gtk_container_add (GTK_CONTAINER (a), s);
g_object_set_data (G_OBJECT (a), "socket", s);
gtk_notebook_append_page (GTK_NOTEBOOK (w), a, get_label ((gchar *) tab->data, 0));
}
return w;
}
void
setup_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 );
}
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 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);
}
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::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 Socket *
create_socket (void)
{
GtkWidget *label;
Socket *socket = g_new (Socket, 1);
socket->box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
socket->socket = gtk_socket_new ();
gtk_box_pack_start (GTK_BOX (socket->box), socket->socket, TRUE, TRUE, 0);
socket->frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (socket->frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (socket->box), socket->frame, TRUE, TRUE, 0);
gtk_widget_show (socket->frame);
label = gtk_label_new (NULL);
gtk_label_set_markup (GTK_LABEL (label), "<span color=\"red\">Empty</span>");
gtk_container_add (GTK_CONTAINER (socket->frame), label);
gtk_widget_show (label);
sockets = g_slist_prepend (sockets, socket);
g_signal_connect (socket->socket, "destroy",
G_CALLBACK (socket_destroyed), socket);
g_signal_connect (socket->socket, "plug_added",
G_CALLBACK (plug_added), socket);
g_signal_connect (socket->socket, "plug_removed",
G_CALLBACK (plug_removed), socket);
return socket;
}
PlayerBackend * playerbackend_init(Player * player)
{
PlayerBackend * backend;
#if GTK_CHECK_VERSION(3, 0, 0)
const GdkRGBA black = { 0.0, 0.0, 0.0, 0.0 };
#else
const GdkColor black = { 0, 0, 0, 0 };
#endif
if((backend = object_new(sizeof(*backend))) == NULL)
return NULL;
_player = backend;
backend->player = player;
backend->view = gtk_socket_new();
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_override_background_color(backend->view,
GTK_STATE_FLAG_NORMAL, &black);
#else
gtk_widget_modify_bg(backend->view, GTK_STATE_NORMAL, &black);
#endif
g_signal_connect_swapped(backend->view, "plug-removed",
G_CALLBACK(_init_on_plug_removed), backend);
backend->pid = -1;
memset(&backend->fd, 0, sizeof(backend->fd));
backend->buf = NULL;
backend->buf_len = 0;
backend->read_id = 0;
backend->write_id = 0;
backend->timeout_id = 0;
playerbackend_reset(backend);
_init_signal();
return backend;
}
static void
remmina_plugin_nx_init (RemminaProtocolWidget *gp)
{
RemminaPluginNxData *gpdata;
gint flags;
gpdata = g_new0 (RemminaPluginNxData, 1);
g_object_set_data_full (G_OBJECT (gp), "plugin-data", gpdata, g_free);
gpdata->socket = gtk_socket_new ();
remmina_plugin_nx_service->protocol_plugin_register_hostkey (gp, gpdata->socket);
gtk_widget_show (gpdata->socket);
g_signal_connect (G_OBJECT (gpdata->socket), "plug-added",
G_CALLBACK (remmina_plugin_nx_on_plug_added), gp);
g_signal_connect (G_OBJECT (gpdata->socket), "plug-removed",
G_CALLBACK (remmina_plugin_nx_on_plug_removed), gp);
gtk_container_add (GTK_CONTAINER (gp), gpdata->socket);
if (pipe (gpdata->event_pipe))
{
g_print ("Error creating pipes.\n");
gpdata->event_pipe[0] = -1;
gpdata->event_pipe[1] = -1;
}
else
{
flags = fcntl (gpdata->event_pipe[0], F_GETFL, 0);
fcntl (gpdata->event_pipe[0], F_SETFL, flags | O_NONBLOCK);
}
}
static void
awn_ua_alignment_init (AwnUAAlignment *self)
{
AwnUAAlignmentPrivate *priv;
priv = AWN_UA_ALIGNMENT_GET_PRIVATE (self);
priv->socket = gtk_socket_new ();
}
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;
}
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 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);
}
/* [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);
}
gint main(gint argc, gchar *argv[])
{
GtkWidget *window;
GtkWidget *hbox;
GtkWidget *button;
//GtkWidget *button2;
GtkWidget *socket;
gtk_init(&argc, &argv);
/*window*/
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(delete_event), NULL);
gtk_window_set_title(GTK_WINDOW(window), "hello world2");
gtk_container_set_border_width(GTK_CONTAINER(window),50);
/*hbox*/
hbox = gtk_hbox_new(FALSE,0);
gtk_container_add(GTK_CONTAINER(window), hbox);
/*button1*/
button = gtk_button_new_with_label("button1");
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(callback), "button1");
gtk_box_pack_start(GTK_BOX(hbox), button,
TRUE, TRUE, 0);
/*button2*/
button = gtk_button_new();
/*g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(callback), "button2");*/
gtk_box_pack_start(GTK_BOX(hbox), button,
TRUE, TRUE, 0);
socket = gtk_socket_new ();
gtk_widget_show (socket);
gtk_container_add (GTK_CONTAINER (button), socket);
gtk_widget_show_all(window);
gtk_widget_realize (socket);/*这句话放在show后面，放在showall前面实践过了之后也行,不用这个好像也行*/
/* The following call is only necessary if one of
* * the ancestors of the socket is not yet visible.
* */
/*最好不用这样的数字输出，否则这个号码无法在Plug中应用。*/
/*g_print ("The ID of the sockets window is %x\n",
gtk_socket_get_id (socket));*/
g_print ("The ID of the sockets window is %d\n",
gtk_socket_get_id (socket));
gtk_main();
return 0;
}
widget_t *
widget_socket(widget_t *w, luapdf_token_t UNUSED(token))
{
w->index = luaH_socket_index;
w->newindex = luaH_socket_newindex;
w->destructor = widget_destructor;
w->widget = gtk_socket_new();
g_object_set_data(G_OBJECT(w->widget), "lua_widget", (gpointer) w);
gtk_widget_show(w->widget);
g_object_connect(G_OBJECT(w->widget),
"signal::plug-added", G_CALLBACK(plug_added_cb), w,
"signal::plug-removed", G_CALLBACK(plug_removed_cb), w,
NULL);
return w;
}
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());
}
int main(int argc, char *argv[])
{
GtkWidget *box, *window;
GtkWidget *button, *plugin;
if (argc > 1) {
snprintf(embed_attrib_buf, sizeof(embed_attrib_buf), "src='%s' type='application/x-shockwave-flash''", argv[1]);
embed_attrib_p = embed_attrib_buf;
}
gtk_init(&argc, &argv);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window), "NS Plugin Runner");
g_signal_connect(G_OBJECT(window), "delete_event",
G_CALLBACK(delete_event), NULL);
gtk_container_set_border_width(GTK_CONTAINER(window), 2);
gtk_window_resize(GTK_WINDOW(window), 610, 510);
gtk_widget_show(window);
box = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(window), box);
gtk_widget_show(box);
button = gtk_button_new_with_label("run");
gtk_box_pack_start(GTK_BOX(box), button, FALSE, TRUE, 0);
gtk_widget_show(button);
plugin = gtk_socket_new();
gtk_box_pack_start(GTK_BOX(box), plugin, TRUE, TRUE, 0);
gtk_widget_show(plugin);
g_signal_connect(G_OBJECT(button), "clicked",
G_CALLBACK(callback), (void*)plugin);
gtk_main ();
if (playing) {
plugin_Shutdown(&npp);
playing = 0;
}
return 0;
}
/* phone_init */
static Phone * _phone_init(PanelAppletHelper * helper, GtkWidget ** widget)
{
Phone * phone;
if((phone = malloc(sizeof(*phone))) == NULL)
{
error_set("%s: %s", applet.name, strerror(errno));
return NULL;
}
phone->helper = helper;
phone->widget = gtk_socket_new();
g_signal_connect(phone->widget, "plug-added", G_CALLBACK(
_phone_on_plug_added), NULL);
g_signal_connect(phone->widget, "plug-removed", G_CALLBACK(
_phone_on_plug_removed), NULL);
phone->source = g_signal_connect(phone->widget, "screen-changed",
G_CALLBACK(_phone_on_screen_changed), NULL);
*widget = phone->widget;
return phone;
}
/**** SOCKET constructor ****/
int
clip_GTK_SOCKETNEW(ClipMachine * cm)
{
ClipVar * cv = _clip_spar(cm, 1);
GtkWidget *wid = NULL;
C_widget *cwid ;
CHECKOPT(1,MAP_t);
wid = gtk_socket_new();
if (!wid) goto err;
cwid = _register_widget(cm, wid, cv);
_clip_mclone(cm,RETPTR(cm),&cwid->obj);
return 0;
err:
return 1;
}
bool NetscapePlugin::platformPostInitializeWindowed(bool needsXEmbed, uint64_t windowID)
{
m_npWindow.type = NPWindowTypeWindow;
if (!needsXEmbed) {
notImplemented();
return false;
}
Display* display = x11HostDisplay();
#if PLATFORM(GTK)
// 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));
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);
m_npWindow.window = GINT_TO_POINTER(gtk_socket_get_id(GTK_SOCKET(socket)));
GdkWindow* window = gtk_widget_get_window(socket);
NPSetWindowCallbackStruct* callbackStruct = static_cast<NPSetWindowCallbackStruct*>(m_npWindow.ws_info);
callbackStruct->display = GDK_WINDOW_XDISPLAY(window);
callbackStruct->visual = GDK_VISUAL_XVISUAL(gdk_window_get_visual(window));
callbackStruct->depth = gdk_visual_get_depth(gdk_window_get_visual(window));
callbackStruct->colormap = XCreateColormap(display, GDK_ROOT_WINDOW(), callbackStruct->visual, AllocNone);
#else
UNUSED_PARAM(windowID);
#endif
XFlush(display);
callSetWindow();
return true;
}
/* embed_get_widget */
static GtkWidget * _embed_get_widget(Embed * embed, PresenterSlide * slide)
{
GtkWidget * ret;
GtkWidget * widget;
#if GTK_CHECK_VERSION(3, 0, 0)
ret = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
#else
ret = gtk_vbox_new(FALSE, 4);
#endif
/* FIXME really implement */
widget = gtk_label_new("<Insert title here>");
gtk_widget_modify_fg(widget, GTK_STATE_NORMAL,
&embed->helper->foreground);
gtk_box_pack_start(GTK_BOX(ret), widget, FALSE, TRUE, 0);
widget = gtk_socket_new();
gtk_widget_modify_bg(widget, GTK_STATE_NORMAL,
&embed->helper->background);
gtk_box_pack_start(GTK_BOX(ret), widget, TRUE, TRUE, 0);
gtk_widget_show_all(ret);
return ret;
}
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();
}
int destination_address(struct navit *nav)
{
GtkWidget *window2, *keyboard, *vbox, *table;
GtkWidget *label_country;
GtkWidget *label_postal, *label_city, *label_district;
GtkWidget *label_street, *label_number;
GtkWidget *hseparator1,*hseparator2;
GtkWidget *button1,*button2,*button3;
int i;
struct search_param *search=&search_param;
struct attr search_attr, country_name, *country_attr;
struct tracking *tracking;
struct country_search *cs;
struct item *item;
GtkTreeSelection* selection;
search->nav=nav;
search->ms=navit_get_mapset(nav);
search->sl=search_list_new(search->ms);
window2 = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window2),_("Enter Destination"));
vbox = gtk_vbox_new(FALSE, 0);
table = gtk_table_new(3, 8, FALSE);
search->entry_country = gtk_entry_new();
label_country = gtk_label_new(_("Country"));
search->entry_postal = gtk_entry_new();
label_postal = gtk_label_new(_("Zip Code"));
search->entry_city = gtk_entry_new();
label_city = gtk_label_new(_("City"));
search->entry_district = gtk_entry_new();
label_district = gtk_label_new(_("District/Township"));
hseparator1 = gtk_vseparator_new();
search->entry_street = gtk_entry_new();
label_street = gtk_label_new(_("Street"));
search->entry_number = gtk_entry_new();
label_number = gtk_label_new(_("Number"));
search->listbox = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (search->listbox),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
// gtk_tree_view_set_model (GTK_TREE_VIEW (search->treeview), NULL);
{
GType types[COL_COUNT+2];
for(i=0;i<COL_COUNT;i++)
types[i]=G_TYPE_STRING;
types[i++]=G_TYPE_POINTER;
types[i++]=G_TYPE_POINTER;
search->liststore=gtk_list_store_newv(COL_COUNT+2,types);
search->liststore2=gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(search->liststore));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (search->liststore2), 0, GTK_SORT_ASCENDING);
// gtk_tree_view_set_model (GTK_TREE_VIEW (search->treeview), GTK_TREE_MODEL(search->liststore2));
search->treeview = gtk_tree_view_new_with_model(search->liststore2);
gtk_tree_view_set_search_column(GTK_TREE_VIEW (search->treeview),3);
}
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(search->listbox),search->treeview);
#if 1
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW (search->treeview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_SINGLE);
g_signal_connect(selection, "changed", G_CALLBACK(select_row), search);
// g_signal_connect(search->liststore, "row-activated", G_CALLBACK(select_row), search);
// g_signal_connect(search->liststore2, "row-activated", G_CALLBACK(select_row), search);
// g_signal_connect(search->treeview, "select-cursor-row", G_CALLBACK(select_row), search);
#endif
hseparator2 = gtk_vseparator_new();
button1 = gtk_button_new_with_label(_("Map"));
button2 = gtk_button_new_with_label(_("Bookmark"));
button3 = gtk_button_new_with_label(_("Destination"));
gtk_table_attach(GTK_TABLE(table), label_country, 0, 1, 0, 1, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_postal, 1, 2, 0, 1, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_city, 2, 3, 0, 1, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_country, 0, 1, 1, 2, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_postal, 1, 2, 1, 2, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_city, 2, 3, 1, 2, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_district, 0, 1, 2, 3, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_street, 1, 2, 2, 3, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_number, 2, 3, 2, 3, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_district, 0, 1, 3, 4, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_street, 1, 2, 3, 4, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_number, 2, 3, 3, 4, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->listbox, 0, 3, 4, 5, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
gtk_table_attach(GTK_TABLE(table), button1, 0, 1, 5, 6, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), button2, 1, 2, 5, 6, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), button3, 2, 3, 5, 6, GTK_FILL, GTK_FILL, 0, 0);
g_signal_connect(G_OBJECT(search->entry_country), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_postal), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_city), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_district), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_street), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_number), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(button1), "clicked", G_CALLBACK(button_map), search);
g_signal_connect(G_OBJECT(button2), "clicked", G_CALLBACK(button_bookmark), search);
g_signal_connect(G_OBJECT(button3), "clicked", G_CALLBACK(button_destination), search);
gtk_widget_grab_focus(search->entry_city);
gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 0);
keyboard=gtk_socket_new();
gtk_box_pack_end(GTK_BOX(vbox), keyboard, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(window2), vbox);
gtk_widget_show_all(window2);
// gtk_socket_steal(GTK_SOCKET(keyboard), spawn_xkbd("xkbd","-geometry 200x100"));
country_attr=country_default();
tracking=navit_get_tracking(nav);
if (tracking && tracking_get_current_attr(tracking, attr_country_id, &search_attr))
country_attr=&search_attr;
cs=country_search_new(country_attr, 0);
item=country_search_get_item(cs);
if (item && item_attr_get(item, attr_country_name, &country_name))
gtk_entry_set_text(GTK_ENTRY(search->entry_country), country_name.u.str);
country_search_destroy(cs);
return 0;
}
nsresult nsPluginNativeWindowGtk::CreateXEmbedWindow(bool aEnableXtFocus) {
NS_ASSERTION(!mSocketWidget,"Already created a socket widget!");
GdkDisplay *display = gdk_display_get_default();
GdkWindow *parent_win = gdk_x11_window_lookup_for_display(display, GetWindow());
mSocketWidget = gtk_socket_new();
//attach the socket to the container widget
gtk_widget_set_parent_window(mSocketWidget, parent_win);
// enable/disable focus event handlers,
// see plugin_window_filter_func() for details
g_object_set_data(G_OBJECT(mSocketWidget), "enable-xt-focus", (void *)aEnableXtFocus);
// 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), nullptr);
g_signal_connect(mSocketWidget, "unrealize",
G_CALLBACK(socket_unrealize_cb), nullptr);
g_signal_connect(mSocketWidget, "destroy",
G_CALLBACK(gtk_widget_destroyed), &mSocketWidget);
gpointer user_data = nullptr;
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.
// TODO GTK3
#if (MOZ_WIDGET_GTK == 2)
gdk_window_set_back_pixmap(gtk_widget_get_window(mSocketWidget), nullptr, FALSE);
#endif
// Resize before we show
SetAllocation();
gtk_widget_show(mSocketWidget);
gdk_flush();
SetWindow(gtk_socket_get_id(GTK_SOCKET(mSocketWidget)));
// Fill out the ws_info structure.
// (The windowless case is done in nsPluginFrame.cpp.)
GdkWindow *gdkWindow = gdk_x11_window_lookup_for_display(display, GetWindow());
if(!gdkWindow)
return NS_ERROR_FAILURE;
mWsInfo.display = GDK_WINDOW_XDISPLAY(gdkWindow);
#if (MOZ_WIDGET_GTK == 2)
mWsInfo.colormap = GDK_COLORMAP_XCOLORMAP(gdk_drawable_get_colormap(gdkWindow));
GdkVisual* gdkVisual = gdk_drawable_get_visual(gdkWindow);
mWsInfo.depth = gdkVisual->depth;
#else
mWsInfo.colormap = None;
GdkVisual* gdkVisual = gdk_window_get_visual(gdkWindow);
mWsInfo.depth = gdk_visual_get_depth(gdkVisual);
#endif
mWsInfo.visual = GDK_VISUAL_XVISUAL(gdkVisual);
return NS_OK;
}
int destination_address(struct navit *nav)
{
GtkWidget *window2, *keyboard, *vbox, *table;
GtkWidget *label_country;
GtkWidget *label_postal, *label_city, *label_district;
GtkWidget *label_street, *label_number;
GtkWidget *hseparator1,*hseparator2;
GtkWidget *button1,*button2,*button3;
int i;
struct search_param *search=&search_param;
search->nav=nav;
search->ms=navit_get_mapset(nav);
search->sl=search_list_new(search->ms);
window2 = gtk_window_new(GTK_WINDOW_TOPLEVEL);
vbox = gtk_vbox_new(FALSE, 0);
table = gtk_table_new(3, 8, FALSE);
search->entry_country = gtk_entry_new();
label_country = gtk_label_new(_("Country"));
search->entry_postal = gtk_entry_new();
label_postal = gtk_label_new(_("Zip Code"));
search->entry_city = gtk_entry_new();
label_city = gtk_label_new(_("City"));
search->entry_district = gtk_entry_new();
label_district = gtk_label_new(_("District/Township"));
hseparator1 = gtk_vseparator_new();
search->entry_street = gtk_entry_new();
label_street = gtk_label_new(_("Street"));
search->entry_number = gtk_entry_new();
label_number = gtk_label_new(_("Number"));
search->treeview=gtk_tree_view_new();
search->listbox = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (search->listbox),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_tree_view_set_model (GTK_TREE_VIEW (search->treeview), NULL);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(search->listbox),search->treeview);
{
GType types[COL_COUNT+1];
for(i=0;i<COL_COUNT;i++)
types[i]=G_TYPE_STRING;
types[i]=G_TYPE_POINTER;
search->liststore=gtk_list_store_newv(COL_COUNT+1,types);
search->liststore2=gtk_tree_model_sort_new_with_model(GTK_TREE_MODEL(search->liststore));
gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (search->liststore2), 0, GTK_SORT_ASCENDING);
gtk_tree_view_set_model (GTK_TREE_VIEW (search->treeview), GTK_TREE_MODEL(search->liststore2));
}
hseparator2 = gtk_vseparator_new();
button1 = gtk_button_new_with_label("Karte");
button2 = gtk_button_new_with_label("Bookmark");
button3 = gtk_button_new_with_label("Ziel");
gtk_table_attach(GTK_TABLE(table), label_country, 0, 1, 0, 1, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_postal, 1, 2, 0, 1, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_city, 2, 3, 0, 1, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_country, 0, 1, 1, 2, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_postal, 1, 2, 1, 2, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_city, 2, 3, 1, 2, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_district, 0, 1, 2, 3, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_street, 1, 2, 2, 3, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), label_number, 2, 3, 2, 3, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_district, 0, 1, 3, 4, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_street, 1, 2, 3, 4, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->entry_number, 2, 3, 3, 4, 0, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), search->listbox, 0, 3, 4, 5, GTK_FILL|GTK_EXPAND, GTK_FILL|GTK_EXPAND, 0, 0);
gtk_table_attach(GTK_TABLE(table), button1, 0, 1, 5, 6, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), button2, 1, 2, 5, 6, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(table), button3, 2, 3, 5, 6, GTK_FILL, GTK_FILL, 0, 0);
g_signal_connect(G_OBJECT(search->entry_country), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_postal), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_city), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_district), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_street), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(search->entry_number), "changed", G_CALLBACK(changed), search);
g_signal_connect(G_OBJECT(button1), "clicked", G_CALLBACK(button_map), search);
g_signal_connect(G_OBJECT(button2), "clicked", G_CALLBACK(button_bookmark), search);
g_signal_connect(G_OBJECT(button3), "clicked", G_CALLBACK(button_destination), search);
gtk_widget_grab_focus(search->entry_city);
gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 0);
keyboard=gtk_socket_new();
gtk_box_pack_end(GTK_BOX(vbox), keyboard, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(window2), vbox);
#if 0
g_signal_connect(G_OBJECT(listbox), "select-row", G_CALLBACK(select_row), NULL);
#endif
gtk_widget_show_all(window2);
gtk_socket_steal(GTK_SOCKET(keyboard), spawn_xkbd("xkbd","-geometry 200x100"));
return 0;
}
static gboolean
workrave_applet_fill(PanelApplet *applet)
{
GdkPixbuf *pixbuf = NULL;
GtkWidget *hbox = NULL;
BonoboUIComponent *ui = NULL;
PanelAppletOrient orient;
// Create menus.
panel_applet_setup_menu_from_file(applet, WORKRAVE_UIDATADIR, "GNOME_WorkraveApplet.xml", NULL,
workrave_applet_verbs, applet);
// Add listeners for menu toggle-items.
ui = panel_applet_get_popup_component(applet);
bonobo_ui_component_add_listener(ui, "ShowLog", showlog_callback, NULL);
bonobo_ui_component_add_listener(ui, "Normal", mode_callback, NULL);
bonobo_ui_component_add_listener(ui, "Suspended", mode_callback, NULL);
bonobo_ui_component_add_listener(ui, "Quiet", mode_callback, NULL);
panel_applet_set_flags(PANEL_APPLET(applet),
PANEL_APPLET_EXPAND_MINOR);
gtk_container_set_border_width(GTK_CONTAINER(applet), 0);
panel_applet_set_background_widget(applet, GTK_WIDGET(applet));
gtk_widget_set_events(GTK_WIDGET(applet),
gtk_widget_get_events(GTK_WIDGET(applet)) | GDK_BUTTON_PRESS_MASK);
g_signal_connect(G_OBJECT(applet), "button_press_event", G_CALLBACK(button_pressed),
g_applet);
// Socket.
g_applet->socket = gtk_socket_new();
gtk_container_set_border_width(GTK_CONTAINER(g_applet->socket), 0);
// Image
pixbuf = gdk_pixbuf_new_from_file(WORKRAVE_PKGDATADIR "/images/workrave-icon-medium.png", NULL);
g_applet->image = gtk_image_new_from_pixbuf(pixbuf);
// Signals.
g_signal_connect(g_applet->socket, "plug_removed", G_CALLBACK(plug_removed), NULL);
g_signal_connect(g_applet->socket, "plug_added", G_CALLBACK(plug_added), NULL);
g_signal_connect(G_OBJECT(applet), "change_orient", G_CALLBACK(change_orient), NULL);
// Container.
hbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(applet), hbox);
gtk_box_pack_end(GTK_BOX(hbox), g_applet->socket, TRUE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(hbox), g_applet->image, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 0);
g_applet->socket_id = gtk_socket_get_id(GTK_SOCKET(g_applet->socket));
g_applet->size = panel_applet_get_size(applet);
orient = panel_applet_get_orient(applet);
switch (orient)
{
case PANEL_APPLET_ORIENT_UP:
g_applet->orientation = 0;
break;
case PANEL_APPLET_ORIENT_RIGHT:
g_applet->orientation = 1;
break;
case PANEL_APPLET_ORIENT_DOWN:
g_applet->orientation = 2;
break;
case PANEL_APPLET_ORIENT_LEFT:
g_applet->orientation = 3;
break;
}
force_no_focus_padding(GTK_WIDGET(applet));
force_no_focus_padding(GTK_WIDGET(g_applet->socket));
force_no_focus_padding(GTK_WIDGET(g_applet->image));
force_no_focus_padding(GTK_WIDGET(hbox));
g_signal_connect(G_OBJECT(applet), "destroy", G_CALLBACK(workrave_applet_destroy), NULL);
g_signal_connect(G_OBJECT(hbox), "realize", G_CALLBACK(workrave_applet_realize), NULL);
g_signal_connect(G_OBJECT(hbox), "unrealize", G_CALLBACK(workrave_applet_unrealize), NULL);
gtk_widget_show(GTK_WIDGET(g_applet->image));
gtk_widget_show(GTK_WIDGET(g_applet->socket));
gtk_widget_show(GTK_WIDGET(hbox));
gtk_widget_show(GTK_WIDGET(applet));
g_signal_connect(G_OBJECT(applet), "size-allocate", G_CALLBACK(size_allocate), NULL);
g_signal_connect(G_OBJECT(applet), "change_background", G_CALLBACK(change_background), NULL);
return TRUE;
}
nsresult nsPluginNativeWindowGtk2::CreateXCompositedWindow() {
NS_ASSERTION(!mSocketWidget,"Already created a socket widget!");
mParentWindow = gtk_window_new(GTK_WINDOW_POPUP);
mSocketWidget = gtk_socket_new();
GdkWindow *parent_win = mParentWindow->window;
//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, "destroy",
G_CALLBACK(gtk_widget_destroyed), &mSocketWidget);
/*gpointer user_data = NULL;
gdk_window_get_user_data(parent_win, &user_data);
*/
GtkContainer *container = GTK_CONTAINER(mParentWindow);
gtk_container_add(container, mSocketWidget);
gtk_widget_realize(mSocketWidget);
// Resize before we show
SetAllocation();
gtk_widget_set_size_request (mSocketWidget, width, height);
/* move offscreen */
gtk_window_move (GTK_WINDOW(mParentWindow), width+1000, height+1000);
gtk_widget_show(mSocketWidget);
gtk_widget_show_all(mParentWindow);
/* store away a reference to the socketwidget */
mPlugWindow = (mSocketWidget);
gdk_flush();
window = (nsPluginPort *)gtk_socket_get_id(GTK_SOCKET(mSocketWidget));
/* This is useful if we still have the plugin window inline
* i.e. firefox vs. fennec */
// gdk_window_set_composited(mSocketWidget->window, TRUE);
if (!mDamage) {
/* we install a general handler instead of one specific to a particular window
* because we don't have a GdkWindow for the plugin window */
gdk_window_add_filter (parent_win, plugin_composite_filter_func, this);
int junk;
if (!XDamageQueryExtension (GDK_DISPLAY (), &xdamage_event_base, &junk))
printf ("This requires the XDamage extension");
mDamage = XDamageCreate(GDK_DISPLAY(), (Drawable)window, XDamageReportNonEmpty);
XCompositeRedirectWindow (GDK_DISPLAY(),
(Drawable)window,
CompositeRedirectManual);
/* this is a hack to avoid having flash causing a crash when it is unloaded.
* libplayback sets up dbus_connection_filters. When flash is unloaded it takes
* libplayback with it, however the connection filters are not removed
* which causes a crash when dbus tries to execute them. dlopening libplayback
* ensures that those functions stay around even after flash is gone. */
static void *libplayback_handle;
if (!libplayback_handle) {
libplayback_handle = dlopen("libplayback-1.so.0", RTLD_NOW);
}
}
// Fill out the ws_info structure.
// (The windowless case is done in nsObjectFrame.cpp.)
GdkWindow *gdkWindow = gdk_window_lookup((XID)window);
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;
}
int main(int argc, char **argv)
{
struct gtkwave_dual_ipc_t *dual_ctx;
char buf[257], buf2[257];
int shmid;
GtkWidget *main_vbox, *mainwindow, *vpan;
int i;
int split_point = -1;
#ifdef __MINGW32__
char mapName[65];
HANDLE hMapFile;
#endif
GtkWidget *xsocket[2] = { NULL, NULL };
WAVE_LOCALE_FIX
if(!gtk_init_check(&argc, &argv))
{
printf("Could not initialize GTK! Is DISPLAY env var/xhost set?\n\n");
exit(255);
}
#ifdef __CYGWIN__
fprintf(stderr, "TWINWAVE| If the viewer crashes with a Bad system call error,\n");
fprintf(stderr, "TWINWAVE| make sure that Cygserver is enabled.\n");
#endif
for(i=0;i<argc;i++)
{
if(!strcmp(argv[i], "+"))
{
split_point = i;
break;
}
if(!strcmp(argv[i], "++"))
{
split_point = i;
use_embedded = 0;
break;
}
}
if(split_point < 0)
{
printf("Usage:\n------\n%s arglist1 separator arglist2\n\n"
"The '+' between argument lists splits and creates one window.\n"
"The '++' between argument lists splits and creates two windows.\n"
"\n", argv[0]);
exit(255);
}
mainwindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(mainwindow), "TwinWave Initializing");
#ifndef MAC_INTEGRATION
gtk_widget_set_usize(GTK_WIDGET(mainwindow), 820, 800);
#else
gtk_widget_set_usize(GTK_WIDGET(mainwindow), 400,32); /* quartz doesn't retarget into mainwindow */
#endif
gtk_widget_show(mainwindow);
gtk_signal_connect(GTK_OBJECT(mainwindow), "destroy", GTK_SIGNAL_FUNC(quit_callback), "WM destroy");
xsocket[0] = gtk_socket_new ();
xsocket[1] = gtk_socket_new ();
gtk_widget_show (xsocket[0]);
gtk_widget_show (xsocket[1]);
gtk_signal_connect(GTK_OBJECT(xsocket[0]), "plug-removed", GTK_SIGNAL_FUNC(plug_removed), NULL);
main_vbox = gtk_vbox_new(FALSE, 5);
gtk_container_border_width(GTK_CONTAINER(main_vbox), 1);
gtk_container_add(GTK_CONTAINER(mainwindow), main_vbox);
gtk_widget_show(main_vbox);
vpan = gtk_vpaned_new ();
gtk_widget_show (vpan);
gtk_box_pack_start (GTK_BOX (main_vbox), vpan, TRUE, TRUE, 1);
gtk_paned_pack1 (GTK_PANED (vpan), xsocket[0], TRUE, FALSE);
gtk_signal_connect(GTK_OBJECT(xsocket[1]), "plug-removed", GTK_SIGNAL_FUNC(plug_removed), NULL);
gtk_paned_pack2 (GTK_PANED (vpan), xsocket[1], TRUE, FALSE);
#ifdef __MINGW32__
shmid = getpid();
sprintf(mapName, "twinwave%d", shmid);
hMapFile = CreateFileMapping(INVALID_HANDLE_VALUE, NULL, PAGE_READWRITE, 0, 2 * sizeof(struct gtkwave_dual_ipc_t), mapName);
if(hMapFile != NULL)
{
dual_ctx = MapViewOfFile(hMapFile, FILE_MAP_ALL_ACCESS, 0, 0, 2 * sizeof(struct gtkwave_dual_ipc_t));
if(dual_ctx)
{
memset(dual_ctx, 0, 2 * sizeof(struct gtkwave_dual_ipc_t));
memcpy(&dual_ctx[0].matchword, DUAL_MATCHWORD, 4);
memcpy(&dual_ctx[1].matchword, DUAL_MATCHWORD, 4);
/* child 0 */
{
int idx;
int n_items = split_point + 5;
int slen;
char **arglist = calloc(n_items, sizeof(char *));
char *mylist;
STARTUPINFO si;
PROCESS_INFORMATION pi;
BOOL rc;
memset(&si, 0, sizeof(STARTUPINFO));
memset(&pi, 0, sizeof(PROCESS_INFORMATION));
sprintf(buf, "0+%08X", shmid);
#ifdef MINGW_USE_XID
sprintf(buf2, "%x", gtk_socket_get_id (GTK_SOCKET(xsocket[0])));
#else
sprintf(buf2, "%x", 0);
#endif
arglist[0] = "gtkwave.exe";
arglist[1] = "-D";
arglist[2] = buf;
arglist[3] = "-X";
arglist[4] = buf2;
for(i=1;i<split_point;i++)
{
arglist[i+4] = argv[i];
}
arglist[i+4] = NULL;
slen = 1;
for(idx=0;idx<i+4;idx++)
{
slen += strlen(arglist[idx]);
slen++;
}
mylist = calloc(1, slen);
for(idx=0;idx<i+4;idx++)
{
strcat(mylist, arglist[idx]);
strcat(mylist, " ");
}
si.cb = sizeof(si);
rc = CreateProcess(
arglist[0],
mylist,
NULL,
NULL,
FALSE,
0,
NULL,
NULL,
&si,
&pi);
if(!rc)
{
fprintf(stderr, "Child 0 failed '%s' '%s'\n", arglist[0], mylist);
exit(255);
}
free(mylist);
free(arglist);
}
/* child 1 */
{
int idx;
int n_items = argc - split_point + 5;
int slen;
char **arglist = calloc(n_items, sizeof(char *));
char *mylist;
STARTUPINFO si;
PROCESS_INFORMATION pi;
BOOL rc;
memset(&si, 0, sizeof(STARTUPINFO));
memset(&pi, 0, sizeof(PROCESS_INFORMATION));
sprintf(buf, "1+%08X", shmid);
#ifdef MINGW_USE_XID
sprintf(buf2, "%x", gtk_socket_get_id (GTK_SOCKET(xsocket[1])));
#else
sprintf(buf2, "%x", 0);
#endif
arglist[0] = "gtkwave.exe";
arglist[1] = "-D";
arglist[2] = buf;
arglist[3] = "-X";
arglist[4] = buf2;
for(i=split_point+1;i<argc;i++)
{
arglist[i-split_point+4] = argv[i];
}
i-=split_point;
arglist[i+4] = NULL;
slen = 1;
for(idx=0;idx<i+4;idx++)
{
slen += strlen(arglist[idx]);
slen++;
}
mylist = calloc(1, slen);
for(idx=0;idx<i+4;idx++)
{
strcat(mylist, arglist[idx]);
strcat(mylist, " ");
}
si.cb = sizeof(si);
rc = CreateProcess(
arglist[0],
mylist,
NULL,
NULL,
FALSE,
0,
NULL,
NULL,
&si,
&pi);
if(!rc)
{
fprintf(stderr, "Child 1 failed '%s' '%s'\n", arglist[0], mylist);
exit(255);
}
free(mylist);
free(arglist);
}
for(;;)
{
Sleep(1000 / 5);
while (gtk_events_pending()) gtk_main_iteration();
if((!dual_ctx[0].viewer_is_initialized)&&(dual_ctx[1].viewer_is_initialized))
{
gtk_window_set_title(GTK_WINDOW(mainwindow), "TwinWave Waiting on Viewer #1");
}
else
if((dual_ctx[0].viewer_is_initialized)&&(!dual_ctx[1].viewer_is_initialized))
{
gtk_window_set_title(GTK_WINDOW(mainwindow), "TwinWave Waiting on Viewer #2");
}
else
if((dual_ctx[0].viewer_is_initialized)&&(dual_ctx[1].viewer_is_initialized))
{
gtk_window_set_title(GTK_WINDOW(mainwindow), "TwinWave");
break;
}
}
#ifdef MINGW_USE_XID
gtk_main();
#endif
}
}
#else
shmid = shmget(0, 2 * sizeof(struct gtkwave_dual_ipc_t), IPC_CREAT | 0600 );
if(shmid >=0)
{
struct shmid_ds ds;
dual_ctx = shmat(shmid, NULL, 0);
if(dual_ctx)
{
memset(dual_ctx, 0, 2 * sizeof(struct gtkwave_dual_ipc_t));
memcpy(&dual_ctx[0].matchword, DUAL_MATCHWORD, 4);
memcpy(&dual_ctx[1].matchword, DUAL_MATCHWORD, 4);
#ifdef __linux__
shmctl(shmid, IPC_RMID, &ds); /* mark for destroy */
#endif
if(fork())
{
if(fork())
{
struct timeval tv;
for(;;)
{
tv.tv_sec = 0;
tv.tv_usec = 1000000 / 5;
select(0, NULL, NULL, NULL, &tv);
while (gtk_events_pending()) gtk_main_iteration();
if((!dual_ctx[0].viewer_is_initialized)&&(dual_ctx[1].viewer_is_initialized))
{
gtk_window_set_title(GTK_WINDOW(mainwindow), "TwinWave Waiting on Viewer #1");
}
else
if((dual_ctx[0].viewer_is_initialized)&&(!dual_ctx[1].viewer_is_initialized))
{
gtk_window_set_title(GTK_WINDOW(mainwindow), "TwinWave Waiting on Viewer #2");
}
else
if((dual_ctx[0].viewer_is_initialized)&&(dual_ctx[1].viewer_is_initialized))
{
gtk_window_set_title(GTK_WINDOW(mainwindow), "TwinWave");
break;
}
}
#ifndef __linux__
while (gtk_events_pending()) gtk_main_iteration();
sleep(2);
shmctl(shmid, IPC_RMID, &ds); /* mark for destroy */
#endif
if(use_embedded)
{
gtk_main();
}
}
else
{
int n_items = split_point + 5;
char **arglist = calloc(n_items, sizeof(char *));
sprintf(buf, "0+%08X", shmid);
if(use_embedded)
{
sprintf(buf2, "%x", gtk_socket_get_id (GTK_SOCKET(xsocket[0])));
}
else
{
sprintf(buf2, "%x", 0);
}
arglist[0] = "gtkwave";
arglist[1] = "-D";
arglist[2] = buf;
arglist[3] = "-X";
arglist[4] = buf2;
for(i=1;i<split_point;i++)
{
arglist[i+4] = argv[i];
}
arglist[i+4] = NULL;
execvp(arglist[0], arglist);
fprintf(stderr, "Child failed\n");
exit(255);
}
}
else
{
int n_items = argc - split_point + 5;
char **arglist = calloc(n_items, sizeof(char *));
sprintf(buf, "1+%08X", shmid);
if(use_embedded)
{
sprintf(buf2, "%x", gtk_socket_get_id (GTK_SOCKET(xsocket[1])));
}
else
{
sprintf(buf2, "%x", 0);
}
arglist[0] = "gtkwave";
arglist[1] = "-D";
arglist[2] = buf;
arglist[3] = "-X";
arglist[4] = buf2;
for(i=split_point+1;i<argc;i++)
{
arglist[i-split_point+4] = argv[i];
}
i-=split_point;
arglist[i+4] = NULL;
execvp(arglist[0], arglist);
fprintf(stderr, "Child failed\n");
exit(255);
}
}
}
#endif
return(0);
}
