Struct gegl::Node

#[repr(transparent)]
pub struct Node { /* private fields */ }

Properties

cache-policy

Readable | Writeable | Construct

dont-cache

Readable | Writeable | Construct

gegl-operation

Readable | Writeable | Construct

name

Readable | Writeable | Construct

operation

Readable | Writeable | Construct

passthrough

Readable | Writeable | Construct

use-opencl

Readable | Writeable | Construct

Signals

computed

invalidated

progress

GLib type: GObject with reference counted clone semantics.

Implementations

impl Node

pub fn blit( &self, scale: f64, roi: &Rectangle, format: &Format, destination_buf: Option<&mut [u8]>, rowstride: i32, flags: BlitFlags )

Render a rectangular region from a node.

scale

the scale to render at 1.0 is default, other values changes the width/height of the sampled region.

roi

the rectangle to render from the node, the coordinate system used is coordinates after scale has been applied.

format

the BablFormat desired.

destination_buf

a memory buffer large enough to contain the data, can be left as NULL when forcing a rendering of a region.

rowstride

rowstride in bytes, or GEGL_AUTO_ROWSTRIDE to compute the rowstride based on the width and bytes per pixel for the specified format.

flags

an or’ed combination of GEGL_BLIT_DEFAULT, GEGL_BLIT_CACHE and GEGL_BLIT_DIRTY. if cache is enabled, a cache will be set up for subsequent requests of image data from this node. By passing in GEGL_BLIT_DIRTY the function will return with the latest rendered results in the cache without regard to wheter the regions has been rendered or not.

pub fn new_child( &self, operation: Option<&str>, props: &[(&str, Value)] ) -> Option<Node>

Creates a new processing node that performs the specified operation with a NULL terminated list of key/value pairs for initial parameter values configuring the operation. Usually the first pair should be “operation” and the type of operation to be associated. If no operation is provided the node doesn’t have an initial operation and can be used to construct a subgraph with special middle-man routing nodes created with gegl_node_get_output_proxy and gegl_node_get_input_proxy.

first_property_name

the first property name

Returns

A newly created Node. The node will be destroyed by the parent. Calling g_object_unref on a node will cause the node to be dropped by the parent. (You may also add additional references using g_object_ref/g_object_unref, but in general relying on the parents reference counting is easiest.)

pub fn link_many(&self, dests: &[&Self])

Synthetic sugar for linking a chain of nodes with “input”->“output”. The list is NULL terminated.

first_sink

the first consumer of data.

pub fn bounding_box(&self) -> Rectangle

Returns the position and dimensions of a rectangle spanning the area defined by a node.

impl Node

pub fn new() -> Node

Create a new graph that can contain further processing nodes.

Returns

A new top level Node (which can be used as a graph). When you are done using this graph instance it should be unreferenced with g_object_unref. This will also free any sub nodes created from this node.

pub fn from_file(path: &str) -> Node

The Node returned contains the graph described by the tree of stacks in the XML document. The tree is connected to the “output” pad of the returned node and thus can be used directly for processing.

path

the path to a file on the local file system to be parsed.

Returns

a GeglNode containing the parsed XML as a subgraph.

pub fn from_serialized(chaindata: &str, path_root: &str) -> Node

pub fn from_xml(xmldata: &str, path_root: &str) -> Node

The Node returned contains the graph described by the tree of stacks in the XML document. The tree is connected to the “output” pad of the returned node and thus can be used directly for processing.

xmldata

a \0 terminated string containing XML data to be parsed.

path_root

a file system path that relative paths in the XML will be resolved in relation to.

Returns

a GeglNode containing the parsed XML as a subgraph.

pub fn builder() -> NodeBuilder

Creates a new builder-pattern struct instance to construct Node objects.

This method returns an instance of NodeBuilder which can be used to create Node objects.

pub fn add_child(&self, child: &Node) -> Option<Node>

Make the GeglNode self, take a reference on child. This reference will be dropped when the reference count on the graph reaches zero.

