## VipsObject VipsObject — the VIPS base object class |

## Stability Level

Stable, unless otherwise indicated

## Functions

#define | VIPS_UNREF()
#define | VIPS_ARG_IMAGE()
#define | VIPS_ARG_INTERPOLATE()
#define | VIPS_ARG_BOOL()
#define | VIPS_ARG_DOUBLE()
#define | VIPS_ARG_BOXED()
#define | VIPS_ARG_INT()
#define | VIPS_ARG_UINT64()
#define | VIPS_ARG_ENUM()
#define | VIPS_ARG_FLAGS()
#define | VIPS_ARG_STRING()
#define | VIPS_ARG_POINTER()
int | vips_argument_get_id ()
void | vips__object_set_member ()
void * | (*VipsArgumentMapFn) ()
void * | vips_argument_map ()
int | vips_object_get_args ()
void * | (*VipsArgumentClassMapFn) ()
void * | vips_argument_class_map ()
gboolean | vips_argument_class_needsstring ()
int | vips_object_get_argument ()
gboolean | vips_object_argument_isset ()
VipsArgumentFlags | vips_object_get_argument_flags ()
int | vips_object_get_argument_priority ()
#define | VIPS_ARGUMENT_FOR_ALL()
#define | VIPS_ARGUMENT_COLLECT_SET()
#define | VIPS_ARGUMENT_COLLECT_GET()
gboolean | vips_value_is_null ()
void | vips_object_set_property ()
void | vips_object_get_property ()
void | vips_object_preclose ()
int | vips_object_build ()
void | vips_object_summary_class ()
void | vips_object_summary ()
void | vips_object_dump ()
void | vips_object_print_summary_class ()
void | vips_object_print_summary ()
void | vips_object_print_dump ()
void | vips_object_print_name ()
gboolean | vips_object_sanity ()
void | vips_object_class_install_argument ()
int | vips_object_set_argument_from_string ()
gboolean | vips_object_argument_needsstring ()
int | vips_object_get_argument_to_string ()
int | vips_object_set_required ()
void * | (*VipsObjectSetArguments) ()
VipsObject * | vips_object_new ()
int | vips_object_set_valist ()
int | vips_object_set ()
int | vips_object_set_from_string ()
VipsObject * | vips_object_new_from_string ()
void | vips_object_to_string ()
void * | vips_object_map ()
void * | (*VipsTypeMapFn) ()
void * | (*VipsTypeMap2Fn) ()
void * | (*VipsClassMapFn) ()
void * | vips_type_map ()
void * | vips_type_map_all ()
int | vips_type_depth ()
GType | vips_type_find ()
const char * | vips_nickname_find ()
void * | vips_class_map_all ()
const VipsObjectClass * | vips_class_find ()
VipsObject ** | vips_object_local_array ()
void | vips_object_local_cb ()
#define | vips_object_local()
void | vips_object_set_static ()
void | vips_object_print_all ()
void | vips_object_sanity_all ()
void | vips_object_rewind ()
void | vips_object_unref_outputs ()
const char * | vips_object_get_description ()

## Properties

gchar * | description | Read / Write
gchar * | nickname | Read / Write

## Signals

void | close | Run Last
gint | postbuild | Run Last
void | postclose | Run Last
void | preclose | Run Last

## Types and Values

enum | VipsArgumentFlags
#define | VIPS_ARGUMENT_REQUIRED_INPUT
#define | VIPS_ARGUMENT_OPTIONAL_INPUT
#define | VIPS_ARGUMENT_REQUIRED_OUTPUT
#define | VIPS_ARGUMENT_OPTIONAL_OUTPUT
| VipsArgument
| VipsArgumentClass
| VipsArgumentInstance
typedef | VipsArgumentTable
#define | VIPS_ARGUMENT_COLLECT_END

## Object Hierarchy

        GObject
        ╰── VipsObject
            ├── VipsOperation
            ├── VipsImage
            ├── VipsInterpolate
            ├── VipsRegion
            ╰── VipsThreadState

## Includes

    #include <vips/vips.h>

## Description

The VipsObject class and associated types and macros.

VipsObject is the base class for all objects in libvips. It has the following major features:

