static GdkFilterReturn
gdk_to_clutter_event_pump__ (GdkXEvent *xevent,
GdkEvent *event,
gpointer data)
{
GdkDisplay *display = gdk_display_get_default ();
GdkWindow *gdk_win;
XEvent *xev = (XEvent*) xevent;
guint32 timestamp = 0;
gdk_win = gdk_x11_window_foreign_new_for_display (display, xev->xany.window);
if (!gdk_win)
gdk_win = gdk_x11_window_foreign_new_for_display (display,
GPOINTER_TO_INT (data));
/*
* Ensure we update the user time on this window if the event
* implies user action.
*/
switch (event->type)
{
case GDK_BUTTON_PRESS:
case GDK_2BUTTON_PRESS:
case GDK_3BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
timestamp = event->button.time;
break;
case GDK_MOTION_NOTIFY:
timestamp = event->motion.time;
break;
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
timestamp = event->key.time;
break;
default: ;
}
if (timestamp && gdk_win)
gdk_x11_window_set_user_time (gdk_win, timestamp);
switch (clutter_x11_handle_event (xev))
{
default:
case CLUTTER_X11_FILTER_CONTINUE:
return GDK_FILTER_CONTINUE;
case CLUTTER_X11_FILTER_TRANSLATE:
return GDK_FILTER_TRANSLATE;
case CLUTTER_X11_FILTER_REMOVE:
return GDK_FILTER_REMOVE;
}
};
void install_check_click_on_desktop (void)
{
Window desktop_window;
GdkWindow *window;
Atom user_time_window;
Atom user_time;
if (!get_desktop_window (&desktop_window)) {
return;
}
/* Access the desktop window. desktop_window is the root window for the
* default screen, so we know using gdk_display_get_default() is correct. */
window = gdk_x11_window_foreign_new_for_display (gdk_display_get_default (),
desktop_window);
/* It may contain an atom to tell us which other window to monitor */
user_time_window = gdk_x11_get_xatom_by_name ("_NET_WM_USER_TIME_WINDOW");
user_time = gdk_x11_get_xatom_by_name ("_NET_WM_USER_TIME");
if (user_time != None && user_time_window != None)
{
/* Looks like the atoms are there */
Atom actual_type;
int actual_format;
gulong nitems;
gulong bytes;
Window *data;
/* We only use this extra property if the actual user-time property's missing */
int status = XGetWindowProperty( GDK_DISPLAY_XDISPLAY(gdk_window_get_display(window)), desktop_window, user_time,
0, 4, False, AnyPropertyType, &actual_type, &actual_format,
&nitems, &bytes, (unsigned char **)&data );
if (actual_type == None)
{
/* No user-time property, so look for the user-time-window */
status = XGetWindowProperty( GDK_DISPLAY_XDISPLAY(gdk_window_get_display(window)), desktop_window, user_time_window,
0, 4, False, AnyPropertyType, &actual_type, &actual_format,
&nitems, &bytes, (unsigned char **)&data );
if (actual_type != None)
{
/* We have another window to monitor */
desktop_window = *data;
window = gdk_x11_window_foreign_new_for_display (gdk_window_get_display (window),
desktop_window);
}
}
}
gdk_window_set_events (window, GDK_PROPERTY_CHANGE_MASK);
gdk_window_add_filter (window, desktop_window_event_filter, NULL);
}
static GdkWindow *
totem_gtk_plug_get_toplevel (GtkPlug *plug)
{
Window root, parent, *children;
guint nchildren;
Window 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_XDISPLAY (gdk_display_get_default ()), xid, &root,
&parent, &children, &nchildren) == 0)
{
g_warning ("Couldn't find window manager window");
return NULL;
}
if (root == parent) {
GdkWindow *toplevel;
toplevel = gdk_x11_window_foreign_new_for_display (gdk_display_get_default (), xid);
return toplevel;
}
xid = parent;
}
while (TRUE);
}
/**
* Makes a dialog window stay above it's parent window.
*/
static void makeDialogTransient(GtkDialog *dialog, unsigned long parentWindowId) {
bool transientOk = false;
if (parentWindowId != PLATFORM_NO_WINDOW) {
#if GTK_CHECK_VERSION(2, 24, 0)
GdkDisplay *display = gdk_display_get_default();
GdkWindow *parent = gdk_x11_window_foreign_new_for_display(display,
(Window)parentWindowId);
#else
GdkWindow *parent = gdk_window_foreign_new((GdkNativeWindow)parentWindowId);
#endif
if (parent != NULL) {
gtk_widget_realize(GTK_WIDGET(dialog));
GdkWindow *ourWindow = gtk_widget_get_window(GTK_WIDGET(dialog));
if (ourWindow != NULL) {
gdk_window_set_transient_for(ourWindow, parent);
transientOk = true;
//g_object_unref(G_OBJECT(ourWindow));
}
g_object_unref(G_OBJECT(parent));
}
}
if (!transientOk) {
gtk_window_set_keep_above(GTK_WINDOW(dialog), TRUE);
}
}
GdkWindow* create_wrapper(GdkWindow* parent, Window tray_icon)
{
gdk_flush();
GdkWindow* icon = gdk_x11_window_foreign_new_for_display(gdk_display_get_default(), tray_icon);
if (icon == NULL)
return NULL;
GdkVisual* visual = gdk_window_get_visual(icon);
GdkWindow* wrapper = NULL;
if (gdk_visual_get_depth(visual) == 24) {
GdkWindowAttr attributes;
attributes.width = DEFAULT_HEIGHT;
attributes.height = DEFAULT_HEIGHT;
attributes.window_type = GDK_WINDOW_CHILD;
attributes.wclass = GDK_INPUT_OUTPUT;
attributes.event_mask = GDK_ALL_EVENTS_MASK;
attributes.visual = visual;
wrapper = gdk_window_new(parent, &attributes, GDK_WA_VISUAL);
//TODO: there should set color correspond by dock background color
/*GdkColor color = {1, 0, 0, 1};*/
/*gdk_window_set_background_rgba(wrapper, &color);*/
XReparentWindow(gdk_x11_get_default_xdisplay(),
tray_icon,
GDK_WINDOW_XID(wrapper),
0, 0);
gdk_window_show(icon);
g_object_set_data(G_OBJECT(wrapper), "wrapper_child", icon);
g_object_set_data(G_OBJECT(icon), "wrapper_parent", wrapper);
} else {
wrapper = icon;
}
return wrapper;
}
static gboolean
drw_selection_find_existing (DrwSelection *drw_selection)
{
Display *xdisplay = GDK_DISPLAY_XDISPLAY(gdk_display_get_default());
Window old;
gdk_error_trap_push ();
old = XGetSelectionOwner (xdisplay,
gdk_x11_get_xatom_by_name (SELECTION_NAME));
if (old) {
XSelectInput (xdisplay, old, StructureNotifyMask);
drw_selection->owner_window = gdk_x11_window_foreign_new_for_display (gdk_display_get_default (), old);
}
XSync (xdisplay, False);
if (gdk_error_trap_pop () == 0 && drw_selection->owner_window) {
gdk_window_add_filter (drw_selection->owner_window,
drw_selection_filter, drw_selection);
XUngrabServer (xdisplay);
return TRUE;
} else {
if (drw_selection->owner_window) {
g_object_unref (drw_selection->owner_window);
drw_selection->owner_window = NULL;
}
return FALSE;
}
}
int grab_window(int src_x, int src_y, int width, int height)
{
GdkWindow *window, *root;
#ifndef GTK3
window = gdk_window_foreign_new(GDK_ROOT_WINDOW());
root = gdk_window_foreign_new(GDK_ROOT_WINDOW());
#else
GdkDisplay *gdpy = gdk_display_get_default();
window = root = gdk_x11_window_foreign_new_for_display(gdpy, GDK_ROOT_WINDOW());
#endif
GdkPixbuf *screenshot;
GError *error = NULL;
if (src_x + width > gdk_screen_width ())
width = gdk_screen_width () - src_x;
if (src_y + height > gdk_screen_height ())
height = gdk_screen_height () - src_y;
time_t now;
time(&now);
char path[MAXPATHLEN];
snprintf(path, sizeof(path), "%s%i%s", "./screen-shot-window", now, ".png");
printf("%s\n", path);
#ifndef GTK3
screenshot = gdk_pixbuf_get_from_drawable (NULL, root, NULL, src_x, src_y, 0, 0, width, height);
#else
screenshot = gdk_pixbuf_get_from_window(root, src_x, src_y, width, height);
#endif
printf("----------------%d\n", gdk_pixbuf_get_rowstride(screenshot));
gdk_pixbuf_save (screenshot, path, "png", &error, "tEXt::CREATOR", "gnome-panel-screenshot", NULL);
return 0;
}
/**
* Attaches the key_filter() function as a filter
* to the the root window, so it will intercept window events.
*/
void
add_filter(void)
{
gdk_window_add_filter(
gdk_x11_window_foreign_new_for_display(
gdk_display_get_default(),GDK_ROOT_WINDOW()),
key_filter, NULL);
}
int grab_whole_screen()
{
GdkWindow *window, *root;
#ifndef GTK3
window = gdk_window_foreign_new(GDK_ROOT_WINDOW());
root = gdk_window_foreign_new(GDK_ROOT_WINDOW());
#else
GdkDisplay *gdpy = gdk_display_get_default();
window = root = gdk_x11_window_foreign_new_for_display(gdpy, GDK_ROOT_WINDOW());
#endif
GdkPixbuf *screenshot;
gint x_real_orig, y_real_orig;
gint x_orig, y_orig;
gint real_width, real_height;
gint width, height;
GError *error = NULL;
#ifndef GTK3
gdk_drawable_get_size(window, &real_width, &real_height);
#else
real_width = gdk_window_get_width(window);
real_height = gdk_window_get_height(window);
#endif
gdk_window_get_origin(window, &x_real_orig, &y_real_orig);
x_orig = x_real_orig;
y_orig = y_real_orig;
width = real_width;
height = real_height;
if (x_orig < 0) {
width = width + x_orig;
x_orig = 0;
}
if (y_orig < 0) {
height = height + y_orig;
y_orig = 0;
}
if (x_orig + width > gdk_screen_width ())
width = gdk_screen_width () - x_orig;
if (y_orig + height > gdk_screen_height ())
height = gdk_screen_height () - y_orig;
char path[MAXPATHLEN];
time_t now;
time(&now);
snprintf(path, sizeof(path), "%s%i%s", "./screen-shot-whole-screen-", now, ".png");
#ifndef GTK3
screenshot = gdk_pixbuf_get_from_drawable (NULL, root, NULL, x_orig, y_orig, 0, 0, width, height);
#else
screenshot = gdk_pixbuf_get_from_window(root, x_orig, y_orig, width, height);
#endif
gdk_pixbuf_save (screenshot, path, "png", &error, "tEXt::CREATOR", "gnome-panel-screenshot", NULL);
return 0;
}
/**
* nemo_preview_create_foreign_window:
* @xid:
*
* Returns: (transfer full): a #GdkWindow
*/
GdkWindow *
nemo_preview_create_foreign_window (guint xid)
{
GdkWindow *retval;
retval = gdk_x11_window_foreign_new_for_display (gdk_display_get_default (),
xid);
return retval;
}
static GList *
gdk_x11_screen_get_window_stack (GdkScreen *screen)
{
GdkX11Screen *x11_screen;
GList *ret = NULL;
Atom type_return;
gint format_return;
gulong nitems_return;
gulong bytes_after_return;
guchar *data = NULL;
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
if (!gdk_x11_screen_supports_net_wm_hint (screen,
gdk_atom_intern_static_string ("_NET_CLIENT_LIST_STACKING")))
return NULL;
x11_screen = GDK_X11_SCREEN (screen);
if (XGetWindowProperty (x11_screen->xdisplay, x11_screen->xroot_window,
gdk_x11_get_xatom_by_name_for_display (x11_screen->display,
"_NET_CLIENT_LIST_STACKING"),
0, G_MAXLONG, False, XA_WINDOW, &type_return,
&format_return, &nitems_return,
&bytes_after_return, &data)
== Success)
{
if ((type_return == XA_WINDOW) && (format_return == 32) &&
(data) && (nitems_return > 0))
{
gulong *stack = (gulong *) data;
GdkWindow *win;
int i;
for (i = 0; i < nitems_return; i++)
{
win = gdk_x11_window_foreign_new_for_display (x11_screen->display,
(Window)stack[i]);
if (win != NULL)
ret = g_list_append (ret, win);
}
}
}
if (data)
XFree (data);
return ret;
}
static GdkWindow *
gimp_ui_get_foreign_window (guint32 window)
{
#ifdef GDK_WINDOWING_X11
return gdk_x11_window_foreign_new_for_display (gdk_display_get_default (),
window);
#endif
#ifdef GDK_WINDOWING_WIN32
return gdk_win32_window_foreign_new_for_display (gdk_display_get_default (),
window);
#endif
return NULL;
}
static void
initialize_root_window (HDDesktop *desktop)
{
HDDesktopPrivate *priv = desktop->priv;
priv->root_window = gdk_x11_window_foreign_new_for_display (gdk_display_get_default (),
gdk_x11_get_default_root_xwindow ());
gdk_window_set_events (priv->root_window,
gdk_window_get_events (priv->root_window) | GDK_PROPERTY_CHANGE_MASK);
gdk_window_add_filter (priv->root_window,
filter_property_changed,
desktop);
}
static void
gcm_window_set_parent_xid (GtkWindow *window, guint32 _xid)
{
GdkDisplay *display;
GdkWindow *parent_window;
GdkWindow *our_window;
display = gdk_display_get_default ();
parent_window = gdk_x11_window_foreign_new_for_display (display, _xid);
our_window = gtk_widget_get_window (GTK_WIDGET (window));
/* set this above our parent */
gtk_window_set_modal (window, TRUE);
gdk_window_set_transient_for (our_window, parent_window);
}
static Bool
gdk_xsettings_watch_cb (Window window,
Bool is_start,
long mask,
void *cb_data)
{
GdkWindow *gdkwin;
GdkScreen *screen = cb_data;
gdkwin = gdk_x11_window_lookup_for_display (gdk_screen_get_display (screen), window);
if (is_start)
{
if (gdkwin)
g_object_ref (gdkwin);
else
{
gdkwin = gdk_x11_window_foreign_new_for_display (gdk_screen_get_display (screen), window);
/* gdk_window_foreign_new_for_display() can fail and return NULL if the
* window has already been destroyed.
*/
if (!gdkwin)
return False;
}
gdk_window_add_filter (gdkwin, gdk_xsettings_client_event_filter, screen);
}
else
{
if (!gdkwin)
{
/* gdkwin should not be NULL here, since if starting the watch succeeded
* we have a reference on the window. It might mean that the caller didn't
* remove the watch when it got a DestroyNotify event. Or maybe the
* caller ignored the return value when starting the watch failed.
*/
g_warning ("gdk_xsettings_watch_cb(): Couldn't find window to unwatch");
return False;
}
gdk_window_remove_filter (gdkwin, gdk_xsettings_client_event_filter, screen);
g_object_unref (gdkwin);
}
return True;
}
/**
* Transfers image data from a GdkWindow and converts it to an RGB(A)
* representation inside a GdkPixbuf. In other words, copies image data
* from a server-side drawable to a client-side RGB(A) buffer.
* This allows to efficiently read individual pixels on the client side.
*
* Create a new GdkPixbuf containing a copy of src scaled to dest_width x dest_height .
* Leaves src unaffected. interp_type should be GDK_INTERP_NEAREST
* if you want maximum speed (but when scaling down GDK_INTERP_NEAREST is usually unusably ugly).
* The default interp_type should be GDK_INTERP_BILINEAR which offers reasonable quality and speed.
*
* @param DockItem* item
* @return GdkPixbuf*
*
*/
GdkPixbuf* Preview::getScaledPixbuf(DockItem* item)
{
GdkWindow *wm_window = gdk_x11_window_foreign_new_for_display(
gdk_display_get_default(), item->m_xid);
GdkRectangle boundingbox;
gdk_window_get_frame_extents(wm_window, &boundingbox);
GdkPixbuf *pb = gdk_pixbuf_get_from_window(wm_window,
0, 0, boundingbox.width - 10, boundingbox.height - 30);
if (pb == NULL) {
return nullptr;
}
int height = m_previewHeight - DEF_PREVIEW_SCALE_HEIGHT_OFFSET;
int width = m_previewWidth - DEF_PREVIEW_SCALE_WIDTH_OFFSET;
int scale_heght = height;
int windowheight = gdk_window_get_height(wm_window);
int heightHalf = (height / 2);
if (windowheight < 300)
scale_heght = heightHalf;
if (windowheight < 200)
scale_heght = heightHalf - 20;
if (windowheight < 100)
scale_heght = heightHalf - 40;
if (windowheight < 50)
scale_heght = heightHalf - 60;
if (scale_heght < 10)
scale_heght = height;
// offers reasonable quality and speed.
GdkPixbuf* scaledpb = gdk_pixbuf_scale_simple(pb, width, scale_heght,
GDK_INTERP_BILINEAR);
g_object_unref(pb);
return scaledpb;
}
gboolean
gpk_window_set_parent_xid (GtkWindow *window, guint32 xid)
{
GdkDisplay *display;
GdkWindow *parent_window;
GdkWindow *our_window;
g_return_val_if_fail (xid != 0, FALSE);
display = gdk_display_get_default ();
parent_window = gdk_x11_window_foreign_new_for_display (display, xid);
our_window = gtk_widget_get_window (GTK_WIDGET (window));
/* set this above our parent */
gtk_window_set_modal (window, TRUE);
gdk_window_set_transient_for (our_window, parent_window);
return TRUE;
}
static GdkWindow *
gdk_x11_screen_get_active_window (GdkScreen *screen)
{
GdkX11Screen *x11_screen;
GdkWindow *ret = NULL;
Atom type_return;
gint format_return;
gulong nitems_return;
gulong bytes_after_return;
guchar *data = NULL;
g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
if (!gdk_x11_screen_supports_net_wm_hint (screen,
gdk_atom_intern_static_string ("_NET_ACTIVE_WINDOW")))
return NULL;
x11_screen = GDK_X11_SCREEN (screen);
if (XGetWindowProperty (x11_screen->xdisplay, x11_screen->xroot_window,
gdk_x11_get_xatom_by_name_for_display (x11_screen->display,
"_NET_ACTIVE_WINDOW"),
0, 1, False, XA_WINDOW, &type_return,
&format_return, &nitems_return,
&bytes_after_return, &data)
== Success)
{
if ((type_return == XA_WINDOW) && (format_return == 32) && (data))
{
Window window = *(Window *) data;
if (window != None)
{
ret = gdk_x11_window_foreign_new_for_display (x11_screen->display,
window);
}
}
}
if (data)
XFree (data);
return ret;
}
JS_EXPORT_API
void dock_draw_window_preview(JSValueRef canvas, double xid, double dest_width, double dest_height)
{
GdkWindow* win = gdk_x11_window_foreign_new_for_display(gdk_display_get_default(), (long)xid);
if (win == NULL) {
return;
}
if (JSValueIsNull(get_global_context(), canvas)) {
g_debug("draw_window_preview with null canvas!");
return;
}
cairo_t* cr = fetch_cairo_from_html_canvas(get_global_context(), canvas);
if (cr == NULL) {
return;
}
cairo_save(cr);
//clear preview content to prevent translucency window problem
cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);
cairo_paint(cr);
cairo_restore(cr);
int width = gdk_window_get_width(win);
int height = gdk_window_get_height(win);
cairo_save(cr);
double scale = 0;
if (width > height) {
scale = dest_width/width;
cairo_scale(cr, scale, scale);
gdk_cairo_set_source_window(cr, win, 0, 0.5*(dest_height/scale-height));
} else {
scale = dest_height/height;
cairo_scale(cr, scale, scale);
gdk_cairo_set_source_window(cr, win, 0.5*(dest_width/scale-width), 0);
}
cairo_paint(cr);
cairo_restore(cr);
canvas_custom_draw_did(cr, NULL);
}
/* Returns a new reference to window */
static GdkWindow *
window_for_actor (ClutterActor *actor)
{
GdkDisplay *display = gdk_display_get_default ();
ClutterActor *stage;
Window xwindow;
GdkWindow *window;
stage = clutter_actor_get_stage (actor);
xwindow = clutter_x11_get_stage_window ((ClutterStage *)stage);
window = gdk_x11_window_lookup_for_display (display, xwindow);
if (window)
g_object_ref (window);
else
window = gdk_x11_window_foreign_new_for_display (display, xwindow);
return window;
}
void
cinnamon_tray_manager_manage_stage (CinnamonTrayManager *manager,
ClutterStage *stage,
StWidget *theme_widget)
{
Window stage_xwindow;
GdkWindow *stage_window;
GdkDisplay *display;
GdkScreen *screen;
g_return_if_fail (manager->priv->stage == NULL);
manager->priv->stage = g_object_ref (stage);
stage_xwindow = clutter_x11_get_stage_window (stage);
/* This is a pretty ugly way to get the GdkScreen for the stage; it
* will normally go through the foreign_new() case with a
* round-trip to the X server, it might be nicer to pass the screen
* in in some way. (The Clutter/Muffin combo is currently incapable
* of multi-screen operation, so alternatively we could just assume
* that clutter_x11_get_default_screen() gives us the right
* screen.) We assume, in any case, that we are using the default
* GDK display.
*/
display = gdk_display_get_default();
stage_window = gdk_x11_window_lookup_for_display (display, stage_xwindow);
if (stage_window)
g_object_ref (stage_window);
else
stage_window = gdk_x11_window_foreign_new_for_display (display, stage_xwindow);
screen = gdk_window_get_screen (stage_window);
g_object_unref (stage_window);
na_tray_manager_manage_screen (manager->priv->na_manager, screen);
g_signal_connect (theme_widget, "style-changed",
G_CALLBACK (cinnamon_tray_manager_style_changed), manager);
cinnamon_tray_manager_style_changed (theme_widget, manager);
}
bool wxNativeContainerWindow::Create(wxNativeContainerWindowId anid)
{
bool rc;
#ifdef __WXGTK3__
GdkWindow * const win = gdk_x11_window_foreign_new_for_display(gdk_display_get_default(), anid);
#else
GdkWindow * const win = gdk_window_foreign_new(anid);
#endif
if ( win )
{
rc = Create(win);
g_object_unref(win);
}
else // invalid native window id
{
rc = false;
}
return rc;
}
static void
check_manager_window (GdkX11Screen *x11_screen,
gboolean notify_changes)
{
GdkDisplay *display;
Display *xdisplay;
Window manager_window_xid;
display = x11_screen->display;
xdisplay = gdk_x11_display_get_xdisplay (display);
if (x11_screen->xsettings_manager_window)
{
gdk_window_remove_filter (x11_screen->xsettings_manager_window, gdk_xsettings_manager_window_filter, x11_screen);
g_object_unref (x11_screen->xsettings_manager_window);
}
gdk_x11_display_grab (display);
manager_window_xid = XGetSelectionOwner (xdisplay, get_selection_atom (x11_screen));
x11_screen->xsettings_manager_window = gdk_x11_window_foreign_new_for_display (display,
manager_window_xid);
/* XXX: Can't use gdk_window_set_events() here because the first call to this
* function happens too early in gdk_init() */
if (x11_screen->xsettings_manager_window)
XSelectInput (xdisplay,
gdk_x11_window_get_xid (x11_screen->xsettings_manager_window),
PropertyChangeMask | StructureNotifyMask);
gdk_x11_display_ungrab (display);
gdk_display_flush (display);
if (x11_screen->xsettings_manager_window)
{
gdk_window_add_filter (x11_screen->xsettings_manager_window, gdk_xsettings_manager_window_filter, x11_screen);
}
read_settings (x11_screen, notify_changes);
}
void
S9xOpenGLDisplayDriver::create_window (int width, int height)
{
XSetWindowAttributes window_attr;
window_attr.colormap = xcolormap;
window_attr.border_pixel = 0;
window_attr.event_mask = StructureNotifyMask | ExposureMask;
window_attr.background_pixmap = None;
xwindow = XCreateWindow (display,
GDK_COMPAT_WINDOW_XID (gtk_widget_get_window (drawing_area)),
0,
0,
width,
height,
0,
vi->depth,
InputOutput,
vi->visual,
CWColormap | CWBorderPixel | CWBackPixmap | CWEventMask,
&window_attr);
XSync (display, False);
output_window_width = width;
output_window_height = height;
XMapWindow (display, xwindow);
XSync (display, False);
#if USE_GTK3
gdk_window = gdk_x11_window_foreign_new_for_display (gtk_widget_get_display (drawing_area), xwindow);
#else
gdk_window = gdk_window_foreign_new (xwindow);
#endif
XSync (display, False);
gdk_window_set_user_data (gdk_window, drawing_area);
}
int main(int argc, char *argv[])
{
setbuf(stdout, NULL);
setbuf(stderr, NULL);
setlocale(LC_ALL, "");
char* domain = textdomain(PACKAGE_NAME);
assert(domain != NULL);
bind_textdomain_codeset(PACKAGE_NAME, "UTF-8");
textdomain(PACKAGE_NAME);
gint update_rate = 100;
gint cell_size = 4;
gboolean print_version = FALSE;
GOptionEntry cmd_options[] = {
{"update-rate", 'u', 0, G_OPTION_ARG_INT, &update_rate, _C("Update rate in msec"), "100"},
{"cell_size", 'c', 0, G_OPTION_ARG_INT, &cell_size, _C("Cell size"), "8"},
{"version", 'v', 0, G_OPTION_ARG_NONE, &print_version, _C("Print version"), NULL},
{NULL}
};
GError *error = NULL;
GOptionContext *cmd_context = g_option_context_new(NULL);
g_option_context_set_help_enabled(cmd_context, TRUE);
g_option_context_add_main_entries(cmd_context, cmd_options, NULL);
gchar **cmd_line = g_strdupv(argv);
gint cmd_count = argc;
if(g_option_context_parse(cmd_context, &cmd_count, &cmd_line, &error) == FALSE)
{
fprintf(stderr, _C("ERROR: %s\n\n"), error->message);
g_error_free(error);
}
else
{
if(print_version == TRUE)
{
printf("game-life: %s\n", PACKAGE_VERSION);
}
else
{
gtk_init(&argc, &argv);
GdkScreen* default_screen = gdk_screen_get_default();
gint screen_height = gdk_screen_get_height(default_screen);
gint screen_width = gdk_screen_get_width(default_screen);
size_t world_height = screen_height / (cell_size +1);
size_t world_width = screen_width / (cell_size +1);
game_universe_t* universe = NULL;
game_init_universe(&universe, world_width, world_height, cell_size);
game_set_random(universe);
GtkWidget* main_wnd = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GdkWindow* root_wnd = gdk_screen_get_root_window(default_screen);
gtk_widget_set_window(main_wnd, root_wnd);
//gtk_window_fullscreen(GTK_WINDOW(main_wnd));
gtk_widget_set_app_paintable(main_wnd, TRUE);
g_signal_connect(main_wnd, "destroy", G_CALLBACK(gtk_main_quit), NULL);
g_signal_connect(main_wnd, "event", G_CALLBACK(event_cb), NULL);
g_signal_connect(main_wnd, "draw", G_CALLBACK(draw_cb), universe);
const char* remote_wnd_env = getenv("XSCREENSAVER_WINDOW");
if(remote_wnd_env != NULL) // FIXME what is this shit? i dont know
{
char* end = NULL;
Window remote_wnd = (Window)strtol(remote_wnd_env, &end, 0);
GdkDisplay* default_display = gdk_display_get_default();
GdkWindow* window = gdk_x11_window_foreign_new_for_display(default_display, remote_wnd);
//GtkStyle* main_wnd_style = gtk_widget_get_style(main_wnd);
//gtk_style_set_background(main_wnd_style, window, GTK_STATE_NORMAL);
gtk_widget_set_window(main_wnd, window);
gtk_widget_set_realized(main_wnd, TRUE);
gtk_window_resize(GTK_WINDOW(main_wnd), screen_width, screen_height);
}
gtk_widget_show_all(main_wnd);
g_timeout_add(update_rate, update_image, main_wnd);
gtk_main();
}
}
g_option_context_free(cmd_context);
g_strfreev(cmd_line);
return 0;
}
bool show(Display* parent) override {
static std::string s_lastUsedDir;
if (s_lastUsedDir.empty())
s_lastUsedDir = g_get_user_special_dir(G_USER_DIRECTORY_DESKTOP);
const char* okLabel;
GtkFileChooserAction action;
switch (m_type) {
case Type::OpenFile:
case Type::OpenFiles:
action = GTK_FILE_CHOOSER_ACTION_OPEN;
okLabel = "_Open";
break;
case Type::OpenFolder:
action = GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER;
okLabel = "_Open Folder";
break;
case Type::SaveFile:
action = GTK_FILE_CHOOSER_ACTION_SAVE;
okLabel = "_Save";
break;
}
// GtkWindow* gtkParent = nullptr;
GtkWidget* dialog = gtk_file_chooser_dialog_new(
m_title.c_str(),
nullptr,
action,
"_Cancel", GTK_RESPONSE_CANCEL,
okLabel, GTK_RESPONSE_ACCEPT,
nullptr);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
GtkFileChooser* chooser = GTK_FILE_CHOOSER(dialog);
m_chooser = chooser;
if (m_type == Type::SaveFile)
gtk_file_chooser_set_do_overwrite_confirmation(chooser, TRUE);
else if (m_type == Type::OpenFiles)
gtk_file_chooser_set_select_multiple(chooser, true);
if (m_type != Type::OpenFolder) {
setupFilters(base::get_file_extension(m_filename));
setupPreview();
}
if (m_initialDir.empty())
gtk_file_chooser_set_current_folder(chooser, s_lastUsedDir.c_str());
else
gtk_file_chooser_set_current_folder(chooser, m_initialDir.c_str());
if (!m_filename.empty()) {
std::string fn = m_filename;
// Add default extension
if (m_type == Type::SaveFile && base::get_file_extension(fn).empty()) {
fn.push_back('.');
fn += m_defExtension;
}
gtk_file_chooser_set_current_name(chooser, fn.c_str());
}
// Setup the "parent" display as the parent of the dialog (we've
// to convert a X11 Window into a GdkWindow to do this).
GdkWindow* gdkParentWindow = nullptr;
if (parent) {
GdkWindow* gdkWindow = gtk_widget_get_root_window(dialog);
gdkParentWindow =
gdk_x11_window_foreign_new_for_display(
gdk_window_get_display(gdkWindow),
(::Window)parent->nativeHandle());
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
gdk_window_set_transient_for(gdkWindow, gdkParentWindow);
}
else {
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER);
}
// Show the dialog
gint res = gtk_dialog_run(GTK_DIALOG(dialog));
if (res == GTK_RESPONSE_ACCEPT) {
s_lastUsedDir = gtk_file_chooser_get_current_folder(chooser);
m_filename = gtk_file_chooser_get_filename(chooser);
if (m_type == Type::OpenFiles) {
GSList* list = gtk_file_chooser_get_filenames(chooser);
g_slist_foreach(
list,
[](void* fn, void* userdata){
auto self = (FileDialogGTK*)userdata;
self->m_filenames.push_back((char*)fn);
g_free(fn);
}, this);
g_slist_free(list);
}
}
gtk_widget_destroy(dialog);
if (gdkParentWindow)
g_object_unref(gdkParentWindow);
// Pump gtk+ events to finally hide the dialog from the screen
while (gtk_events_pending())
gtk_main_iteration();
return (res == GTK_RESPONSE_ACCEPT);
}
static void
gs_theme_window_real_realize (GtkWidget *widget)
{
GdkWindow *window;
Window remote_xwindow;
GtkRequisition requisition;
GtkAllocation allocation;
const char *preview_xid;
int x;
int y;
int width;
int height;
int event_mask;
event_mask = 0;
window = NULL;
preview_xid = g_getenv ("XSCREENSAVER_WINDOW");
if (preview_xid != NULL)
{
char *end;
remote_xwindow = (Window) strtoul (preview_xid, &end, 0);
if ((remote_xwindow != 0) && (end != NULL) &&
((*end == ' ') || (*end == '\0')) &&
((remote_xwindow < G_MAXULONG) || (errno != ERANGE)))
{
window = gdk_x11_window_foreign_new_for_display (gdk_display_get_default (), remote_xwindow);
if (window != NULL)
{
/* This is a kludge; we need to set the same
* flags gs-window-x11.c does, to ensure they
* don't get unset by gtk_window_map() later.
*/
gtk_window_set_decorated (GTK_WINDOW (widget), FALSE);
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (widget), TRUE);
gtk_window_set_skip_pager_hint (GTK_WINDOW (widget), TRUE);
gtk_window_set_keep_above (GTK_WINDOW (widget), TRUE);
gtk_window_fullscreen (GTK_WINDOW (widget));
event_mask = GDK_EXPOSURE_MASK | GDK_STRUCTURE_MASK;
gtk_widget_set_events (widget, gtk_widget_get_events (widget) | event_mask);
}
}
}
if (window == NULL)
{
GtkWidgetClass *parent_class;
parent_class = GTK_WIDGET_CLASS (gs_theme_window_parent_class);
if (parent_class->realize != NULL)
parent_class->realize (widget);
return;
}
gtk_style_context_set_background (gtk_widget_get_style_context (widget),
window);
gdk_window_set_decorations (window, (GdkWMDecoration) 0);
gdk_window_set_events (window, gdk_window_get_events (window) | event_mask);
gtk_widget_set_window (widget, window);
gdk_window_set_user_data (window, widget);
gtk_widget_set_realized (widget, TRUE);
gdk_window_get_geometry (window, &x, &y, &width, &height);
if (width < MIN_SIZE || height < MIN_SIZE)
{
g_critical ("This window is way too small to use");
exit (1);
}
gtk_widget_get_preferred_size (widget, &requisition, NULL);
allocation.x = x;
allocation.y = y;
allocation.width = width;
allocation.height = height;
gtk_widget_size_allocate (widget, &allocation);
gtk_window_resize (GTK_WINDOW (widget), width, height);
}
GtkWidget *
create_dialog (void)
{
GtkWidget *dlg;
GtkWidget *hbox, *vbox, *hbox2, *bbox;
GtkWidget *image;
GtkWidget *text;
GtkWidget *main_widget = NULL;
GtkWidget *topb = NULL;
/* create dialog window */
dlg = gtk_dialog_new ();
if (options.data.splash)
gtk_window_set_type_hint (GTK_WINDOW (dlg), GDK_WINDOW_TYPE_HINT_SPLASHSCREEN);
else
gtk_window_set_type_hint (GTK_WINDOW (dlg), GDK_WINDOW_TYPE_HINT_NORMAL);
gtk_window_set_title (GTK_WINDOW (dlg), options.data.dialog_title);
gtk_widget_set_name (dlg, "yad-dialog-window");
#ifndef G_OS_WIN32
if (options.parent)
{
gdk_window_set_transient_for (gtk_widget_get_window (dlg),
gdk_x11_window_foreign_new_for_display (gdk_display_get_default (),
options.parent));
}
#endif
if (options.data.no_escape)
g_signal_connect (G_OBJECT (dlg), "close", G_CALLBACK (ignore_close_cb) , NULL);
/* get buttons container */
bbox = gtk_dialog_get_action_area (GTK_DIALOG (dlg));
/* set window icon */
if (options.data.window_icon)
{
if (g_file_test (options.data.window_icon, G_FILE_TEST_EXISTS))
gtk_window_set_icon_from_file (GTK_WINDOW (dlg), options.data.window_icon, NULL);
else
gtk_window_set_icon_name (GTK_WINDOW (dlg), options.data.window_icon);
}
/* set window borders */
if (options.data.borders == -1)
options.data.borders = (gint) gtk_container_get_border_width (GTK_CONTAINER (dlg));
gtk_container_set_border_width (GTK_CONTAINER (dlg), (guint) options.data.borders);
/* set window size and position */
if (!options.data.geometry && !options.data.maximized && !options.data.fullscreen)
{
gtk_window_set_default_size (GTK_WINDOW (dlg), options.data.width, options.data.height);
if (options.data.center)
gtk_window_set_position (GTK_WINDOW (dlg), GTK_WIN_POS_CENTER);
else if (options.data.mouse)
gtk_window_set_position (GTK_WINDOW (dlg), GTK_WIN_POS_MOUSE);
}
/* set window behavior */
if (options.data.sticky)
gtk_window_stick (GTK_WINDOW (dlg));
gtk_window_set_keep_above (GTK_WINDOW (dlg), options.data.ontop);
gtk_window_set_decorated (GTK_WINDOW (dlg), !options.data.undecorated);
gtk_window_set_skip_taskbar_hint (GTK_WINDOW (dlg), options.data.skip_taskbar);
gtk_window_set_skip_pager_hint (GTK_WINDOW (dlg), options.data.skip_taskbar);
/* create timeout indicator widget */
if (options.data.timeout)
{
if (G_LIKELY (options.data.to_indicator) && g_ascii_strcasecmp (options.data.to_indicator, "none"))
{
topb = gtk_progress_bar_new ();
gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (topb), 1.0);
gtk_widget_set_name (topb, "yad-timeout-indicator");
}
}
/* add top label widgets */
#if !GTK_CHECK_VERSION(3,0,0)
hbox = hbox2 = gtk_hbox_new (FALSE, 0);
#else
hbox = hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
#endif
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))), hbox, TRUE, TRUE, 5);
#if !GTK_CHECK_VERSION(3,0,0)
vbox = gtk_vbox_new (FALSE, 0);
#else
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
#endif
/* add timeout indicator */
if (topb)
{
if (g_ascii_strcasecmp (options.data.to_indicator, "top") == 0)
{
#if !GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (topb), GTK_PROGRESS_LEFT_TO_RIGHT);
#endif
gtk_box_pack_start (GTK_BOX (vbox), topb, FALSE, FALSE, 2);
}
else if (g_ascii_strcasecmp (options.data.to_indicator, "bottom") == 0)
{
#if !GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (topb), GTK_PROGRESS_LEFT_TO_RIGHT);
#endif
gtk_box_pack_end (GTK_BOX (vbox), topb, FALSE, FALSE, 2);
}
else if (g_ascii_strcasecmp (options.data.to_indicator, "left") == 0)
{
#if !GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (topb), GTK_PROGRESS_BOTTOM_TO_TOP);
#endif
gtk_box_pack_start (GTK_BOX (hbox), topb, FALSE, FALSE, 2);
}
else if (g_ascii_strcasecmp (options.data.to_indicator, "right") == 0)
{
#if !GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_orientation (GTK_PROGRESS_BAR (topb), GTK_PROGRESS_BOTTOM_TO_TOP);
#endif
gtk_box_pack_end (GTK_BOX (hbox), topb, FALSE, FALSE, 2);
}
if (settings.show_remain)
{
gchar *lbl = g_strdup_printf (_("%d sec"), options.data.timeout);
#if GTK_CHECK_VERSION(3,0,0)
gtk_progress_bar_set_show_text (GTK_PROGRESS_BAR (topb), TRUE);
#endif
gtk_progress_bar_set_text (GTK_PROGRESS_BAR (topb), lbl);
g_free (lbl);
}
}
/* must be after indicator! */
gtk_box_pack_end (GTK_BOX (hbox), vbox, TRUE, TRUE, 0);
if (options.data.image_on_top)
{
#if !GTK_CHECK_VERSION(3,0,0)
hbox2 = gtk_hbox_new (FALSE, 0);
#else
hbox2 = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
#endif
gtk_box_pack_start (GTK_BOX (vbox), hbox2, FALSE, FALSE, 0);
}
if (options.data.dialog_image)
{
GdkPixbuf *pb = NULL;
pb = get_pixbuf (options.data.dialog_image, YAD_BIG_ICON);
image = gtk_image_new_from_pixbuf (pb);
if (pb)
g_object_unref (pb);
gtk_widget_set_name (image, "yad-dialog-image");
gtk_misc_set_alignment (GTK_MISC (image), 0.5, 0.0);
gtk_box_pack_start (GTK_BOX (hbox2), image, FALSE, FALSE, 2);
}
if (options.data.dialog_text)
{
/* for dnd's tooltip we don't need text label */
if (options.mode != YAD_MODE_DND || !options.dnd_data.tooltip)
{
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);
g_free (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;
}
if (options.data.image_on_top)
gtk_box_pack_start (GTK_BOX (hbox2), text, TRUE, TRUE, 2);
else
gtk_box_pack_start (GTK_BOX (vbox), text, FALSE, FALSE, 2);
#if !GTK_CHECK_VERSION(3,0,0)
if (!options.data.fixed)
g_signal_connect (G_OBJECT (text), "size-allocate", G_CALLBACK (text_size_allocate_cb), NULL);
#endif
}
}
/* add main widget */
switch (options.mode)
{
case YAD_MODE_CALENDAR:
main_widget = calendar_create_widget (dlg);
break;
case YAD_MODE_COLOR:
main_widget = color_create_widget (dlg);
break;
case YAD_MODE_DND:
dnd_init (dlg);
break;
case YAD_MODE_ENTRY:
main_widget = entry_create_widget (dlg);
break;
case YAD_MODE_FILE:
main_widget = file_create_widget (dlg);
break;
case YAD_MODE_FONT:
main_widget = font_create_widget (dlg);
break;
case YAD_MODE_FORM:
main_widget = form_create_widget (dlg);
break;
#ifdef HAVE_HTML
case YAD_MODE_HTML:
main_widget = html_create_widget (dlg);
break;
#endif
case YAD_MODE_ICONS:
main_widget = icons_create_widget (dlg);
break;
case YAD_MODE_LIST:
main_widget = list_create_widget (dlg);
break;
case YAD_MODE_MULTI_PROGRESS:
main_widget = multi_progress_create_widget (dlg);
break;
case YAD_MODE_NOTEBOOK:
main_widget = notebook_create_widget (dlg);
break;
case YAD_MODE_PANED:
main_widget = paned_create_widget (dlg);
break;
case YAD_MODE_PROGRESS:
main_widget = progress_create_widget (dlg);
break;
case YAD_MODE_SCALE:
main_widget = scale_create_widget (dlg);
break;
case YAD_MODE_TEXTINFO:
main_widget = text_create_widget (dlg);
break;
default:
;
}
if (main_widget)
{
if (options.data.expander)
{
GtkWidget *exp;
exp = gtk_expander_new_with_mnemonic (options.data.expander);
gtk_expander_set_expanded (GTK_EXPANDER (exp), FALSE);
gtk_container_add (GTK_CONTAINER (exp), main_widget);
gtk_box_pack_start (GTK_BOX (vbox), exp, TRUE, TRUE, 2);
}
else
gtk_box_pack_start (GTK_BOX (vbox), main_widget, TRUE, TRUE, 2);
}
/* add buttons */
if (!options.data.no_buttons)
{
if (options.data.buttons)
{
GSList *tmp = options.data.buttons;
do
{
GtkWidget *btn;
YadButton *b = (YadButton *) tmp->data;
btn = gtk_button_new ();
gtk_container_add (GTK_CONTAINER (btn), get_label (b->name, 2));
gtk_button_set_alignment (GTK_BUTTON (btn), 0.5, 0.5);
g_object_set_data (G_OBJECT (btn), "resp", GINT_TO_POINTER (b->response));
g_signal_connect (G_OBJECT (btn), "clicked", G_CALLBACK (btn_cb), b->cmd);
gtk_box_pack_start (GTK_BOX (bbox), btn, FALSE, FALSE, 0);
tmp = tmp->next;
}
while (tmp != NULL);
}
else
{
if (options.mode == YAD_MODE_PROGRESS || options.mode == YAD_MODE_MULTI_PROGRESS)
gtk_dialog_add_buttons (GTK_DIALOG (dlg), GTK_STOCK_CLOSE, YAD_RESPONSE_OK, NULL);
else
{
if (gtk_alternative_dialog_button_order (NULL))
gtk_dialog_add_buttons (GTK_DIALOG (dlg),
GTK_STOCK_OK, YAD_RESPONSE_OK, GTK_STOCK_CANCEL, YAD_RESPONSE_CANCEL, NULL);
else
gtk_dialog_add_buttons (GTK_DIALOG (dlg),
GTK_STOCK_CANCEL, YAD_RESPONSE_CANCEL, GTK_STOCK_OK, YAD_RESPONSE_OK, NULL);
}
gtk_dialog_set_default_response (GTK_DIALOG (dlg), YAD_RESPONSE_OK);
}
gtk_button_box_set_layout (GTK_BUTTON_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dlg))),
options.data.buttons_layout);
}
/* show widgets */
gtk_widget_show_all (gtk_dialog_get_content_area (GTK_DIALOG (dlg)));
if (options.data.no_buttons)
gtk_widget_hide (bbox);
/* parse geometry, if given. must be after showing widget */
if (options.data.geometry && !options.data.maximized && !options.data.fullscreen)
{
gtk_widget_realize (dlg);
gtk_window_parse_geometry (GTK_WINDOW (dlg), options.data.geometry);
}
gtk_widget_show (dlg);
/* set maximized or fixed size after showing widget */
if (options.data.maximized)
gtk_window_maximize (GTK_WINDOW (dlg));
else if (options.data.fullscreen)
gtk_window_fullscreen (GTK_WINDOW (dlg));
else
{
gtk_window_set_resizable (GTK_WINDOW (dlg), !options.data.fixed);
if (options.data.fixed)
gtk_widget_set_size_request (dlg, options.data.width, options.data.height);
}
/* set timeout */
if (options.data.timeout)
{
g_timeout_add_seconds (options.data.timeout, timeout_cb, dlg);
g_timeout_add_seconds (1, timeout_indicator_cb, topb);
}
#ifndef G_OS_WIN32
/* print xid */
if (options.print_xid)
{
fprintf (stderr, "0x%lX", GDK_WINDOW_XID (gtk_widget_get_window (dlg)));
fflush (stderr);
}
#endif
return dlg;
}
static gboolean
handle_file_chooser_open (XdpFileChooser *object,
GDBusMethodInvocation *invocation,
const gchar *arg_sender,
const gchar *arg_app_id,
const gchar *arg_parent_window,
const gchar *arg_title,
GVariant *arg_options)
{
const gchar *method_name;
GtkFileChooserAction action;
gboolean multiple;
GtkWidget *dialog;
GdkWindow *foreign_parent = NULL;
GtkWidget *fake_parent;
FileDialogHandle *handle;
XdpFileChooser *chooser = XDP_FILE_CHOOSER (g_dbus_method_invocation_get_user_data (invocation));
const char *cancel_label;
const char *accept_label;
GVariantIter *iter;
const char *current_name;
const char *path;
g_autoptr (GVariant) choices = NULL;
method_name = g_dbus_method_invocation_get_method_name (invocation);
g_print ("%s, app_id: %s, object: %p, user_data: %p\n",
method_name, arg_app_id, object,
g_dbus_method_invocation_get_user_data (invocation));
fake_parent = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_object_ref_sink (fake_parent);
action = GTK_FILE_CHOOSER_ACTION_OPEN;
multiple = FALSE;
if (strcmp (method_name, "SaveFile") == 0)
action = GTK_FILE_CHOOSER_ACTION_SAVE;
else if (strcmp (method_name, "OpenFiles") == 0)
multiple = TRUE;
if (!g_variant_lookup (arg_options, "accept_label", "&s", &accept_label))
accept_label = _("_Open");
cancel_label = _("_Cancel");
dialog = gtk_file_chooser_dialog_new (arg_title, GTK_WINDOW (fake_parent), action,
cancel_label, GTK_RESPONSE_CANCEL,
accept_label, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
gtk_file_chooser_set_select_multiple (GTK_FILE_CHOOSER (dialog), multiple);
handle = dialog_handle_new (arg_app_id, arg_sender, dialog, G_DBUS_INTERFACE_SKELETON (chooser));
handle->dialog = dialog;
handle->action = action;
handle->multiple = multiple;
choices = g_variant_lookup_value (arg_options, "choices", G_VARIANT_TYPE ("a(ssa(ss)s)"));
if (choices)
{
int i;
GtkWidget *box;
box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_widget_show (box);
for (i = 0; i < g_variant_n_children (choices); i++)
{
GVariant *value = g_variant_get_child_value (choices, i);
gtk_container_add (GTK_CONTAINER (box), deserialize_choice (value, handle));
}
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dialog), box);
}
if (g_variant_lookup (arg_options, "filters", "a(sa(us))", &iter))
{
GVariant *variant;
while (g_variant_iter_next (iter, "@(sa(us))", &variant))
{
GtkFileFilter *filter;
filter = gtk_file_filter_from_gvariant (variant);
gtk_file_chooser_add_filter (GTK_FILE_CHOOSER (dialog), filter);
g_variant_unref (variant);
}
g_variant_iter_free (iter);
}
if (strcmp (method_name, "SaveFile") == 0)
{
if (g_variant_lookup (arg_options, "current_name", "&s", ¤t_name))
gtk_file_chooser_set_current_name (GTK_FILE_CHOOSER (dialog), current_name);
/* TODO: is this useful ?
* In a sandboxed situation, the current folder and current file
* are likely in the fuse filesystem
*/
if (g_variant_lookup (arg_options, "current_folder", "&ay", &path))
gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (dialog), path);
if (g_variant_lookup (arg_options, "current_file", "&ay", &path))
gtk_file_chooser_select_filename (GTK_FILE_CHOOSER (dialog), path);
}
g_object_unref (fake_parent);
#ifdef GDK_WINDOWING_X11
if (g_str_has_prefix (arg_parent_window, "x11:"))
{
int xid;
if (sscanf (arg_parent_window, "x11:%x", &xid) != 1)
g_warning ("invalid xid");
else
foreign_parent = gdk_x11_window_foreign_new_for_display (gtk_widget_get_display (dialog), xid);
}
#endif
else
g_warning ("Unhandled parent window type %s\n", arg_parent_window);
gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
g_signal_connect (G_OBJECT (dialog), "response",
G_CALLBACK (handle_file_chooser_open_response), handle);
if (action == GTK_FILE_CHOOSER_ACTION_OPEN)
{
GtkWidget *readonly;
readonly = gtk_check_button_new_with_label ("Open files read-only");
gtk_widget_show (readonly);
g_signal_connect (readonly, "toggled",
G_CALLBACK (read_only_toggled), handle);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (dialog), readonly);
}
gtk_widget_realize (dialog);
if (foreign_parent)
gdk_window_set_transient_for (gtk_widget_get_window (dialog), foreign_parent);
gtk_widget_show (dialog);
xdp_file_chooser_complete_open_file (chooser,
invocation,
handle->base.id);
return TRUE;
}
static GdkPixbuf *
take_window_shot (Window child,
gboolean include_decoration)
{
GdkDisplay *display;
GdkScreen *screen;
GdkWindow *window;
Window xid;
gint x_orig, y_orig;
gint x = 0, y = 0;
gint width, height;
GdkPixbuf *tmp, *tmp2;
GdkPixbuf *retval;
display = gdk_display_get_default ();
screen = gdk_screen_get_default ();
if (include_decoration)
xid = find_toplevel_window (gdk_x11_display_get_xdisplay (display), child);
else
xid = child;
window = gdk_x11_window_foreign_new_for_display (display, xid);
width = gdk_window_get_width (window);
height = gdk_window_get_height (window);
gdk_window_get_origin (window, &x_orig, &y_orig);
if (x_orig < 0)
{
x = - x_orig;
width = width + x_orig;
x_orig = 0;
}
if (y_orig < 0)
{
y = - y_orig;
height = height + y_orig;
y_orig = 0;
}
if (x_orig + width > gdk_screen_get_width (screen))
width = gdk_screen_get_width (screen) - x_orig;
if (y_orig + height > gdk_screen_get_height (screen))
height = gdk_screen_get_height (screen) - y_orig;
tmp = gdk_pixbuf_get_from_drawable (NULL, window, NULL,
x, y, 0, 0, width, height);
if (include_decoration)
tmp2 = remove_shaped_area (tmp, xid);
else
tmp2 = add_border_to_shot (tmp);
retval = create_shadowed_pixbuf (tmp2);
g_object_unref (tmp);
g_object_unref (tmp2);
return retval;
}