child

a GeglNode.

Returns

the child.

pub fn blit_buffer( &self, buffer: Option<&Buffer>, roi: Option<&Rectangle>, level: i32, abyss_policy: AbyssPolicy )

Render a rectangular region from a node to the given buffer.

buffer

the Buffer to render to.

roi

the rectangle to render.

level

mipmap level to render (0 for all)

pub fn connect(&self, a_pad_name: &str, b: &Node, b_pad_name: &str) -> bool

Makes a connection between the pads of two nodes, one pad should be a source pad the other a sink pad, order does not matter.

Returns TRUE if the connection was successfully made.

a_pad_name

and the pad of the node we want connected.

b

another node

b_pad_name

and its pad to be connected.

pub fn connect_from( &self, input_pad_name: &str, source: &Node, output_pad_name: &str ) -> bool

Makes a connection between the pads of two nodes.

Returns TRUE if the connection was successfully made.

input_pad_name

the name of the input pad we are connecting to

source

the node producing data we want to connect.

output_pad_name

the output pad we want to use on the source.

pub fn connect_to( &self, output_pad_name: &str, sink: &Node, input_pad_name: &str ) -> bool

Makes a connection between the pads of two nodes.

Returns TRUE if the connection was successfully made.

output_pad_name

the output pad we want to use on the source.

sink

the node we’re connecting an input to

input_pad_name

the name of the input pad we are connecting to

pub fn create_child(&self, operation: &str) -> Option<Node>

Creates a new processing node that performs the specified operation. All properties of the operation will have their default values. This is included as an addition to gegl_node_new_child in the public API to have a non varargs entry point for bindings as well as sometimes simpler more readable code.

operation

the type of node to create.

Returns

a newly created node. The node will be destroyed by the parent. Calling g_object_unref on a node will cause the node to be dropped by the parent. (You may also add additional references using g_object_ref/g_object_unref, but in general relying on the parents reference counting is easiest.)

pub fn detect(&self, x: i32, y: i32) -> Option<Node>

Performs hit detection by returning the node providing data at a given coordinate pair. Currently operates only on bounding boxes and not pixel data.

x

x coordinate

y

y coordinate

Returns

the GeglNode providing the data ending up at x,y in the output of self.

pub fn disconnect(&self, input_pad: &str) -> bool

Disconnects node connected to input_pad of self (if any).

Returns TRUE if a connection was broken.

input_pad

the input pad to disconnect.

pub fn find_property(&self, property_name: &str) -> Option<ParamSpec>

property_name

the name of the property to get a paramspec for.

Returns

the GParamSpec of property or NULL if no such property exists.

pub fn children(&self) -> Vec<Node>

Returns

a list of the nodes contained within a GeglNode that is a subgraph. Use g_list_free () on the list when done.

pub fn consumers(&self, output_pad: &str) -> (i32, Vec<Node>, Vec<GString>)

Retrieve which pads on which nodes are connected to a named output_pad, and the number of connections. Both the location for the generated nodes array and pads array can be left as NULL. If they are non NULL both should be freed with g_free. The arrays are NULL terminated.

Returns the number of consumers connected to this output_pad.

output_pad

the output pad we want to know who uses.

Returns

nodes

optional return location for array of nodes.

pads

optional return location for array of pad names.

pub fn gegl_operation(&self) -> Option<Operation>

Returns

The operation object associated with this node or NULL if there is no op associated.

pub fn input_proxy(&self, pad_name: &str) -> Option<Node>

Proxies are used to route between nodes of a subgraph contained within a node.

pad_name

the name of the pad.

Returns

Returns an input proxy for the named pad. If no input proxy exists with this name a new one will be created.

pub fn operation(&self) -> Option<GString>

Returns

The type of processing operation associated with this node, or NULL if there is no op associated. The special name “GraphNode” is returned if the node is the container of a subgraph.