Functional class creation Vips objects have a very regular lifecycle: initialise, build, use, destroy. They behave rather like function calls and are free of side-effects.

Run-time introspection Vips objects can be fully introspected at run-time. There is not need for separate source-code analysis.

Command-line interface Any vips object can be run from the command-line with the `vips` driver program.

#### The VipsObject lifecycle

VipsObject s have a strictly defined lifecycle, split broadly as construct and then use. In detail, the stages are:

1. g_object_new(). The VipsObject is created with `g_object_new()`. Objects in this state are blank slates and need to have their various parameters set.

2. g_object_set(). You loop over the VipsArgument that the object has defined with `vips_argument_map()`. Arguments have a set of flags attached to them for required, optional, input, output, type, and so on. You must set all required arguments.

3. vips_object_build(). Call this to construct the object and get it ready for use. Building an object happens in four stages, see below.

4. g_object_get(). The object has now been built. You can read out any computed values.

5. g_object_unref(). When you are done with an object, you can unref it. See the section on reference counting for an explanation of the convention that VipsObject uses. When the last ref to an object is released, the object is closed. Objects close in three stages, see below.

The stages inside `vips_object_build()` are:

1. Chain up through the object's `build` class methods. At each stage, each class does any initial setup and checking, then chains up to its superclass.

2. The innermost `build` method inside VipsObject itself checks that all input arguments have been set and then returns.

3. All object `build` methods now finish executing, from innermost to outermost. They know all input arguments have been checked and supplied, so now they set all output arguments.

4. vips_object_build() finishes the process by checking that all output objects have been set, and then triggering the “postbuild” signal. “postbuild” only runs if the object has constructed successfuly.

VipsOperation has a cache of recent operation objects, see that class for an explanation of `vips_cache_operation_build()`.

Finally the stages inside close are:

1. “preclose”. This is emitted at the start of the VipsObject dispose. The object is still functioning.

2. “close”. This runs just after all VipsArgument held by the object have been released.

3. “postclose”. This runs right at the end. The object pointer is still valid, but nothing else is.

#### VipsArgument

libvips has a simple mechanism for automating at least some aspects of `GObject` properties. You add a set of macros to your `_class_init()` which describe the arguments, and set the get and set functions to the vips ones.

See extending for a complete example.

#### The VipsObject reference counting convention

VipsObject has a set of conventions to simplify reference counting.

1. All input `GObject` have a ref added to them, owned by the object. When a VipsObject is unreffed, all of these refs to input objects are automatically dropped.

2. All output `GObject` hold a ref to the object. When a `GObject` which is an output of a VipsObject is disposed, it must drop this reference. VipsObject which are outputs of other VipsObject will do this automatically.

See VipsOperation for an example of VipsObject reference counting.

## Functions

### VIPS_UNREF()

    #define             VIPS_UNREF( X )

### VIPS_ARG_IMAGE()

    #define             VIPS_ARG_IMAGE( CLASS, NAME, PRIORITY, LONG, DESC, FLAGS, OFFSET )

### VIPS_ARG_INTERPOLATE()

    #define             VIPS_ARG_INTERPOLATE( CLASS, NAME, PRIORITY, LONG, DESC, FLAGS, OFFSET )

### VIPS_ARG_BOOL()

    #define             VIPS_ARG_BOOL( CLASS, NAME, PRIORITY, LONG, DESC, \
                	FLAGS, OFFSET, VALUE )

### VIPS_ARG_DOUBLE()

    #define             VIPS_ARG_DOUBLE( CLASS, NAME, PRIORITY, LONG, DESC, \
                	FLAGS, OFFSET, MIN, MAX, VALUE )

### VIPS_ARG_BOXED()

    #define             VIPS_ARG_BOXED( CLASS, NAME, PRIORITY, LONG, DESC, \
                	FLAGS, OFFSET, TYPE )

### VIPS_ARG_INT()

    #define             VIPS_ARG_INT( CLASS, NAME, PRIORITY, LONG, DESC, \
                	FLAGS, OFFSET, MIN, MAX, VALUE )

### VIPS_ARG_UINT64()

    #define             VIPS_ARG_UINT64( CLASS, NAME, PRIORITY, LONG, DESC, \
                	FLAGS, OFFSET, MIN, MAX, VALUE )

