isa/gnome-shell
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
90e7aae962
gnome-shell/src/shell-screenshot.c
Carlos Garnacho 1a06d93e95 shell: Avoid use of gdk_pixbuf_get_from_surface() 
Unlike one might think, this function does not come from
GdkPixbuf but GDK. Also adopt this conversion code between
surface formats.

Part-of: <https://gitlab.gnome.org/GNOME/gnome-shell/-/merge_requests/2655>
2023-03-03 20:38:03 +00:00

1396 lines
45 KiB
C
Raw Blame History

/* -*- mode: C; c-file-style: "gnu"; indent-tabs-mode: nil; -*- */
#include <clutter/clutter.h>
#include <cogl/cogl.h>
#include <meta/display.h>
#include <meta/util.h>
#include <meta/meta-plugin.h>
#include <meta/meta-cursor-tracker.h>
#include <st/st.h>
#include "shell-global.h"
#include "shell-screenshot.h"
#include "shell-util.h"
typedef enum _ShellScreenshotFlag
{
SHELL_SCREENSHOT_FLAG_NONE,
SHELL_SCREENSHOT_FLAG_INCLUDE_CURSOR,
} ShellScreenshotFlag;
typedef enum _ShellScreenshotMode
{
SHELL_SCREENSHOT_SCREEN,
SHELL_SCREENSHOT_WINDOW,
SHELL_SCREENSHOT_AREA,
} ShellScreenshotMode;
enum
{
SCREENSHOT_TAKEN,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = { 0, };
typedef struct _ShellScreenshotPrivate ShellScreenshotPrivate;
struct _ShellScreenshot
{
GObject parent_instance;
ShellScreenshotPrivate *priv;
};
struct _ShellScreenshotPrivate
{
ShellGlobal *global;
GOutputStream *stream;
ShellScreenshotFlag flags;
ShellScreenshotMode mode;
GDateTime *datetime;
cairo_surface_t *image;
cairo_rectangle_int_t screenshot_area;
gboolean include_frame;
float scale;
ClutterContent *cursor_content;
graphene_point_t cursor_point;
float cursor_scale;
};
G_DEFINE_TYPE_WITH_PRIVATE (ShellScreenshot, shell_screenshot, G_TYPE_OBJECT);
static void
shell_screenshot_class_init (ShellScreenshotClass *screenshot_class)
{
signals[SCREENSHOT_TAKEN] =
g_signal_new ("screenshot-taken",
G_TYPE_FROM_CLASS(screenshot_class),
G_SIGNAL_RUN_LAST,
0,
NULL, NULL, NULL,
G_TYPE_NONE,
1,
META_TYPE_RECTANGLE);
}
static void
shell_screenshot_init (ShellScreenshot *screenshot)
{
screenshot->priv = shell_screenshot_get_instance_private (screenshot);
screenshot->priv->global = shell_global_get ();
}
static void
on_screenshot_written (GObject *source,
GAsyncResult *task,
gpointer user_data)
{
ShellScreenshot *screenshot = SHELL_SCREENSHOT (source);
ShellScreenshotPrivate *priv = screenshot->priv;
GTask *result = user_data;
g_task_return_boolean (result, g_task_propagate_boolean (G_TASK (task), NULL));
g_object_unref (result);
g_clear_pointer (&priv->image, cairo_surface_destroy);
g_clear_object (&priv->stream);
g_clear_pointer (&priv->datetime, g_date_time_unref);
}
static cairo_format_t
util_cairo_format_for_content (cairo_content_t content)
{
switch (content)
{
case CAIRO_CONTENT_COLOR:
return CAIRO_FORMAT_RGB24;
case CAIRO_CONTENT_ALPHA:
return CAIRO_FORMAT_A8;
case CAIRO_CONTENT_COLOR_ALPHA:
default:
return CAIRO_FORMAT_ARGB32;
}
}
static cairo_surface_t *
util_cairo_surface_coerce_to_image (cairo_surface_t *surface,
cairo_content_t content,
int src_x,
int src_y,
int width,
int height)
{
cairo_surface_t *copy;
cairo_t *cr;
copy = cairo_image_surface_create (util_cairo_format_for_content (content),
width,
height);
cr = cairo_create (copy);
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_set_source_surface (cr, surface, -src_x, -src_y);
cairo_paint (cr);
cairo_destroy (cr);
return copy;
}
static void
convert_alpha (guchar *dest_data,
int dest_stride,
guchar *src_data,
int src_stride,
int src_x,
int src_y,
int width,
int height)
{
int x, y;
src_data += src_stride * src_y + src_x * 4;
for (y = 0; y < height; y++)
{
uint32_t *src = (guint32 *) src_data;
for (x = 0; x < width; x++)
{
unsigned int alpha = src[x] >> 24;
if (alpha == 0)
{
dest_data[x * 4 + 0] = 0;
dest_data[x * 4 + 1] = 0;
dest_data[x * 4 + 2] = 0;
}
else
{
dest_data[x * 4 + 0] = (((src[x] & 0xff0000) >> 16) * 255 + alpha / 2) / alpha;
dest_data[x * 4 + 1] = (((src[x] & 0x00ff00) >> 8) * 255 + alpha / 2) / alpha;
dest_data[x * 4 + 2] = (((src[x] & 0x0000ff) >> 0) * 255 + alpha / 2) / alpha;
}
dest_data[x * 4 + 3] = alpha;
}
src_data += src_stride;
dest_data += dest_stride;
}
}
static void
convert_no_alpha (guchar *dest_data,
int dest_stride,
guchar *src_data,
int src_stride,
int src_x,
int src_y,
int width,
int height)
{
int x, y;
src_data += src_stride * src_y + src_x * 4;
for (y = 0; y < height; y++)
{
uint32_t *src = (uint32_t *) src_data;
for (x = 0; x < width; x++)
{
dest_data[x * 3 + 0] = src[x] >> 16;
dest_data[x * 3 + 1] = src[x] >> 8;
dest_data[x * 3 + 2] = src[x];
}
src_data += src_stride;
dest_data += dest_stride;
}
}
static GdkPixbuf *
util_pixbuf_from_surface (cairo_surface_t *surface,
gint src_x,
gint src_y,
gint width,
gint height)
{
cairo_content_t content;
GdkPixbuf *dest;
/* General sanity checks */
g_return_val_if_fail (surface != NULL, NULL);
g_return_val_if_fail (width > 0 && height > 0, NULL);
content = cairo_surface_get_content (surface) | CAIRO_CONTENT_COLOR;
dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB,
!!(content & CAIRO_CONTENT_ALPHA),
8,
width, height);
if (cairo_surface_get_type (surface) == CAIRO_SURFACE_TYPE_IMAGE &&
cairo_image_surface_get_format (surface) == util_cairo_format_for_content (content))
{
surface = cairo_surface_reference (surface);
}
else
{
surface = util_cairo_surface_coerce_to_image (surface, content,
src_x, src_y,
width, height);
src_x = 0;
src_y = 0;
}
cairo_surface_flush (surface);
if (cairo_surface_status (surface) || dest == NULL)
{
cairo_surface_destroy (surface);
g_clear_object (&dest);
return NULL;
}
if (gdk_pixbuf_get_has_alpha (dest))
{
convert_alpha (gdk_pixbuf_get_pixels (dest),
gdk_pixbuf_get_rowstride (dest),
cairo_image_surface_get_data (surface),
cairo_image_surface_get_stride (surface),
src_x, src_y,
width, height);
}
else
{
convert_no_alpha (gdk_pixbuf_get_pixels (dest),
gdk_pixbuf_get_rowstride (dest),
cairo_image_surface_get_data (surface),
cairo_image_surface_get_stride (surface),
src_x, src_y,
width, height);
}
cairo_surface_destroy (surface);
return dest;
}
static void
write_screenshot_thread (GTask *result,
gpointer object,
gpointer task_data,
GCancellable *cancellable)
{
ShellScreenshot *screenshot = SHELL_SCREENSHOT (object);
ShellScreenshotPrivate *priv;
g_autoptr (GOutputStream) stream = NULL;
g_autoptr(GdkPixbuf) pixbuf = NULL;
g_autofree char *creation_time = NULL;
GError *error = NULL;
g_assert (screenshot != NULL);
priv = screenshot->priv;
stream = g_object_ref (priv->stream);
pixbuf = util_pixbuf_from_surface (priv->image,
0, 0,
cairo_image_surface_get_width (priv->image),
cairo_image_surface_get_height (priv->image));
creation_time = g_date_time_format (priv->datetime, "%c");
if (!creation_time)
creation_time = g_date_time_format (priv->datetime, "%FT%T%z");
gdk_pixbuf_save_to_stream (pixbuf, stream, "png", NULL, &error,
"tEXt::Software", "gnome-screenshot",
"tEXt::Creation Time", creation_time,
NULL);
if (error)
g_task_return_error (result, error);
else
g_task_return_boolean (result, TRUE);
}
static void
do_grab_screenshot (ShellScreenshot *screenshot,
int x,
int y,
int width,
int height,
ShellScreenshotFlag flags)
{
ShellScreenshotPrivate *priv = screenshot->priv;
ClutterStage *stage = shell_global_get_stage (priv->global);
cairo_rectangle_int_t screenshot_rect = { x, y, width, height };
int image_width;
int image_height;
float scale;
cairo_surface_t *image;
ClutterPaintFlag paint_flags = CLUTTER_PAINT_FLAG_NONE;
g_autoptr (GError) error = NULL;
clutter_stage_get_capture_final_size (stage, &screenshot_rect,
&image_width,
&image_height,
&scale);
image = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
image_width, image_height);
if (flags & SHELL_SCREENSHOT_FLAG_INCLUDE_CURSOR)
paint_flags |= CLUTTER_PAINT_FLAG_FORCE_CURSORS;
else
paint_flags |= CLUTTER_PAINT_FLAG_NO_CURSORS;
if (!clutter_stage_paint_to_buffer (stage, &screenshot_rect, scale,
cairo_image_surface_get_data (image),
cairo_image_surface_get_stride (image),
CLUTTER_CAIRO_FORMAT_ARGB32,
paint_flags,
&error))
{
cairo_surface_destroy (image);
g_warning ("Failed to take screenshot: %s", error->message);
return;
}
priv->image = image;
priv->datetime = g_date_time_new_now_local ();
}
static void
draw_cursor_image (cairo_surface_t *surface,
cairo_rectangle_int_t area)
{
CoglTexture *texture;
int width, height;
int stride;
guint8 *data;
MetaDisplay *display;
MetaCursorTracker *tracker;
cairo_surface_t *cursor_surface;
cairo_region_t *screenshot_region;
cairo_t *cr;
int x, y;
int xhot, yhot;
double xscale, yscale;
graphene_point_t point;
display = shell_global_get_display (shell_global_get ());
tracker = meta_cursor_tracker_get_for_display (display);
texture = meta_cursor_tracker_get_sprite (tracker);
if (!texture)
return;
screenshot_region = cairo_region_create_rectangle (&area);
meta_cursor_tracker_get_pointer (tracker, &point, NULL);
x = point.x;
y = point.y;
if (!cairo_region_contains_point (screenshot_region, point.x, point.y))
{
cairo_region_destroy (screenshot_region);
return;
}
meta_cursor_tracker_get_hot (tracker, &xhot, &yhot);
width = cogl_texture_get_width (texture);
height = cogl_texture_get_height (texture);
stride = 4 * width;
data = g_new (guint8, stride * height);
cogl_texture_get_data (texture, CLUTTER_CAIRO_FORMAT_ARGB32, stride, data);
/* FIXME: cairo-gl? */
cursor_surface = cairo_image_surface_create_for_data (data,
CAIRO_FORMAT_ARGB32,
width, height,
stride);
cairo_surface_get_device_scale (surface, &xscale, &yscale);
if (xscale != 1.0 || yscale != 1.0)
{
int monitor;
float monitor_scale;
MetaRectangle cursor_rect = {
.x = x, .y = y, .width = width, .height = height
};
monitor = meta_display_get_monitor_index_for_rect (display, &cursor_rect);
monitor_scale = meta_display_get_monitor_scale (display, monitor);
cairo_surface_set_device_scale (cursor_surface, monitor_scale, monitor_scale);
}
cr = cairo_create (surface);
cairo_set_source_surface (cr,
cursor_surface,
x - xhot - area.x,
y - yhot - area.y);
cairo_paint (cr);
cairo_destroy (cr);
cairo_surface_destroy (cursor_surface);
cairo_region_destroy (screenshot_region);
g_free (data);
}
static void
grab_screenshot (ShellScreenshot *screenshot,
ShellScreenshotFlag flags,
GTask *result)
{
ShellScreenshotPrivate *priv = screenshot->priv;
MetaDisplay *display;
int width, height;
GTask *task;
display = shell_global_get_display (priv->global);
meta_display_get_size (display, &width, &height);
do_grab_screenshot (screenshot,
0, 0, width, height,
flags);
priv->screenshot_area.x = 0;
priv->screenshot_area.y = 0;
priv->screenshot_area.width = width;
priv->screenshot_area.height = height;
task = g_task_new (screenshot, NULL, on_screenshot_written, result);
g_task_run_in_thread (task, write_screenshot_thread);
g_object_unref (task);
}
static void
grab_screenshot_content (ShellScreenshot *screenshot,
GTask *result)
{
ShellScreenshotPrivate *priv = screenshot->priv;
MetaDisplay *display;
int width, height;
cairo_rectangle_int_t screenshot_rect;
ClutterStage *stage;
int image_width;
int image_height;
float scale;
g_autoptr (GError) error = NULL;
g_autoptr (ClutterContent) content = NULL;
g_autoptr (GTask) task = result;
MetaCursorTracker *tracker;
CoglTexture *cursor_texture;
int cursor_hot_x, cursor_hot_y;
display = shell_global_get_display (priv->global);
meta_display_get_size (display, &width, &height);
screenshot_rect = (cairo_rectangle_int_t) {
.x = 0,
.y = 0,
.width = width,
.height = height,
};
stage = shell_global_get_stage (priv->global);
clutter_stage_get_capture_final_size (stage, &screenshot_rect,
&image_width,
&image_height,
&scale);
priv->scale = scale;
content = clutter_stage_paint_to_content (stage, &screenshot_rect, scale,
CLUTTER_PAINT_FLAG_NO_CURSORS,
&error);
if (!content)
{
g_task_return_error (result, g_steal_pointer (&error));
return;
}
tracker = meta_cursor_tracker_get_for_display (display);
cursor_texture = meta_cursor_tracker_get_sprite (tracker);
// If the cursor is invisible, the texture is NULL.
if (cursor_texture)
{
unsigned int width, height;
CoglContext *ctx;
CoglPipeline *pipeline;
CoglTexture2D *texture;
CoglOffscreen *offscreen;
ClutterStageView *view;
// Copy the texture to prevent it from changing shortly after.
width = cogl_texture_get_width (cursor_texture);
height = cogl_texture_get_height (cursor_texture);
ctx = clutter_backend_get_cogl_context (clutter_get_default_backend ());
texture = cogl_texture_2d_new_with_size (ctx, width, height);
offscreen = cogl_offscreen_new_with_texture (texture);
cogl_framebuffer_clear4f (COGL_FRAMEBUFFER (offscreen),
COGL_BUFFER_BIT_COLOR,
0, 0, 0, 0);
pipeline = cogl_pipeline_new (ctx);
cogl_pipeline_set_layer_texture (pipeline, 0, cursor_texture);
cogl_framebuffer_draw_textured_rectangle (COGL_FRAMEBUFFER (offscreen),
pipeline,
-1, 1, 1, -1,
0, 0, 1, 1);
cogl_object_unref (pipeline);
g_object_unref (offscreen);
priv->cursor_content =
clutter_texture_content_new_from_texture (texture, NULL);
cogl_object_unref (texture);
priv->cursor_scale = meta_cursor_tracker_get_scale (tracker);
meta_cursor_tracker_get_pointer (tracker, &priv->cursor_point, NULL);
view = clutter_stage_get_view_at (stage,
priv->cursor_point.x,
priv->cursor_point.y);
meta_cursor_tracker_get_hot (tracker, &cursor_hot_x, &cursor_hot_y);
priv->cursor_point.x -= cursor_hot_x * priv->cursor_scale;
priv->cursor_point.y -= cursor_hot_y * priv->cursor_scale;
// Align the coordinates to the pixel grid the same way it's done in
// MetaCursorRenderer.
if (view)
{
cairo_rectangle_int_t view_layout;
float view_scale;
clutter_stage_view_get_layout (view, &view_layout);
view_scale = clutter_stage_view_get_scale (view);
priv->cursor_point.x -= view_layout.x;
priv->cursor_point.y -= view_layout.y;
priv->cursor_point.x =
floorf (priv->cursor_point.x * view_scale) / view_scale;
priv->cursor_point.y =
floorf (priv->cursor_point.y * view_scale) / view_scale;
priv->cursor_point.x += view_layout.x;
priv->cursor_point.y += view_layout.y;
}
}
g_task_return_pointer (result, g_steal_pointer (&content), g_object_unref);
}
static void
grab_window_screenshot (ShellScreenshot *screenshot,
ShellScreenshotFlag flags,
GTask *result)
{
ShellScreenshotPrivate *priv = screenshot->priv;
GTask *task;
MetaDisplay *display = shell_global_get_display (priv->global);
MetaWindow *window = meta_display_get_focus_window (display);
ClutterActor *window_actor;
gfloat actor_x, actor_y;
MetaRectangle rect;
window_actor = CLUTTER_ACTOR (meta_window_get_compositor_private (window));
clutter_actor_get_position (window_actor, &actor_x, &actor_y);
meta_window_get_frame_rect (window, &rect);
if (!priv->include_frame)
meta_window_frame_rect_to_client_rect (window, &rect, &rect);
priv->screenshot_area = rect;
priv->image = meta_window_actor_get_image (META_WINDOW_ACTOR (window_actor),
NULL);
if (!priv->image)
{
g_task_report_new_error (screenshot, on_screenshot_written, result, NULL,
G_IO_ERROR, G_IO_ERROR_FAILED,
"Capturing window failed");
return;
}
priv->datetime = g_date_time_new_now_local ();
if (flags & SHELL_SCREENSHOT_FLAG_INCLUDE_CURSOR)
{
if (meta_window_get_client_type (window) == META_WINDOW_CLIENT_TYPE_WAYLAND)
{
float resource_scale;
resource_scale = clutter_actor_get_resource_scale (window_actor);
cairo_surface_set_device_scale (priv->image, resource_scale, resource_scale);
}
draw_cursor_image (priv->image, priv->screenshot_area);
}
g_signal_emit (screenshot, signals[SCREENSHOT_TAKEN], 0, &rect);
task = g_task_new (screenshot, NULL, on_screenshot_written, result);
g_task_run_in_thread (task, write_screenshot_thread);
g_object_unref (task);
}
static gboolean
finish_screenshot (ShellScreenshot *screenshot,
GAsyncResult *result,
cairo_rectangle_int_t **area,
GError **error)
{
ShellScreenshotPrivate *priv = screenshot->priv;
if (!g_task_propagate_boolean (G_TASK (result), error))
return FALSE;
if (area)
*area = &priv->screenshot_area;
return TRUE;
}
static void
on_after_paint (ClutterStage *stage,
ClutterStageView *view,
ClutterFrame *frame,
GTask *result)
{
ShellScreenshot *screenshot = g_task_get_task_data (result);
ShellScreenshotPrivate *priv = screenshot->priv;
MetaDisplay *display = shell_global_get_display (priv->global);
GTask *task;
g_signal_handlers_disconnect_by_func (stage, on_after_paint, result);
if (priv->mode == SHELL_SCREENSHOT_AREA)
{
do_grab_screenshot (screenshot,
priv->screenshot_area.x,
priv->screenshot_area.y,
priv->screenshot_area.width,
priv->screenshot_area.height,
priv->flags);
task = g_task_new (screenshot, NULL, on_screenshot_written, result);
g_task_run_in_thread (task, write_screenshot_thread);
}
else
{
grab_screenshot (screenshot, priv->flags, result);
}
g_signal_emit (screenshot, signals[SCREENSHOT_TAKEN], 0,
(cairo_rectangle_int_t *) &priv->screenshot_area);
meta_enable_unredirect_for_display (display);
}
/**
* shell_screenshot_screenshot:
* @screenshot: the #ShellScreenshot
* @include_cursor: Whether to include the cursor or not
* @stream: The stream for the screenshot
* @callback: (scope async): function to call returning success or failure
* of the async grabbing
* @user_data: the data to pass to callback function
*
* Takes a screenshot of the whole screen
* in @stream as png image.
*
*/
void
shell_screenshot_screenshot (ShellScreenshot *screenshot,
gboolean include_cursor,
GOutputStream *stream,
GAsyncReadyCallback callback,
gpointer user_data)
{
ShellScreenshotPrivate *priv;
GTask *result;
ShellScreenshotFlag flags;
g_return_if_fail (SHELL_IS_SCREENSHOT (screenshot));
g_return_if_fail (G_IS_OUTPUT_STREAM (stream));
priv = screenshot->priv;
if (priv->stream != NULL) {
if (callback)
g_task_report_new_error (screenshot,
callback,
user_data,
shell_screenshot_screenshot,
G_IO_ERROR,
G_IO_ERROR_PENDING,
"Only one screenshot operation at a time "
"is permitted");
return;
}
result = g_task_new (screenshot, NULL, callback, user_data);
g_task_set_source_tag (result, shell_screenshot_screenshot);
g_task_set_task_data (result, screenshot, NULL);
priv->stream = g_object_ref (stream);
flags = SHELL_SCREENSHOT_FLAG_NONE;
if (include_cursor)
flags |= SHELL_SCREENSHOT_FLAG_INCLUDE_CURSOR;
if (meta_is_wayland_compositor ())
{
grab_screenshot (screenshot, flags, result);
g_signal_emit (screenshot, signals[SCREENSHOT_TAKEN], 0,
(cairo_rectangle_int_t *) &priv->screenshot_area);
}
else
{
MetaDisplay *display = shell_global_get_display (priv->global);
ClutterStage *stage = shell_global_get_stage (priv->global);
meta_disable_unredirect_for_display (display);
clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
priv->flags = flags;
priv->mode = SHELL_SCREENSHOT_SCREEN;
g_signal_connect (stage, "after-paint",
G_CALLBACK (on_after_paint), result);
}
}
/**
* shell_screenshot_screenshot_finish:
* @screenshot: the #ShellScreenshot
* @result: the #GAsyncResult that was provided to the callback
* @area: (out) (transfer none): the area that was grabbed in screen coordinates
* @error: #GError for error reporting
*
* Finish the asynchronous operation started by shell_screenshot_screenshot()
* and obtain its result.
*
* Returns: whether the operation was successful
*
*/
gboolean
shell_screenshot_screenshot_finish (ShellScreenshot *screenshot,
GAsyncResult *result,
cairo_rectangle_int_t **area,
GError **error)
{
g_return_val_if_fail (SHELL_IS_SCREENSHOT (screenshot), FALSE);
g_return_val_if_fail (G_IS_TASK (result), FALSE);
g_return_val_if_fail (g_async_result_is_tagged (result,
shell_screenshot_screenshot),
FALSE);
return finish_screenshot (screenshot, result, area, error);
}
static void
screenshot_stage_to_content_on_after_paint (ClutterStage *stage,
ClutterStageView *view,
ClutterFrame *frame,
GTask *result)
{
ShellScreenshot *screenshot = g_task_get_task_data (result);
ShellScreenshotPrivate *priv = screenshot->priv;
MetaDisplay *display = shell_global_get_display (priv->global);
g_signal_handlers_disconnect_by_func (stage,
screenshot_stage_to_content_on_after_paint,
result);
meta_enable_unredirect_for_display (display);
grab_screenshot_content (screenshot, result);
}
/**
* shell_screenshot_screenshot_stage_to_content:
* @screenshot: the #ShellScreenshot
* @callback: (scope async): function to call returning success or failure
* of the async grabbing
* @user_data: the data to pass to callback function
*
* Takes a screenshot of the whole screen as #ClutterContent.
*
*/
void
shell_screenshot_screenshot_stage_to_content (ShellScreenshot *screenshot,
GAsyncReadyCallback callback,
gpointer user_data)
{
ShellScreenshotPrivate *priv;
GTask *result;
g_return_if_fail (SHELL_IS_SCREENSHOT (screenshot));
result = g_task_new (screenshot, NULL, callback, user_data);
g_task_set_source_tag (result, shell_screenshot_screenshot_stage_to_content);
g_task_set_task_data (result, screenshot, NULL);
if (meta_is_wayland_compositor ())
{
grab_screenshot_content (screenshot, result);
}
else
{
priv = screenshot->priv;
MetaDisplay *display = shell_global_get_display (priv->global);
ClutterStage *stage = shell_global_get_stage (priv->global);
meta_disable_unredirect_for_display (display);
clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
g_signal_connect (stage, "after-paint",
G_CALLBACK (screenshot_stage_to_content_on_after_paint),
result);
}
}
/**
* shell_screenshot_screenshot_stage_to_content_finish:
* @screenshot: the #ShellScreenshot
* @result: the #GAsyncResult that was provided to the callback
* @scale: (out) (optional): location to store the content scale
* @cursor_content: (out) (optional): location to store the cursor content
* @cursor_point: (out) (optional): location to store the point at which to
* draw the cursor content
* @cursor_scale: (out) (optional): location to store the cursor scale
* @error: #GError for error reporting
*
* Finish the asynchronous operation started by
* shell_screenshot_screenshot_stage_to_content() and obtain its result.
*
* Returns: (transfer full): the #ClutterContent, or NULL
*
*/
ClutterContent *
shell_screenshot_screenshot_stage_to_content_finish (ShellScreenshot *screenshot,
GAsyncResult *result,
float *scale,
ClutterContent **cursor_content,
graphene_point_t *cursor_point,
float *cursor_scale,
GError **error)
{
ShellScreenshotPrivate *priv = screenshot->priv;
ClutterContent *content;
g_return_val_if_fail (SHELL_IS_SCREENSHOT (screenshot), FALSE);
g_return_val_if_fail (G_IS_TASK (result), FALSE);
g_return_val_if_fail (g_async_result_is_tagged (result,
shell_screenshot_screenshot_stage_to_content),
FALSE);
content = g_task_propagate_pointer (G_TASK (result), error);
if (!content)
return NULL;
if (scale)
*scale = priv->scale;
if (cursor_content)
*cursor_content = g_steal_pointer (&priv->cursor_content);
else
g_clear_pointer (&priv->cursor_content, g_object_unref);
if (cursor_point)
*cursor_point = priv->cursor_point;
if (cursor_scale)
*cursor_scale = priv->cursor_scale;
return content;
}
/**
* shell_screenshot_screenshot_area:
* @screenshot: the #ShellScreenshot
* @x: The X coordinate of the area
* @y: The Y coordinate of the area
* @width: The width of the area
* @height: The height of the area
* @stream: The stream for the screenshot
* @callback: (scope async): function to call returning success or failure
* of the async grabbing
* @user_data: the data to pass to callback function
*
* Takes a screenshot of the passed in area and saves it
* in @stream as png image.
*
*/
void
shell_screenshot_screenshot_area (ShellScreenshot *screenshot,
int x,
int y,
int width,
int height,
GOutputStream *stream,
GAsyncReadyCallback callback,
gpointer user_data)
{
ShellScreenshotPrivate *priv;
GTask *result;
g_autoptr (GTask) task = NULL;
g_return_if_fail (SHELL_IS_SCREENSHOT (screenshot));
g_return_if_fail (G_IS_OUTPUT_STREAM (stream));
priv = screenshot->priv;
if (priv->stream != NULL) {
if (callback)
g_task_report_new_error (screenshot,
callback,
NULL,
shell_screenshot_screenshot_area,
G_IO_ERROR,
G_IO_ERROR_PENDING,
"Only one screenshot operation at a time "
"is permitted");
return;
}
result = g_task_new (screenshot, NULL, callback, user_data);
g_task_set_source_tag (result, shell_screenshot_screenshot_area);
g_task_set_task_data (result, screenshot, NULL);
priv->stream = g_object_ref (stream);
priv->screenshot_area.x = x;
priv->screenshot_area.y = y;
priv->screenshot_area.width = width;
priv->screenshot_area.height = height;
if (meta_is_wayland_compositor ())
{
do_grab_screenshot (screenshot,
priv->screenshot_area.x,
priv->screenshot_area.y,
priv->screenshot_area.width,
priv->screenshot_area.height,
SHELL_SCREENSHOT_FLAG_NONE);
g_signal_emit (screenshot, signals[SCREENSHOT_TAKEN], 0,
(cairo_rectangle_int_t *) &priv->screenshot_area);
task = g_task_new (screenshot, NULL, on_screenshot_written, result);
g_task_run_in_thread (task, write_screenshot_thread);
}
else
{
MetaDisplay *display = shell_global_get_display (priv->global);
ClutterStage *stage = shell_global_get_stage (priv->global);
meta_disable_unredirect_for_display (display);
clutter_actor_queue_redraw (CLUTTER_ACTOR (stage));
priv->flags = SHELL_SCREENSHOT_FLAG_NONE;
priv->mode = SHELL_SCREENSHOT_AREA;
g_signal_connect (stage, "after-paint",
G_CALLBACK (on_after_paint), result);
}
}
/**
* shell_screenshot_screenshot_area_finish:
* @screenshot: the #ShellScreenshot
* @result: the #GAsyncResult that was provided to the callback
* @area: (out) (transfer none): the area that was grabbed in screen coordinates
* @error: #GError for error reporting
*
* Finish the asynchronous operation started by shell_screenshot_screenshot_area()
* and obtain its result.
*
* Returns: whether the operation was successful
*
*/
gboolean
shell_screenshot_screenshot_area_finish (ShellScreenshot *screenshot,
GAsyncResult *result,
cairo_rectangle_int_t **area,
GError **error)
{
g_return_val_if_fail (SHELL_IS_SCREENSHOT (screenshot), FALSE);
g_return_val_if_fail (G_IS_TASK (result), FALSE);
g_return_val_if_fail (g_async_result_is_tagged (result,
shell_screenshot_screenshot_area),
FALSE);
return finish_screenshot (screenshot, result, area, error);
}
/**
* shell_screenshot_screenshot_window:
* @screenshot: the #ShellScreenshot
* @include_frame: Whether to include the frame or not
* @include_cursor: Whether to include the cursor or not
* @stream: The stream for the screenshot
* @callback: (scope async): function to call returning success or failure
* of the async grabbing
* @user_data: the data to pass to callback function
*
* Takes a screenshot of the focused window (optionally omitting the frame)
* in @stream as png image.
*
*/
void
shell_screenshot_screenshot_window (ShellScreenshot *screenshot,
gboolean include_frame,
gboolean include_cursor,
GOutputStream *stream,
GAsyncReadyCallback callback,
gpointer user_data)
{
ShellScreenshotPrivate *priv;
MetaDisplay *display;
MetaWindow *window;
GTask *result;
g_return_if_fail (SHELL_IS_SCREENSHOT (screenshot));
g_return_if_fail (G_IS_OUTPUT_STREAM (stream));
priv = screenshot->priv;
display = shell_global_get_display (priv->global);
window = meta_display_get_focus_window (display);
if (priv->stream != NULL || !window) {
if (callback)
g_task_report_new_error (screenshot,
callback,
NULL,
shell_screenshot_screenshot_window,
G_IO_ERROR,
G_IO_ERROR_PENDING,
"Only one screenshot operation at a time "
"is permitted");
return;
}
result = g_task_new (screenshot, NULL, callback, user_data);
g_task_set_source_tag (result, shell_screenshot_screenshot_window);
priv->stream = g_object_ref (stream);
priv->include_frame = include_frame;
grab_window_screenshot (screenshot, include_cursor, result);
}
/**
* shell_screenshot_screenshot_window_finish:
* @screenshot: the #ShellScreenshot
* @result: the #GAsyncResult that was provided to the callback
* @area: (out) (transfer none): the area that was grabbed in screen coordinates
* @error: #GError for error reporting
*
* Finish the asynchronous operation started by shell_screenshot_screenshot_window()
* and obtain its result.
*
* Returns: whether the operation was successful
*
*/
gboolean
shell_screenshot_screenshot_window_finish (ShellScreenshot *screenshot,
GAsyncResult *result,
cairo_rectangle_int_t **area,
GError **error)
{
g_return_val_if_fail (SHELL_IS_SCREENSHOT (screenshot), FALSE);
g_return_val_if_fail (G_IS_TASK (result), FALSE);
g_return_val_if_fail (g_async_result_is_tagged (result,
shell_screenshot_screenshot_window),
FALSE);
return finish_screenshot (screenshot, result, area, error);
}
/**
* shell_screenshot_pick_color:
* @screenshot: the #ShellScreenshot
* @x: The X coordinate to pick
* @y: The Y coordinate to pick
* @callback: (scope async): function to call returning success or failure
* of the async grabbing
*
* Picks the pixel at @x, @y and returns its color as #ClutterColor.
*
*/
void
shell_screenshot_pick_color (ShellScreenshot *screenshot,
int x,
int y,
GAsyncReadyCallback callback,
gpointer user_data)
{
ShellScreenshotPrivate *priv;
g_autoptr (GTask) result = NULL;
g_return_if_fail (SHELL_IS_SCREENSHOT (screenshot));
result = g_task_new (screenshot, NULL, callback, user_data);
g_task_set_source_tag (result, shell_screenshot_pick_color);
priv = screenshot->priv;
priv->screenshot_area.x = x;
priv->screenshot_area.y = y;
priv->screenshot_area.width = 1;
priv->screenshot_area.height = 1;
do_grab_screenshot (screenshot,
priv->screenshot_area.x,
priv->screenshot_area.y,
1,
1,
SHELL_SCREENSHOT_FLAG_NONE);
g_task_return_boolean (result, TRUE);
}
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
#define INDEX_A 3
#define INDEX_R 2
#define INDEX_G 1
#define INDEX_B 0
#else
#define INDEX_A 0
#define INDEX_R 1
#define INDEX_G 2
#define INDEX_B 3
#endif
/**
* shell_screenshot_pick_color_finish:
* @screenshot: the #ShellScreenshot
* @result: the #GAsyncResult that was provided to the callback
* @color: (out caller-allocates): the picked color
* @error: #GError for error reporting
*
* Finish the asynchronous operation started by shell_screenshot_pick_color()
* and obtain its result.
*
* Returns: whether the operation was successful
*
*/
gboolean
shell_screenshot_pick_color_finish (ShellScreenshot *screenshot,
GAsyncResult *result,
ClutterColor *color,
GError **error)
{
ShellScreenshotPrivate *priv;
g_return_val_if_fail (SHELL_IS_SCREENSHOT (screenshot), FALSE);
g_return_val_if_fail (G_IS_TASK (result), FALSE);
g_return_val_if_fail (color != NULL, FALSE);
g_return_val_if_fail (g_async_result_is_tagged (result,
shell_screenshot_pick_color),
FALSE);
if (!g_task_propagate_boolean (G_TASK (result), error))
return FALSE;
priv = screenshot->priv;
/* protect against mutter changing the format used for stage captures */
g_assert (cairo_image_surface_get_format (priv->image) == CAIRO_FORMAT_ARGB32);
if (color)
{
uint8_t *data = cairo_image_surface_get_data (priv->image);
color->alpha = data[INDEX_A];
color->red = data[INDEX_R];
color->green = data[INDEX_G];
color->blue = data[INDEX_B];
}
return TRUE;
}
#undef INDEX_A
#undef INDEX_R
#undef INDEX_G
#undef INDEX_B
static void
composite_to_stream_on_png_saved (GObject *pixbuf,
GAsyncResult *result,
gpointer user_data)
{
GTask *task = G_TASK (user_data);
GError *error = NULL;
if (!gdk_pixbuf_save_to_stream_finish (result, &error))
g_task_return_error (task, error);
else
g_task_return_pointer (task, g_object_ref (pixbuf), g_object_unref);
g_object_unref (task);
}
/**
* shell_screenshot_composite_to_stream:
* @texture: the source texture
* @x: x coordinate of the rectangle
* @y: y coordinate of the rectangle
* @width: width of the rectangle, or -1 to use the full texture
* @height: height of the rectangle, or -1 to use the full texture
* @scale: scale of the source texture
* @cursor: (nullable): the cursor texture
* @cursor_x: x coordinate to put the cursor texture at, relative to the full
* source texture
* @cursor_y: y coordinate to put the cursor texture at, relative to the full
* source texture
* @cursor_scale: scale of the cursor texture
* @stream: the stream to write the PNG image into
* @callback: (scope async): function to call returning success or failure
* @user_data: the data to pass to callback function
*
* Composite a rectangle defined by x, y, width, height from the texture to a
* pixbuf and write it as a PNG image into the stream.
*
*/
void
shell_screenshot_composite_to_stream (CoglTexture *texture,
int x,
int y,
int width,
int height,
float scale,
CoglTexture *cursor,
int cursor_x,
int cursor_y,
float cursor_scale,
GOutputStream *stream,
GAsyncReadyCallback callback,
gpointer user_data)
{
CoglContext *ctx;
CoglTexture *sub_texture;
cairo_surface_t *surface;
cairo_surface_t *cursor_surface;
cairo_t *cr;
g_autoptr (GTask) task = NULL;
g_autoptr (GdkPixbuf) pixbuf = NULL;
g_autofree char *creation_time = NULL;
g_autoptr (GDateTime) date_time = NULL;
task = g_task_new (NULL, NULL, callback, user_data);
g_task_set_source_tag (task, shell_screenshot_composite_to_stream);
if (width == -1 || height == -1)
{
x = 0;
y = 0;
width = cogl_texture_get_width (texture);
height = cogl_texture_get_height (texture);
}
ctx = clutter_backend_get_cogl_context (clutter_get_default_backend ());
sub_texture = cogl_sub_texture_new (ctx, texture, x, y, width, height);
surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
cogl_texture_get_width (sub_texture),
cogl_texture_get_height (sub_texture));
cogl_texture_get_data (sub_texture, CLUTTER_CAIRO_FORMAT_ARGB32,
cairo_image_surface_get_stride (surface),
cairo_image_surface_get_data (surface));
cairo_surface_mark_dirty (surface);
cogl_object_unref (sub_texture);
cairo_surface_set_device_scale (surface, scale, scale);
if (cursor != NULL)
{
// Paint the cursor on top.
cursor_surface =
cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
cogl_texture_get_width (cursor),
cogl_texture_get_height (cursor));
cogl_texture_get_data (cursor, CLUTTER_CAIRO_FORMAT_ARGB32,
cairo_image_surface_get_stride (cursor_surface),
cairo_image_surface_get_data (cursor_surface));
cairo_surface_mark_dirty (cursor_surface);
cairo_surface_set_device_scale (cursor_surface,
1 / cursor_scale,
1 / cursor_scale);
cr = cairo_create (surface);
cairo_set_source_surface (cr, cursor_surface,
(cursor_x - x) / scale,
(cursor_y - y) / scale);
cairo_paint (cr);
cairo_destroy (cr);
cairo_surface_destroy (cursor_surface);
}
/* Save to an image. */
pixbuf = util_pixbuf_from_surface (surface,
0, 0,
cairo_image_surface_get_width (surface),
cairo_image_surface_get_height (surface));
cairo_surface_destroy (surface);
date_time = g_date_time_new_now_local ();
creation_time = g_date_time_format (date_time, "%c");
if (!creation_time)
creation_time = g_date_time_format (date_time, "%FT%T%z");
gdk_pixbuf_save_to_stream_async (pixbuf, stream, "png", NULL,
composite_to_stream_on_png_saved,
g_steal_pointer (&task),
"tEXt::Software", "gnome-screenshot",
"tEXt::Creation Time", creation_time,
NULL);
}
/**
* shell_screenshot_composite_to_stream_finish:
* @result: the #GAsyncResult that was provided to the callback
* @error: #GError for error reporting
*
* Finish the asynchronous operation started by
* shell_screenshot_composite_to_stream () and obtain its result.
*
* Returns: (transfer full) (nullable): a GdkPixbuf with the final image if the
* operation was successful, or NULL on error.
*
*/
GdkPixbuf *
shell_screenshot_composite_to_stream_finish (GAsyncResult *result,
GError **error)
{
g_return_val_if_fail (G_IS_TASK (result), FALSE);
g_return_val_if_fail (g_async_result_is_tagged (result,
shell_screenshot_composite_to_stream),
FALSE);
return g_task_propagate_pointer (G_TASK (result), error);
}
ShellScreenshot *
shell_screenshot_new (void)
{
return g_object_new (SHELL_TYPE_SCREENSHOT, NULL);
}
Reference in New Issue View Git Blame Copy Permalink