Logo Search packages:      
Sourcecode: beast version File versions

bseitem.gen-proc.c


/**
 ** Generated data (by mkcproc.pl)
 **/
#line 1 "bseitem.proc"

#include <bse/bseplugin.h>
#include <bse/bseprocedure.h>
#include <bse/bseitem.h>
#include <bse/bsecontainer.h>
#include <bse/bseundostack.h>
#include <bse/bseparasite.h>  // FIXME


#line 29 "bseitem.proc"


/* --- get-type --- */
static void
get_type_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 31 "bseitem.proc"
 {
#line 33 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", "Item", NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(out_pspecs++) = sfi_pspec_string ("string", NULL, NULL,
                      NULL, SFI_PARAM_STANDARD);
#line 37 "bseitem.proc"
}  }
static BseErrorType
#line 37 "bseitem.proc"
get_type_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 40 "bseitem.proc"
{
#line 41 "bseitem.proc"
  
  BseItem *item = (BseItem*) bse_value_get_object (in_values++);
  
#line 44 "bseitem.proc"
  
  if (!BSE_IS_ITEM (item))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
#line 48 "bseitem.proc"
  
  sfi_value_set_static_string (out_values++, g_type_name (G_OBJECT_TYPE (item)));
  
  return BSE_ERROR_NONE;
}

/* --- get-type-name --- */
static void
get_type_name_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 54 "bseitem.proc"
 {
#line 56 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", "Item", NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(out_pspecs++) = sfi_pspec_string ("string", NULL, NULL,
                      NULL,
                      SFI_PARAM_STANDARD);
#line 61 "bseitem.proc"
}  }
static BseErrorType
#line 61 "bseitem.proc"
get_type_name_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 64 "bseitem.proc"
{
#line 65 "bseitem.proc"
  
  BseItem *item = (BseItem*) bse_value_get_object (in_values++);
  
#line 68 "bseitem.proc"
  
  if (!BSE_IS_ITEM (item))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
#line 72 "bseitem.proc"
  
  sfi_value_set_string (out_values++, g_type_name (G_OBJECT_TYPE (item)));
  
  return BSE_ERROR_NONE;
}

/* --- get-type-blurb --- */
static void
get_type_blurb_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 78 "bseitem.proc"
 {
#line 80 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", "Item", NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(out_pspecs++) = sfi_pspec_string ("string", NULL, NULL,
                      NULL,
                      SFI_PARAM_STANDARD);
#line 85 "bseitem.proc"
}  }
static BseErrorType
#line 85 "bseitem.proc"
get_type_blurb_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 88 "bseitem.proc"
{
#line 89 "bseitem.proc"
  
  BseItem *item = (BseItem*) bse_value_get_object (in_values++);
  
#line 92 "bseitem.proc"
  
  if (!BSE_IS_ITEM (item))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
#line 96 "bseitem.proc"
  
  sfi_value_set_string (out_values++, bse_type_get_blurb (G_OBJECT_TYPE (item)));
  
  return BSE_ERROR_NONE;
}

/* --- get-type-authors --- */
static void
get_type_authors_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 102 "bseitem.proc"
 {
#line 104 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", "Item", NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(out_pspecs++) = sfi_pspec_string ("string", NULL, NULL,
                      NULL,
                      SFI_PARAM_STANDARD);
#line 109 "bseitem.proc"
}  }
static BseErrorType
#line 109 "bseitem.proc"
get_type_authors_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 112 "bseitem.proc"
{
#line 113 "bseitem.proc"
  
  BseItem *item = (BseItem*) bse_value_get_object (in_values++);
  
#line 116 "bseitem.proc"
  
  if (!BSE_IS_ITEM (item))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
#line 120 "bseitem.proc"
  
  sfi_value_set_string (out_values++, bse_type_get_authors (G_OBJECT_TYPE (item)));
  
  return BSE_ERROR_NONE;
}

/* --- get-type-license --- */
static void
get_type_license_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 126 "bseitem.proc"
 {
#line 128 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", "Item", NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(out_pspecs++) = sfi_pspec_string ("string", NULL, NULL,
                      NULL,
                      SFI_PARAM_STANDARD);
#line 133 "bseitem.proc"
}  }
static BseErrorType
#line 133 "bseitem.proc"
get_type_license_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 136 "bseitem.proc"
{
#line 137 "bseitem.proc"
  
  BseItem *item = (BseItem*) bse_value_get_object (in_values++);
  
#line 140 "bseitem.proc"
  
  if (!BSE_IS_ITEM (item))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
#line 144 "bseitem.proc"
  
  sfi_value_set_string (out_values++, bse_type_get_license (G_OBJECT_TYPE (item)));
  
  return BSE_ERROR_NONE;
}

/* --- get-parent --- */
static void
get_parent_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 150 "bseitem.proc"
 {
#line 152 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", "Item", NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(out_pspecs++) = bse_param_spec_object ("parent", "Parent", NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
#line 156 "bseitem.proc"
}  }
static BseErrorType
#line 156 "bseitem.proc"
get_parent_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 159 "bseitem.proc"
{
#line 160 "bseitem.proc"
  
  BseItem *item = (BseItem*) bse_value_get_object (in_values++);
  
#line 163 "bseitem.proc"
  
  if (!BSE_IS_ITEM (item))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
#line 167 "bseitem.proc"
  
  bse_value_set_object (out_values++, item->parent);
  
  return BSE_ERROR_NONE;
}

