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 gboolean
matecomponent_plug_button_event (GtkWidget *widget,
GdkEventButton *event)
{
#if defined (GDK_WINDOWING_X11)
XEvent xevent;
#endif
g_return_val_if_fail (MATECOMPONENT_IS_PLUG (widget), FALSE);
if (!MATECOMPONENT_PLUG (widget)->priv->forward_events || !GTK_WIDGET_TOPLEVEL (widget))
return FALSE;
#if defined (GDK_WINDOWING_X11)
if (event->type == GDK_BUTTON_PRESS) {
xevent.xbutton.type = ButtonPress;
/* X does an automatic pointer grab on button press
* if we have both button press and release events
* selected.
* We don't want to hog the pointer on our parent.
*/
gdk_display_pointer_ungrab
(gtk_widget_get_display (widget),
GDK_CURRENT_TIME);
} else
xevent.xbutton.type = ButtonRelease;
xevent.xbutton.display = GDK_WINDOW_XDISPLAY (widget->window);
xevent.xbutton.window = GDK_WINDOW_XWINDOW (GTK_PLUG (widget)->socket_window);
xevent.xbutton.root = GDK_WINDOW_XWINDOW (gdk_screen_get_root_window
(gdk_drawable_get_screen (widget->window)));
/*
* FIXME: the following might cause
* big problems for non-GTK apps
*/
xevent.xbutton.x = 0;
xevent.xbutton.y = 0;
xevent.xbutton.x_root = 0;
xevent.xbutton.y_root = 0;
xevent.xbutton.state = event->state;
xevent.xbutton.button = event->button;
xevent.xbutton.same_screen = TRUE; /* FIXME ? */
gdk_error_trap_push ();
XSendEvent (GDK_WINDOW_XDISPLAY (widget->window),
GDK_WINDOW_XWINDOW (GTK_PLUG (widget)->socket_window),
False, NoEventMask, &xevent);
gdk_flush ();
gdk_error_trap_pop ();
#elif defined (GDK_WINDOWING_WIN32)
/* FIXME: Need to do something? */
#endif
return TRUE;
}
static VALUE
plug_construct(VALUE self, VALUE socket_id)
{
#ifdef GDK_NATIVE_WINDOW_POINTER
gtk_plug_construct(GTK_PLUG(RVAL2GOBJ(self)), GUINT_TO_POINTER(NUM2ULONG(socket_id)));
#else
gtk_plug_construct(GTK_PLUG(RVAL2GOBJ(self)), (guint32)NUM2UINT(socket_id));
#endif
return self;
}
EggTrayIcon *
egg_tray_icon_new_for_xscreen (Screen *xscreen, const char *name)
{
EggTrayIcon *icon;
char buffer[256];
GdkWindow *root_window;
g_return_val_if_fail (xscreen != NULL, NULL);
icon = g_object_new (EGG_TYPE_TRAY_ICON, NULL);
gtk_window_set_title (GTK_WINDOW (icon), name);
#if HAVE_GTK_MULTIHEAD
/* FIXME: this code does not compile, screen is undefined. Now try
* getting the GdkScreen from xscreen (:. Dunno how to solve this
* (there is prolly some easy way I cant think of right now)
*/
gtk_plug_construct_for_display (GTK_PLUG (icon),
gdk_screen_get_display (screen), 0);
#else
gtk_plug_construct (GTK_PLUG (icon), 0);
#endif
gtk_widget_realize (GTK_WIDGET (icon));
/* Now see if there's a manager window around */
g_snprintf (buffer, sizeof (buffer),
"_NET_SYSTEM_TRAY_S%d",
XScreenNumberOfScreen (xscreen));
icon->selection_atom = XInternAtom (DisplayOfScreen (xscreen),
buffer, False);
icon->manager_atom = XInternAtom (DisplayOfScreen (xscreen),
"MANAGER", False);
icon->system_tray_opcode_atom = XInternAtom (DisplayOfScreen (xscreen),
"_NET_SYSTEM_TRAY_OPCODE", False);
egg_tray_icon_update_manager_window (icon);
#if HAVE_GTK_MULTIHEAD
root_window = gdk_screen_get_root_window (gtk_widget_get_screen (screen));
#else
root_window = gdk_window_lookup (gdk_x11_get_default_root_xwindow ());
#endif
/* Add a root window filter so that we get changes on MANAGER */
gdk_window_add_filter (root_window,
egg_tray_icon_manager_filter, icon);
return icon;
}
void
totem_interface_set_transient_for (GtkWindow *window, GtkWindow *parent)
{
#ifdef GDK_WINDOWING_X11
GdkDisplay *display;
display = gdk_display_get_default ();
if (GDK_IS_X11_DISPLAY (display) &&
GTK_IS_PLUG (parent)) {
GdkWindow *toplevel;
gtk_widget_realize (GTK_WIDGET (window));
toplevel = totem_gtk_plug_get_toplevel (GTK_PLUG (parent));
if (toplevel != NULL) {
gdk_window_set_transient_for
(gtk_widget_get_window (GTK_WIDGET (window)), toplevel);
g_object_unref (toplevel);
}
return;
}
#endif /* GDK_WINDOWING_X11 */
gtk_window_set_transient_for (GTK_WINDOW (window),
GTK_WINDOW (parent));
}
void NetscapePlugin::platformGeometryDidChange()
{
if (m_isWindowed) {
uint64_t windowID = 0;
#if PLATFORM(GTK)
windowID = static_cast<uint64_t>(GDK_WINDOW_XID(gtk_plug_get_socket_window(GTK_PLUG(m_platformPluginWidget))));
#endif
IntRect clipRect(m_clipRect);
clipRect.move(-m_frameRectInWindowCoordinates.x(), -m_frameRectInWindowCoordinates.y());
controller()->windowedPluginGeometryDidChange(m_frameRectInWindowCoordinates, clipRect, windowID);
return;
}
Display* display = x11HostDisplay();
if (m_drawable)
XFreePixmap(display, m_drawable);
if (m_pluginSize.isEmpty()) {
m_drawable = 0;
return;
}
m_drawable = XCreatePixmap(display, rootWindowID(), m_pluginSize.width(), m_pluginSize.height(), displayDepth());
XSync(display, false); // Make sure that the server knows about the Drawable.
}
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;
}
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);
}
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 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);
}
/**
* matecomponent_plug_construct_full:
* @plug: The #MateComponentPlug.
* @socket_id: the XID of the socket's window.
*
* Finish the creation of a #MateComponentPlug widget. This function
* will generally only be used by classes deriving
* from #MateComponentPlug.
*/
void
matecomponent_plug_construct_full (MateComponentPlug *plug,
GdkDisplay *display,
guint32 socket_id)
{
gtk_plug_construct_for_display
(GTK_PLUG (plug), display, socket_id);
}
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
}
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);
}
void NetscapePluginX11::visibilityDidChange()
{
ASSERT(m_plugin.isWindowed());
uint64_t windowID = 0;
#if PLATFORM(GTK)
windowID = static_cast<uint64_t>(GDK_WINDOW_XID(gtk_plug_get_socket_window(GTK_PLUG(m_platformPluginWidget))));
#endif
m_plugin.controller()->windowedPluginVisibilityDidChange(m_plugin.isVisible(), windowID);
m_plugin.controller()->windowedPluginGeometryDidChange(m_plugin.frameRectInWindowCoordinates(), m_plugin.clipRect(), windowID);
}
void NetscapePlugin::platformVisibilityDidChange()
{
if (!m_isWindowed)
return;
uint64_t windowID = 0;
#if PLATFORM(GTK)
windowID = static_cast<uint64_t>(GDK_WINDOW_XID(gtk_plug_get_socket_window(GTK_PLUG(m_platformPluginWidget))));
#endif
controller()->windowedPluginVisibilityDidChange(m_isVisible, windowID);
controller()->windowedPluginGeometryDidChange(m_frameRectInWindowCoordinates, m_clipRect, windowID);
}
static Window
bacon_video_widget_gst_get_toplevel (GtkWidget *widget)
{
GtkWidget *parent;
parent = gtk_widget_get_toplevel (GTK_WIDGET (widget));
if (parent == NULL)
return 0;
if (GTK_IS_PLUG (parent))
return bacon_video_widget_gtk_plug_get_toplevel (GTK_PLUG (parent));
else
return GDK_WINDOW_XID(gtk_widget_get_window (parent));
}
EggTrayIcon *
egg_tray_icon_new_for_xscreen (Screen *xscreen, const char *name)
{
EggTrayIcon *icon;
char buffer[256];
GdkWindow *root_window;
GdkDisplay *display;
GdkScreen *screen;
g_return_val_if_fail (xscreen != NULL, NULL);
icon = g_object_new (EGG_TYPE_TRAY_ICON, NULL);
gtk_window_set_title (GTK_WINDOW (icon), name);
display = gdk_x11_lookup_xdisplay (DisplayOfScreen (xscreen));
screen = gdk_display_get_screen (display, XScreenNumberOfScreen (xscreen));
gtk_plug_construct_for_display (GTK_PLUG (icon),
display, 0);
gtk_window_set_screen (GTK_WINDOW (icon), screen);
gtk_widget_realize (GTK_WIDGET (icon));
/* Now see if there's a manager window around */
g_snprintf (buffer, sizeof (buffer),
"_NET_SYSTEM_TRAY_S%d",
XScreenNumberOfScreen (xscreen));
icon->selection_atom = XInternAtom (DisplayOfScreen (xscreen),
buffer, False);
icon->manager_atom = XInternAtom (DisplayOfScreen (xscreen),
"MANAGER", False);
icon->system_tray_opcode_atom = XInternAtom (DisplayOfScreen (xscreen),
"_NET_SYSTEM_TRAY_OPCODE", False);
egg_tray_icon_update_manager_window (icon);
root_window = gdk_screen_get_root_window (gtk_widget_get_screen (GTK_WIDGET (icon)));
/* Add a root window filter so that we get changes on MANAGER */
gdk_window_add_filter (root_window,
egg_tray_icon_manager_filter, icon);
return icon;
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkEmbeddedWindowPeer_construct
(JNIEnv *env, jobject obj, jlong socket_id)
{
void *ptr;
gdk_threads_enter ();
ptr = gtkpeer_get_widget (env, obj);
if (GTK_WIDGET_REALIZED (GTK_WIDGET (ptr)))
g_printerr ("ERROR: GtkPlug is already realized\n");
gtk_plug_construct (GTK_PLUG (ptr), (GdkNativeWindow) socket_id);
gdk_threads_leave ();
}
void
lmplayer_interface_set_transient_for (GtkWindow *window, GtkWindow *parent)
{
if (GTK_IS_PLUG (parent)) {
GdkWindow *toplevel;
gtk_widget_realize (GTK_WIDGET (window));
toplevel = lmplayer_gtk_plug_get_toplevel (GTK_PLUG (parent));
if (toplevel != NULL) {
gdk_window_set_transient_for
(GTK_WIDGET (window)->window, toplevel);
g_object_unref (toplevel);
}
} else {
gtk_window_set_transient_for (GTK_WINDOW (window),
GTK_WINDOW (parent));
}
}
void NetscapePluginX11::geometryDidChange()
{
if (m_plugin.isWindowed()) {
uint64_t windowID = 0;
#if PLATFORM(GTK)
windowID = static_cast<uint64_t>(GDK_WINDOW_XID(gtk_plug_get_socket_window(GTK_PLUG(m_platformPluginWidget))));
#endif
m_plugin.controller()->windowedPluginGeometryDidChange(m_plugin.frameRectInWindowCoordinates(), m_plugin.clipRect(), windowID);
return;
}
m_drawable.reset();
if (m_plugin.size().isEmpty())
return;
m_drawable = XCreatePixmap(x11HostDisplay(), rootWindowID(), m_plugin.size().width(), m_plugin.size().height(), displayDepth());
XSync(x11HostDisplay(), false); // Make sure that the server knows about the Drawable.
}
EggTrayIcon * egg_tray_icon_new (const char *name, GdkPixbuf *pix) {
EggTrayIcon *icon;
char buffer[256];
GdkWindow *root_window;
Screen *xscreen=DefaultScreenOfDisplay (GDK_DISPLAY());
g_return_val_if_fail (pix!= NULL, NULL);
icon = g_object_new (EGG_TYPE_TRAY_ICON, NULL);
gtk_window_set_title (GTK_WINDOW (icon), name);
gtk_plug_construct (GTK_PLUG (icon), 0);
gtk_widget_realize (GTK_WIDGET (icon));
icon->ready=FALSE;
icon->default_pix=pix;
/* Now see if there's a manager window around */
g_snprintf (buffer, sizeof (buffer), "_NET_SYSTEM_TRAY_S%d",
XScreenNumberOfScreen (xscreen));
icon->selection_atom = XInternAtom (DisplayOfScreen (xscreen),
buffer, False);
icon->manager_atom = XInternAtom (DisplayOfScreen (xscreen),
"MANAGER", False);
icon->system_tray_opcode_atom = XInternAtom (DisplayOfScreen (xscreen),
"_NET_SYSTEM_TRAY_OPCODE", False);
gtk_window_present (GTK_WINDOW (icon));
egg_tray_icon_update_manager_window (icon);
root_window = gdk_window_lookup (gdk_x11_get_default_root_xwindow ());
/* Add a root window filter so that we get changes on MANAGER */
gdk_window_add_filter (root_window, egg_tray_icon_manager_filter, icon);
return icon;
}
static void
gtk_plug_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GtkPlug *plug = GTK_PLUG (object);
GtkPlugPrivate *priv = plug->priv;
switch (prop_id)
{
case PROP_EMBEDDED:
g_value_set_boolean (value, priv->socket_window != NULL);
break;
case PROP_SOCKET_WINDOW:
g_value_set_object (value, priv->socket_window);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
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();
}
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;
}
/* 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;
}
/* 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;
}
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);
}
WebKitWebView *
client_new(const gchar *uri)
{
struct Client *c;
WebKitWebContext *wc;
gchar *f;
if (uri != NULL && cooperative_instances && !cooperative_alone)
{
write(cooperative_pipe_fp, uri, strlen(uri));
write(cooperative_pipe_fp, "\n", 1);
return NULL;
}
c = malloc(sizeof(struct Client));
if (!c)
{
fprintf(stderr, __NAME__": fatal: malloc failed\n");
exit(EXIT_FAILURE);
}
c->hover_uri = NULL;
c->win = NULL;
if (embed != 0)
{
c->win = gtk_plug_new(embed);
if (!gtk_plug_get_embedded(GTK_PLUG(c->win)))
{
fprintf(stderr, __NAME__": Can't plug-in to XID %ld.\n", embed);
gtk_widget_destroy(c->win);
c->win = NULL;
embed = 0;
}
}
if (c->win == NULL)
{
c->win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_wmclass(GTK_WINDOW(c->win), __NAME__, __NAME_CAPITALIZED__);
}
gtk_window_set_default_size(GTK_WINDOW(c->win), 800, 600);
g_signal_connect(G_OBJECT(c->win), "destroy", G_CALLBACK(client_destroy), c);
gtk_window_set_title(GTK_WINDOW(c->win), __NAME__);
c->web_view = webkit_web_view_new();
wc = webkit_web_view_get_context(WEBKIT_WEB_VIEW(c->web_view));
webkit_web_view_set_zoom_level(WEBKIT_WEB_VIEW(c->web_view), global_zoom);
g_signal_connect(G_OBJECT(c->web_view), "notify::title",
G_CALLBACK(changed_title), c);
g_signal_connect(G_OBJECT(c->web_view), "notify::uri",
G_CALLBACK(changed_uri), c);
g_signal_connect(G_OBJECT(c->web_view), "notify::estimated-load-progress",
G_CALLBACK(changed_load_progress), c);
g_signal_connect(G_OBJECT(c->web_view), "create",
G_CALLBACK(client_new_request), NULL);
g_signal_connect(G_OBJECT(c->web_view), "close",
G_CALLBACK(client_destroy_request), c);
g_signal_connect(G_OBJECT(c->web_view), "decide-policy",
G_CALLBACK(decide_policy), NULL);
g_signal_connect(G_OBJECT(c->web_view), "key-press-event",
G_CALLBACK(key_web_view), c);
g_signal_connect(G_OBJECT(c->web_view), "button-press-event",
G_CALLBACK(key_web_view), c);
g_signal_connect(G_OBJECT(c->web_view), "scroll-event",
G_CALLBACK(key_web_view), c);
g_signal_connect(G_OBJECT(c->web_view), "mouse-target-changed",
G_CALLBACK(hover_web_view), c);
g_signal_connect(G_OBJECT(c->web_view), "web-process-crashed",
G_CALLBACK(crashed_web_view), c);
if (!initial_wc_setup_done)
{
if (accepted_language[0] != NULL)
webkit_web_context_set_preferred_languages(wc, accepted_language);
g_signal_connect(G_OBJECT(wc), "download-started",
G_CALLBACK(download_handle_start), NULL);
trust_user_certs(wc);
initial_wc_setup_done = TRUE;
}
if (user_agent != NULL)
g_object_set(G_OBJECT(webkit_web_view_get_settings(WEBKIT_WEB_VIEW(c->web_view))),
"user-agent", user_agent, NULL);
c->location = gtk_entry_new();
g_signal_connect(G_OBJECT(c->location), "key-press-event",
G_CALLBACK(key_location), c);
/* XXX Progress bars don't work/look as intended anymore. Level bars
* are a dirty workaround (kind of). */
c->progress = gtk_level_bar_new();
gtk_level_bar_set_value(GTK_LEVEL_BAR(c->progress), 0);
gtk_widget_set_size_request(c->progress, 100, -1);
c->top_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_box_pack_start(GTK_BOX(c->top_box), c->location, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(c->top_box), c->progress, FALSE, FALSE, 0);
c->vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 0);
gtk_box_pack_start(GTK_BOX(c->vbox), c->top_box, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(c->vbox), c->web_view, TRUE, TRUE, 0);
gtk_container_add(GTK_CONTAINER(c->win), c->vbox);
gtk_widget_grab_focus(c->web_view);
gtk_widget_show_all(c->win);
if (uri != NULL)
{
f = ensure_uri_scheme(uri);
webkit_web_view_load_uri(WEBKIT_WEB_VIEW(c->web_view), f);
g_free(f);
}
clients++;
return WEBKIT_WEB_VIEW(c->web_view);
}
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;
}
int main(int argc, char **argv)
{
GError *error = NULL;
unsigned long wid=0;
gtk_init( &argc, &argv );
int i;
for(i=0; i<argc; i++) {
if(strcmp("-h", argv[i])==0 || strcmp("--help", argv[i])==0) {
printHelp();
return 0;
}
else if(strcmp("-V", argv[i])==0 || strcmp("--version", argv[i])==0) {
printf("gtk_preview version 1.0\n");
return 0;
} else if(argc>1)
sscanf(argv[1], "%ld", &wid);
}
const char* ui_file = DATA_DIR "/preview.ui";
GtkBuilder *builder = gtk_builder_new();
if( ! gtk_builder_add_from_file( builder, ui_file, &error ) ) {
g_warning( "%s", error->message );
g_free( error );
return 1;
}
GtkWidget *previewUI = GTK_WIDGET( gtk_builder_get_object( builder, "frame1" ) );
gtk_builder_connect_signals( builder, NULL );
/* a plug when embedded, a window when a window */
GtkWidget* window;
if(wid==0) {
window = gtk_dialog_new();
gtk_container_add (GTK_CONTAINER (GTK_DIALOG (window)->vbox), previewUI);
g_signal_connect(window, "response", G_CALLBACK(on_dlg_response), NULL);
} else {
window = gtk_plug_new(wid);
gtk_container_add (GTK_CONTAINER (window), previewUI);
}
GdkColor black = {0, 0, 0, 0};
gtk_widget_modify_bg(previewUI, GTK_STATE_NORMAL, &black);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_widget_destroyed),
&window);
gtk_widget_show_all ( window );
g_object_unref( G_OBJECT( builder ) );
if(wid)
fprintf(stderr, "--- is embedded: %d\n", gtk_plug_get_embedded(GTK_PLUG(window)));
gchar** files = gtk_rc_get_default_files();
GFile* file = g_file_new_for_path(files[0]);
GFileMonitor* monitor = g_file_monitor_file(file, G_FILE_MONITOR_NONE, NULL, NULL);
g_signal_connect (monitor, "changed",
G_CALLBACK (reloadstyle), NULL);
gtk_main();
return 0;
}