### VIPS_ARG_ENUM()

    #define             VIPS_ARG_ENUM( CLASS, NAME, PRIORITY, LONG, DESC, \
                	FLAGS, OFFSET, TYPE, VALUE )

### VIPS_ARG_FLAGS()

    #define             VIPS_ARG_FLAGS( CLASS, NAME, PRIORITY, LONG, DESC, \
                	FLAGS, OFFSET, TYPE, VALUE )

### VIPS_ARG_STRING()

    #define             VIPS_ARG_STRING( CLASS, NAME, PRIORITY, LONG, DESC, FLAGS, OFFSET, \
                	VALUE )

### VIPS_ARG_POINTER()

    #define             VIPS_ARG_POINTER( CLASS, NAME, PRIORITY, LONG, DESC, FLAGS, OFFSET )

### vips_argument_get_id ()

    int
    vips_argument_get_id (void);

Allocate a new property id. See `g_object_class_install_property()`.

[skip]

#### Returns

a new property id > 0

### vips__object_set_member ()

    void
    vips__object_set_member (VipsObject *object,
                             GParamSpec *pspec,
                             GObject **member,
                             GObject *argument);

### VipsArgumentMapFn ()

    void *
    (*VipsArgumentMapFn) (VipsObject *object,
                          GParamSpec *pspec,
                          VipsArgumentClass *argument_class,
                          VipsArgumentInstance *argument_instance,
                          void *a,
                          void *b);

### vips_argument_map ()

    void *
    vips_argument_map (VipsObject *object,
                       VipsArgumentMapFn fn,
                       void *a,
                       void *b);

Loop over the vips_arguments to an object. Stop when `fn` returns non-`NULL` and return that value.

[skip]

#### Parameters

object | object whose args should be enumerated |
fn | call this function for every argument |
a | client data |
b | client data |

#### Returns

`NULL` if `fn` returns `NULL` for all arguments, otherwise the first non-`NULL` value from `fn` .

### vips_object_get_args ()

    int
    vips_object_get_args (VipsObject *object,
                          const char ***names,
                          int **flags,
                          int *n_args);

Get all `GParamSpec` names and VipsArgumentFlags for an object.

This is handy for language bindings. From C, it's usually more convenient to use `vips_argument_map()`.

[skip]

#### Parameters

object | object whose args should be retrieved |
names | output array of `GParamSpec` names. | [transfer none][array length=n_args][allow-none]
flags | output array of VipsArgumentFlags. | [transfer none][array length=n_args][allow-none]
n_args | length of output arrays. | [allow-none]

#### Returns

0 on success, -1 on error

### VipsArgumentClassMapFn ()

    void *
    (*VipsArgumentClassMapFn) (VipsObjectClass *object_class,
                               GParamSpec *pspec,
                               VipsArgumentClass *argument_class,
                               void *a,
                               void *b);

### vips_argument_class_map ()

    void *
    vips_argument_class_map (VipsObjectClass *object_class,
                             VipsArgumentClassMapFn fn,
                             void *a,
                             void *b);

And loop over a class. Same as ^^, but with no VipsArgumentInstance.

[skip]

### vips_argument_class_needsstring ()

    gboolean
    vips_argument_class_needsstring (VipsArgumentClass *argument_class);

### vips_object_get_argument ()

    int
    vips_object_get_argument (VipsObject *object,
                              const char *name,
                              GParamSpec **pspec,
                              VipsArgumentClass **argument_class,
                              VipsArgumentInstance **argument_instance);

Look up the three things you need to work with a vips argument.

[skip]

#### Parameters

object | the object to fetch the args from |
name | arg to fetch |
pspec | the pspec for this arg. | [transfer none]
argument_class | the argument_class for this arg. | [transfer none]
argument_instance | the argument_instance for this arg. | [transfer none]

#### Returns

0 on success, or -1 on error.

### vips_object_argument_isset ()

    gboolean
    vips_object_argument_isset (VipsObject *object,
                                const char *name);

Convenience: has an argument been assigned. Useful for bindings.

#### Parameters

