Class RenderReplay

java.lang.Object
org.javagi.base.ProxyInstance
org.gnome.gsk.RenderReplay
All Implemented Interfaces:
Proxy
@Generated("org.javagi.JavaGI") public class RenderReplay extends ProxyInstance

A facility to replay a RenderNode and its children, potentially modifying them.

This is a utility tool to walk a rendernode tree. The most powerful way is to provide a function via setNodeFilter(RenderReplayNodeFilter) to filter each individual node and then run filterNode(RenderNode) on the nodes you want to filter.

If you want to just walk the node tree and extract information without any modifications, you can also use RenderNode.getChildren().

Here is a little example application that redacts text in a node file:

#include <gtk/gtk.h>

static GskRenderNode *
redact_nodes (GskRenderReplay *replay,
              GskRenderNode   *node,
              gpointer         user_data)
{
  GskRenderNode *result;

  if (gsk_render_node_get_node_type (node) == GSK_TEXT_NODE)
    {
      graphene_rect_t bounds;
      const GdkRGBA *color;

      gsk_render_node_get_bounds (node, &bounds);
      color = gsk_text_node_get_color (node);

      result = gsk_color_node_new (color, &bounds);
    }
  else
    {
      result = gsk_render_replay_default (replay, node);
    }

  return result;
}

int
main (int argc, char *argv[])
{
  GFile *file;
  GBytes *bytes;
  GskRenderNode *result, *node;
  GskRenderReplay *replay;

  gtk_init ();

  if (argc != 3)
    {
      g_print ("usage: %s INFILE OUTFILE\\n", argv[0]);
      return 0;
    }

  file = g_file_new_for_commandline_arg (argv[1]);
  bytes = g_file_load_bytes (file, NULL, NULL, NULL);
  g_object_unref (file);
  if (bytes == NULL)
    return 1;

  node = gsk_render_node_deserialize (bytes, NULL, NULL);
  g_bytes_unref (bytes);
  if (node == NULL)
    return 1;

  replay = gsk_render_replay_new ();
  gsk_render_replay_set_node_filter (replay, redact_nodes, NULL, NULL);
  result = gsk_render_replay_filter_node (replay, node);
  gsk_render_replay_free (replay);

  if (!gsk_render_node_write_to_file (result, argv[2], NULL))
    return 1;

  gsk_render_node_unref (result);
  gsk_render_node_unref (node);

  return 0;
}
Since:
4.22

  • Constructor Details

    • RenderReplay

      public RenderReplay(MemorySegment address)
      Create a RenderReplay proxy instance for the provided memory address.
      Parameters:
      address - the memory address of the native object

    • RenderReplay

      public RenderReplay()
      Creates a new replay object to replay nodes.
      Since:
      4.22

  • Method Details

    • getType

      public static @Nullable Type getType()
      Get the GType of the RenderReplay class.
      Returns:
      the GType

    • getMemoryLayout

      public static MemoryLayout getMemoryLayout()
      The memory layout of the native struct.
      Returns:
      the memory layout

    • default_

      public @Nullable RenderNode default_(RenderNode node)

      Replays the node using the default method.

      The default method calls filterNode(RenderNode) on all its child nodes and the filter functions for all its properties. If none of them are changed, it returns the passed in node. Otherwise it constructs a new node with the changed children and properties.

      It may not be possible to construct a new node when any of the callbacks return NULL. In that case, this function will return NULL, too.

      Parameters:
      node - the node to replay
      Returns:
      The replayed node
      Since:
      4.22

    • filterFont

      public Font filterFont(Font font)
      Filters a font using the current filter function.
      Parameters:
      font - The font to filter
      Returns:
      the filtered font
      Since:
      4.22

    • filterNode

      public @Nullable RenderNode filterNode(RenderNode node)

      Replays a node using the replay's filter function.

      After the replay the node may be unchanged, or it may be removed, which will result in null being returned.

      If no filter node is set, default_(RenderNode) is called instead.

      Parameters:
      node - the node to replay
      Returns:
      The replayed node
      Since:
      4.22

    • filterTexture

      public Texture filterTexture(Texture texture)
      Filters a texture using the current filter function.
      Parameters:
      texture - The texture to filter
      Returns:
      the filtered texture
      Since:
      4.22

    • free

      public void free()
      Frees a GskRenderReplay.
      Since:
      4.22

    • setFontFilter

      public void setFontFilter(@Nullable RenderReplayFontFilter filter)

      Sets a filter function to be called by default_(RenderNode) for nodes that contain fonts.

      You can call GskRenderReplay.filterFont to filter a font yourself.

      Parameters:
      filter - the font filter function
      Since:
      4.22

    • setNodeFilter

      public void setNodeFilter(@Nullable RenderReplayNodeFilter filter)

      Sets the function to use as a node filter.

      This is the most complex function to use for replaying nodes. It can either:

      • keep the node and just return it unchanged

      • create a replacement node and return that

      • discard the node by returning NULL

      • call default_(RenderNode) to have the default handler run for this node, which calls your function on its children

      Parameters:
      filter - the function to call to replay nodes
      Since:
      4.22

    • setTextureFilter

      public void setTextureFilter(@Nullable RenderReplayTextureFilter filter)

      Sets a filter function to be called by default_(RenderNode) for nodes that contain textures.

      You can call GskRenderReplay.filterTexture to filter a texture yourself.

      Parameters:
      filter - the texture filter function
      Since:
      4.22