Gtk4 Screenshot with GtkSnapshot

Platform
,
1

According to my research, there is currently no direct way to take a screenshot of a widget with Gtk4. The repeatedly mentioned GtkSnapshot object is used exclusively internally, i.e. when a GtkWidget is rendered.
So the only option left is to derive your own GtkWidget and then override the virtual function “snapshot” accordingly. This is also recommended in the documentation: “The typical way to obtain a GtkSnapshot object is as an argument to the Gtk.WidgetClass.snapshot vfunc.”

Using a block entry from April 2020, I have now tried to get a GtkSnapshot:

void
demo_snapshot (GtkWidget *widget, GtkSnapshot *snapshot)
{
  GdkRGBA red, green, yellow, blue;
  float w, h;

  gdk_rgba_parse (&red, "red");
  gdk_rgba_parse (&green, "green");
  gdk_rgba_parse (&yellow, "yellow");
  gdk_rgba_parse (&blue, "blue");

  w = gtk_widget_get_width (widget) / 2.0;
  h = gtk_widget_get_height (widget) / 2.0;

  gtk_snapshot_append_color (snapshot, &red,
                             &GRAPHENE_RECT_INIT(0, 0, w, h));
  gtk_snapshot_append_color (snapshot, &green,
                             &GRAPHENE_RECT_INIT(w, 0, w, h));
  gtk_snapshot_append_color (snapshot, &yellow,
                             &GRAPHENE_RECT_INIT(0, h, w, h));
  gtk_snapshot_append_color (snapshot, &blue,
                             &GRAPHENE_RECT_INIT(w, h, w, h));

  // generates an error message
  GskRenderNode* node = gtk_snapshot_to_node (snapshot);

}

Unfortunately, I get the following error message here:

/*  (_snapshot-2:8960): Gtk-WARNING **: 12:10:01.002: Too many gtk_snapshot_push() calls. 5 states remaining.
**
Gtk:ERROR:../../../gtk/gtksnapshot.c:247:gtk_snapshot_get_current_state: assertion failed: (size > 0)
Bail out! Gtk:ERROR:../../../gtk/gtksnapshot.c:247:gtk_snapshot_get_current_state: assertion failed: (size > 0)
Aborted (core dumped)
*/

How could I use the GtkSnapshot to read and print it out into a GdkTexture?

2

Gtk.Snapshot is usually used to determine how the widget is rendered. The snapshot method is called by GTK to render the widget.

The question is: Do you need to screenshot the widget as part of your program?

If not, you could just use the GTK inspector to save the render node of your widget and then use the GTK node tool to create a picture out of it.

If you do need to screenshot the widget during program run time, it seems to me that you should create a new Gtk.Snapshot yourself, render your widget to it and convert this to your picture.
libadwaita has a tool to create its images for the docs, which screenshots widgets, so this code could be of interest to you:

3

Why? just use the existing snapshot function, but pass your own GtkSnapshot object.

Something like this (untested):

snapshot = gtk_snapshot_new ();
gtk_widget_snapshot (widget, snapshot);
node = gtk_snapshot_free_to_node (snapshot);
renderer = gtk_native_get_renderer (gtk_widget_get_native (widget));
texture = gsk_renderer_render_texture (renderer,
                                       node,
                                       &GRAPHENE_RECT_INIT (0, 0, widget.get_width(), widget.get_height()));
gdk_texture_save_to_png (texture, png_file);
4

Thank you for the answers. Unfortunately, this does not work.
My research elsewhere has shown the following:

The gtk_widget_snapshot() function is specifically designed to call in the rendering context of a widget. It is commonly used internally by GTK to draw a widget in a specific render flow.
gtk_widget_snapshot() requires a valid GtkSnapshot context, which is usually provided in the rendering process. This context exists only within the boundaries of a widget and its signal chain.

So the question remains how to use a GtkSnapshot to create a screenshot?

5

Weird… I just made a quick test, that works on my side.
Is your widget attached to a window?

The “only” part is not true. While the typical case is to use the snapshot object provided by the gtk rendering chain, you can create your own one and pass it to the snapshot() function. It’s for example done by libadwaita to render miniatures of the tabs in the TabOverview.

1 Like
6

You are right, it works - thank you!

1 Like