object | the object to fetch the args from |
name | arg to fetch |

#### Returns

`TRUE` if the argument has been assigned.

### vips_object_get_argument_flags ()

    VipsArgumentFlags
    vips_object_get_argument_flags (VipsObject *object,
                                    const char *name);

Convenience: get the flags for an argument. Useful for bindings.

#### Parameters

object | the object to fetch the args from |
name | arg to fetch |

#### Returns

The VipsArgumentFlags for this argument.

### vips_object_get_argument_priority ()

    int
    vips_object_get_argument_priority (VipsObject *object,
                                       const char *name);

Convenience: get the priority for an argument. Useful for bindings.

#### Parameters

object | the object to fetch the args from |
name | arg to fetch |

#### Returns

The priority of this argument.

### VIPS_ARGUMENT_FOR_ALL()

    #define             VIPS_ARGUMENT_FOR_ALL( OBJECT, PSPEC, ARG_CLASS, ARG_INSTANCE )

### VIPS_ARGUMENT_COLLECT_SET()

    #define             VIPS_ARGUMENT_COLLECT_SET( PSPEC, ARG_CLASS, AP )

### VIPS_ARGUMENT_COLLECT_GET()

    #define             VIPS_ARGUMENT_COLLECT_GET( PSPEC, ARG_CLASS, AP )

### vips_value_is_null ()

    gboolean
    vips_value_is_null (GParamSpec *psoec,
                        const GValue *value);

### vips_object_set_property ()

    void
    vips_object_set_property (GObject *gobject,
                              guint property_id,
                              const GValue *value,
                              GParamSpec *pspec);

### vips_object_get_property ()

    void
    vips_object_get_property (GObject *gobject,
                              guint property_id,
                              GValue *value,
                              GParamSpec *pspec);

### vips_object_preclose ()

    void
    vips_object_preclose (VipsObject *object);

### vips_object_build ()

    int
    vips_object_build (VipsObject *object);

### vips_object_summary_class ()

    void
    vips_object_summary_class (VipsObjectClass *klass,
                               VipsBuf *buf);

Generate a human-readable summary for a class.

[skip]

#### Parameters

klass | class to summarise |
buf | write summary here |

### vips_object_summary ()

    void
    vips_object_summary (VipsObject *object,
                         VipsBuf *buf);

Generate a human-readable summary for an object.

[skip]

#### Parameters

object | object to summarise |
buf | write summary here |

### vips_object_dump ()

    void
    vips_object_dump (VipsObject *object,
                      VipsBuf *buf);

Dump everything that vips knows about an object to a string.

[skip]

#### Parameters

object | object to dump |
buf | write dump here |

### vips_object_print_summary_class ()

    void
    vips_object_print_summary_class (VipsObjectClass *klass);

### vips_object_print_summary ()

    void
    vips_object_print_summary (VipsObject *object);

### vips_object_print_dump ()

    void
    vips_object_print_dump (VipsObject *object);

### vips_object_print_name ()

    void
    vips_object_print_name (VipsObject *object);

### vips_object_sanity ()

    gboolean
    vips_object_sanity (VipsObject *object);

### vips_object_class_install_argument ()

    void
    vips_object_class_install_argument (VipsObjectClass *cls,
                                        GParamSpec *pspec,
                                        VipsArgumentFlags flags,
                                        int priority,
                                        guint offset);

### vips_object_set_argument_from_string ()

    int
    vips_object_set_argument_from_string (VipsObject *object,
                                          const char *name,
                                          const char *value);

### vips_object_argument_needsstring ()

    gboolean
    vips_object_argument_needsstring (VipsObject *object,
                                      const char *name);

### vips_object_get_argument_to_string ()

    int
    vips_object_get_argument_to_string (VipsObject *object,
                                        const char *name,
                                        const char *arg);

### vips_object_set_required ()

    int
    vips_object_set_required (VipsObject *object,
                              const char *value);

### VipsObjectSetArguments ()

    void *
    (*VipsObjectSetArguments) (VipsObject *object,
                               void *a,
                               void *b);

### vips_object_new ()

    VipsObject *
    vips_object_new (GType type,
                     VipsObjectSetArguments set,
                     void *a,
                     void *b);