pub fn output_proxy(&self, pad_name: &str) -> Option<Node>

Proxies are used to route between nodes of a subgraph contained within a node.

pad_name

the name of the pad.

Returns

Returns a output proxy for the named pad. If no output proxy exists with this name a new one will be created.

pub fn parent(&self) -> Option<Node>

Returns a GeglNode that keeps a reference on a child.

Returns

the parent of a node or NULL.

pub fn is_passthrough(&self) -> bool

pub fn property(&self, property_name: &str) -> Value

This is mainly included for language bindings. Using gegl_node_get is more convenient when programming in C.

property_name

the name of the property to get

Returns

value

pointer to a GValue where the value of the property should be stored

pub fn has_pad(&self, pad_name: &str) -> bool

Returns TRUE if the node has a pad with the specified name

pad_name

the pad name we are looking for

pub fn introspectable_get_bounding_box(&self) -> Option<Rectangle>

Returns the position and dimensions of a rectangle spanning the area defined by a node.

Returns

pointer a Rectangle

pub fn introspectable_get_property(&self, property_name: &str) -> Option<Value>

property_name

the name of the property to get

Returns

pointer to a GValue containing the value of the property

pub fn is_graph(&self) -> bool

pub fn link(&self, sink: &Node)

Synthetic sugar for linking the “output” pad of self to the “input” pad of sink.

sink

the consumer of data.

pub fn list_input_pads(&self) -> Vec<GString>

If the node has any input pads this function returns a null terminated array of pad names, otherwise it returns NULL. The return value can be freed with g_strfreev().

pub fn list_output_pads(&self) -> Vec<GString>

If the node has any output pads this function returns a null terminated array of pad names, otherwise it returns NULL. The return value can be freed with g_strfreev().

pub fn new_processor(&self, rectangle: &Rectangle) -> Option<Processor>

rectangle

the Rectangle to work on or NULL to work on all available data.

Returns

a new Processor.

pub fn process(&self)

Render a composition. This can be used for instance on a node with a “png-save” operation to render all necessary data, and make it be written to file. This function wraps the usage of a GeglProcessor in a single blocking function call. If you need a non-blocking operation, then make a direct use of gegl_processor_work. See Processor.

---

GeglNode *gegl; GeglRectangle roi; GeglNode *png_save; unsigned char *buffer;

gegl = gegl_parse_xml (xml_data); roi = gegl_node_get_bounding_box (gegl);

create png_save from the graph, the parent/child relationship

only mean anything when it comes to memory management.

png_save = gegl_node_new_child (gegl, “operation”, “gegl:png-save”, “path”, “output.png”, NULL);

gegl_node_link (gegl, png_save); gegl_node_process (png_save);

buffer = malloc (roi.wroi.h4); gegl_node_blit (gegl, 1.0, &roi, babl_format(“R’G’B’A u8”), buffer, GEGL_AUTO_ROWSTRIDE, GEGL_BLIT_DEFAULT);

pub fn progress(&self, progress: f64, message: &str)

pub fn remove_child(&self, child: &Node) -> Option<Node>

Removes a child from a GeglNode. The reference previously held will be dropped so increase the reference count before removing when reparenting a child between two graphs.

child

a GeglNode.

Returns

the child.

pub fn set_enum_as_string(&self, key: &str, value: &str)

pub fn set_passthrough(&self, passthrough: bool)

pub fn set_property(&self, property_name: &str, value: &Value)

This is mainly included for language bindings. Using gegl_node_set is more convenient when programming in C.

property_name

the name of the property to set

value

a GValue containing the value to be set in the property.

pub fn set_time(&self, time: f64)

Sets the right value in animated properties of this node and all its dependendcies to be the specified time position.

time

the time to set the properties which have keyfraes attached to

pub fn to_xml(&self, path_root: &str) -> Option<GString>

Returns a freshly allocated \0 terminated string containing a XML serialization of the composition produced by a node (and thus also the nodes contributing data to the specified node). To export a gegl graph, connect the internal output node to an output proxy (see gegl_node_get_output_proxy.) and use the proxy node as the basis for the serialization.

