gboolean
meta_ui_window_is_dummy (MetaUI *ui,
Window xwindow)
{
GdkWindow *frames_window = gtk_widget_get_window (GTK_WIDGET (ui->frames));
return xwindow == gdk_x11_window_get_xid (frames_window);
}
void
gtk_gl_swap_buffers (GtkWidget *widget)
{
Display *display = gdk_x11_get_default_xdisplay ();
Window window = gdk_x11_window_get_xid (gtk_widget_get_window (widget));
glXSwapBuffers (display, window);
}
static void
cem_gl_area_configure(GtkWidget *area, gpointer data)
{
GLint attributes[] = { GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None};
CemGLAreaPrivate *priv;
gtk_widget_set_double_buffered(area, FALSE);
priv = cem_gl_area_get_instance_private(area);
priv->drawing_window = gtk_widget_get_window(GTK_WIDGET(area));
priv->x_window = gdk_x11_window_get_xid(GDK_WINDOW(priv->drawing_window));
priv->x_display = gdk_x11_get_default_xdisplay();
priv->x_visual = glXChooseVisual(priv->x_display, 0, attributes);
priv->x_context = glXCreateContext(priv->x_display, priv->x_visual, NULL, GL_TRUE);
XGetWindowAttributes(priv->x_display, priv->x_window, &priv->x_attributes);
glXMakeCurrent(priv->x_display, priv->x_window, priv->x_context);
XMapWindow(priv->x_display, priv->x_window);
glViewport(0, 0, priv->x_attributes.width, priv->x_attributes.height);
glOrtho(-10, 10, -10, 10, -10, 10);
glScalef(5.0, 5.0, 5.0);
}
/**
* gcm_import_show_details:
**/
static gboolean
gcm_import_show_details (GtkWindow *window,
gboolean is_profile_id,
const gchar *data)
{
gboolean ret;
GError *error = NULL;
GPtrArray *argv;
guint xid;
/* spawn new viewer async and modal to this dialog */
argv = g_ptr_array_new_with_free_func (g_free);
xid = gdk_x11_window_get_xid (gtk_widget_get_window (GTK_WIDGET(window)));
g_ptr_array_add (argv, g_build_filename (BINDIR, "gcm-viewer", NULL));
g_ptr_array_add (argv, g_strdup_printf ("--parent-window=%u", xid));
if (is_profile_id)
g_ptr_array_add (argv, g_strdup_printf ("--profile=%s", data));
else
g_ptr_array_add (argv, g_strdup_printf ("--file=%s", data));
g_ptr_array_add (argv, NULL);
ret = g_spawn_async (NULL,
(gchar **) argv->pdata,
NULL,
0,
NULL, NULL,
NULL,
&error);
if (!ret) {
g_warning ("failed to spawn viewer: %s", error->message);
g_error_free (error);
}
g_ptr_array_unref (argv);
return ret;
}
static
struct QsDrawX11Context *qsDrawX11Context_create(GtkWidget *w)
{
struct QsDrawX11Context *x;
x = g_malloc0(sizeof(*x));
x->dsp = gdk_x11_get_default_xdisplay();
QS_ASSERT(x->dsp);
x->xwin = gdk_x11_window_get_xid(gtk_widget_get_window(w));
QS_ASSERT(x->xwin);
x->cmap = DefaultColormap(x->dsp, DefaultScreen(x->dsp));
QS_ASSERT(x->cmap);
x->gc = XCreateGC(x->dsp, x->xwin, 0, 0);
QS_ASSERT(x->gc);
x->bg.pixel = 0;
x->bg.red = 0x0001; /* X11 uses shorts not bytes */
x->bg.green = 0xFFFF;
x->bg.blue = 0xFFFF;
x->bg.flags = 0;
#ifdef QS_DEBUG
QS_ASSERT(XAllocColor(x->dsp, x->cmap, &x->bg));
#else
XAllocColor(x->dsp, x->cmap, &x->bg);
#endif
return x;
}
static void
socket_unrealize_cb(GtkWidget *widget, gpointer data)
{
// Unmap and reparent any child windows that GDK does not yet know about.
// (See bug 540114 comment 10.)
GdkWindow* socket_window = gtk_widget_get_window(widget);
GdkDisplay* gdkDisplay = gdk_display_get_default();
Display* display = GDK_DISPLAY_XDISPLAY(gdkDisplay);
// Ignore X errors that may happen if windows get destroyed (possibly
// requested by the plugin) between XQueryTree and when we operate on them.
gdk_error_trap_push();
Window root, parent;
Window* children;
unsigned int nchildren;
if (!XQueryTree(display, gdk_x11_window_get_xid(socket_window),
&root, &parent, &children, &nchildren))
return;
for (unsigned int i = 0; i < nchildren; ++i) {
Window child = children[i];
if (!gdk_x11_window_lookup_for_display(gdkDisplay, child)) {
// This window is not known to GDK.
XUnmapWindow(display, child);
XReparentWindow(display, child, DefaultRootWindow(display), 0, 0);
}
}
if (children) XFree(children);
XSync(display, False);
gdk_error_trap_pop();
}
/* Ask X to move to the desktop on which @window currently is
* and the present @window. */
void
empathy_move_to_window_desktop (GtkWindow *window,
guint32 timestamp)
{
#ifdef GDK_WINDOWING_X11
GdkScreen *screen;
Screen *xscreen;
GdkWindow *gdk_window;
int workspace;
screen = gtk_window_get_screen (window);
if (!GDK_IS_X11_SCREEN (screen))
goto out;
xscreen = gdk_x11_screen_get_xscreen (screen);
gdk_window = gtk_widget_get_window (GTK_WIDGET (window));
workspace = window_get_workspace (xscreen,
gdk_x11_window_get_xid (gdk_window));
if (workspace == -1)
goto out;
_wnck_activate_workspace (xscreen, workspace, timestamp);
out:
gtk_window_present_with_time (window, timestamp);
#endif
}
static gint64 get_xid(GtkWidget *widget)
{
#ifdef GDK_WINDOWING_X11
return (gint64)gdk_x11_window_get_xid(gtk_widget_get_window(widget));
#else
return -1;
#endif
}
void
gtk_gl_make_current (GtkWidget *widget)
{
Display *display = gdk_x11_get_default_xdisplay ();
Window window = gdk_x11_window_get_xid (gtk_widget_get_window (widget));
GSList *node = gtk_glx_get_context (widget);
GtkGLContext *gtkgc = node->data;
g_return_if_fail (True == glXMakeCurrent (display, window, gtkgc->context));
}
static void
call_prepare_print (GtkPrintOperation *op,
PortalData *portal)
{
GtkPrintOperationPrivate *priv = op->priv;
GVariant *settings;
GVariant *setup;
GVariantBuilder opt_builder;
GVariant *options;
char *parent_window_str = NULL;
g_variant_builder_init (&opt_builder, G_VARIANT_TYPE_VARDICT);
options = g_variant_builder_end (&opt_builder);
if (priv->print_settings)
settings = gtk_print_settings_to_gvariant (priv->print_settings);
else
{
GVariantBuilder builder;
g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
settings = g_variant_builder_end (&builder);
}
if (priv->default_page_setup)
setup = gtk_page_setup_to_gvariant (priv->default_page_setup);
else
{
GtkPageSetup *page_setup = gtk_page_setup_new ();
setup = gtk_page_setup_to_gvariant (page_setup);
g_object_unref (page_setup);
}
if (portal->parent != NULL && gtk_widget_is_visible (GTK_WIDGET (portal->parent)))
{
GdkWindow *window = gtk_widget_get_window (GTK_WIDGET (portal->parent));
#ifdef GDK_WINDOWING_X11
if (GDK_IS_X11_WINDOW (window))
parent_window_str = g_strdup_printf ("x11:%x", (guint32)gdk_x11_window_get_xid (window));
#endif
}
g_dbus_proxy_call (portal->proxy,
"PreparePrint",
g_variant_new ("(ss@a{sv}@a{sv}@a{sv})",
parent_window_str ? parent_window_str : "",
_("Print"), /* title */
settings,
setup,
options),
G_DBUS_CALL_FLAGS_NONE,
-1,
NULL,
prepare_print_called,
portal);
g_free (parent_window_str);
}
// -----------------------------------------------------------------------------
void g_window_workspace(GtkWidget* pWidget, int space)
{
DEBUGLOGB;
#if !_USEWKSPACE
#if GTK_CHECK_VERSION(3,0,0)
Screen* xscreen = gdk_x11_screen_get_xscreen(gdk_screen_get_default());
Window xwindow = gdk_x11_window_get_xid(gtk_widget_get_window(pWidget));
#else
Screen* xscreen = GDK_SCREEN_XSCREEN(gdk_screen_get_default());
Window xwindow = GDK_WINDOW_XWINDOW(gtk_widget_get_window(pWidget));
#endif
_wncki_change_workspace(xscreen, xwindow, space);
#else // !_USEWKSPACE
WnckScreen* screen = wnck_screen_get_default();
if( screen )
{
DEBUGLOGS("got default screen");
wnck_screen_force_update(screen);
DEBUGLOGP("sticky is off and workspace is %d\n", space);
WnckWindow* window = wnck_window_get(gdk_x11_drawable_get_xid(gtk_widget_get_window(pWidget)));
if( window && !wnck_window_is_pinned(window) )
{
DEBUGLOGS("got non-pinned window");
WnckWorkspace* trgtWrk = wnck_screen_get_workspace (screen, space);
WnckWorkspace* actvWrk = wnck_screen_get_active_workspace(screen);
if( trgtWrk && actvWrk && trgtWrk != actvWrk )
{
DEBUGLOGS("got target workspace is diff from current so moving window to target");
wnck_window_move_to_workspace(window, trgtWrk);
}
}
#ifdef _DEBUGLOG
else
{
DEBUGLOGP("WnckWindow for clock window is%svalid\n", window ? " " : " NOT ");
guint xw1 = GDK_WINDOW_XWINDOW (gtk_widget_get_window(pWidget));
guint xw2 = gdk_x11_drawable_get_xid(gtk_widget_get_window(pWidget));
DEBUGLOGP("X11 XID1 for clock window is %d\n", (int)xw1);
DEBUGLOGP("X11 XID2 for clock window is %d\n", (int)xw2);
}
#endif
}
#endif // !_USEWKSPACE
DEBUGLOGE;
}
sys_result_t
ui_widget_getnative(ui_widget_t* widget, Window* xwindow)
{
GdkWindow* gdk_window = gtk_widget_get_window(widget->widget);
gboolean is_native = gdk_window_ensure_native(gdk_window);
if(!is_native)
return CLIPT_EINVALID;
Window ret = gdk_x11_window_get_xid(gdk_window);
*xwindow = ret;
return CLIPT_OK;
}
static void
cinnamon_gtk_embed_on_window_realize (GtkWidget *widget,
CinnamonGtkEmbed *embed)
{
/* Here automatic=FALSE means to use CompositeRedirectManual.
* That is, the X server shouldn't draw the window onto the
* screen.
*/
clutter_x11_texture_pixmap_set_window (CLUTTER_X11_TEXTURE_PIXMAP (embed),
gdk_x11_window_get_xid (gtk_widget_get_window (widget)),
FALSE);
}
static gboolean
do_inhibit_for_window (GdkWindow *window)
{
GError *error;
gboolean res;
const char UNUSED_VARIABLE *startup_id;
const char *app_id;
const char *reason;
guint toplevel_xid;
guint flags;
startup_id = g_getenv ("DESKTOP_AUTOSTART_ID");
#if 1
app_id = "caja-cd-burner";
reason = "A CD burn is in progress.";
#else
app_id = "caja";
reason = "A file transfer is in progress.";
#endif
#if GTK_CHECK_VERSION (3, 0, 0)
toplevel_xid = gdk_x11_window_get_xid (window);
#else
toplevel_xid = GDK_DRAWABLE_XID (window);
#endif
flags = GSM_INHIBITOR_FLAG_LOGOUT
| GSM_INHIBITOR_FLAG_SWITCH_USER
| GSM_INHIBITOR_FLAG_SUSPEND;
error = NULL;
res = dbus_g_proxy_call (sm_proxy,
"Inhibit",
&error,
G_TYPE_STRING, app_id,
G_TYPE_UINT, toplevel_xid,
G_TYPE_STRING, reason,
G_TYPE_UINT, flags,
G_TYPE_INVALID,
G_TYPE_UINT, &cookie,
G_TYPE_INVALID);
if (! res) {
g_warning ("Failed to inhibit: %s", error->message);
g_error_free (error);
return FALSE;
}
g_debug ("Inhibiting session manager: %u", cookie);
return TRUE;
}
static bool grab_mouse(GtkWidget *widget)
{
// This should be possible with pure GTK code as well, using
// gdk_device_grab(). However, while gdk_device_grab() will prevent clicks
// outside of the game window, the mouse gets stuck near the edge of the
// window when trying to move outside.
#ifdef GDK_WINDOWING_X11
Display * const dpy = gdk_x11_display_get_xdisplay(gdk_display_get_default());
Window xwindow = gdk_x11_window_get_xid(gtk_widget_get_window(widget));
int result = XGrabPointer(dpy, xwindow, true, 0, GrabModeAsync, GrabModeAsync, xwindow, None, CurrentTime);
return result == GrabSuccess;
#endif
return true;
}
/**
* cs_screen_get_mouse_monitor:
* @screen: a #CsScreen
*
* Gets the index of the monitor that the mouse pointer currently
* occupies.
*
* Return value: the monitor index for the pointer
*/
gint
cs_screen_get_mouse_monitor (CsScreen *screen)
{
GdkDisplay *gdk_display;
Window xroot, root_return, child_return;
int root_x_return, root_y_return;
int win_x_return, win_y_return;
unsigned int mask_return;
gint scale_factor;
gint i;
gint ret = 0;
g_return_val_if_fail (CS_IS_SCREEN (screen), 0);
gdk_display = gdk_screen_get_display (screen->gdk_screen);
xroot = gdk_x11_window_get_xid (gdk_screen_get_root_window (screen->gdk_screen));
gdk_error_trap_push ();
XQueryPointer (gdk_x11_display_get_xdisplay (gdk_display),
xroot,
&root_return,
&child_return,
&root_x_return,
&root_y_return,
&win_x_return,
&win_y_return,
&mask_return);
gdk_error_trap_pop_ignored ();
scale_factor = gdk_screen_get_monitor_scale_factor (screen->gdk_screen, 0);
root_x_return /= scale_factor;
root_y_return /= scale_factor;
for (i = 0; i < screen->n_monitor_infos; i++)
{
GdkRectangle iter = screen->monitor_infos[i].rect;
if (root_x_return >= iter.x && root_x_return <= iter.x + iter.width &&
root_y_return >= iter.y && root_y_return <= iter.y + iter.height)
{
ret = i;
break;
}
}
return ret;
}
int
main (int argc, char **argv)
{
GdkDisplay *display;
GdkScreen *screen;
GOptionContext *context;
GError *error = NULL;
/* Since we depend on this, avoid the possibility of lt-cinnamon-perf-helper */
g_set_prgname ("cinnamon-perf-helper");
context = g_option_context_new (" - server to create windows for performance testing");
g_option_context_add_main_entries (context, opt_entries, NULL);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_print ("option parsing failed: %s\n", error->message);
g_option_context_free (context);
return 1;
}
display = gdk_display_get_default ();
screen = gdk_screen_get_default ();
xdisplay = gdk_x11_display_get_xdisplay (display);
xroot = gdk_x11_window_get_xid (gdk_screen_get_root_window (screen));
atom_wm_state = gdk_x11_get_xatom_by_name_for_display (display, "WM_STATE");
atom__net_wm_name = gdk_x11_get_xatom_by_name_for_display (display, "_NET_WM_NAME");
atom_utf8_string = gdk_x11_get_xatom_by_name_for_display (display, "UTF8_STRING");
g_bus_own_name (G_BUS_TYPE_SESSION,
BUS_NAME,
G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT |
G_BUS_NAME_OWNER_FLAGS_REPLACE,
on_bus_acquired,
on_name_acquired,
on_name_lost,
NULL,
NULL);
establish_timeout ();
gtk_main ();
g_option_context_free (context);
return 0;
}
void
nsGTKRemoteService::HandleCommandsFor(GtkWidget* widget,
nsIWeakReference* aWindow)
{
g_signal_connect(G_OBJECT(widget), "property_notify_event",
G_CALLBACK(HandlePropertyChange), aWindow);
gtk_widget_add_events(widget, GDK_PROPERTY_CHANGE_MASK);
#if (MOZ_WIDGET_GTK == 2)
Window window = GDK_WINDOW_XWINDOW(widget->window);
#else
Window window = gdk_x11_window_get_xid(gtk_widget_get_window(widget));
#endif
nsXRemoteService::HandleCommandsFor(window);
}
void gd_egl_init(VirtualConsole *vc)
{
GdkWindow *gdk_window = gtk_widget_get_window(vc->gfx.drawing_area);
if (!gdk_window) {
return;
}
Window x11_window = gdk_x11_window_get_xid(gdk_window);
if (!x11_window) {
return;
}
vc->gfx.ectx = qemu_egl_init_ctx();
vc->gfx.esurface = qemu_egl_init_surface_x11
(vc->gfx.ectx, (EGLNativeWindowType)x11_window);
assert(vc->gfx.esurface);
}
static gboolean
do_inhibit_for_window (GdkWindow *window)
{
GError *error;
gboolean res;
const char *app_id;
const char *reason;
guint toplevel_xid;
guint flags;
#if 1
app_id = "nautilus-cd-burner";
reason = "A CD burn is in progress.";
#else
app_id = "nautilus";
reason = "A file transfer is in progress.";
#endif
toplevel_xid = gdk_x11_window_get_xid (window);
flags = CSM_INHIBITOR_FLAG_LOGOUT
| CSM_INHIBITOR_FLAG_SWITCH_USER
| CSM_INHIBITOR_FLAG_SUSPEND;
error = NULL;
res = dbus_g_proxy_call (sm_proxy,
"Inhibit",
&error,
G_TYPE_STRING, app_id,
G_TYPE_UINT, toplevel_xid,
G_TYPE_STRING, reason,
G_TYPE_UINT, flags,
G_TYPE_INVALID,
G_TYPE_UINT, &cookie,
G_TYPE_INVALID);
if (! res) {
g_warning ("Failed to inhibit: %s", error->message);
g_error_free (error);
return FALSE;
}
g_debug ("Inhibiting session manager: %u", cookie);
return TRUE;
}
gboolean
nsGTKRemoteService::HandlePropertyChange(GtkWidget *aWidget,
GdkEventProperty *pevent,
nsIWeakReference *aThis)
{
if (pevent->state == GDK_PROPERTY_NEW_VALUE) {
Atom changedAtom = gdk_x11_atom_to_xatom(pevent->atom);
#if (MOZ_WIDGET_GTK == 2)
XID window = GDK_WINDOW_XWINDOW(pevent->window);
#else
XID window = gdk_x11_window_get_xid(gtk_widget_get_window(aWidget));
#endif
return HandleNewProperty(window,
GDK_DISPLAY_XDISPLAY(gdk_display_get_default()),
pevent->time, changedAtom, aThis);
}
return FALSE;
}
static void
shell_embedded_window_realize (GtkWidget *widget)
{
ShellEmbeddedWindow *window = SHELL_EMBEDDED_WINDOW (widget);
GTK_WIDGET_CLASS (shell_embedded_window_parent_class)->realize (widget);
/* Using XReparentWindow() is simpler than using gdk_window_reparent(),
* since it avoids maybe having to create a new foreign GDK window for
* the stage. However, GDK will be left thinking that the parent of
* window->window is the root window - it's not immediately clear
* to me whether that is more or less likely to cause problems than
* modifying the GDK hierarchy.
*/
XReparentWindow (GDK_DISPLAY_XDISPLAY (gtk_widget_get_display (widget)),
gdk_x11_window_get_xid (gtk_widget_get_window (widget)),
window->priv->stage_xwindow,
window->priv->position.x, window->priv->position.y);
}
void gd_egl_init(VirtualConsole *vc)
{
GdkWindow *gdk_window = gtk_widget_get_window(vc->gfx.drawing_area);
if (!gdk_window) {
return;
}
#if GTK_CHECK_VERSION(3, 0, 0)
Window x11_window = gdk_x11_window_get_xid(gdk_window);
#else
Window x11_window = gdk_x11_drawable_get_xid(gdk_window);
#endif
if (!x11_window) {
return;
}
vc->gfx.ectx = qemu_egl_init_ctx();
vc->gfx.esurface = qemu_egl_init_surface_x11(vc->gfx.ectx, x11_window);
assert(vc->gfx.esurface);
}
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);
}
static gboolean
wait_for_property_notify (void)
{
GdkDisplay *display = NULL;
GdkScreen *screen;
GdkWindow *root;
Window rootwin;
property_changed = FALSE;
display = gdk_display_get_default ();
screen = gdk_display_get_default_screen (display);
root = gdk_screen_get_root_window (screen);
rootwin = gdk_x11_window_get_xid (root);
XSelectInput (GDK_DISPLAY_XDISPLAY (display), rootwin, PropertyChangeMask);
gdk_window_add_filter (root, property_notify_filter, NULL);
g_timeout_add (PROPERTY_CHANGE_TIMEOUT, on_property_notify_timeout, NULL);
gtk_main ();
return property_changed;
}
/**
* gcm_utils_install_package:
**/
gboolean
gcm_utils_install_package (const gchar *package_name, GtkWindow *window)
{
GDBusConnection *connection;
GVariant *args = NULL;
GVariant *response = NULL;
GVariantBuilder *builder = NULL;
GError *error = NULL;
gboolean ret = FALSE;
guint32 xid = 0;
gchar **packages = NULL;
g_return_val_if_fail (package_name != NULL, FALSE);
#ifndef HAVE_PACKAGEKIT
g_warning ("cannot install %s: this package was not compiled with --enable-packagekit", package_name);
goto out;
#endif
/* get xid of this window */
if (window != NULL)
xid = gdk_x11_window_get_xid (gtk_widget_get_window (GTK_WIDGET(window)));
/* we're expecting an array of packages */
packages = g_strsplit (package_name, "|", 1);
/* get a session bus connection */
connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
if (connection == NULL) {
/* TRANSLATORS: no DBus session bus */
g_print ("%s %s\n", _("Failed to connect to session bus:"), error->message);
g_error_free (error);
goto out;
}
/* create arguments */
builder = g_variant_builder_new (G_VARIANT_TYPE ("(uass)"));
g_variant_builder_add_value (builder, g_variant_new_uint32 (xid));
g_variant_builder_add_value (builder, g_variant_new_strv ((const gchar * const *)packages, -1));
g_variant_builder_add_value (builder, g_variant_new_string ("hide-confirm-search,hide-finished"));
args = g_variant_builder_end (builder);
/* execute sync method */
response = g_dbus_connection_call_sync (connection,
PK_DBUS_SERVICE,
PK_DBUS_PATH,
PK_DBUS_INTERFACE_MODIFY,
"InstallPackageNames",
args,
NULL,
G_DBUS_CALL_FLAGS_NONE,
G_MAXINT, NULL, &error);
if (response == NULL) {
/* TRANSLATORS: the DBus method failed */
g_warning ("%s %s\n", _("The request failed:"), error->message);
g_error_free (error);
goto out;
}
/* success */
ret = TRUE;
out:
if (builder != NULL)
g_variant_builder_unref (builder);
if (args != NULL)
g_variant_unref (args);
if (response != NULL)
g_variant_unref (response);
g_strfreev (packages);
return ret;
}
gboolean
rb_missing_plugins_install (const char **details, gboolean ignore_blacklist, GClosure *closure)
{
RBPluginInstallContext *ctx;
GstInstallPluginsContext *install_ctx;
GstInstallPluginsReturn status;
int i, num;
num = g_strv_length ((char **)details);
g_return_val_if_fail (num > 0, FALSE);
ctx = g_new0 (RBPluginInstallContext, 1);
ctx->closure = g_closure_ref (closure);
ctx->details = g_strdupv ((char **)details);
num = g_strv_length (ctx->details);
for (i = 0; i < num; ++i) {
if (ignore_blacklist == FALSE && rb_plugin_install_plugin_is_blacklisted (ctx->details[i])) {
g_message ("Missing plugin: %s (ignoring)", ctx->details[i]);
g_free (ctx->details[i]);
ctx->details[i] = ctx->details[num-1];
ctx->details[num-1] = NULL;
--num;
--i;
} else {
g_message ("Missing plugin: %s", ctx->details[i]);
}
}
if (num == 0) {
g_message ("All missing plugins are blacklisted, doing nothing");
rb_plugin_install_context_free (ctx);
return FALSE;
}
install_ctx = gst_install_plugins_context_new ();
if (parent_window != NULL && gtk_widget_get_realized (GTK_WIDGET (parent_window))) {
#ifdef GDK_WINDOWING_X11
gulong xid = 0;
xid = gdk_x11_window_get_xid (gtk_widget_get_window (GTK_WIDGET (parent_window)));
gst_install_plugins_context_set_xid (install_ctx, xid);
#endif
}
status = gst_install_plugins_async (ctx->details, install_ctx,
on_plugin_installation_done,
ctx);
gst_install_plugins_context_free (install_ctx);
rb_debug ("gst_install_plugins_async() result = %d", status);
if (status != GST_INSTALL_PLUGINS_STARTED_OK) {
if (status == GST_INSTALL_PLUGINS_HELPER_MISSING) {
g_message ("Automatic missing codec installation not supported "
"(helper script missing)");
} else {
g_warning ("Failed to start codec installation: %s",
gst_install_plugins_return_get_name (status));
}
rb_plugin_install_context_free (ctx);
return FALSE;
}
return TRUE;
}
static gboolean
totem_disc_recorder_plugin_start_burning (TotemDiscRecorderPlugin *pi,
const char *path,
gboolean copy)
{
GtkWindow *main_window;
GdkScreen *screen;
GdkDisplay *display;
gchar *command_line;
GList *uris;
GAppInfo *info;
GdkAppLaunchContext *context;
GError *error = NULL;
char *xid_arg;
main_window = totem_object_get_main_window (pi->priv->totem);
screen = gtk_widget_get_screen (GTK_WIDGET (main_window));
display = gdk_display_get_default ();
/* Build a command line to use */
xid_arg = NULL;
#ifdef GDK_WINDOWING_X11
if (GDK_IS_X11_DISPLAY (display))
xid_arg = g_strdup_printf ("-x %d", (int) gdk_x11_window_get_xid (gtk_widget_get_window (GTK_WIDGET (main_window))));
#endif /* GDK_WINDOWING_X11 */
g_object_unref (main_window);
if (copy != FALSE)
command_line = g_strdup_printf ("brasero %s -c", xid_arg ? xid_arg : "");
else
command_line = g_strdup_printf ("brasero %s -r", xid_arg ? xid_arg : "");
/* Build the app info */
info = g_app_info_create_from_commandline (command_line, NULL,
G_APP_INFO_CREATE_SUPPORTS_URIS | G_APP_INFO_CREATE_SUPPORTS_STARTUP_NOTIFICATION, &error);
g_free (command_line);
if (error != NULL)
goto error;
/* Create a launch context and launch it */
context = gdk_display_get_app_launch_context (gtk_widget_get_display (GTK_WIDGET (main_window)));
gdk_app_launch_context_set_screen (context, screen);
uris = g_list_prepend (NULL, (gpointer) path);
g_app_info_launch_uris (info, uris, G_APP_LAUNCH_CONTEXT (context), &error);
g_list_free (uris);
g_object_unref (info);
g_object_unref (context);
if (error != NULL)
goto error;
return TRUE;
error:
main_window = totem_object_get_main_window (pi->priv->totem);
if (copy != FALSE)
totem_interface_error (_("The video disc could not be duplicated."), error->message, main_window);
else
totem_interface_error (_("The movie could not be recorded."), error->message, main_window);
g_error_free (error);
g_object_unref (main_window);
return FALSE;
}
/* Returns NULL if screen could not be created. For instance, if
* the driver does not support Xrandr 1.2.
*/
MateRRScreen *
mate_rr_screen_new (GdkScreen *gdk_screen,
MateRRScreenChanged callback,
gpointer data,
GError **error)
{
#ifdef HAVE_RANDR
Display *dpy = GDK_SCREEN_XDISPLAY (gdk_screen);
int event_base;
int ignore;
#endif
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
_mate_desktop_init_i18n ();
#ifdef HAVE_RANDR
if (XRRQueryExtension (dpy, &event_base, &ignore))
{
MateRRScreen *screen = g_new0 (MateRRScreen, 1);
screen->gdk_screen = gdk_screen;
screen->gdk_root = gdk_screen_get_root_window (gdk_screen);
#if GTK_CHECK_VERSION(3, 0, 0)
screen->xroot = gdk_x11_window_get_xid (screen->gdk_root);
#else
screen->xroot = gdk_x11_drawable_get_xid (screen->gdk_root);
#endif
screen->xdisplay = dpy;
screen->xscreen = gdk_x11_screen_get_xscreen (screen->gdk_screen);
screen->connector_type_atom = XInternAtom (dpy, "ConnectorType", FALSE);
screen->callback = callback;
screen->data = data;
screen->randr_event_base = event_base;
XRRQueryVersion (dpy, &screen->rr_major_version, &screen->rr_minor_version);
if (screen->rr_major_version > 1 || (screen->rr_major_version == 1 && screen->rr_minor_version < 2)) {
g_set_error (error, MATE_RR_ERROR, MATE_RR_ERROR_NO_RANDR_EXTENSION,
"RANDR extension is too old (must be at least 1.2)");
g_free (screen);
return NULL;
}
screen->info = screen_info_new (screen, TRUE, error);
if (!screen->info) {
g_free (screen);
return NULL;
}
if (screen->callback) {
XRRSelectInput (screen->xdisplay,
screen->xroot,
RRScreenChangeNotifyMask);
gdk_x11_register_standard_event_type (gdk_screen_get_display (gdk_screen),
event_base,
RRNotify + 1);
gdk_window_add_filter (screen->gdk_root, screen_on_event, screen);
}
return screen;
}
else
{
#endif /* HAVE_RANDR */
g_set_error (error, MATE_RR_ERROR, MATE_RR_ERROR_NO_RANDR_EXTENSION,
_("RANDR extension is not present"));
return NULL;
#ifdef HAVE_RANDR
}
#endif
}
gboolean
gtk_file_chooser_native_portal_show (GtkFileChooserNative *self)
{
FilechooserPortalData *data;
GtkWindow *transient_for;
GDBusConnection *connection;
char *parent_window_str;
GDBusMessage *message;
GVariantBuilder opt_builder;
GtkFileChooserAction action;
gboolean multiple;
const char *method_name;
if (!gtk_should_use_portal ())
return FALSE;
connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, NULL);
if (connection == NULL)
return FALSE;
action = gtk_file_chooser_get_action (GTK_FILE_CHOOSER (self));
multiple = gtk_file_chooser_get_select_multiple (GTK_FILE_CHOOSER (self));
if (action == GTK_FILE_CHOOSER_ACTION_OPEN)
method_name = "OpenFile";
else if (action == GTK_FILE_CHOOSER_ACTION_SAVE)
method_name = "SaveFile";
else
{
g_warning ("GTK_FILE_CHOOSER_ACTION_%s is not supported by GtkFileChooserNativePortal", action == GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER ? "SELECT_FOLDER" : "CREATE_FOLDER");
return FALSE;
}
data = g_new0 (FilechooserPortalData, 1);
data->self = g_object_ref (self);
data->connection = connection;
message = g_dbus_message_new_method_call ("org.freedesktop.portal.Desktop",
"/org/freedesktop/portal/desktop",
"org.freedesktop.portal.FileChooser",
method_name);
parent_window_str = NULL;
transient_for = gtk_native_dialog_get_transient_for (GTK_NATIVE_DIALOG (self));
if (transient_for != NULL && gtk_widget_is_visible (GTK_WIDGET (transient_for)))
{
GdkWindow *window = gtk_widget_get_window (GTK_WIDGET (transient_for));
#ifdef GDK_WINDOWING_X11
if (GDK_IS_X11_WINDOW(window))
parent_window_str = g_strdup_printf ("x11:%x", (guint32)gdk_x11_window_get_xid (window));
#endif
}
if (gtk_native_dialog_get_modal (GTK_NATIVE_DIALOG (self)))
data->modal = TRUE;
if (data->modal && transient_for != NULL)
{
data->grab_widget = gtk_invisible_new_for_screen (gtk_widget_get_screen (GTK_WIDGET (transient_for)));
gtk_grab_add (GTK_WIDGET (data->grab_widget));
}
g_variant_builder_init (&opt_builder, G_VARIANT_TYPE_VARDICT);
g_variant_builder_add (&opt_builder, "{sv}", "multiple",
g_variant_new_boolean (multiple));
if (self->accept_label)
g_variant_builder_add (&opt_builder, "{sv}", "accept_label",
g_variant_new_string (self->accept_label));
if (self->cancel_label)
g_variant_builder_add (&opt_builder, "{sv}", "cancel_label",
g_variant_new_string (self->cancel_label));
g_variant_builder_add (&opt_builder, "{sv}", "modal",
g_variant_new_boolean (data->modal));
g_variant_builder_add (&opt_builder, "{sv}", "filters", get_filters (GTK_FILE_CHOOSER (self)));
if (GTK_FILE_CHOOSER_NATIVE (self)->current_name)
g_variant_builder_add (&opt_builder, "{sv}", "current_name",
g_variant_new_string (GTK_FILE_CHOOSER_NATIVE (self)->current_name));
if (GTK_FILE_CHOOSER_NATIVE (self)->current_folder)
{
gchar *path;
path = g_file_get_path (GTK_FILE_CHOOSER_NATIVE (self)->current_folder);
g_variant_builder_add (&opt_builder, "{sv}", "current_folder",
g_variant_new_bytestring (path));
g_free (path);
}
if (GTK_FILE_CHOOSER_NATIVE (self)->current_file)
{
gchar *path;
path = g_file_get_path (GTK_FILE_CHOOSER_NATIVE (self)->current_file);
g_variant_builder_add (&opt_builder, "{sv}", "current_file",
g_variant_new_bytestring (path));
g_free (path);
}
if (GTK_FILE_CHOOSER_NATIVE (self)->choices)
g_variant_builder_add (&opt_builder, "{sv}", "choices",
serialize_choices (GTK_FILE_CHOOSER_NATIVE (self)));
g_dbus_message_set_body (message,
g_variant_new ("(ss@a{sv})",
parent_window_str ? parent_window_str : "",
gtk_native_dialog_get_title (GTK_NATIVE_DIALOG (self)),
g_variant_builder_end (&opt_builder)));
g_free (parent_window_str);
g_dbus_connection_send_message_with_reply (data->connection,
message,
G_DBUS_SEND_MESSAGE_FLAGS_NONE,
G_MAXINT,
NULL,
NULL,
open_file_msg_cb,
data);
g_object_unref (message);
self->mode_data = data;
return TRUE;
}