g_object_new() the object, set any arguments with `set` , call `vips_object_build()` and return the complete object.

[skip]

#### Parameters

type | object to create |
set | set arguments with this |
a | client data |
b | client data |

#### Returns

the new object

### vips_object_set_valist ()

    int
    vips_object_set_valist (VipsObject *object,
                            va_list ap);

See `vips_object_set()`.

#### Parameters

object | object to set arguments on |
ap | `NULL`-terminated list of argument/value pairs |

#### Returns

0 on success, -1 on error

### vips_object_set ()

    int
    vips_object_set (VipsObject *object,
                     ...);

Set a list of vips object arguments. For example:

    1
    2
    3
    4
    vips_object_set (operation,
      "input", in,
      "output", &out,
      NULL);

Input arguments are given in-line, output arguments are given as pointers to where the output value should be written.

See also: `vips_object_set_valist()`, `vips_object_set_from_string()`.

#### Parameters

object | object to set arguments on |
... | `NULL`-terminated list of argument/value pairs |

#### Returns

0 on success, -1 on error

### vips_object_set_from_string ()

    int
    vips_object_set_from_string (VipsObject *object,
                                 const char *string);

Set object arguments from a string. The string can be something like "a=12", or "a = 12, b = 13", or "fred". The string can optionally be enclosed in brackets.

You'd typically use this between creating the object and building it.

See also: `vips_object_set()`, `vips_object_build()`, `vips_cache_operation_buildp()`.

#### Parameters

object | object to set arguments on |
string | arguments as a string |

#### Returns

0 on success, -1 on error

### vips_object_new_from_string ()

    VipsObject *
    vips_object_new_from_string (VipsObjectClass *object_class,
                                 const char *p);

### vips_object_to_string ()

    void
    vips_object_to_string (VipsObject *object,
                           VipsBuf *buf);

The inverse of `vips_object_new_from_string()`: turn `object` into eg. "VipsInterpolateSnohalo1(blur=.333333)".

#### Parameters

object | object to stringify |
buf | write string here |

### vips_object_map ()

    void *
    vips_object_map (VipsSListMap2Fn fn,
                     void *a,
                     void *b);

Call a function for all alive objects. Stop when `fn` returns non-`NULL` and return that value.

[skip]

#### Parameters

fn | function to call for all objects |
a | client data |
b | client data |

#### Returns

`NULL` if `fn` returns `NULL` for all arguments, otherwise the first non-`NULL` value from `fn` .

### VipsTypeMapFn ()

    void *
    (*VipsTypeMapFn) (GType type,
                      void *a);

### VipsTypeMap2Fn ()

    void *
    (*VipsTypeMap2Fn) (GType type,
                       void *a,
                       void *b);

### VipsClassMapFn ()

    void *
    (*VipsClassMapFn) (VipsObjectClass *cls,
                       void *a);

### vips_type_map ()

    void *
    vips_type_map (GType base,
                   VipsTypeMap2Fn fn,
                   void *a,
                   void *b);

Map over a type's children. Stop when `fn` returns non-`NULL` and return that value.

[skip]

#### Parameters

base | base type |
fn | call this function for every type |
a | client data |
b | client data |

#### Returns

`NULL` if `fn` returns `NULL` for all arguments, otherwise the first non-`NULL` value from `fn` .

### vips_type_map_all ()

    void *
    vips_type_map_all (GType base,
                       VipsTypeMapFn fn,
                       void *a);

Map over a type's children, direct and indirect. Stop when `fn` returns non-`NULL` and return that value.

[skip]

#### Parameters

base | base type |
fn | call this function for every type |
a | client data |

#### Returns

`NULL` if `fn` returns `NULL` for all arguments, otherwise the first non-`NULL` value from `fn` .

### vips_type_depth ()

    int
    vips_type_depth (GType type);

### vips_type_find ()

    GType
    vips_type_find (const char *basename,
                    const char *nickname);

Search below `basename` , return the `GType` of the class whose name or `nickname` matches, or 0 for not found. If `basename` is NULL, the whole of VipsObject is searched.

This function uses a cache, so it should be quick.

See also: `vips_class_find()`

#### Parameters

