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 );
}
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);
}
static void
vim_widget_connect_plug (VimWidget *widget)
{
gchar *cmd;
gchar *VIMRC_FILE = anjuta_util_get_user_config_file_path ("gvim", "anjuta.vimrc", NULL);
GError *err = NULL;
widget->priv->socket_id = gtk_socket_get_id ((GtkSocket *) widget->priv->socket);
g_assert (widget->priv->socket_id != 0);
/* TODO: Make unique */
widget->priv->servername = g_strdup_printf ("ANJUTA%d", widget->priv->socket_id);
g_signal_connect_after (widget->priv->socket,
"plug-added",
G_CALLBACK(vim_widget_plug_added_cb),
widget);
cmd = g_strdup_printf ("gvim -u %s -S %s --socketid %d --servername %s \n",
VIMRC_FILE, GVIMRC_FILE, widget->priv->socket_id, widget->priv->servername);
g_message ("Executing %s\n", cmd);
/* Run vim */
g_spawn_command_line_async (cmd, &err);
g_free (cmd);
if (err)
{
DEBUG_PRINT ("VimPlugin: Error: %s", err);
g_object_unref (err);
err = 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;
}
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);
}
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;
}
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;
}
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);
}
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;
}
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;
}
/* playerbackend_start */
int playerbackend_start(PlayerBackend * player)
{
int ret;
char const buf[] = "pausing loadfile " PLAYER_SPLASH " 0\nframe_step\n";
char wid[32];
char * argv[] = { BINDIR "/mplayer", "mplayer", "-slave", "-wid", NULL,
"-quiet", "-idle", "-framedrop", "-softvol",
"-softvol-max", "200", "-identify", "-noconsolecontrols",
"-nomouseinput", NULL };
GError * error = NULL;
argv[4] = wid;
/* XXX not portable */
snprintf(wid, sizeof(wid), "%lu", (unsigned long)gtk_socket_get_id(
GTK_SOCKET(player->view)));
if(pipe(player->fd[0]) != 0 || pipe(player->fd[1]) != 0)
return -player_error(player->player, strerror(errno), 1);
if((player->pid = fork()) == -1)
return -player_error(player->player, strerror(errno), 1);
if(player->pid == 0) /* child */
{
close(player->fd[0][0]);
close(player->fd[1][1]);
if(dup2(player->fd[1][0], 0) == -1)
exit(player_error(NULL, "dup2", 2));
if(dup2(player->fd[0][1], 1) == -1)
exit(player_error(NULL, "dup2", 2));
execv(argv[0], &argv[1]);
exit(player_error(NULL, argv[0], 2));
}
close(player->fd[0][1]);
close(player->fd[1][0]);
player->channel[0] = g_io_channel_unix_new(player->fd[0][0]);
if(g_io_channel_set_encoding(player->channel[0], NULL, &error)
!= G_IO_STATUS_NORMAL)
{
player_error(player->player, error->message, 1);
g_error_free(error);
error = NULL;
}
g_io_channel_set_buffered(player->channel[0], FALSE);
player->read_id = g_io_add_watch(player->channel[0], G_IO_IN,
_command_read, player);
player->channel[1] = g_io_channel_unix_new(player->fd[1][1]);
if(g_io_channel_set_encoding(player->channel[1], NULL, &error)
!= G_IO_STATUS_NORMAL)
{
player_error(player->player, error->message, 1);
g_error_free(error);
}
g_io_channel_set_buffered(player->channel[1], FALSE);
ret = _playerbackend_command(player, buf, sizeof(buf) - 1);
player_set_paused(player->player, TRUE);
return ret;
}
void
add_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;
}
int
clip_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;
}
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;
}
void
new_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);
}
static gint
luaH_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 gboolean
remmina_plugin_nx_open_connection (RemminaProtocolWidget *gp)
{
RemminaPluginNxData *gpdata;
RemminaFile *remminafile;
const gchar *resolution;
gint width, height;
gpdata = (RemminaPluginNxData*) g_object_get_data (G_OBJECT (gp), "plugin-data");
remminafile = remmina_plugin_nx_service->protocol_plugin_get_file (gp);
resolution = remmina_plugin_nx_service->file_get_string (remminafile, "resolution");
if (!resolution || !strchr (resolution, 'x'))
{
remmina_plugin_nx_service->protocol_plugin_set_expand (gp, TRUE);
gtk_widget_set_size_request (GTK_WIDGET (gp), 640, 480);
}
else
{
width = remmina_plugin_nx_service->file_get_int (remminafile, "resolution_width", 640);
height = remmina_plugin_nx_service->file_get_int (remminafile, "resolution_height", 480);
remmina_plugin_nx_service->protocol_plugin_set_width (gp, width);
remmina_plugin_nx_service->protocol_plugin_set_height (gp, height);
gtk_widget_set_size_request (GTK_WIDGET (gp), width, height);
}
gpdata->socket_id = gtk_socket_get_id (GTK_SOCKET (gpdata->socket));
if (pthread_create (&gpdata->thread, NULL, remmina_plugin_nx_main_thread, gp))
{
remmina_plugin_nx_service->protocol_plugin_set_error (gp,
"Failed to initialize pthread. Falling back to non-thread mode...");
gpdata->thread = 0;
return FALSE;
}
else
{
return TRUE;
}
}
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;
}
void
add_child (GtkWidget *window,
gboolean active)
{
Socket *socket;
char *argv[3] = { "./testsocket_child", NULL, NULL };
char buffer[20];
int out_fd;
GIOChannel *channel;
GError *error = NULL;
if (active)
{
socket = create_socket ();
gtk_box_pack_start (GTK_BOX (box), socket->box, TRUE, TRUE, 0);
gtk_widget_show (socket->box);
sprintf(buffer, "%#lx", (gulong) gtk_socket_get_id (GTK_SOCKET (socket->socket)));
argv[1] = buffer;
}
if (!g_spawn_async_with_pipes (NULL, argv, NULL, 0, NULL, NULL, NULL, NULL, &out_fd, NULL, &error))
{
fprintf (stderr, "Can't exec testsocket_child: %s\n", error->message);
exit (1);
}
n_children++;
channel = g_io_channel_unix_new (out_fd);
g_io_channel_set_close_on_unref (channel, TRUE);
g_io_channel_set_flags (channel, G_IO_FLAG_NONBLOCK, &error);
if (error)
{
fprintf (stderr, "Error making channel non-blocking: %s\n", error->message);
exit (1);
}
g_io_add_watch (channel, G_IO_IN | G_IO_HUP, child_read_watch, NULL);
g_io_channel_unref (channel);
}
void
awn_applet_proxy_execute (AwnAppletProxy *proxy)
{
AwnAppletProxyPrivate *priv;
GdkScreen *screen;
GError *error = NULL;
gint panel_id = AWN_PANEL_ID_DEFAULT;
gchar *exec;
gchar **argv = NULL;
GPid pid;
GSpawnFlags flags = G_SPAWN_SEARCH_PATH|G_SPAWN_DO_NOT_REAP_CHILD;
priv = AWN_APPLET_PROXY_GET_PRIVATE (proxy);
priv->size_req_initialized = FALSE;
gtk_widget_realize (GTK_WIDGET (proxy));
/* FIXME: update tooltip with name of the applet?! */
/* Load the applet */
screen = gtk_widget_get_screen (GTK_WIDGET (proxy));
gint64 socket_id = (gint64) gtk_socket_get_id (GTK_SOCKET (proxy));
g_object_get (G_OBJECT (gtk_widget_get_toplevel (GTK_WIDGET (proxy))),
"panel-id", &panel_id, NULL);
if (g_getenv ("AWN_APPLET_GDB"))
{
exec = g_strdup_printf (DEBUG_APPLET_EXEC, priv->path, priv->uid,
socket_id, panel_id);
}
else
{
exec = g_strdup_printf (APPLET_EXEC, priv->path, priv->uid,
socket_id, panel_id);
}
g_shell_parse_argv (exec, NULL, &argv, &error);
g_warn_if_fail (error == NULL);
if (gdk_spawn_on_screen (
screen, NULL, argv, NULL, flags, NULL, NULL, &pid, &error))
{
priv->running = TRUE;
g_child_watch_add(pid, on_child_exit, proxy);
gchar *desktop = g_path_get_basename (priv->path);
g_debug ("Spawned awn-applet[%d] for \"%s\", UID: %s, XID: %" G_GINT64_FORMAT,
pid, desktop, priv->uid, socket_id);
g_free (desktop);
}
else
{
g_warning ("Unable to load applet %s: %s", priv->path, error->message);
g_error_free (error);
g_signal_emit (proxy, _proxy_signals[APPLET_CRASHED], 0);
}
g_strfreev (argv);
g_free (exec);
}
nsresult nsPluginNativeWindowGtk::CallSetWindow(nsRefPtr<nsNPAPIPluginInstance> &aPluginInstance)
{
if (aPluginInstance) {
if (type == NPWindowTypeWindow) {
if (!mSocketWidget) {
nsresult rv;
// The documentation on the types for many variables in NP(N|P)_GetValue
// is vague. Often boolean values are NPBool (1 byte), but
// https://developer.mozilla.org/en/XEmbed_Extension_for_Mozilla_Plugins
// treats NPPVpluginNeedsXEmbed as PRBool (int), and
// on x86/32-bit, flash stores to this using |movl 0x1,&needsXEmbed|.
// thus we can't use NPBool for needsXEmbed, or the three bytes above
// it on the stack would get clobbered. so protect with the larger bool.
int needsXEmbed = 0;
rv = aPluginInstance->GetValueFromPlugin(NPPVpluginNeedsXEmbed, &needsXEmbed);
// If the call returned an error code make sure we still use our default value.
if (NS_FAILED(rv)) {
needsXEmbed = 0;
}
#ifdef DEBUG
printf("nsPluginNativeWindowGtk: NPPVpluginNeedsXEmbed=%d\n", needsXEmbed);
#endif
bool isOOPPlugin = aPluginInstance->GetPlugin()->GetLibrary()->IsOOP();
if (needsXEmbed || isOOPPlugin) {
bool enableXtFocus = !needsXEmbed;
rv = CreateXEmbedWindow(enableXtFocus);
}
else {
#if (MOZ_WIDGET_GTK == 2)
rv = CreateXtWindow();
#else
return NS_ERROR_FAILURE;
#endif
}
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.
SetAllocation();
// Need to reset "window" each time as nsPluginFrame::DidReflow sets it
// to the ancestor window.
#if (MOZ_WIDGET_GTK == 2)
if (GTK_IS_XTBIN(mSocketWidget)) {
// Point the NPWindow structures window to the actual X window
SetWindow(GTK_XTBIN(mSocketWidget)->xtwindow);
}
else { // XEmbed or OOP&Xt
SetWindow(gtk_socket_get_id(GTK_SOCKET(mSocketWidget)));
}
#else
// Gtk3 supports only OOP by GtkSocket
SetWindow(gtk_socket_get_id(GTK_SOCKET(mSocketWidget)));
#endif
#ifdef DEBUG
printf("nsPluginNativeWindowGtk: call SetWindow with xid=%p\n", (void *)window);
#endif
} // NPWindowTypeWindow
aPluginInstance->SetWindow(this);
}
else if (mPluginInstance)
mPluginInstance->SetWindow(nullptr);
SetPluginInstance(aPluginInstance);
return NS_OK;
}
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;
}
/***f* socket/staticFuncs/socketFunc
* AUTHOR
* PGB
* SOURCE
*/
static int socketFunc ( ClientData data, Tcl_Interp *interp,
int objc, Tcl_Obj * const objv[] )
{
const char *cmds[] = { "delete", "configure", "getID", "getPlugID", NULL };
enum cmdIdx { DeleteIdx, ConfigureIdx, GetIDIdx, GetPlugIDIdx };
int idx;
GtkSocket *socket = GTK_SOCKET ( data );
if ( objc < 2 )
{
Tcl_WrongNumArgs ( interp, 1, objv, "command" );
return TCL_ERROR;
}
if ( Tcl_GetIndexFromObj ( interp, objv[1], cmds, "command",
TCL_EXACT, &idx ) != TCL_OK )
return TCL_ERROR;
switch ( idx )
{
case DeleteIdx:
return gnoclDelete ( interp, GTK_WIDGET ( socket ), objc, objv );
case ConfigureIdx:
{
int ret = TCL_ERROR;
if ( gnoclParseAndSetOptions ( interp, objc - 1, objv + 1,
socketOptions, G_OBJECT ( socket ) ) == TCL_OK )
{
ret = configure ( interp, socket, socketOptions );
}
gnoclClearOptions ( socketOptions );
return ret;
}
break;
case GetIDIdx:
{
long xid;
Tcl_Obj *val;
if ( objc != 2 )
{
Tcl_WrongNumArgs ( interp, 2, objv, NULL );
return TCL_ERROR;
}
#ifdef WIN32
xid = gtk_socket_get_id(socket);
#else
xid = GDK_WINDOW_XWINDOW ( GTK_WIDGET ( socket )->window );
#endif
val = Tcl_NewLongObj ( xid );
Tcl_SetObjResult ( interp, val );
}
break;
case GetPlugIDIdx:
{
long xid = 0;
Tcl_Obj *val;
if ( objc != 2 )
{
Tcl_WrongNumArgs ( interp, 2, objv, NULL );
return TCL_ERROR;
}
if ( socket->plug_window )
#ifdef WIN32
xid = gdk_win32_drawable_get_handle( socket->plug_window );
#else
xid = GDK_WINDOW_XWINDOW ( socket->plug_window );
#endif
val = Tcl_NewLongObj ( xid );
Tcl_SetObjResult ( interp, val );
}
break;
}
return TCL_OK;
}
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;
}
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;
}
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);
}