/* --- get-project --- */
static void
get_project_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 173 "bseitem.proc"
 {
#line 175 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", "Item", NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(out_pspecs++) = bse_param_spec_object ("project", "Project", NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
#line 179 "bseitem.proc"
}  }
static BseErrorType
#line 179 "bseitem.proc"
get_project_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 182 "bseitem.proc"
{
#line 183 "bseitem.proc"
  
  BseItem *item = (BseItem*) bse_value_get_object (in_values++);
  
#line 186 "bseitem.proc"
  
  if (!BSE_IS_ITEM (item))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
#line 190 "bseitem.proc"
  
  bse_value_set_object (out_values++, bse_item_get_project (item));
  
  return BSE_ERROR_NONE;
}

/* --- get-uname-path --- */
static void
get_uname_path_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 196 "bseitem.proc"
 {
#line 198 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", NULL, NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(out_pspecs++) = sfi_pspec_string ("uname_path", NULL, NULL,
                      NULL, SFI_PARAM_STANDARD);
#line 202 "bseitem.proc"
}  }
static BseErrorType
#line 202 "bseitem.proc"
get_uname_path_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 205 "bseitem.proc"
{
#line 206 "bseitem.proc"
  
  BseItem *item = bse_value_get_object (in_values++);
  BseProject *project;
  
#line 210 "bseitem.proc"
  
  if (!BSE_IS_ITEM (item))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
  project = bse_item_get_project (item);
  
#line 216 "bseitem.proc"
  
  sfi_value_take_string (out_values++,
                   project ? bse_container_make_upath (BSE_CONTAINER (project), item) : NULL);
  
  return BSE_ERROR_NONE;
}

/* --- internal --- */
static void
internal_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 223 "bseitem.proc"
 {
#line 225 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", "Item", NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(out_pspecs++) = sfi_pspec_bool ("internal", "Internal", NULL,
                          FALSE, SFI_PARAM_STANDARD);
#line 229 "bseitem.proc"
}  }
static BseErrorType
#line 229 "bseitem.proc"
internal_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 232 "bseitem.proc"
{
#line 233 "bseitem.proc"
  
  BseItem *item = (BseItem*) bse_value_get_object (in_values++);
  
#line 236 "bseitem.proc"
  
  if (!BSE_IS_ITEM (item))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
#line 240 "bseitem.proc"
  
  sfi_value_set_bool (out_values++, BSE_ITEM_INTERNAL (item));
  
  return BSE_ERROR_NONE;
}

/* --- use --- */
static void
use_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 246 "bseitem.proc"
 {
#line 248 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", "Item", NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(out_pspecs++) = bse_param_spec_object ("used_item", "Item", NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
#line 252 "bseitem.proc"
}  }
static BseErrorType
#line 252 "bseitem.proc"
use_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 255 "bseitem.proc"
{
#line 256 "bseitem.proc"
  
  BseItem *item = (BseItem*) bse_value_get_object (in_values++);
  
#line 259 "bseitem.proc"
  
  if (!BSE_IS_ITEM (item) || (!item->parent && !item->use_count))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
#line 263 "bseitem.proc"
  
  bse_item_use (item);
  
#line 266 "bseitem.proc"
  
  bse_value_set_object (out_values++, item);
  
  return BSE_ERROR_NONE;
}

/* --- unuse --- */
static void
unuse_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 272 "bseitem.proc"
 {
#line 274 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", "Item", NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
#line 276 "bseitem.proc"
}  }
static BseErrorType
#line 276 "bseitem.proc"
unuse_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 279 "bseitem.proc"
{
#line 280 "bseitem.proc"
  
  BseItem *item = (BseItem*) bse_value_get_object (in_values++);
  
#line 283 "bseitem.proc"
  
  if (!BSE_IS_ITEM (item))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
#line 287 "bseitem.proc"
  
  if (item->use_count < 1)
    return BSE_ERROR_NOT_OWNER;

  bse_item_unuse (item);
  
  return BSE_ERROR_NONE;
}

/* --- set-name --- */
static void
set_name_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 296 "bseitem.proc"
 {
#line 298 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", "Item", NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(in_pspecs++) = sfi_pspec_string ("name", "Name", NULL,
                      NULL, SFI_PARAM_STANDARD);
#line 302 "bseitem.proc"
}  }
static BseErrorType
#line 302 "bseitem.proc"
set_name_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 305 "bseitem.proc"
{
#line 306 "bseitem.proc"
  
  BseItem *item     = bse_value_get_object (in_values++);
  const gchar *name = g_value_get_string (in_values++);

#line 310 "bseitem.proc"
  
  if (!BSE_IS_ITEM (item))
    return BSE_ERROR_PROC_PARAM_INVAL;

#line 314 "bseitem.proc"
  
  if (!bse_string_equals (name, BSE_OBJECT_UNAME (item)))
    bse_item_set (item, "uname", name, NULL);

  return BSE_ERROR_NONE;
}


