gi-gsk-4.0.9: Gsk bindings

Copyright | Will Thompson and Iñaki García Etxebarria
License | LGPL-2.1
Maintainer | Iñaki García Etxebarria
Safe Haskell | None
Language | Haskell2010

GI.Gsk.Structs.RenderReplay

Contents

- Exported types
- Methods
  - default
  - filterFont
  - filterNode
  - filterTexture
  - free
  - new
  - setFontFilter
  - setNodeFilter
  - setTextureFilter

Description

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 `renderReplaySetNodeFilter` to filter each individual node and then run `renderReplayFilterNode` 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 `renderNodeGetChildren`.

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

Synopsis

- newtype RenderReplay = RenderReplay (ManagedPtr RenderReplay)
- renderReplayDefault :: (HasCallStack, MonadIO m, IsRenderNode a) => RenderReplay -> a -> m (Maybe RenderNode)
- renderReplayFilterFont :: (HasCallStack, MonadIO m, IsFont a) => RenderReplay -> a -> m Font
- renderReplayFilterNode :: (HasCallStack, MonadIO m, IsRenderNode a) => RenderReplay -> a -> m (Maybe RenderNode)
- renderReplayFilterTexture :: (HasCallStack, MonadIO m, IsTexture a) => RenderReplay -> a -> m Texture
- renderReplayFree :: (HasCallStack, MonadIO m) => RenderReplay -> m ()
- renderReplayNew :: (HasCallStack, MonadIO m) => m RenderReplay
- renderReplaySetFontFilter :: (HasCallStack, MonadIO m) => RenderReplay -> Maybe RenderReplayFontFilter -> m ()
- renderReplaySetNodeFilter :: (HasCallStack, MonadIO m) => RenderReplay -> Maybe RenderReplayNodeFilter -> m ()
- renderReplaySetTextureFilter :: (HasCallStack, MonadIO m) => RenderReplay -> Maybe RenderReplayTextureFilter -> m ()

# Exported types

newtype RenderReplay Source #

Memory-managed wrapper type.

Constructors

RenderReplay (ManagedPtr RenderReplay) |

#### Instances

Instances details

Eq RenderReplay Source # |
Instance details Defined in GI.Gsk.Structs.RenderReplay Methods (==) :: RenderReplay -> RenderReplay -> Bool Source # (/=) :: RenderReplay -> RenderReplay -> Bool Source #
BoxedPtr RenderReplay Source # |
Instance details Defined in GI.Gsk.Structs.RenderReplay Methods boxedPtrCopy :: RenderReplay -> IO RenderReplay Source # boxedPtrFree :: RenderReplay -> IO () Source #
ManagedPtrNewtype RenderReplay Source # |
Instance details Defined in GI.Gsk.Structs.RenderReplay Methods toManagedPtr :: RenderReplay -> ManagedPtr RenderReplay Source #

# Methods

### Click to display all available methods, including inherited ones

Expand

#### Methods

default, filterFont, filterNode, filterTexture, free.

#### Getters

None.

#### Setters

setFontFilter, setNodeFilter, setTextureFilter.

## default

renderReplayDefault Source #

Arguments

:: (HasCallStack, MonadIO m, IsRenderNode a) |
=> RenderReplay | `self`: the replay
-> a | `node`: the node to replay
-> m (Maybe RenderNode) | Returns: The replayed node

Replays the node using the default method.

The default method calls `renderReplayFilterNode` 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.

Since: 4.22

## filterFont

renderReplayFilterFont Source #

Arguments

:: (HasCallStack, MonadIO m, IsFont a) |
=> RenderReplay | `self`: the replay
-> a | `font`: The font to filter
-> m Font | Returns: the filtered font

Filters a font using the current filter function.

Since: 4.22

## filterNode

renderReplayFilterNode Source #

Arguments

:: (HasCallStack, MonadIO m, IsRenderNode a) |
=> RenderReplay | `self`: the replay
-> a | `node`: the node to replay
-> m (Maybe RenderNode) | Returns: The replayed 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 `Nothing` being returned.

If no filter node is set, `renderReplayDefault` is called instead.

Since: 4.22

## filterTexture

renderReplayFilterTexture Source #

Arguments

:: (HasCallStack, MonadIO m, IsTexture a) |
=> RenderReplay | `self`: the replay
-> a | `texture`: The texture to filter
-> m Texture | Returns: the filtered texture

Filters a texture using the current filter function.

Since: 4.22

## free

renderReplayFree Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> RenderReplay | `self`: the replay object to free
-> m () |

Frees a `GskRenderReplay`.

Since: 4.22

## new

renderReplayNew Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> m RenderReplay | Returns: A new replay object to replay nodes

Creates a new replay object to replay nodes.

Since: 4.22

## setFontFilter

renderReplaySetFontFilter Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> RenderReplay | `self`: the replay
-> Maybe RenderReplayFontFilter | `filter`: the font filter function
-> m () |

Sets a filter function to be called by `renderReplayDefault` for nodes that contain fonts.

You can call [method`gskRenderReplay`.filter_font] to filter a font yourself.

Since: 4.22

## setNodeFilter

renderReplaySetNodeFilter Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> RenderReplay |
-> Maybe RenderReplayNodeFilter | `filter`: the function to call to replay nodes
-> m () |

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 `renderReplayDefault` to have the default handler run for this node, which calls your function on its children

Since: 4.22

## setTextureFilter

renderReplaySetTextureFilter Source #

Arguments

:: (HasCallStack, MonadIO m) |
=> RenderReplay | `self`: the replay
-> Maybe RenderReplayTextureFilter | `filter`: the texture filter function
-> m () |

Sets a filter function to be called by `renderReplayDefault` for nodes that contain textures.

You can call [method`gskRenderReplay`.filter_texture] to filter a texture yourself.

Since: 4.22