basename | name of base class |
nickname | search for a class with this nickname |

#### Returns

the `GType` of the class, or 0 if the class is not found.

### vips_nickname_find ()

    const char *
    vips_nickname_find (GType type);

Return the VIPS nickname for a `GType`. Handy for language bindings.

#### Parameters

type | GType to search for |

#### Returns

the class nickname.

[transfer none]

### vips_class_map_all ()

    void *
    vips_class_map_all (GType type,
                        VipsClassMapFn fn,
                        void *a);

Loop over all the subclasses of `type` . Non-abstract classes only. Stop when `fn` returns non-`NULL` and return that value.

[skip]

#### Parameters

type | base type |
fn | call this function for every type |
a | client data |

#### Returns

`NULL` if `fn` returns `NULL` for all arguments, otherwise the first non-`NULL` value from `fn` .

### vips_class_find ()

    const VipsObjectClass *
    vips_class_find (const char *basename,
                     const char *nickname);

Search below `basename` , return the first class whose name or `nickname` matches.

See also: `vips_type_find()`

#### Parameters

basename | name of base class |
nickname | search for a class with this nickname |

#### Returns

the found class.

[transfer none]

### vips_object_local_array ()

    VipsObject **
    vips_object_local_array (VipsObject *parent,
                             int n);

Make an array of NULL VipsObject pointers. When `parent` closes, every non-NULL pointer in the array will be unreffed and the array will be freed. Handy for creating a set of temporary images for a function.

The array is NULL-terminated, ie. contains an extra NULL element at the end.

Example:

    1
    2
    3
    4
    5
    6
    7
    8
    9
    VipsObject **t;

    t = vips_object_local_array( a, 5 );
    if(
      vips_add( a, b, &t[0], NULL ) ||
      vips_invert( t[0], &t[1], NULL ) ||
      vips_add( t[1], t[0], &t[2], NULL ) ||
      vips_costra( t[2], out, NULL ) )
      return( -1 );

See also: `vips_object_local()`.

[skip]

#### Parameters

parent | objects unref when this object unrefs |
n | array size |

#### Returns

an array of NULL pointers of length `n`

### vips_object_local_cb ()

    void
    vips_object_local_cb (VipsObject *vobject,
                          GObject *gobject);

### vips_object_local()

    #define             vips_object_local( V, G )

### vips_object_set_static ()

    void
    vips_object_set_static (VipsObject *object,
                            gboolean static_object);

### vips_object_print_all ()

    void
    vips_object_print_all (void);

### vips_object_sanity_all ()

    void
    vips_object_sanity_all (void);

### vips_object_rewind ()

    void
    vips_object_rewind (VipsObject *object);

### vips_object_unref_outputs ()

    void
    vips_object_unref_outputs (VipsObject *object);

Unref all assigned output objects. Useful for language bindings.

After an object is built, all output args are owned by the caller. If something goes wrong before then, we have to unref the outputs that have been made so far. This function can also be useful for callers when they've finished processing outputs themselves.

See also: `vips_cache_operation_build()`.

#### Parameters

object | object to drop output refs from |

### vips_object_get_description ()

    const char *
    vips_object_get_description (VipsObject *object);

Fetch the object description. Useful for language bindings.

`object.description` is only avaliable after `_build()`, which can be too late. This function fetches from the instance, if possible, but falls back to the class description if we are too early.

#### Parameters

object | object to fetch description from |

#### Returns

the object description

## Types and Values

### enum VipsArgumentFlags

Flags we associate with each object argument.

Have separate input & output flags. Both set is an error; neither set is OK.

Input gobjects are automatically reffed, output gobjects automatically ref us. We also automatically watch for "destroy" and unlink.

`VIPS_ARGUMENT_SET_ALWAYS` is handy for arguments which are set from C. For example, VipsImage::width is a property that gives access to the Xsize member of struct _VipsImage. We default its 'assigned' to TRUE since the field is always set directly by C.

`VIPS_ARGUMENT_DEPRECATED` arguments are not shown in help text, are not looked for if required, are not checked for "have-been-set". You can deprecate a required argument, but you must obviously add a new required argument if you do.