/* --- get-name --- */
static void
get_name_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 322 "bseitem.proc"
 {
#line 324 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", "Item", NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(out_pspecs++) = sfi_pspec_string ("name", "Name", NULL,
                      NULL, SFI_PARAM_STANDARD);
#line 328 "bseitem.proc"
}  }
static BseErrorType
#line 328 "bseitem.proc"
get_name_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 331 "bseitem.proc"
{
#line 332 "bseitem.proc"
  
  BseItem *item = (BseItem*) bse_value_get_object (in_values++);
  
#line 335 "bseitem.proc"
  
  if (!BSE_IS_ITEM (item))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
#line 339 "bseitem.proc"
  
  sfi_value_set_string (out_values++, BSE_OBJECT_UNAME (item));
  
  return BSE_ERROR_NONE;
}

/* --- get-name-or-type --- */
static void
get_name_or_type_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 345 "bseitem.proc"
 {
#line 347 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", "Item", NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(out_pspecs++) = sfi_pspec_string ("name", "Name", NULL,
                      NULL, SFI_PARAM_STANDARD);
#line 351 "bseitem.proc"
}  }
static BseErrorType
#line 351 "bseitem.proc"
get_name_or_type_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 354 "bseitem.proc"
{
#line 355 "bseitem.proc"
  
  BseItem *item = (BseItem*) bse_value_get_object (in_values++);
  gchar *name = NULL;
  
#line 359 "bseitem.proc"
  
  if (!BSE_IS_ITEM (item))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
#line 363 "bseitem.proc"
  
  name = BSE_OBJECT_UNAME (item);
  if (name)
    sfi_value_set_string (out_values++, name);
  else
    sfi_value_set_string (out_values++, BSE_OBJECT_TYPE_NAME (item));
  
  return BSE_ERROR_NONE;
}

/* --- common-ancestor --- */
static void
common_ancestor_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 373 "bseitem.proc"
 {
#line 375 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", "Item", "First item",
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(in_pspecs++) = bse_param_spec_object ("item2", "Item2", "Second item",
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(out_pspecs++) = bse_param_spec_object ("ancestor", "ancestor", "Common ancestor of both items",
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
#line 381 "bseitem.proc"
}  }
static BseErrorType
#line 381 "bseitem.proc"
common_ancestor_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 384 "bseitem.proc"
{
#line 385 "bseitem.proc"
  
  BseItem *item  = bse_value_get_object (in_values++);
  BseItem *item2 = bse_value_get_object (in_values++);
  
#line 389 "bseitem.proc"
  
  if (!BSE_IS_ITEM (item) || !BSE_IS_ITEM (item2))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
#line 393 "bseitem.proc"
  
  bse_value_set_object (out_values++, bse_item_common_ancestor (item, item2));
  
  return BSE_ERROR_NONE;
}

/* --- get-seqid --- */
static void
get_seqid_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 399 "bseitem.proc"
 {
#line 403 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", "Item", NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(out_pspecs++) = sfi_pspec_int ("seq_id", "Sequential ID", NULL,
                   0, 0, G_MAXINT, 1, SFI_PARAM_STANDARD);
#line 407 "bseitem.proc"
}  }
static BseErrorType
#line 407 "bseitem.proc"
get_seqid_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 410 "bseitem.proc"
{
#line 411 "bseitem.proc"
  
  BseItem *item = (BseItem*) bse_value_get_object (in_values++);
  
#line 414 "bseitem.proc"
  
  if (!BSE_IS_ITEM (item))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
#line 418 "bseitem.proc"
  
  sfi_value_set_int (out_values++, bse_item_get_seqid (item));
  
  return BSE_ERROR_NONE;
}

/* --- check-is-a --- */
static void
check_is_a_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 424 "bseitem.proc"
 {
#line 426 "bseitem.proc"
  *(in_pspecs++)    = bse_param_spec_object ("item", "Item", "The Item",
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(in_pspecs++)    = sfi_pspec_string ("type_name", "Type Name", NULL,
                      NULL, SFI_PARAM_STANDARD);
  *(out_pspecs++)   = sfi_pspec_bool ("is_a", NULL, NULL,
                    FALSE, SFI_PARAM_STANDARD);
#line 432 "bseitem.proc"
}  }
static BseErrorType
#line 432 "bseitem.proc"
check_is_a_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 435 "bseitem.proc"
{
#line 436 "bseitem.proc"
  
  BseItem *item    = bse_value_get_object (in_values++);
  gchar *type_name = sfi_value_get_string (in_values++);
  GType type;
  gboolean is_a;
  
#line 442 "bseitem.proc"
  
  if (!type_name)
    type_name = "";
  
#line 446 "bseitem.proc"
  
  type = g_type_from_name (type_name);
  is_a = item && g_type_is_a (G_OBJECT_TYPE (item), type);
  
#line 450 "bseitem.proc"
  
  sfi_value_set_bool (out_values++, is_a);
  
  return BSE_ERROR_NONE;
}