path_root

filesystem path to construct relative paths from.

pub fn to_xml_full( &self, tail: Option<&Node>, path_root: &str ) -> Option<GString>

Returns a freshly allocated \0 terminated string containing a XML serialization of a segment of a graph from self to tail nodes. If tail is None then this behaves just like gegl_node_to_xml.

tail

a Node

path_root

filesystem path to construct relative paths from.

Returns

XML serialization of a graph segment.

pub fn cache_policy(&self) -> CachePolicy

pub fn set_cache_policy(&self, cache_policy: CachePolicy)

pub fn is_dont_cache(&self) -> bool

pub fn set_dont_cache(&self, dont_cache: bool)

pub fn set_gegl_operation(&self, gegl_operation: Option<&Operation>)

pub fn name(&self) -> Option<GString>

pub fn set_name(&self, name: Option<&str>)

pub fn set_operation(&self, operation: Option<&str>)

pub fn uses_opencl(&self) -> bool

pub fn set_use_opencl(&self, use_opencl: bool)

pub fn connect_computed<F: Fn(&Self, &Rectangle) + 'static>( &self, f: F ) -> SignalHandlerId

pub fn connect_invalidated<F: Fn(&Self, &Rectangle) + 'static>( &self, f: F ) -> SignalHandlerId

pub fn connect_progress<F: Fn(&Self, f64) + 'static>( &self, f: F ) -> SignalHandlerId

pub fn connect_cache_policy_notify<F: Fn(&Self) + 'static>( &self, f: F ) -> SignalHandlerId

pub fn connect_dont_cache_notify<F: Fn(&Self) + 'static>( &self, f: F ) -> SignalHandlerId

pub fn connect_gegl_operation_notify<F: Fn(&Self) + 'static>( &self, f: F ) -> SignalHandlerId

pub fn connect_name_notify<F: Fn(&Self) + 'static>( &self, f: F ) -> SignalHandlerId

pub fn connect_operation_notify<F: Fn(&Self) + 'static>( &self, f: F ) -> SignalHandlerId

pub fn connect_passthrough_notify<F: Fn(&Self) + 'static>( &self, f: F ) -> SignalHandlerId

pub fn connect_use_opencl_notify<F: Fn(&Self) + 'static>( &self, f: F ) -> SignalHandlerId

Trait Implementations

impl Clone for Node

fn clone(&self) -> Self

Makes a clone of this shared reference.

This increments the strong reference count of the object. Dropping the object will decrement it again.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Node

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Node

fn default() -> Self

Returns the “default value” for a type.

impl HasParamSpec for Node

type ParamSpec = ParamSpecObject

type SetValue = Node

Preferred value to be used as setter for the associated ParamSpec.

type BuilderFn = fn(_: &str) -> ParamSpecObjectBuilder<'_, Node>

fn param_spec_builder() -> Self::BuilderFn

impl Hash for Node

fn hash<H>(&self, state: &mut H)where H: Hasher,

Hashes the memory address of this object.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Node

fn cmp(&self, other: &Self) -> Ordering

Comparison for two GObjects.

Compares the memory addresses of the provided objects.

fn max(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Selfwhere Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Selfwhere Self: Sized + PartialOrd<Self>,

Restrict a value to a certain interval.

impl ParentClassIs for Node

type Parent = Object

impl<OT: ObjectType> PartialEq<OT> for Node

fn eq(&self, other: &OT) -> bool

Equality for two GObjects.

Two GObjects are equal if their memory addresses are equal.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<OT: ObjectType> PartialOrd<OT> for Node

fn partial_cmp(&self, other: &OT) -> Option<Ordering>

Partial comparison for two GObjects.

Compares the memory addresses of the provided objects.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StaticType for Node

fn static_type() -> Type

Returns the type identifier of Self.

impl Eq for Node