Input args with `VIPS_ARGUMENT_MODIFY` will be modified by the operation. This is used for things like the in-place drawing operations.

#### Members

VIPS_ARGUMENT_NONE | no flags |
VIPS_ARGUMENT_REQUIRED | must be set in the constructor |
VIPS_ARGUMENT_CONSTRUCT | can only be set in the constructor |
VIPS_ARGUMENT_SET_ONCE | can only be set once |
VIPS_ARGUMENT_SET_ALWAYS | don't do use-before-set checks |
VIPS_ARGUMENT_INPUT | is an input argument (one we depend on) |
VIPS_ARGUMENT_OUTPUT | is an output argument (depends on us) |
VIPS_ARGUMENT_DEPRECATED | just there for back-compat, hide |
VIPS_ARGUMENT_MODIFY | the input argument will be modified |

### VIPS_ARGUMENT_REQUIRED_INPUT

    #define             VIPS_ARGUMENT_REQUIRED_INPUT

### VIPS_ARGUMENT_OPTIONAL_INPUT

    #define             VIPS_ARGUMENT_OPTIONAL_INPUT

### VIPS_ARGUMENT_REQUIRED_OUTPUT

    #define             VIPS_ARGUMENT_REQUIRED_OUTPUT

### VIPS_ARGUMENT_OPTIONAL_OUTPUT

    #define             VIPS_ARGUMENT_OPTIONAL_OUTPUT

### VipsArgument

    typedef struct {
    	GParamSpec *pspec; /* pspec for this argument */

    	/* More stuff, see below */
    } VipsArgument;

### VipsArgumentClass

    typedef struct {
    	VipsArgument parent;

    	/* The class of the object we are an arg for.
    	 */
    	VipsObjectClass *object_class;

    	VipsArgumentFlags flags;
    	int priority;		/* Order args by this */
    	guint offset;		/* G_STRUCT_OFFSET of member in object */
    } VipsArgumentClass;

### VipsArgumentInstance

    typedef struct {
    	VipsArgument parent;

    	/* The class we are part of.
    	 */
    	VipsArgumentClass *argument_class;

    	/* The object we are attached to.
    	 */
    	VipsObject *object;

    	/* Has been set.
    	 */
    	gboolean assigned;

    	/* If this is an output argument, keep the id of our "close" handler
    	 * here.
    	 */
    	gulong close_id;

    	/* We need to listen for "invalidate" on input images and send our own
    	 * "invalidate" out. If we go, we need to disconnect.
    	 */
    	gulong invalidate_id;
    } VipsArgumentInstance;

### VipsArgumentTable

    typedef GHashTable VipsArgumentTable;

### VIPS_ARGUMENT_COLLECT_END

    #define             VIPS_ARGUMENT_COLLECT_END

## Property Details

### The `“description”` property

      “description”              gchar *

Class description.

Flags: Read / Write

Default value: ""

### The `“nickname”` property

      “nickname”                 gchar *

Class nickname.

Flags: Read / Write

Default value: ""

## Signal Details

### The `“close”` signal

    void
    user_function (VipsObject *object,
                   gpointer    user_data)

The ::close signal is emitted once during object close. The object is dying and may not work.

#### Parameters

object | the object that is closing |
user_data | user data set when the signal handler was connected. |

Flags: Run Last

### The `“postbuild”` signal

    gint
    user_function (VipsObject *object,
                   gpointer    user_data)

The ::postbuild signal is emitted once just after successful object construction. Return non-zero to cause object construction to fail.

#### Parameters

object | the object that has been built |
user_data | user data set when the signal handler was connected. |

Flags: Run Last

### The `“postclose”` signal

    void
    user_function (VipsObject *object,
                   gpointer    user_data)

The ::postclose signal is emitted once after object close. The object pointer is still valid, but nothing else.

#### Parameters

object | the object that has closed |
user_data | user data set when the signal handler was connected. |

Flags: Run Last

### The `“preclose”` signal

    void
    user_function (VipsObject *object,
                   gpointer    user_data)

The ::preclose signal is emitted once just before object close starts. The oject is still alive.

#### Parameters

object | the object that is to close |
user_data | user data set when the signal handler was connected. |

Flags: Run Last

## See Also

operation