guint
egg_tray_icon_send_message (EggTrayIcon *icon,
gint timeout,
const gchar *message,
gint len)
{
guint stamp;
g_return_val_if_fail (EGG_IS_TRAY_ICON (icon), 0);
g_return_val_if_fail (timeout >= 0, 0);
g_return_val_if_fail (message != NULL, 0);
if (icon->manager_window == None)
return 0;
if (len < 0)
len = strlen (message);
stamp = icon->stamp++;
/* Get ready to send the message */
egg_tray_icon_send_manager_message (icon, SYSTEM_TRAY_BEGIN_MESSAGE,
(Window)gtk_plug_get_id (GTK_PLUG (icon)),
timeout, len, stamp);
/* Now to send the actual message */
gdk_error_trap_push ();
while (len > 0)
{
XClientMessageEvent ev;
Display *xdisplay;
xdisplay = GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (GTK_WIDGET (icon)));
ev.type = ClientMessage;
ev.window = (Window)gtk_plug_get_id (GTK_PLUG (icon));
ev.format = 8;
ev.message_type = XInternAtom (xdisplay,
"_NET_SYSTEM_TRAY_MESSAGE_DATA", False);
if (len > 20)
{
memcpy (&ev.data, message, 20);
len -= 20;
message += 20;
}
else
{
memcpy (&ev.data, message, len);
len = 0;
}
XSendEvent (xdisplay,
icon->manager_window, False, StructureNotifyMask, (XEvent *)&ev);
XSync (xdisplay, False);
}
gdk_error_trap_pop ();
return stamp;
}
static GdkWindow *
lmplayer_gtk_plug_get_toplevel (GtkPlug *plug)
{
Window root, parent, *children;
guint nchildren;
GdkNativeWindow xid;
g_return_val_if_fail (GTK_IS_PLUG (plug), NULL);
xid = gtk_plug_get_id (plug);
do
{
/* FIXME: multi-head */
if (XQueryTree (GDK_DISPLAY (), xid, &root,
&parent, &children, &nchildren) == 0)
{
g_warning ("Couldn't find window manager window");
return NULL;
}
if (root == parent) {
GdkWindow *toplevel;
toplevel = gdk_window_foreign_new (xid);
return toplevel;
}
xid = parent;
}
while (TRUE);
}
static CORBA_char *
impl_MateComponent_Control_getWindowId (PortableServer_Servant servant,
const CORBA_char *cookie,
CORBA_Environment *ev)
{
guint32 x11_id;
MateComponentControl *control = MATECOMPONENT_CONTROL (
matecomponent_object_from_servant (servant));
GdkScreen *gdkscreen;
int screen_num;
if (!control->priv->plug)
create_plug (control);
g_assert (control->priv->plug != NULL);
screen_num = parse_cookie (cookie);
if (screen_num != -1)
gdkscreen = gdk_display_get_screen (
gdk_display_get_default (), screen_num);
else
gdkscreen = gdk_screen_get_default ();
gtk_window_set_screen (GTK_WINDOW (control->priv->plug), gdkscreen);
gtk_widget_show (control->priv->plug);
x11_id = gtk_plug_get_id (GTK_PLUG (control->priv->plug));
dbgprintf ("plug id %u\n", x11_id);
return matecomponent_control_window_id_from_x11 (x11_id);
}
/* Adapted from totem-interface.c */
static Window
bacon_video_widget_gtk_plug_get_toplevel (GtkPlug *plug)
{
Window root, parent, *children;
guint nchildren;
Window xid;
g_return_val_if_fail (GTK_IS_PLUG (plug), 0);
xid = gtk_plug_get_id (plug);
do
{
/* FIXME: multi-head */
if (XQueryTree (GDK_DISPLAY_XDISPLAY (gdk_display_get_default ()), xid, &root,
&parent, &children, &nchildren) == 0)
{
g_warning ("Couldn't find window manager window");
return 0;
}
if (root == parent)
return xid;
xid = parent;
}
while (TRUE);
}
static int _calendar_embedded(void)
{
GtkWidget * window;
GtkWidget * widget;
Calendar * calendar;
unsigned long id;
window = gtk_plug_new(0);
gtk_widget_realize(window);
g_signal_connect_swapped(window, "embedded", G_CALLBACK(
_embedded_on_embedded), window);
if((calendar = calendar_new()) == NULL)
{
gtk_widget_destroy(window);
return -1;
}
widget = calendar_get_widget(calendar);
gtk_container_add(GTK_CONTAINER(window), widget);
id = gtk_plug_get_id(GTK_PLUG(window));
printf("%lu\n", id);
fclose(stdout);
gtk_main();
calendar_delete(calendar);
gtk_widget_destroy(window);
return 0;
}
void egg_tray_icon_cancel_message(EggTrayIcon * icon, guint id)
{
g_return_if_fail(EGG_IS_TRAY_ICON(icon));
g_return_if_fail(id > 0);
egg_tray_icon_send_manager_message(icon, SYSTEM_TRAY_CANCEL_MESSAGE, (Window) gtk_plug_get_id(GTK_PLUG(icon)),
id, 0, 0);
}
static void egg_tray_icon_send_dock_request (EggTrayIcon *icon) {
egg_tray_icon_send_manager_message (icon,
SYSTEM_TRAY_REQUEST_DOCK,
icon->manager_window,
gtk_plug_get_id (GTK_PLUG (icon)),
0, 0);
}
static VALUE
plug_get_id(VALUE self)
{
GdkNativeWindow id = gtk_plug_get_id(GTK_PLUG(RVAL2GOBJ(self)));
#ifdef GDK_NATIVE_WINDOW_POINTER
return UINT2NUM(GPOINTER_TO_UINT(id));
#else
return UINT2NUM(id);
#endif
}
static void
realize_cb (GtkWidget *socket, gpointer user_data)
{
GtkWidget *plug, *w;
g_warning ("Realize");
plug = gtk_plug_new (0);
w = gtk_button_new_with_label ("Baa");
gtk_widget_show_all (w);
gtk_widget_show (plug);
gtk_container_add (GTK_CONTAINER (plug), w);
GTK_PLUG (plug)->socket_window = GTK_WIDGET (socket)->window;
gtk_socket_add_id (GTK_SOCKET (socket),
gtk_plug_get_id (GTK_PLUG (plug)));
gdk_window_show (GTK_WIDGET (plug)->window);
}
int
main (int argc, char *argv[])
{
if (!gtk_init_check (&argc, &argv)) {
fprintf (stderr, "Failed to initialize GTK\n");
return EXIT_FAILURE;
}
uzbl_init (&argc, &argv);
if (uzbl.state.exit) {
goto main_exit;
}
if (uzbl.gui.web_view) {
gtk_widget_grab_focus (GTK_WIDGET (uzbl.gui.web_view));
}
/* Verbose feedback. */
if (uzbl_variables_get_int ("verbose")) {
printf ("Uzbl start location: %s\n", argv[0]);
if (uzbl.state.xembed_socket_id) {
printf ("plug_id %d\n", (int)gtk_plug_get_id (uzbl.gui.plug));
} else {
Window xwin = GDK_WINDOW_XID (gtk_widget_get_window (GTK_WIDGET (uzbl.gui.main_window)));
printf ("window_id %d\n", (int)xwin);
}
printf ("pid %i\n", getpid ());
printf ("name: %s\n", uzbl.state.instance_name);
gchar *commit = uzbl_variables_get_string ("COMMIT");
printf ("commit: %s\n", commit);
g_free (commit);
}
uzbl.state.gtk_started = TRUE;
gtk_main ();
main_exit:
/* Cleanup and exit. */
clean_up ();
return EXIT_SUCCESS;
}
static void tray_widget_send_dock_request(struct _tray_widget_icon *widget_icon)
{
XClientMessageEvent ev;
ev.type = ClientMessage;
ev.window = widget_icon->manager_window;
ev.message_type = widget_icon->system_tray_opcode_atom;
ev.format = 32;
ev.data.l[0] = gdk_x11_get_server_time(GTK_WIDGET(widget_icon)->window);
ev.data.l[1] = 0;
ev.data.l[2] = gtk_plug_get_id(GTK_PLUG(widget_icon));
ev.data.l[3] = 0;
ev.data.l[4] = 0;
Display *display = GDK_DISPLAY_XDISPLAY(gtk_widget_get_display(GTK_WIDGET(widget_icon)));
gdk_error_trap_push();
XSendEvent(display, widget_icon->manager_window, False, NoEventMask, (XEvent *) &ev);
XSync(display, False);
gdk_error_trap_pop();
}
/* Set up gtk, gobject, variable defaults and other things that tests and other
* external applications need to do anyhow. */
void
uzbl_init (int *argc, char ***argv)
{
gchar *uri = NULL;
gboolean verbose = FALSE;
gchar *config_file = NULL;
gchar **connect_socket_names = NULL;
gboolean print_events = FALSE;
gchar *geometry = NULL;
gboolean print_version = FALSE;
gboolean bug_info = FALSE;
/* Commandline arguments. */
const GOptionEntry
options[] = {
{ "verbose", 'v', 0, G_OPTION_ARG_NONE, &verbose,
"Whether to print all messages or just errors.", NULL },
{ "named", 'n', 0, G_OPTION_ARG_STRING, &uzbl.state.instance_name,
"Name of the current instance (defaults to Xorg window id or random for GtkSocket mode)", "NAME" },
{ "config", 'c', 0, G_OPTION_ARG_STRING, &config_file,
"Path to config file or '-' for stdin", "FILE" },
/* TODO: explain the difference between these two options */
{ "xembed-socket", 's', 0, G_OPTION_ARG_INT, &uzbl.state.xembed_socket_id,
"Xembed socket ID, this window should embed itself", "SOCKET" },
{ "connect-socket", 0, 0, G_OPTION_ARG_STRING_ARRAY, &connect_socket_names,
"Connect to server socket for event managing", "CSOCKET" },
{ "print-events", 'p', 0, G_OPTION_ARG_NONE, &print_events,
"Whether to print events to stdout.", NULL },
{ "geometry", 'g', 0, G_OPTION_ARG_STRING, &geometry,
"Set window geometry (format: 'WIDTHxHEIGHT+-X+-Y' or 'maximized')", "GEOMETRY" },
{ "version", 'V', 0, G_OPTION_ARG_NONE, &print_version,
"Print the version and exit", NULL },
{ "bug-info", 'B', 0, G_OPTION_ARG_NONE, &bug_info,
"Print information for a bug report and exit", NULL },
{ NULL, 0, 0, 0, NULL, NULL, NULL }
};
/* Parse commandline arguments. */
GOptionContext *context = g_option_context_new ("");
g_option_context_add_main_entries (context, options, NULL);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
g_option_context_parse (context, argc, argv, NULL);
g_option_context_free (context);
if (*argc >= 2) {
uri = (*argv)[1];
}
if (*argc >= 3) {
fprintf (stderr, "Extra arguments to %s ignored\n", (*argv)[0]);
}
/* Print bug information. */
if (bug_info) {
printf ("Commit: %s\n", COMMIT);
printf ("GTK compile: %d.%d.%d\n",
GTK_MAJOR_VERSION,
GTK_MINOR_VERSION,
GTK_MICRO_VERSION);
printf ("GTK run: %d.%d.%d\n",
gtk_major_version,
gtk_minor_version,
gtk_micro_version);
printf ("WebKit compile: %d.%d.%d\n",
WEBKIT_MAJOR_VERSION,
WEBKIT_MINOR_VERSION,
WEBKIT_MICRO_VERSION);
#define webkit_version(type) webkit_##type##_version ()
printf ("WebKit run: %d.%d.%d\n",
webkit_version (major),
webkit_version (minor),
webkit_version (micro));
#undef webkit_version
printf ("WebKit2: %d\n", 0);
#ifdef HAVE_LIBSOUP_CHECK_VERSION
printf ("libsoup compile: %d.%d.%d\n",
SOUP_MAJOR_VERSION,
SOUP_MINOR_VERSION,
SOUP_MICRO_VERSION);
printf ("libsoup run: %u.%u.%u\n",
soup_get_major_version (),
soup_get_minor_version (),
soup_get_micro_version ());
#else
printf ("libsoup compile: < 2.41.1\n");
#endif
exit (EXIT_SUCCESS);
}
/* Only print version. */
if (print_version) {
printf ("Commit: %s\n", COMMIT);
exit (EXIT_SUCCESS);
}
/* Embedded mode. */
if (uzbl.state.xembed_socket_id) {
uzbl.state.plug_mode = TRUE;
}
#if !GLIB_CHECK_VERSION (2, 31, 0)
if (!g_thread_supported ()) {
g_thread_init (NULL);
}
#endif
/* HTTP client. */
uzbl.net.soup_session = webkit_get_default_session ();
uzbl_soup_init (uzbl.net.soup_session);
uzbl_io_init ();
uzbl_js_init ();
uzbl_variables_init ();
uzbl_commands_init ();
uzbl_events_init ();
uzbl_requests_init ();
uzbl_scheme_init ();
/* Initialize the GUI. */
uzbl_gui_init ();
uzbl_inspector_init ();
#if WEBKIT_CHECK_VERSION (2, 9, 4)
uzbl_variables_setup_data_manager ();
#endif
/* Uzbl has now been started. */
uzbl.state.started = TRUE;
/* XDG */
ensure_xdg_vars ();
/* Connect to the event manager(s). */
gchar **name = connect_socket_names;
while (name && *name) {
uzbl_io_init_connect_socket (*name++);
}
uzbl_io_flush_buffer ();
/* Send the startup event. */
pid_t pid = getpid ();
gchar *pid_str = g_strdup_printf ("%d", pid);
g_setenv ("UZBL_PID", pid_str, TRUE);
if (!uzbl.state.instance_name) {
uzbl.state.instance_name = g_strdup (pid_str);
}
g_free (pid_str);
uzbl_events_send (INSTANCE_START, NULL,
TYPE_INT, pid,
NULL);
/* Generate an event with a list of built in commands. */
uzbl_commands_send_builtin_event ();
/* Set variables based on flags. */
if (verbose) {
uzbl_variables_set ("verbose", "1");
}
if (print_events) {
uzbl_variables_set ("print_events", "1");
}
/* Load default config. */
const gchar * const *default_command = default_config;
while (default_command && *default_command) {
uzbl_commands_run (*default_command++, NULL);
}
/* Load provided configuration file. */
read_config_file (config_file);
if (uzbl.gui.main_window) {
/* We need to ensure there is a window, before we can get XID. */
gtk_widget_realize (uzbl.gui.main_window);
Window xwin = GDK_WINDOW_XID (gtk_widget_get_window (uzbl.gui.main_window));
gchar *xwin_str = g_strdup_printf ("%d", (int)xwin);
g_setenv ("UZBL_XID", xwin_str, TRUE);
g_free (xwin_str);
}
if (uzbl.state.plug_mode) {
uzbl_events_send (PLUG_CREATED, NULL,
TYPE_INT, gtk_plug_get_id (uzbl.gui.plug),
NULL);
}
/* Navigate to a URI if requested. */
if (uri) {
GArray *argv = uzbl_commands_args_new ();
uzbl_commands_args_append (argv, g_strdup (uri));
uzbl_commands_run_argv ("uri", argv, NULL);
uzbl_commands_args_free (argv);
}
/* Set the geometry if requested. */
if (uzbl.gui.main_window && geometry) {
GArray *args = uzbl_commands_args_new ();
uzbl_commands_args_append (args, g_strdup (geometry));
uzbl_commands_run_argv ("geometry", args, NULL);
uzbl_commands_args_free (args);
}
/* Finally show the window */
if (uzbl.gui.main_window) {
gtk_widget_show_all (uzbl.gui.main_window);
} else {
gtk_widget_show_all (GTK_WIDGET (uzbl.gui.plug));
}
/* Apply the show_status variable. All widgets are shown with the above
* call. Unfortunately, GTK has the wonderful thing where all widgets must
* be explicitly shown and there's no way to exclude widgets from "all", so
* this is necessary here. */
gtk_widget_set_visible (uzbl.gui.status_bar, uzbl_variables_get_int ("show_status"));
/* Update status bar. */
uzbl_gui_update_title ();
}
static int _progress(Prefs * prefs, char * argv[])
{
Progress p;
struct stat st;
GtkWidget * vbox;
GtkWidget * hbox;
GtkSizeGroup * left;
GtkSizeGroup * right;
GtkWidget * widget;
PangoFontDescription * bold;
char const * q;
unsigned long id;
memset(&p, 0, sizeof(p));
p.prefs = prefs;
if(prefs->bufsiz == 0)
errno = EINVAL;
if(prefs->bufsiz == 0 || (p.buf = malloc(prefs->bufsiz)) == NULL)
return _progress_error(&p, "malloc", 1);
p.bufsiz = prefs->bufsiz;
if(pipe(p.fds) != 0)
return _progress_error(&p, "pipe", 1);
if((p.pid = fork()) == -1)
{
close(p.fds[0]);
close(p.fds[1]);
return _progress_error(&p, "fork", 1);
}
if(p.pid != 0)
return _progress_exec(&p, argv);
close(p.fds[0]);
if(gettimeofday(&p.tv, NULL) != 0)
return _progress_error(&p, "gettimeofday", 1);
if(prefs->filename == NULL)
prefs->filename = _("Standard input");
else if((p.fd = open(prefs->filename, O_RDONLY)) < 0)
return _progress_error(&p, prefs->filename, 1);
else if(fstat(p.fd, &st) == 0 && S_ISREG(st.st_mode))
prefs->length = st.st_size;
p.in_channel = g_io_channel_unix_new(p.fd);
g_io_channel_set_encoding(p.in_channel, NULL, NULL);
p.in_id = 0;
g_idle_add(_progress_idle_in, &p);
p.out_channel = g_io_channel_unix_new(p.fds[1]);
g_io_channel_set_encoding(p.out_channel, NULL, NULL);
p.out_id = 0;
/* graphical interface */
if((prefs->flags & PREFS_x) == 0)
{
p.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
#if GTK_CHECK_VERSION(3, 0, 0) && !GTK_CHECK_VERSION(3, 14, 0)
gtk_window_set_has_resize_grip(GTK_WINDOW(p.window), FALSE);
#endif
gtk_window_set_title(GTK_WINDOW(p.window), prefs->title != NULL
? prefs->title : _("Progress"));
g_signal_connect_swapped(p.window, "delete-event", G_CALLBACK(
_progress_closex), p.window);
}
else
{
p.window = gtk_plug_new(0);
g_signal_connect_swapped(p.window, "embedded", G_CALLBACK(
_progress_embedded), &p);
}
#if GTK_CHECK_VERSION(3, 0, 0)
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#else
vbox = gtk_vbox_new(FALSE, 0);
hbox = gtk_hbox_new(FALSE, 0);
#endif
left = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
right = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
/* file */
widget = gtk_label_new(_("File: "));
bold = pango_font_description_new();
pango_font_description_set_weight(bold, PANGO_WEIGHT_BOLD);
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_override_font(widget, bold);
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_widget_modify_font(widget, bold);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(left, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
if((q = g_filename_to_utf8(prefs->filename, -1, NULL, NULL, NULL))
== NULL)
q = prefs->filename;
widget = gtk_label_new(q);
gtk_label_set_ellipsize(GTK_LABEL(widget), PANGO_ELLIPSIZE_MIDDLE);
#if GTK_CHECK_VERSION(3, 0, 0)
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(right, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
/* done */
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#else
hbox = gtk_hbox_new(FALSE, 0);
#endif
widget = gtk_label_new(_("Done: "));
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_override_font(widget, bold);
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_widget_modify_font(widget, bold);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(left, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
p.done = gtk_label_new(_("0.0 kB"));
#if GTK_CHECK_VERSION(3, 0, 0)
g_object_set(p.done, "halign", GTK_ALIGN_START, NULL);
#else
gtk_misc_set_alignment(GTK_MISC(p.done), 0.0, 0.5);
#endif
gtk_size_group_add_widget(right, p.done);
gtk_box_pack_start(GTK_BOX(hbox), p.done, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 4);
/* remaining */
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#else
hbox = gtk_hbox_new(FALSE, 0);
#endif
widget = gtk_label_new(_("Remaining: "));
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_override_font(widget, bold);
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_widget_modify_font(widget, bold);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(left, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
p.remaining = gtk_label_new("");
g_timeout_add(250, _progress_timeout, &p);
#if GTK_CHECK_VERSION(3, 0, 0)
g_object_set(p.remaining, "halign", GTK_ALIGN_START, NULL);
#else
gtk_misc_set_alignment(GTK_MISC(p.remaining), 0.0, 0.5);
#endif
gtk_size_group_add_widget(right, p.remaining);
gtk_box_pack_start(GTK_BOX(hbox), p.remaining, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 4);
/* progress */
p.progress = gtk_progress_bar_new();
p.pulse = 0;
if(prefs->prefix != NULL)
{
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#else
hbox = gtk_hbox_new(FALSE, 0);
#endif
widget = gtk_label_new(prefs->prefix);
#if GTK_CHECK_VERSION(3, 0, 0)
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(left, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
gtk_size_group_add_widget(right, p.progress);
gtk_box_pack_start(GTK_BOX(hbox), p.progress, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 4);
}
else
gtk_box_pack_start(GTK_BOX(vbox), p.progress, TRUE, TRUE, 4);
/* cancel */
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
#else
hbox = gtk_hbox_new(FALSE, 0);
#endif
#if GTK_CHECK_VERSION(3, 10, 0)
widget = gtk_button_new_with_label(_("Cancel"));
gtk_button_set_image(GTK_BUTTON(widget),
gtk_image_new_from_icon_name(GTK_STOCK_CANCEL,
GTK_ICON_SIZE_BUTTON));
#else
widget = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
#endif
g_signal_connect(G_OBJECT(widget), "clicked", G_CALLBACK(
_progress_cancel), NULL);
gtk_box_pack_end(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(p.window), vbox);
gtk_container_set_border_width(GTK_CONTAINER(p.window), 4);
gtk_widget_show_all(vbox);
if((prefs->flags & PREFS_x) == 0)
/* show the window */
gtk_widget_show(p.window);
else
{
/* print the window ID and force a flush */
id = gtk_plug_get_id(GTK_PLUG(p.window));
printf("%lu\n", id);
fclose(stdout);
}
gtk_main();
close(p.fd);
close(p.fds[1]);
return p.ret;
}
void
create_plug (void)
{
GtkWidget *win, *vbox, *text;
GtkWidget *main_widget = NULL;
tabs = get_tabs (options.plug, FALSE);
while (!tabs)
{
usleep (1000);
tabs = get_tabs (options.plug, FALSE);
}
win = gtk_plug_new (0);
/* set window borders */
if (options.data.borders == -1)
options.data.borders = (gint) gtk_container_get_border_width (GTK_CONTAINER (win));
gtk_container_set_border_width (GTK_CONTAINER (win), (guint) options.data.borders);
#if !GTK_CHECK_VERSION(3,0,0)
vbox = gtk_vbox_new (FALSE, 0);
#else
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
#endif
gtk_container_add (GTK_CONTAINER (win), vbox);
/* add dialog text */
if (options.data.dialog_text)
{
gchar *buf = g_strcompress (options.data.dialog_text);
text = gtk_label_new (NULL);
if (!options.data.no_markup)
gtk_label_set_markup (GTK_LABEL (text), buf);
else
gtk_label_set_text (GTK_LABEL (text), buf);
gtk_widget_set_name (text, "yad-dialog-label");
gtk_label_set_line_wrap (GTK_LABEL (text), TRUE);
gtk_label_set_selectable (GTK_LABEL (text), options.data.selectable_labels);
gtk_label_set_justify (GTK_LABEL (text), options.data.text_align);
switch (options.data.text_align)
{
case GTK_JUSTIFY_LEFT:
case GTK_JUSTIFY_FILL:
gtk_misc_set_alignment (GTK_MISC (text), 0.0, 0.5);
break;
case GTK_JUSTIFY_CENTER:
gtk_misc_set_alignment (GTK_MISC (text), 0.5, 0.5);
break;
case GTK_JUSTIFY_RIGHT:
gtk_misc_set_alignment (GTK_MISC (text), 1.0, 0.5);
break;
}
gtk_box_pack_start (GTK_BOX (vbox), text, FALSE, FALSE, 2);
#if !GTK_CHECK_VERSION(3,0,0)
g_signal_connect (G_OBJECT (text), "size-allocate", G_CALLBACK (text_size_allocate_cb), NULL);
#endif
g_free (buf);
}
/* add main widget */
switch (options.mode)
{
case YAD_MODE_CALENDAR:
main_widget = calendar_create_widget (win);
break;
case YAD_MODE_COLOR:
main_widget = color_create_widget (win);
break;
case YAD_MODE_ENTRY:
main_widget = entry_create_widget (win);
break;
case YAD_MODE_FILE:
main_widget = file_create_widget (win);
break;
case YAD_MODE_FONT:
main_widget = font_create_widget (win);
break;
case YAD_MODE_FORM:
main_widget = form_create_widget (win);
break;
#ifdef HAVE_HTML
case YAD_MODE_HTML:
main_widget = html_create_widget (win);
break;
#endif
case YAD_MODE_ICONS:
main_widget = icons_create_widget (win);
break;
case YAD_MODE_LIST:
main_widget = list_create_widget (win);
break;
case YAD_MODE_MULTI_PROGRESS:
main_widget = multi_progress_create_widget (win);
break;
case YAD_MODE_PROGRESS:
main_widget = progress_create_widget (win);
break;
case YAD_MODE_SCALE:
main_widget = scale_create_widget (win);
break;
case YAD_MODE_TEXTINFO:
main_widget = text_create_widget (win);
break;
default:
;
}
if (main_widget)
gtk_box_pack_start (GTK_BOX (vbox), main_widget, TRUE, TRUE, 2);
gtk_widget_show_all (win);
/* add plug data */
tabs[options.tabnum].pid = getpid ();
tabs[options.tabnum].xid = gtk_plug_get_id (GTK_PLUG (win));
/* FIXME: may be a race here */
tabs[0].xid++;
shmdt (tabs);
}
/* mixerwindow_new */
MixerWindow * mixerwindow_new(char const * device, MixerLayout layout,
gboolean embedded)
{
MixerWindow * mixer;
GtkAccelGroup * accel;
GtkWidget * vbox;
GtkWidget * widget;
MixerProperties properties;
char buf[80];
unsigned long id;
if((mixer = object_new(sizeof(*mixer))) == NULL)
return NULL;
accel = gtk_accel_group_new();
mixer->window = NULL;
mixer->about = NULL;
if(embedded)
{
mixer->window = gtk_plug_new(0);
g_signal_connect_swapped(mixer->window, "embedded", G_CALLBACK(
on_embedded), mixer);
}
else
{
mixer->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_add_accel_group(GTK_WINDOW(mixer->window), accel);
gtk_window_set_default_size(GTK_WINDOW(mixer->window), 800,
350);
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_icon_name(GTK_WINDOW(mixer->window),
"stock_volume");
#endif
gtk_window_set_title(GTK_WINDOW(mixer->window), _("Mixer"));
g_signal_connect_swapped(mixer->window, "delete-event",
G_CALLBACK(on_closex), mixer);
}
mixer->mixer = NULL;
mixer->fullscreen = FALSE;
if(mixer->window != NULL)
{
gtk_widget_realize(mixer->window);
mixer->mixer = mixer_new(mixer->window, device, layout);
}
if(mixer->mixer == NULL)
{
mixerwindow_delete(mixer);
return NULL;
}
#if GTK_CHECK_VERSION(3, 0, 0)
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
#else
vbox = gtk_vbox_new(FALSE, 0);
#endif
#ifndef EMBEDDED
/* menubar */
if(embedded == FALSE)
{
if(layout == ML_TABBED)
_mixer_menubar[1].menu = _mixer_menu_view_tabbed;
mixer->menubar = desktop_menubar_create(_mixer_menubar, mixer,
accel);
gtk_box_pack_start(GTK_BOX(vbox), mixer->menubar, FALSE, TRUE,
0);
}
else
mixer->menubar = NULL;
#else
desktop_accel_create(_mixer_accel, mixer, accel);
#endif
/* toolbar */
if(embedded == FALSE)
{
if(layout != ML_TABBED)
_mixer_toolbar[3].name = "";
widget = desktop_toolbar_create(_mixer_toolbar, mixer, accel);
gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, TRUE, 0);
}
#ifndef EMBEDDED
g_object_unref(accel);
#endif
widget = mixer_get_widget(mixer->mixer);
gtk_box_pack_start(GTK_BOX(vbox), widget, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(mixer->window), vbox);
gtk_widget_show_all(vbox);
if(embedded)
{
/* print the window ID and force a flush */
id = gtk_plug_get_id(GTK_PLUG(mixer->window));
printf("%lu\n", id);
fclose(stdout);
}
else
{
/* set the window title */
if(mixer_get_properties(mixer->mixer, &properties) == 0)
{
snprintf(buf, sizeof(buf), "%s - %s%s%s", _("Mixer"),
properties.name,
strlen(properties.version) ? " " : "",
properties.version);
gtk_window_set_title(GTK_WINDOW(mixer->window), buf);
}
gtk_widget_show(mixer->window);
}
return mixer;
}
Download * download_new(DownloadPrefs * prefs, char const * url)
{
Download * download;
char * p;
char buf[256];
GtkWidget * vbox;
GtkWidget * hbox;
GtkSizeGroup * left;
GtkWidget * widget;
PangoFontDescription * bold;
unsigned long id;
/* verify arguments */
if(prefs == NULL || url == NULL)
{
errno = EINVAL;
_download_error(NULL, NULL, 1);
return NULL;
}
if((download = malloc(sizeof(*download))) == NULL)
{
_download_error(NULL, "malloc", 1);
return NULL;
}
/* initialize structure */
download->prefs.output = (prefs->output != NULL) ? strdup(prefs->output)
: NULL;
download->prefs.user_agent = (prefs->user_agent != NULL)
? strdup(prefs->user_agent) : NULL;
if((p = _ghtml_make_url(NULL, url)) != NULL)
url = p;
download->url = strdup(url);
free(p);
if(download->url != NULL && prefs->output == NULL)
download->prefs.output = strdup(basename(download->url));
download->conn = NULL;
download->data_received = 0;
download->content_length = 0;
download->timeout = 0;
download->pulse = 0;
/* verify initialization */
if((prefs->output != NULL && download->prefs.output == NULL)
|| (prefs->user_agent != NULL
&& download->prefs.user_agent == NULL)
|| download->url == NULL
|| gettimeofday(&download->tv, NULL) != 0)
{
_download_error(NULL, "gettimeofday", 1);
download_delete(download);
return NULL;
}
/* window */
if(prefs->embedded == 0)
{
download->window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
snprintf(buf, sizeof(buf), "%s %s", _("Download"),
download->url);
#if GTK_CHECK_VERSION(2, 6, 0)
gtk_window_set_icon_name(GTK_WINDOW(download->window),
"stock_download");
#endif
gtk_window_set_resizable(GTK_WINDOW(download->window), FALSE);
gtk_window_set_title(GTK_WINDOW(download->window), buf);
g_signal_connect_swapped(download->window, "delete-event",
G_CALLBACK(_download_on_closex), download);
}
else
{
download->window = gtk_plug_new(0);
g_signal_connect_swapped(download->window, "embedded",
G_CALLBACK(_download_on_embedded), download);
}
#if GTK_CHECK_VERSION(3, 0, 0)
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 2);
#else
vbox = gtk_vbox_new(FALSE, 2);
#endif
bold = pango_font_description_new();
pango_font_description_set_weight(bold, PANGO_WEIGHT_BOLD);
left = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
/* address */
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
#else
hbox = gtk_hbox_new(FALSE, 4);
#endif
widget = gtk_label_new(_("Address: "));
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_override_font(widget, bold);
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_widget_modify_font(widget, bold);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(left, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
download->address = gtk_entry_new();
gtk_entry_set_text(GTK_ENTRY(download->address), download->url);
gtk_editable_set_editable(GTK_EDITABLE(download->address), FALSE);
gtk_box_pack_start(GTK_BOX(hbox), download->address, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
/* labels */
_download_label(vbox, bold, left, _("File: "), &download->filename,
download->prefs.output);
_download_label(vbox, bold, left, _("Status: "), &download->status,
_("Resolving..."));
_download_label(vbox, bold, left, _("Received: "), &download->received,
_("0.0 kB"));
_download_label(vbox, bold, left, _("Remaining: "),
&download->remaining, _("Unknown"));
/* progress bar */
download->progress = gtk_progress_bar_new();
gtk_box_pack_start(GTK_BOX(vbox), download->progress, FALSE, FALSE, 0);
/* checkbox */
download->check = gtk_check_button_new_with_label(
_("Close window when the download is complete"));
gtk_box_pack_start(GTK_BOX(vbox), download->check, FALSE, FALSE, 0);
/* button */
#if GTK_CHECK_VERSION(3, 0, 0)
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
#else
hbox = gtk_hbox_new(FALSE, 4);
#endif
download->cancel = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
g_signal_connect_swapped(download->cancel, "clicked", G_CALLBACK(
_download_on_cancel), download);
gtk_box_pack_end(GTK_BOX(hbox), download->cancel, FALSE, TRUE, 0);
download->browse = gtk_button_new_with_mnemonic("_Open folder");
gtk_widget_set_no_show_all(download->browse, TRUE);
widget = gtk_image_new_from_stock(GTK_STOCK_OPEN, GTK_ICON_SIZE_BUTTON);
gtk_button_set_image(GTK_BUTTON(download->browse), widget);
g_signal_connect_swapped(download->browse, "clicked", G_CALLBACK(
_download_on_browse), download);
gtk_box_pack_end(GTK_BOX(hbox), download->browse, FALSE, TRUE, 0);
gtk_box_pack_end(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(download->window), 4);
gtk_container_add(GTK_CONTAINER(download->window), vbox);
download->timeout = g_idle_add(_download_on_idle, download);
_download_refresh(download);
gtk_widget_show_all(vbox);
if(prefs->embedded == 0)
gtk_widget_show(download->window);
else
{
id = gtk_plug_get_id(GTK_PLUG(download->window));
printf("%lu\n", id);
fclose(stdout);
}
_download_cnt++;
return download;
}
/* panel_window_get_xid */
uint32_t panel_window_get_xid(PanelWindow * panel)
{
return (panel->position == PANEL_WINDOW_POSITION_EMBEDDED)
? gtk_plug_get_id(GTK_PLUG(panel->window)) : 0;
}
