static void
build_filename_ready_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
GtkWidget *toplevel;
ScreenshotDialog *dialog;
GdkPixbuf *screenshot = user_data;
gchar *save_uri;
GError *error = NULL;
save_uri = screenshot_build_filename_finish (res, &error);
if (error != NULL)
{
g_critical ("Impossible to find a valid location to save the screenshot: %s",
error->message);
g_error_free (error);
exit(1);
}
dialog = screenshot_dialog_new (screenshot, save_uri);
toplevel = screenshot_dialog_get_toplevel (dialog);
gtk_widget_show (toplevel);
g_signal_connect (toplevel,
"response",
G_CALLBACK (screenshot_dialog_response_cb),
dialog);
g_free (save_uri);
}
static void
finish_prepare_screenshot (char *initial_uri, GdkWindow *window, GdkRectangle *rectangle)
{
ScreenshotDialog *dialog;
gboolean include_mask = (!take_window_shot && !take_area_shot);
/* always disable window border for full-desktop or selected-area screenshots */
if (!take_window_shot)
screenshot = screenshot_get_pixbuf (window, rectangle, include_pointer, FALSE, include_mask);
else
{
screenshot = screenshot_get_pixbuf (window, rectangle, include_pointer, include_border, include_mask);
switch (border_effect[0])
{
case 's': /* shadow */
screenshot_add_shadow (&screenshot);
break;
case 'b': /* border */
screenshot_add_border (&screenshot);
break;
case 'n': /* none */
default:
break;
}
}
/* release now the lock, it was acquired when we were finding the window */
screenshot_release_lock ();
if (screenshot == NULL)
{
screenshot_show_error_dialog (NULL,
_("Unable to take a screenshot of the current window"),
NULL);
exit (1);
}
play_sound_effect (window);
dialog = screenshot_dialog_new (screenshot, initial_uri, take_window_shot);
g_free (initial_uri);
screenshot_save_start (screenshot, save_done_notification, dialog);
run_dialog (dialog);
}
static gboolean
handle_screenshot (XdpImplScreenshot *object,
GDBusMethodInvocation *invocation,
const char *arg_handle,
const char *arg_app_id,
const char *arg_parent_window,
GVariant *arg_options)
{
g_autoptr(Request) request = NULL;
const char *sender;
ScreenshotDialogHandle *handle;
g_autoptr(GError) error = NULL;
g_autofree char *filename = NULL;
gboolean success;
gboolean modal;
GtkWidget *dialog;
GdkDisplay *display;
GdkScreen *screen;
ExternalWindow *external_parent = NULL;
GtkWidget *fake_parent;
sender = g_dbus_method_invocation_get_sender (invocation);
request = request_new (sender, arg_app_id, arg_handle);
org_gnome_shell_screenshot_call_screenshot_sync (shell,
FALSE,
TRUE,
"Screenshot",
&success,
&filename,
NULL, NULL);
if (!g_variant_lookup (arg_options, "modal", "b", &modal))
modal = TRUE;
if (arg_parent_window)
{
external_parent = create_external_window_from_handle (arg_parent_window);
if (!external_parent)
g_warning ("Failed to associate portal window with parent window %s",
arg_parent_window);
}
if (external_parent)
display = external_window_get_display (external_parent);
else
display = gdk_display_get_default ();
screen = gdk_display_get_default_screen (display);
fake_parent = g_object_new (GTK_TYPE_WINDOW,
"type", GTK_WINDOW_TOPLEVEL,
"screen", screen,
NULL);
g_object_ref_sink (fake_parent);
dialog = GTK_WIDGET (screenshot_dialog_new (arg_app_id, filename));
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (fake_parent));
gtk_window_set_modal (GTK_WINDOW (dialog), modal);
handle = g_new0 (ScreenshotDialogHandle, 1);
handle->impl = object;
handle->invocation = invocation;
handle->request = g_object_ref (request);
handle->dialog = g_object_ref (dialog);
handle->external_parent = external_parent;
handle->uri = g_filename_to_uri (filename, NULL, NULL);
g_signal_connect (request, "handle-close", G_CALLBACK (handle_close), handle);
g_signal_connect (dialog, "done", G_CALLBACK (screenshot_dialog_done), handle);
gtk_widget_realize (dialog);
if (external_parent)
external_window_set_parent_of (external_parent, gtk_widget_get_window (dialog));
gtk_widget_show (dialog);
request_export (request, g_dbus_method_invocation_get_connection (invocation));
return TRUE;
}
static void
build_filename_ready_cb (GObject *source,
GAsyncResult *res,
gpointer user_data)
{
ScreenshotApplication *self = user_data;
GError *error = NULL;
char *save_path;
save_path = screenshot_build_filename_finish (res, &error);
if (save_path != NULL)
{
GFile *file;
file = g_file_new_for_path (save_path);
g_free (save_path);
self->priv->save_uri = g_file_get_uri (file);
g_object_unref (file);
}
else
self->priv->save_uri = NULL;
/* now release the application */
g_application_release (G_APPLICATION (self));
if (error != NULL)
{
g_critical ("Impossible to find a valid location to save the screenshot: %s",
error->message);
g_error_free (error);
if (screenshot_config->interactive)
screenshot_show_dialog (NULL,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
_("Unable to capture a screenshot"),
_("Error creating file"));
else
{
screenshot_play_sound_effect ("dialog-error", _("Unable to capture a screenshot"));
if (screenshot_config->file != NULL)
exit (EXIT_FAILURE);
}
return;
}
screenshot_play_sound_effect ("screen-capture", _("Screenshot taken"));
if (!g_strcmp0 (g_getenv ("XDG_CURRENT_DESKTOP"), "Unity") || screenshot_config->interactive)
{
self->priv->dialog = screenshot_dialog_new (self->priv->screenshot, self->priv->save_uri);
g_signal_connect (self->priv->dialog->dialog,
"response",
G_CALLBACK (screenshot_dialog_response_cb),
self);
}
else
{
g_application_hold (G_APPLICATION (self));
screenshot_save_to_file (self);
}
}