/* --- list-items --- */
static void
list_items_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 456 "bseitem.proc"
 {
#line 458 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", NULL, NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(in_pspecs++) = sfi_pspec_string ("property_name", NULL, "Item property name",
                      NULL, SFI_PARAM_STANDARD);
  *(out_pspecs++) = bse_param_spec_boxed ("item_list", "Item List", NULL, BSE_TYPE_ITEM_SEQ, SFI_PARAM_STANDARD);
#line 463 "bseitem.proc"
}  }
static BseErrorType
#line 463 "bseitem.proc"
list_items_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 466 "bseitem.proc"
{
#line 467 "bseitem.proc"
  
  BseItem *self     = bse_value_get_object (in_values++);
  gchar   *property = sfi_value_get_string (in_values++);
  
#line 471 "bseitem.proc"
  
  if (!BSE_IS_ITEM (self) || !property)
    return BSE_ERROR_PROC_PARAM_INVAL;
  
#line 475 "bseitem.proc"
  
  bse_value_take_boxed (out_values++, bse_item_list_items (self, property));
  
  return BSE_ERROR_NONE;
}

/* --- get-icon --- */
static void
get_icon_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 481 "bseitem.proc"
 {
#line 483 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", NULL, NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(out_pspecs++) = bse_param_spec_boxed ("icon", NULL, NULL,
                        BSE_TYPE_ICON, SFI_PARAM_STANDARD);
#line 487 "bseitem.proc"
}  }
static BseErrorType
#line 487 "bseitem.proc"
get_icon_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 490 "bseitem.proc"
{
#line 491 "bseitem.proc"
  
  BseItem *self     = bse_value_get_object (in_values++);
  
#line 494 "bseitem.proc"
  
  if (!BSE_IS_ITEM (self))
    return BSE_ERROR_PROC_PARAM_INVAL;
  
#line 498 "bseitem.proc"
  
  bse_value_set_boxed (out_values++, bse_object_get_icon (BSE_OBJECT (self)));
  
  return BSE_ERROR_NONE;
}

/* --- group-undo --- */
static void
group_undo_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 504 "bseitem.proc"
 {
#line 506 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", NULL, NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(in_pspecs++) = sfi_pspec_string ("name", NULL, "A name for the undo group to be created",
                            NULL, SFI_PARAM_STANDARD);
#line 510 "bseitem.proc"
}  }
static BseErrorType
#line 510 "bseitem.proc"
group_undo_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 513 "bseitem.proc"
{
#line 514 "bseitem.proc"
  
  BseItem *self     = bse_value_get_object (in_values++);
  gchar *name       = sfi_value_get_string (in_values++);
  BseUndoStack *ustack;

#line 519 "bseitem.proc"
  
  if (!BSE_IS_ITEM (self) || !name)
    return BSE_ERROR_PROC_PARAM_INVAL;

  ustack = bse_item_undo_open (self, "item-group-undo");
  bse_undo_stack_add_merger (ustack, name);
  bse_item_undo_close (ustack);
  
  return BSE_ERROR_NONE;
}

/* --- ungroup-undo --- */
static void
ungroup_undo_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 530 "bseitem.proc"
 {
#line 532 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", NULL, NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
#line 534 "bseitem.proc"
}  }
static BseErrorType
#line 534 "bseitem.proc"
ungroup_undo_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 537 "bseitem.proc"
{
#line 538 "bseitem.proc"
  
  BseItem *self     = bse_value_get_object (in_values++);
  BseUndoStack *ustack;

#line 542 "bseitem.proc"
  
  if (!BSE_IS_ITEM (self))
    return BSE_ERROR_PROC_PARAM_INVAL;

  ustack = bse_item_undo_open (self, "item-ungroup-undo");
  bse_undo_stack_remove_merger (ustack);
  bse_item_undo_close (ustack);
  
  return BSE_ERROR_NONE;
}

/* --- undo --- */
static void
undo_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 553 "bseitem.proc"
 {
#line 555 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", NULL, NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
#line 557 "bseitem.proc"
}  }
static BseErrorType
#line 557 "bseitem.proc"
undo_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 560 "bseitem.proc"
{
#line 561 "bseitem.proc"
  
  BseItem *self     = bse_value_get_object (in_values++);
  BseProject *project;

#line 565 "bseitem.proc"
  
  if (!BSE_IS_ITEM (self))
    return BSE_ERROR_PROC_PARAM_INVAL;

  project = bse_item_get_project (self);
  if (project)
    bse_item_exec_void (project, "undo");

  return BSE_ERROR_NONE;
}

/* --- redo --- */
static void
redo_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 576 "bseitem.proc"
 {
#line 578 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", NULL, NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
#line 580 "bseitem.proc"
}  }
static BseErrorType
#line 580 "bseitem.proc"
redo_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 583 "bseitem.proc"
{
#line 584 "bseitem.proc"
  
  BseItem *self     = bse_value_get_object (in_values++);
  BseProject *project;

#line 588 "bseitem.proc"
  
  if (!BSE_IS_ITEM (self))
    return BSE_ERROR_PROC_PARAM_INVAL;

  project = bse_item_get_project (self);
  if (project)
    bse_item_exec_void (project, "redo");

  return BSE_ERROR_NONE;
}

