C++ (Cpp) gegl_node_remove_child示例

示例#1

文件： gimpwarptool.c 项目： AjayRamanathan/gimp

gboolean
gimp_warp_tool_undo (GimpTool    *tool,
                     GimpDisplay *display)
{
  GimpWarpTool *wt = GIMP_WARP_TOOL (tool);
  GeglNode     *to_delete;
  GeglNode     *previous;
  const gchar  *type;

  if (! wt->render_node)
    return FALSE;

  to_delete = gegl_node_get_producer (wt->render_node, "aux", NULL);
  type = gegl_node_get_operation (to_delete);

  if (strcmp (type, "gegl:warp"))
    return FALSE;

  previous = gegl_node_get_producer (to_delete, "input", NULL);

  gegl_node_disconnect (to_delete,       "input");
  gegl_node_connect_to (previous,        "output",
                        wt->render_node, "aux");

  wt->redo_stack = g_list_prepend (wt->redo_stack, g_object_ref (to_delete));

  gegl_node_remove_child (wt->graph, to_delete);

  gimp_warp_tool_update_stroke (wt, to_delete);

  return TRUE;
}

示例#2

文件： gimpfilterstack.c 项目： AdamGrzonkowski/gimp-1

static void
gimp_filter_stack_remove (GimpContainer *container,
                          GimpObject    *object)
{
  GimpFilterStack *stack  = GIMP_FILTER_STACK (container);
  GimpFilter      *filter = GIMP_FILTER (object);
  gint             n_children;

  if (stack->graph)
    {
      gimp_filter_stack_remove_node (stack, filter);
      gegl_node_remove_child (stack->graph, gimp_filter_get_node (filter));
    }

  GIMP_CONTAINER_CLASS (parent_class)->remove (container, object);

  gimp_filter_set_is_last_node (filter, FALSE);

  n_children = gimp_container_get_n_children (container);

  if (n_children > 0)
    {
      GimpFilter *last_node = (GimpFilter *)
        gimp_container_get_child_by_index (container, n_children - 1);

      gimp_filter_set_is_last_node (last_node, TRUE);
    }
}

示例#3

文件： colortransfer.c 项目： chubinou/darktable

void cleanup_pipe (struct dt_iop_module_t *self, dt_dev_pixelpipe_t *pipe, dt_dev_pixelpipe_iop_t *piece)
{
#ifdef HAVE_GEGL
  // clean up everything again.
  (void)gegl_node_remove_child(pipe->gegl, piece->input);
  // no free necessary, no data is alloc'ed
#else
  free(piece->data);
#endif
}

示例#4

void cleanup_pipe (struct dt_iop_module_t *self, dt_dev_pixelpipe_t *pipe, dt_dev_pixelpipe_iop_t *piece)
{
    // clean up everything again.
#ifdef HAVE_GEGL
    // dt_iop_tonecurve_data_t *d = (dt_iop_tonecurve_data_t *)(piece->data);
    (void)gegl_node_remove_child(pipe->gegl, piece->input);
    // (void)gegl_node_remove_child(pipe->gegl, d->node);
    // (void)gegl_node_remove_child(pipe->gegl, piece->output);
#endif
    dt_iop_tonecurve_data_t *d = (dt_iop_tonecurve_data_t *)(piece->data);
    dt_draw_curve_destroy(d->curve);
    free(piece->data);
}

示例#5

文件： gimpapplicator.c 项目： Natella/gimp

GeglBuffer *
gimp_applicator_dup_apply_buffer (GimpApplicator      *applicator,
                                  const GeglRectangle *rect)
{
  GeglBuffer *buffer;
  GeglNode   *offset;
  GeglNode   *dest;

  buffer = gegl_buffer_new (GEGL_RECTANGLE (0, 0, rect->width, rect->height),
                            babl_format ("RGBA float"));

  offset = gegl_node_new_child (applicator->node,
                                "operation", "gegl:translate",
                                "x",
                                (gdouble) - applicator->apply_offset_x - rect->x,
                                "y",
                                (gdouble) - applicator->apply_offset_y - rect->y,
                                NULL);

  dest = gegl_node_new_child (applicator->node,
                              "operation", "gegl:write-buffer",
                              "buffer",    buffer,
                              NULL);

  gegl_node_link_many (applicator->apply_offset_node,
                       offset,
                       dest,
                       NULL);

  gegl_node_blit (dest, 1.0, GEGL_RECTANGLE (0, 0, rect->width, rect->height),
                  NULL, NULL, 0, GEGL_BLIT_DEFAULT);

  gegl_node_disconnect (offset, "input");

  gegl_node_remove_child (applicator->node, offset);
  gegl_node_remove_child (applicator->node, dest);

  return buffer;
}

示例#6

文件： gegl-operation-meta.c 项目： Distrotech/gegl

static void
_gegl_operation_meta_node_cleanup (gpointer data,
                                   GObject *where_the_object_was)
{
  GeglOperationMetaNodeCleanupContext *ctx = data;

  if (ctx->child)
    {
      g_object_remove_weak_pointer (G_OBJECT (ctx->child), (void**)&ctx->child);
      gegl_node_remove_child (ctx->parent, ctx->child);
    }

  g_free (data);
}

示例#7

文件： gimpwarptool.c 项目： Distrotech/gimp

static void
gimp_warp_tool_remove_op (GimpWarpTool *wt,
                          GeglNode     *op)
{
  GeglNode *previous;

  g_return_if_fail (GEGL_IS_NODE (wt->render_node));

  previous = gegl_node_get_producer (op, "input", NULL);

  gegl_node_disconnect (op,              "input");
  gegl_node_connect_to (previous,        "output",
                        wt->render_node, "aux");

  gegl_node_remove_child (wt->graph, op);
}

示例#8

文件： gimpfilterstack.c 项目： Anstep/gimp

static void
gimp_filter_stack_remove (GimpContainer *container,
                          GimpObject    *object)
{
  GimpFilterStack *stack  = GIMP_FILTER_STACK (container);
  GimpFilter      *filter = GIMP_FILTER (object);

  if (stack->graph)
    {
      gimp_filter_stack_remove_node (stack, filter);
      gegl_node_remove_child (stack->graph, gimp_filter_get_node (filter));
    }

  GIMP_CONTAINER_CLASS (parent_class)->remove (container, object);

  gimp_filter_set_is_last_node (filter, FALSE);
  gimp_filter_stack_update_last_node (stack);
}

示例#9

文件： gegl-editor-layer.c 项目： RemyAWM/mygeglnadeeditor

gint layer_node_removed (gpointer host, GeglEditor* editor, gint node_id)
{
  g_print("remove\n");
  GeglEditorLayer* self = (GeglEditorLayer*)host;
  //TODO: put this in its own function
  GeglNode*		node = NULL;
  GSList*		pair = self->pairs;
  for(;pair != NULL; pair = pair->next)
    {
      node_id_pair*	data = pair->data;
      if(data->id == node_id)
	{
	  node = data->node;
	  break;
	}
    }

  g_assert(node != NULL);

  gegl_node_disconnect_all_pads(node);
  gegl_node_remove_child(self->gegl, node);
}