/* --- clear-undo --- */
static void
clear_undo_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 599 "bseitem.proc"
 {
#line 601 "bseitem.proc"
  *(in_pspecs++) = bse_param_spec_object ("item", NULL, NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
#line 603 "bseitem.proc"
}  }
static BseErrorType
#line 603 "bseitem.proc"
clear_undo_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 606 "bseitem.proc"
{
#line 607 "bseitem.proc"
  
  BseItem *self     = bse_value_get_object (in_values++);
  BseProject *project;

#line 611 "bseitem.proc"
  
  if (!BSE_IS_ITEM (self))
    return BSE_ERROR_PROC_PARAM_INVAL;

  project = bse_item_get_project (self);
  if (project)
    bse_item_exec_void (project, "clear-undo");

  return BSE_ERROR_NONE;
}

/* --- undo-depth --- */
static void
undo_depth_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 622 "bseitem.proc"
 {
#line 624 "bseitem.proc"
  *(in_pspecs++)    = bse_param_spec_object ("item", NULL, NULL,
                                 BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(out_pspecs++)   = sfi_pspec_int ("undo_depth", NULL, "Number of times undo can be called",
                         0, 0, G_MAXINT, 1, SFI_PARAM_STANDARD);
#line 628 "bseitem.proc"
}  }
static BseErrorType
#line 628 "bseitem.proc"
undo_depth_exec (BseProcedureClass *proc,
        const GValue      *in_values,
        GValue            *out_values)
#line 631 "bseitem.proc"
{
#line 632 "bseitem.proc"
  
  BseItem *self     = bse_value_get_object (in_values++);
  gint depth = 0;
  BseProject *project;

#line 637 "bseitem.proc"
  
  if (!BSE_IS_ITEM (self))
    return BSE_ERROR_PROC_PARAM_INVAL;

  project = bse_item_get_project (self);
  if (project)
    bse_item_exec (project, "undo-depth", &depth);

#line 645 "bseitem.proc"
  
  sfi_value_set_int (out_values++, depth);

  return BSE_ERROR_NONE;
}

/* --- redo-depth --- */
static void
redo_depth_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 651 "bseitem.proc"
 {
#line 653 "bseitem.proc"
  *(in_pspecs++)    = bse_param_spec_object ("item", NULL, NULL,
                                 BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(out_pspecs++)   = sfi_pspec_int ("redo_depth", NULL, "Number of times redo can be called",
                         0, 0, G_MAXINT, 1, SFI_PARAM_STANDARD);
#line 657 "bseitem.proc"
}  }
static BseErrorType
#line 657 "bseitem.proc"
redo_depth_exec (BseProcedureClass *proc,
        const GValue      *in_values,
        GValue            *out_values)
#line 660 "bseitem.proc"
{
#line 661 "bseitem.proc"
  
  BseItem *self     = bse_value_get_object (in_values++);
  gint depth = 0;
  BseProject *project;

#line 666 "bseitem.proc"
  
  if (!BSE_IS_ITEM (self))
    return BSE_ERROR_PROC_PARAM_INVAL;

  project = bse_item_get_project (self);
  if (project)
    bse_item_exec (project, "redo-depth", &depth);

#line 674 "bseitem.proc"
  
  sfi_value_set_int (out_values++, depth);

  return BSE_ERROR_NONE;
}

/* --- fixme-set-parasite --- */
static void
fixme_set_parasite_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 680 "bseitem.proc"
 {
#line 681 "bseitem.proc"
  *(in_pspecs++)    = bse_param_spec_object ("item", NULL, NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(in_pspecs++)    = sfi_pspec_string ("name", NULL, NULL, NULL, SFI_PARAM_STANDARD);
  *(in_pspecs++)    = sfi_pspec_fblock ("parasite", NULL, NULL, SFI_PARAM_STANDARD);
#line 685 "bseitem.proc"
}  }
static BseErrorType
#line 685 "bseitem.proc"
fixme_set_parasite_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 688 "bseitem.proc"
{
#line 689 "bseitem.proc"
  
  BseItem *self     = bse_value_get_object (in_values++);
  const gchar *name = sfi_value_get_string (in_values++);
  SfiFBlock *fblock = sfi_value_get_fblock (in_values++);
  
#line 694 "bseitem.proc"
  
  if (!BSE_IS_ITEM (self) || !name || !fblock)
    return BSE_ERROR_PROC_PARAM_INVAL;
  
#line 698 "bseitem.proc"
  
  bse_parasite_set_floats (BSE_OBJECT (self), name, fblock->n_values, fblock->values);
  
  return BSE_ERROR_NONE;
}

/* --- fixme-get-parasite --- */
static void
fixme_get_parasite_setup (BseProcedureClass *proc, GParamSpec **in_pspecs, GParamSpec **out_pspecs) {
#line 704 "bseitem.proc"
 {
#line 705 "bseitem.proc"
  *(in_pspecs++)    = bse_param_spec_object ("item", NULL, NULL,
                         BSE_TYPE_ITEM, SFI_PARAM_STANDARD);
  *(in_pspecs++)    = sfi_pspec_string ("name", NULL, NULL, NULL, SFI_PARAM_STANDARD);
  *(out_pspecs++)   = sfi_pspec_fblock ("parasite", NULL, NULL, SFI_PARAM_STANDARD);
#line 709 "bseitem.proc"
}  }
static BseErrorType
#line 709 "bseitem.proc"
fixme_get_parasite_exec (BseProcedureClass *proc,
      const GValue      *in_values,
      GValue            *out_values)
#line 712 "bseitem.proc"
{
#line 713 "bseitem.proc"
  
  BseItem *self     = bse_value_get_object (in_values++);
  const gchar *name = sfi_value_get_string (in_values++);
  
#line 717 "bseitem.proc"
  
  if (!BSE_IS_ITEM (self) || !name)
    return BSE_ERROR_PROC_PARAM_INVAL;
  
#line 721 "bseitem.proc"
  
  sfi_value_take_fblock (out_values++, bse_parasite_get_floats (BSE_OBJECT (self), name));
  
  return BSE_ERROR_NONE;
}

/* --- Export to BSE --- */
static void
__enode_get_type__fill_strings (BseExportStrings *es)
{
  es->blurb = "Retrieve an item's type name.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_get_type = {
  { NULL, BSE_EXPORT_NODE_PROC,
    "BseItem+get-type", 
    NULL,
    "/Methods/BseItem/General/Get Type",
    NULL,
    __enode_get_type__fill_strings,
  },
  0, get_type_setup, get_type_exec, 
};
static void
__enode_get_type_name__fill_strings (BseExportStrings *es)
{
  es->blurb = "Retrieve an item's type name.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_get_type_name = {
  { (BseExportNode*) &__enode_get_type, BSE_EXPORT_NODE_PROC,
    "BseItem+get-type-name", 
    NULL,
    "/Methods/BseItem/General/Get Type Name",
    NULL,
    __enode_get_type_name__fill_strings,
  },
  0, get_type_name_setup, get_type_name_exec, 
};
static void
__enode_get_type_blurb__fill_strings (BseExportStrings *es)
{
  es->blurb = "Retrieve an item's type description.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_get_type_blurb = {
  { (BseExportNode*) &__enode_get_type_name, BSE_EXPORT_NODE_PROC,
    "BseItem+get-type-blurb", 
    NULL,
    "/Methods/BseItem/General/Get Type Blurb",
    NULL,
    __enode_get_type_blurb__fill_strings,
  },
  0, get_type_blurb_setup, get_type_blurb_exec, 
};
static void
__enode_get_type_authors__fill_strings (BseExportStrings *es)
{
  es->blurb = "Retrieve authors of an item's type implementation.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_get_type_authors = {
  { (BseExportNode*) &__enode_get_type_blurb, BSE_EXPORT_NODE_PROC,
    "BseItem+get-type-authors", 
    NULL,
    "/Methods/BseItem/General/Get Type Authors",
    NULL,
    __enode_get_type_authors__fill_strings,
  },
  0, get_type_authors_setup, get_type_authors_exec, 
};
static void
__enode_get_type_license__fill_strings (BseExportStrings *es)
{
  es->blurb = "Retrieve the license for an item's type implementation.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_get_type_license = {
  { (BseExportNode*) &__enode_get_type_authors, BSE_EXPORT_NODE_PROC,
    "BseItem+get-type-license", 
    NULL,
    "/Methods/BseItem/General/Get Type License",
    NULL,
    __enode_get_type_license__fill_strings,
  },
  0, get_type_license_setup, get_type_license_exec, 
};
static void
__enode_get_parent__fill_strings (BseExportStrings *es)
{
  es->blurb = "Retrieve an item's parent.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_get_parent = {
  { (BseExportNode*) &__enode_get_type_license, BSE_EXPORT_NODE_PROC,
    "BseItem+get-parent", 
    NULL,
    "/Methods/BseItem/General/Get Parent",
    NULL,
    __enode_get_parent__fill_strings,
  },
  0, get_parent_setup, get_parent_exec, 
};
static void
__enode_get_project__fill_strings (BseExportStrings *es)
{
  es->blurb = "Retrieve an item's project.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_get_project = {
  { (BseExportNode*) &__enode_get_parent, BSE_EXPORT_NODE_PROC,
    "BseItem+get-project", 
    NULL,
    "/Methods/BseItem/General/Get Project",
    NULL,
    __enode_get_project__fill_strings,
  },
  0, get_project_setup, get_project_exec, 
};
static void
__enode_get_uname_path__fill_strings (BseExportStrings *es)
{
  es->blurb = "Retrieve the project relative uname path for this item.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_get_uname_path = {
  { (BseExportNode*) &__enode_get_project, BSE_EXPORT_NODE_PROC,
    "BseItem+get-uname-path", 
    NULL,
    "/Methods/BseItem/General/Get Uname Path",
    NULL,
    __enode_get_uname_path__fill_strings,
  },
  0, get_uname_path_setup, get_uname_path_exec, 
};
static void
__enode_internal__fill_strings (BseExportStrings *es)
{
  es->blurb = "Check whether an item is internal, i.e. owned by another non-internal item.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_internal = {
  { (BseExportNode*) &__enode_get_uname_path, BSE_EXPORT_NODE_PROC,
    "BseItem+internal", 
    NULL,
    "/Methods/BseItem/General/Internal",
    NULL,
    __enode_internal__fill_strings,
  },
  0, internal_setup, internal_exec, 
};
static void
__enode_use__fill_strings (BseExportStrings *es)
{
  es->blurb = "Increment use count to keep an item alive.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_use = {
  { (BseExportNode*) &__enode_internal, BSE_EXPORT_NODE_PROC,
    "BseItem+use", 
    NULL,
    "/Methods/BseItem/General/Use",
    NULL,
    __enode_use__fill_strings,
  },
  0, use_setup, use_exec, 
};
static void
__enode_unuse__fill_strings (BseExportStrings *es)
{
  es->blurb = "Decrement use count for when an item is not needed anymore.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_unuse = {
  { (BseExportNode*) &__enode_use, BSE_EXPORT_NODE_PROC,
    "BseItem+unuse", 
    NULL,
    "/Methods/BseItem/General/Unuse",
    NULL,
    __enode_unuse__fill_strings,
  },
  0, unuse_setup, unuse_exec, 
};
static void
__enode_set_name__fill_strings (BseExportStrings *es)
{
  es->blurb = "Set an item's name.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_set_name = {
  { (BseExportNode*) &__enode_unuse, BSE_EXPORT_NODE_PROC,
    "BseItem+set-name", 
    NULL,
    "/Methods/BseItem/General/Set Name",
    NULL,
    __enode_set_name__fill_strings,
  },
  0, set_name_setup, set_name_exec, 
};
static void
__enode_get_name__fill_strings (BseExportStrings *es)
{
  es->blurb = "Retrieve an item's name.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_get_name = {
  { (BseExportNode*) &__enode_set_name, BSE_EXPORT_NODE_PROC,
    "BseItem+get-name", 
    NULL,
    "/Methods/BseItem/General/Get Name",
    NULL,
    __enode_get_name__fill_strings,
  },
  0, get_name_setup, get_name_exec, 
};
static void
__enode_get_name_or_type__fill_strings (BseExportStrings *es)
{
  es->blurb = "Retrieve an item's name or type if it has no name.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_get_name_or_type = {
  { (BseExportNode*) &__enode_get_name, BSE_EXPORT_NODE_PROC,
    "BseItem+get-name-or-type", 
    NULL,
    "/Methods/BseItem/General/Get Name Or Type",
    NULL,
    __enode_get_name_or_type__fill_strings,
  },
  0, get_name_or_type_setup, get_name_or_type_exec, 
};
static void
__enode_common_ancestor__fill_strings (BseExportStrings *es)
{
  es->blurb = "Retrieve the common ancestor of two items if there's any.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_common_ancestor = {
  { (BseExportNode*) &__enode_get_name_or_type, BSE_EXPORT_NODE_PROC,
    "BseItem+common-ancestor", 
    NULL,
    "/Methods/BseItem/General/Common Ancestor",
    NULL,
    __enode_common_ancestor__fill_strings,
  },
  0, common_ancestor_setup, common_ancestor_exec, 
};
static void
__enode_get_seqid__fill_strings (BseExportStrings *es)
{
  es->blurb = ("Retrieve an item's sequential ID. The sequential ID depends "
         "on the item's type an it's position inbetween siblings "
         "of the same type within it's immediate container.");
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_get_seqid = {
  { (BseExportNode*) &__enode_common_ancestor, BSE_EXPORT_NODE_PROC,
    "BseItem+get-seqid", 
    NULL,
    "/Methods/BseItem/General/Get Seqid",
    NULL,
    __enode_get_seqid__fill_strings,
  },
  0, get_seqid_setup, get_seqid_exec, 
};
static void
__enode_check_is_a__fill_strings (BseExportStrings *es)
{
  es->blurb = "Check whether an item has a certain type.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_check_is_a = {
  { (BseExportNode*) &__enode_get_seqid, BSE_EXPORT_NODE_PROC,
    "BseItem+check-is-a", 
    NULL,
    "/Methods/BseItem/General/Check Is A",
    NULL,
    __enode_check_is_a__fill_strings,
  },
  0, check_is_a_setup, check_is_a_exec, 
};
static void
__enode_list_items__fill_strings (BseExportStrings *es)
{
  es->blurb = "List possible values for an item property of an item.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_list_items = {
  { (BseExportNode*) &__enode_check_is_a, BSE_EXPORT_NODE_PROC,
    "BseItem+list-items", 
    NULL,
    "/Methods/BseItem/General/List Items",
    NULL,
    __enode_list_items__fill_strings,
  },
  0, list_items_setup, list_items_exec, 
};
static void
__enode_get_icon__fill_strings (BseExportStrings *es)
{
  es->blurb = "Get the current icon of an item.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_get_icon = {
  { (BseExportNode*) &__enode_list_items, BSE_EXPORT_NODE_PROC,
    "BseItem+get-icon", 
    NULL,
    "/Methods/BseItem/General/Get Icon",
    NULL,
    __enode_get_icon__fill_strings,
  },
  0, get_icon_setup, get_icon_exec, 
};
static void
__enode_group_undo__fill_strings (BseExportStrings *es)
{
  es->blurb = "Request multiple modifying actions on an item to be grouped together as single undo operation.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_group_undo = {
  { (BseExportNode*) &__enode_get_icon, BSE_EXPORT_NODE_PROC,
    "BseItem+group-undo", 
    NULL,
    "/Methods/BseItem/General/Group Undo",
    NULL,
    __enode_group_undo__fill_strings,
  },
  0, group_undo_setup, group_undo_exec, 
};
static void
__enode_ungroup_undo__fill_strings (BseExportStrings *es)
{
  es->blurb = "Ends the undo grouping opened up by a previous group-undo() call.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_ungroup_undo = {
  { (BseExportNode*) &__enode_group_undo, BSE_EXPORT_NODE_PROC,
    "BseItem+ungroup-undo", 
    NULL,
    "/Methods/BseItem/General/Ungroup Undo",
    NULL,
    __enode_ungroup_undo__fill_strings,
  },
  0, ungroup_undo_setup, ungroup_undo_exec, 
};
static void
__enode_undo__fill_strings (BseExportStrings *es)
{
  es->blurb = "Call the undo function of the project corresponding to this item if any.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_undo = {
  { (BseExportNode*) &__enode_ungroup_undo, BSE_EXPORT_NODE_PROC,
    "BseItem+undo", 
    NULL,
    "/Methods/BseItem/General/Undo",
    NULL,
    __enode_undo__fill_strings,
  },
  0, undo_setup, undo_exec, 
};
static void
__enode_redo__fill_strings (BseExportStrings *es)
{
  es->blurb = "Call the redo function of the project corresponding to this item if any.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_redo = {
  { (BseExportNode*) &__enode_undo, BSE_EXPORT_NODE_PROC,
    "BseItem+redo", 
    NULL,
    "/Methods/BseItem/General/Redo",
    NULL,
    __enode_redo__fill_strings,
  },
  0, redo_setup, redo_exec, 
};
static void
__enode_clear_undo__fill_strings (BseExportStrings *es)
{
  es->blurb = "Call the clear-undo function of the project corresponding to this item if any.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_clear_undo = {
  { (BseExportNode*) &__enode_redo, BSE_EXPORT_NODE_PROC,
    "BseItem+clear-undo", 
    NULL,
    "/Methods/BseItem/General/Clear Undo",
    NULL,
    __enode_clear_undo__fill_strings,
  },
  0, clear_undo_setup, clear_undo_exec, 
};
static void
__enode_undo_depth__fill_strings (BseExportStrings *es)
{
  es->blurb = "Call the undo-depth function of the project corresponding to this item if any.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_undo_depth = {
  { (BseExportNode*) &__enode_clear_undo, BSE_EXPORT_NODE_PROC,
    "BseItem+undo-depth", 
    NULL,
    "/Methods/BseItem/General/Undo Depth",
    NULL,
    __enode_undo_depth__fill_strings,
  },
  0, undo_depth_setup, undo_depth_exec, 
};
static void
__enode_redo_depth__fill_strings (BseExportStrings *es)
{
  es->blurb = "Call the redo-depth function of the project corresponding to this item if any.";
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_redo_depth = {
  { (BseExportNode*) &__enode_undo_depth, BSE_EXPORT_NODE_PROC,
    "BseItem+redo-depth", 
    NULL,
    "/Methods/BseItem/General/Redo Depth",
    NULL,
    __enode_redo_depth__fill_strings,
  },
  0, redo_depth_setup, redo_depth_exec, 
};
static void
__enode_fixme_set_parasite__fill_strings (BseExportStrings *es)
{
  es->blurb = NULL;
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_fixme_set_parasite = {
  { (BseExportNode*) &__enode_redo_depth, BSE_EXPORT_NODE_PROC,
    "BseItem+fixme-set-parasite", 
    NULL,
    "/Methods/BseItem/General/Fixme Set Parasite",
    NULL,
    __enode_fixme_set_parasite__fill_strings,
  },
  0, fixme_set_parasite_setup, fixme_set_parasite_exec, 
};
static void
__enode_fixme_get_parasite__fill_strings (BseExportStrings *es)
{
  es->blurb = NULL;
  es->authors = "Tim Janik <timj@gtk.org>";
  es->license = "GNU Lesser General Public License";
}
static BseExportNodeProc __enode_fixme_get_parasite = {
  { (BseExportNode*) &__enode_fixme_set_parasite, BSE_EXPORT_NODE_PROC,
    "BseItem+fixme-get-parasite", 
    NULL,
    "/Methods/BseItem/General/Fixme Get Parasite",
    NULL,
    __enode_fixme_get_parasite__fill_strings,
  },
  0, fixme_get_parasite_setup, fixme_get_parasite_exec, 
};
BseExportNode* bse__builtin_init_bseitem_gen_proc_c (void);
BseExportNode* bse__builtin_init_bseitem_gen_proc_c (void)
{
  return (BseExportNode*) &__enode_fixme_get_parasite;
}

/**
 ** Generated data ends here
 **/

Generated by  Doxygen 1.6.0   Back to index